Advanced

// Multi-stage approval workflow with parallel/sequential stages
type ApprovalState = // => Type declaration defines structure
  // => Enum-like union type for state values
  // => Type system ensures only valid states used
  "Draft" | "AutoCheck" | "HumanReview" | "ManagerApproval" | "Escalation" | "Published" | "Rejected"; // => Seven workflow states
 
type ApprovalEvent = // => Type declaration defines structure
  // => Defines event alphabet for FSM
  // => Events trigger state transitions
  "submit" | "auto_approved" | "flagged" | "approved" | "rejected" | "resolved_approved" | "resolved_rejected"; // => Seven events
 
interface ApprovalContext {
  // => Type declaration defines structure
  documentId: string; // => Unique document identifier
  submittedBy: string; // => User who submitted
  autoCheckScore: number; // => AI confidence score (0-1)
  reviewers: string[]; // => List of reviewers
  escalationReason?: string; // => Why escalated (optional)
  history: string[]; // => State transition audit trail
}
 
class ApprovalWorkflow {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: ApprovalState = "Draft"; // => Initial state
  // => FSM begins execution in Draft state
  private context: ApprovalContext; // => Workflow context
  // => Initialized alongside FSM state
 
  constructor(documentId: string, submittedBy: string) {
    this.context = {
      documentId, // => Set document ID
      submittedBy, // => Set submitter
      autoCheckScore: 0, // => Initial score: 0
      reviewers: [], // => No reviewers yet
      history: ["Draft"], // => Audit trail starts
    };
  }
 
  transition(event: ApprovalEvent, data?: any): void {
    // => Ternary: condition ? true_branch : false_branch
    // => Executes validated state transition
    // => Updates this.state if valid
    const previousState = this.state; // => Capture previous for audit
 
    // State-specific transitions
    switch (this.state) {
      case "Draft": // => Case: handles specific value
        if (event === "submit") {
          // => Event type guard condition
          // => Event type check
          this.state = "AutoCheck"; // => Draft → AutoCheck
          this.runAutoCheck(); // => Execute automated checks
        }
        break;
 
      case "AutoCheck": // => Case: handles specific value
        if (event === "auto_approved") {
          // => Event type guard condition
          // => Event type check
          this.state = "ManagerApproval"; // => AutoCheck → ManagerApproval
        } else if (event === "flagged") {
          this.state = "HumanReview"; // => AutoCheck → HumanReview
          this.assignReviewers(data); // => Assign human reviewers
        }
        break;
 
      case "HumanReview": // => Case: handles specific value
        if (event === "approved") {
          // => Event type guard condition
          // => Event type check
          this.state = "ManagerApproval"; // => HumanReview → ManagerApproval
        } else if (event === "rejected") {
          this.state = "Rejected"; // => HumanReview → Rejected
        }
        break;
 
      case "ManagerApproval": // => Case: handles specific value
        if (event === "approved") {
          // => Event type guard condition
          // => Event type check
          this.state = "Published"; // => ManagerApproval → Published
        } else if (event === "flagged") {
          this.state = "Escalation"; // => ManagerApproval → Escalation
          this.context.escalationReason = data; // => Store escalation reason
        }
        break;
 
      case "Escalation": // => Case: handles specific value
        if (event === "resolved_approved") {
          // => Event type guard condition
          // => Event type check
          this.state = "Published"; // => Escalation → Published
        } else if (event === "resolved_rejected") {
          this.state = "Rejected"; // => Escalation → Rejected
        }
        break;
 
      default:
        // => Default case
        // => Default case
        console.log(`No transition for ${event} in ${this.state}`); // => Output for verification
        // => Debug/audit output
        // => Log for observability
        return; // => Invalid transition, no state change
    }
 
    // Audit trail: record all transitions
    this.context.history.push(`${previousState} --[${event}]--> ${this.state}`); // => Log state transition with event
  }
 
  private runAutoCheck(): void {
    // => Extended state (data beyond FSM state)
    // Simulate AI-based automated check (0-1 confidence score)
    this.context.autoCheckScore = Math.random(); // => Random score 0-1
 
    if (this.context.autoCheckScore > 0.8) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      // => High confidence: auto-approve
      this.transition("auto_approved");
      // => Executes validated state transition
      // => Updates this.state if valid
    } else {
      // => Fallback branch
      // => Low confidence: flag for human review
      this.transition("flagged");
      // => Executes validated state transition
      // => Updates this.state if valid
    }
  }
 
  private assignReviewers(reviewers: string[]): void {
    // => Extended state (data beyond FSM state)
    this.context.reviewers = reviewers; // => Assign reviewers for manual review
  }
 
  getState(): ApprovalState {
    return this.state; // => Return current state
  }
 
  getContext(): ApprovalContext {
    return this.context; // => Return full workflow context
  }
}
 
// Usage: Multi-stage approval workflow
const workflow = new ApprovalWorkflow("DOC-12345", "alice@example.com"); // => Instance creation via constructor
// => Constructor creates new object instance
// => Create new instance
// => Create new instance
// => Initialize workflow
// => state: "Draft", context initialized
 
workflow.transition("submit");
// => Executes validated state transition
// => Updates this.state if valid
// => Draft → AutoCheck, runAutoCheck() executes
// => Based on autoCheckScore: either AutoCheck → ManagerApproval or AutoCheck → HumanReview
 
console.log(`Current state: ${workflow.getState()}`); // => Output for verification
// => Chained method calls or nested operations
// => Debug/audit output
// => Log for observability
// => Output: Current state: AutoCheck (or ManagerApproval/HumanReview depending on score)
 
// Simulate human review path
if (workflow.getState() === "HumanReview") {
  // => Conditional branch
  // => Chained method calls or nested operations
  // => Conditional check
  // => Branch execution based on condition
  workflow.getContext().reviewers = ["bob@example.com", "charlie@example.com"];
  // => Assign reviewers
  workflow.transition("approved");
  // => Executes validated state transition
  // => Updates this.state if valid
  // => HumanReview → ManagerApproval
}
 
console.log(`Audit trail: ${JSON.stringify(workflow.getContext().history)}`); // => Output for verification
// => Chained method calls or nested operations
// => Debug/audit output
// => Log for observability
// => Output: Full state transition history

// Workflow engine with guard conditions for conditional branching
type OrderState = "Pending" | "FraudCheck" | "Processing" | "Shipped" | "Delivered"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type OrderEvent = "validate" | "approve" | "ship" | "deliver"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
interface OrderContext {
  // => Type declaration defines structure
  orderId: string; // => Order identifier
  totalAmount: number; // => Order total ($)
  isPrime: boolean; // => Prime member flag
  destination: string; // => Shipping destination
}
 
class OrderWorkflow {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: OrderState = "Pending"; // => Initial state
  // => FSM begins execution in Pending state
  private context: OrderContext; // => Order context
  // => Initialized alongside FSM state
 
  constructor(orderId: string, totalAmount: number, isPrime: boolean, destination: string) {
    this.context = { orderId, totalAmount, isPrime, destination };
    // => Initialize order context
  }
 
  transition(event: OrderEvent): void {
    // => Executes validated state transition
    // => Updates this.state if valid
    switch (this.state) {
      case "Pending": // => Case: handles specific value
        if (event === "validate") {
          // => Event type guard condition
          // => Event type check
          // Guard condition: high-value orders go to fraud check
          if (this.context.totalAmount > 500) {
            // => Conditional branch
            // => Conditional check
            // => Branch execution based on condition
            // => Order > \$500: fraud check required
            this.state = "FraudCheck"; // => State transition execution
            // => Transition: set state to FraudCheck
            // => State mutation (core FSM operation)
            console.log("High-value order → Fraud check"); // => Output for verification
            // => Debug/audit output
            // => Log for observability
          } else {
            // => Fallback branch
            // => Order ≤ \$500: skip fraud check
            this.state = "Processing"; // => State transition execution
            // => Transition: set state to Processing
            // => State mutation (core FSM operation)
            console.log("Standard order → Processing"); // => Output for verification
            // => Debug/audit output
            // => Log for observability
          }
        }
        break;
 
      case "FraudCheck": // => Case: handles specific value
        if (event === "approve") {
          // => Event type guard condition
          // => Event type check
          this.state = "Processing"; // => FraudCheck → Processing
        }
        break;
 
      case "Processing": // => Case: handles specific value
        if (event === "ship") {
          // => Event type guard condition
          // => Event type check
          // Guard condition: Prime orders get faster routing
          if (this.context.isPrime) {
            // => Conditional branch
            // => Conditional check
            // => Branch execution based on condition
            console.log("Prime order → Priority shipping"); // => Output for verification
            // => Debug/audit output
            // => Log for observability
          }
          this.state = "Shipped"; // => Processing → Shipped
        }
        break;
 
      case "Shipped": // => Case: handles specific value
        if (event === "deliver") {
          // => Event type guard condition
          // => Event type check
          this.state = "Delivered"; // => Shipped → Delivered
        }
        break;
 
      default:
        // => Default case
        // => Default case
        console.log(`Invalid transition: ${event} in ${this.state}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
  }
 
  getState(): OrderState {
    return this.state; // => Return current state
  }
}
 
// Usage: Conditional branching based on order value
const lowValueOrder = new OrderWorkflow("ORD-001", 45.99, false, "US"); // => Instance creation via constructor
// => Constructor creates new object instance
// => Create new instance
// => Create new instance
// => Initialize lowValueOrder
// => totalAmount: \$45.99, not Prime
 
lowValueOrder.transition("validate");
// => Executes validated state transition
// => Updates this.state if valid
// => Pending → Processing (skips fraud check)
console.log(lowValueOrder.getState()); // => Output: Processing
 
const highValueOrder = new OrderWorkflow("ORD-002", 1200.5, true, "US"); // => Instance creation via constructor
// => Constructor creates new object instance
// => Create new instance
// => Create new instance
// => Initialize highValueOrder
// => totalAmount: \$1200.50, Prime member
 
highValueOrder.transition("validate");
// => Executes validated state transition
// => Updates this.state if valid
// => Pending → FraudCheck (high-value requires fraud check)
console.log(highValueOrder.getState()); // => Output: FraudCheck
 
highValueOrder.transition("approve");
// => Executes validated state transition
// => Updates this.state if valid
// => FraudCheck → Processing
console.log(highValueOrder.getState()); // => Output: Processing

// Workflow with compensation (undo/rollback) logic
type PaymentState = "Pending" | "Authorized" | "Captured" | "Refunding" | "Refunded"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type PaymentEvent = "authorize" | "capture" | "refund" | "error"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
class PaymentWorkflow {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: PaymentState = "Pending"; // => Initial state
  // => FSM begins execution in Pending state
  private compensationStack: string[] = []; // => Stack for undo operations
  // => Initialized alongside FSM state
 
  transition(event: PaymentEvent): void {
    // => Executes validated state transition
    // => Updates this.state if valid
    const previousState = this.state; // => Capture for compensation
 
    switch (this.state) {
      case "Pending": // => Case: handles specific value
        if (event === "authorize") {
          // => Event type guard condition
          // => Event type check
          this.state = "Authorized"; // => Pending → Authorized
          this.compensationStack.push("release_authorization");
          // => Add to collection
          // => Add to collection
          // => Stack compensation action: release auth if error occurs
        }
        break;
 
      case "Authorized": // => Case: handles specific value
        if (event === "capture") {
          // => Event type guard condition
          // => Event type check
          this.state = "Captured"; // => Authorized → Captured
          this.compensationStack.push("initiate_refund");
          // => Add to collection
          // => Add to collection
          // => Stack compensation: refund if error occurs after capture
        } else if (event === "error") {
          this.compensate(); // => Error occurred: execute compensation
        }
        break;
 
      case "Captured": // => Case: handles specific value
        if (event === "refund") {
          // => Event type guard condition
          // => Event type check
          this.state = "Refunding"; // => Captured → Refunding
        } else if (event === "error") {
          this.compensate(); // => Error: compensate by refunding
        }
        break;
 
      case "Refunding": // => Case: handles specific value
        // Simulate async refund completion
        setTimeout(() => {
          // => Chained method calls or nested operations
          this.state = "Refunded"; // => Refunding → Refunded (async)
        }, 1000);
        break;
 
      default:
        // => Default case
        // => Default case
        console.log(`No transition for ${event} in ${this.state}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
 
    console.log(`${previousState} → ${this.state}`); // => Output for verification
    // => Debug/audit output
    // => Log for observability
  }
 
  private compensate(): void {
    // => Extended state (data beyond FSM state)
    // Execute compensation actions in reverse order (LIFO stack)
    console.log("Executing compensation..."); // => Output for verification
    // => Debug/audit output
    // => Log for observability
    while (this.compensationStack.length > 0) {
      // => Loop while condition true
      // => Loop while condition true
      const action = this.compensationStack.pop(); // => Pop compensation action
      console.log(`  Compensating: ${action}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      // => Execute: release_authorization or initiate_refund
    }
    this.state = "Pending"; // => Rollback to Pending (consistent state)
    console.log("Rolled back to Pending"); // => Output for verification
    // => Debug/audit output
    // => Log for observability
  }
 
  getState(): PaymentState {
    return this.state; // => Return current state
  }
}
 
// Usage: Error triggers compensation
const payment = new PaymentWorkflow(); // => state: "Pending"
 
payment.transition("authorize");
// => Executes validated state transition
// => Updates this.state if valid
// => Pending → Authorized, compensation: "release_authorization" stacked
 
payment.transition("capture");
// => Executes validated state transition
// => Updates this.state if valid
// => Authorized → Captured, compensation: "initiate_refund" stacked
 
payment.transition("error");
// => Executes validated state transition
// => Updates this.state if valid
// => Error in Captured state → compensate()
// => Executes: initiate_refund, release_authorization (LIFO order)
// => Captured → Pending (rollback complete)
 
console.log(payment.getState()); // => Output: Pending

// Workflow with timeout-based state transitions
type CheckoutState = "Cart" | "Checkout" | "PaymentPending" | "Completed" | "Abandoned"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type CheckoutEvent = "proceed" | "pay" | "timeout"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
class CheckoutWorkflow {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: CheckoutState = "Cart"; // => Initial state
  // => FSM begins execution in Cart state
  private timeoutHandle?: NodeJS.Timeout; // => Timeout timer reference
  // => Initialized alongside FSM state
 
  transition(event: CheckoutEvent): void {
    // => Executes validated state transition
    // => Updates this.state if valid
    switch (this.state) {
      case "Cart": // => Case: handles specific value
        if (event === "proceed") {
          // => Event type guard condition
          // => Event type check
          this.state = "Checkout"; // => Cart → Checkout
          this.startTimeout(120000); // => 2-minute timeout
          // => If no activity in 2 min → auto-abandon
        }
        break;
 
      case "Checkout": // => Case: handles specific value
        if (event === "pay") {
          // => Event type guard condition
          // => Event type check
          this.clearTimeout(); // => Cancel timeout (user acted)
          this.state = "PaymentPending"; // => Checkout → PaymentPending
          this.startTimeout(300000); // => 5-minute payment timeout
        } else if (event === "timeout") {
          this.state = "Abandoned"; // => Checkout → Abandoned (timeout)
        }
        break;
 
      case "PaymentPending": // => Case: handles specific value
        if (event === "timeout") {
          // => Event type guard condition
          // => Event type check
          this.state = "Abandoned"; // => PaymentPending → Abandoned
        }
        // Simulate payment completion (not shown)
        break;
 
      default:
        // => Default case
        // => Default case
        console.log(`No transition for ${event} in ${this.state}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
  }
 
  private startTimeout(milliseconds: number): void {
    // => Extended state (data beyond FSM state)
    this.clearTimeout(); // => Clear any existing timeout
    this.timeoutHandle = setTimeout(() => {
      // => Chained method calls or nested operations
      console.log("Timeout occurred"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      this.transition("timeout"); // => Auto-transition on timeout
      // => Updates this.state if valid
    }, milliseconds);
    // => Schedule timeout event after N milliseconds
  }
 
  private clearTimeout(): void {
    // => Extended state (data beyond FSM state)
    if (this.timeoutHandle) {
      // => Conditional check
      // => Branch execution based on condition
      clearTimeout(this.timeoutHandle); // => Cancel scheduled timeout
      this.timeoutHandle = undefined;
    }
  }
 
  getState(): CheckoutState {
    return this.state; // => Return current state
  }
}
 
// Usage: Timeout-based abandonment
const checkout = new CheckoutWorkflow(); // => state: "Cart"
 
checkout.transition("proceed");
// => Executes validated state transition
// => Updates this.state if valid
// => Cart → Checkout, 2-minute timeout started
 
// User waits 2+ minutes without action
// => Automatic: Checkout → Abandoned (timeout fires)
 
setTimeout(() => {
  // => Chained method calls or nested operations
  console.log(`Final state: ${checkout.getState()}`); // => Output for verification
  // => Chained method calls or nested operations
  // => Debug/audit output
  // => Log for observability
  // => Output: Final state: Abandoned
}, 130000);

// Workflow coordinating external service calls
type RideState = "Requested" | "PriceCalculating" | "WaitingDriver" | "InProgress" | "Completed" | "Failed"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type RideEvent = "calculate" | "assign" | "start" | "end" | "service_error"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
class RideWorkflow {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: RideState = "Requested"; // => Initial state
  // => FSM begins execution in Requested state
 
  async transition(event: RideEvent): Promise<void> {
    // => Executes validated state transition
    // => Updates this.state if valid
    switch (this.state) {
      case "Requested": // => Case: handles specific value
        if (event === "calculate") {
          // => Event type guard condition
          // => Event type check
          this.state = "PriceCalculating"; // => Requested → PriceCalculating
          try {
            // => Begin error handling
            // => Begin error handling
            await this.callPricingService(); // => External service: pricing
            this.transition("assign"); // => Success → next state
            // => Updates this.state if valid
          } catch (error) {
            // => Catch errors
            // => Catch errors
            this.transition("service_error"); // => Failure → error state
            // => Updates this.state if valid
          }
        }
        break;
 
      case "PriceCalculating": // => Case: handles specific value
        if (event === "assign") {
          // => Event type guard condition
          // => Event type check
          this.state = "WaitingDriver"; // => PriceCalculating → WaitingDriver
          try {
            // => Begin error handling
            // => Begin error handling
            await this.callDriverService(); // => External service: driver matching
            this.transition("start");
            // => Executes validated state transition
            // => Updates this.state if valid
          } catch (error) {
            // => Catch errors
            // => Catch errors
            this.transition("service_error");
            // => Executes validated state transition
            // => Updates this.state if valid
          }
        } else if (event === "service_error") {
          this.state = "Failed"; // => PriceCalculating → Failed
        }
        break;
 
      case "WaitingDriver": // => Case: handles specific value
        if (event === "start") {
          // => Event type guard condition
          // => Event type check
          this.state = "InProgress"; // => WaitingDriver → InProgress
        } else if (event === "service_error") {
          this.state = "Failed"; // => State transition execution
          // => Transition: set state to Failed
          // => State mutation (core FSM operation)
        }
        break;
 
      case "InProgress": // => Case: handles specific value
        if (event === "end") {
          // => Event type guard condition
          // => Event type check
          this.state = "Completed"; // => InProgress → Completed
        }
        break;
 
      default:
        // => Default case
        // => Default case
        console.log(`No transition for ${event} in ${this.state}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
  }
 
  private async callPricingService(): Promise<void> {
    // => Extended state (data beyond FSM state)
    // Simulate external pricing service call
    return new Promise((resolve, reject) => {
      // => Returns value to caller
      // => Constructor creates new object instance
      // => Return computed result
      setTimeout(() => {
        // => Chained method calls or nested operations
        const success = Math.random() > 0.1; // => 90% success rate
        success ? resolve() : reject(new Error("Pricing service failed"));
        // => Ternary: condition ? true_branch : false_branch
      }, 300);
    });
  }
 
  private async callDriverService(): Promise<void> {
    // => Extended state (data beyond FSM state)
    // Simulate external driver matching service
    return new Promise((resolve, reject) => {
      // => Returns value to caller
      // => Constructor creates new object instance
      // => Return computed result
      setTimeout(() => {
        // => Chained method calls or nested operations
        const success = Math.random() > 0.05; // => 95% success rate
        success ? resolve() : reject(new Error("Driver service failed"));
        // => Ternary: condition ? true_branch : false_branch
      }, 500);
    });
  }
 
  getState(): RideState {
    return this.state; // => Return current state
  }
}
 
// Usage: Async external service coordination
const ride = new RideWorkflow(); // => state: "Requested"
 
ride.transition("calculate");
// => Executes validated state transition
// => Updates this.state if valid
// => Requested → PriceCalculating
// => Calls pricing service (async)
// => Success: PriceCalculating → WaitingDriver → ...
// => Failure: PriceCalculating → Failed
 
setTimeout(() => {
  // => Chained method calls or nested operations
  console.log(`Final state: ${ride.getState()}`); // => Output for verification
  // => Chained method calls or nested operations
  // => Debug/audit output
  // => Log for observability
  // => Output: WaitingDriver or Failed (depending on service responses)
}, 2000);

// State compression using parameterized states
// BEFORE compression: 30 states for 3 document types × 10 statuses
 
// AFTER compression: 10 states + document type in context
type DocumentStatus = "Draft" | "PendingReview" | "Approved" | "Published" | "Archived"; // => 5 core states (reduced from 15)
 
type DocumentType = "Article" | "Report" | "Whitepaper"; // => 3 document types
 
interface DocumentContext {
  // => Type declaration defines structure
  documentType: DocumentType; // => Type in context (not in state)
  title: string;
  author: string;
}
 
class CompressedDocumentFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: DocumentStatus = "Draft"; // => Parameterized state
  // => FSM begins execution in Draft state
  private context: DocumentContext; // => Type stored in context
  // => Initialized alongside FSM state
 
  constructor(documentType: DocumentType, title: string, author: string) {
    this.context = { documentType, title, author };
    // => Context carries type information
  }
 
  transition(event: string): void {
    // => Executes validated state transition
    // => Updates this.state if valid
    // Single transition logic for all document types
    switch (this.state) {
      case "Draft": // => Case: handles specific value
        if (event === "submit") {
          // => Event type guard condition
          // => Event type check
          this.state = "PendingReview"; // => Draft → PendingReview
        }
        break;
      case "PendingReview": // => Case: handles specific value
        if (event === "approve") {
          // => Event type guard condition
          // => Event type check
          this.state = "Approved"; // => PendingReview → Approved
        }
        break;
      // Type-specific behavior via context (not separate states)
      case "Approved": // => Case: handles specific value
        if (event === "publish") {
          // => Event type guard condition
          // => Event type check
          if (this.context.documentType === "Article") {
            // => Conditional branch
            // => Conditional check
            // => Branch execution based on condition
            console.log("Publishing article to blog"); // => Output for verification
            // => Debug/audit output
            // => Log for observability
          } else if (this.context.documentType === "Report") {
            console.log("Publishing report to library"); // => Output for verification
            // => Debug/audit output
            // => Log for observability
          }
          this.state = "Published"; // => Approved → Published
        }
        break;
      default:
        // => Default case
        // => Default case
        console.log(`Invalid event: ${event}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
  }
 
  getState(): DocumentStatus {
    return this.state; // => Return current state
  }
 
  getContext(): DocumentContext {
    return this.context; // => Return context with type
  }
}
 
// Usage: Single FSM handles all document types
const article = new CompressedDocumentFSM("Article", "My Post", "Alice"); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize article
// => documentType: "Article" in context (not in state name)
 
article.transition("submit"); // => Draft → PendingReview
// => Updates this.state if valid
article.transition("approve"); // => PendingReview → Approved
// => Updates this.state if valid
article.transition("publish"); // => Approved → Published (article-specific logic)
// => Updates this.state if valid
console.log(article.getState()); // => Output: Published
 
const report = new CompressedDocumentFSM("Report", "Q4 Analysis", "Bob"); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize report
// => Same FSM structure, different type in context
 
report.transition("submit");
// => Executes validated state transition
// => Updates this.state if valid
report.transition("approve");
// => Executes validated state transition
// => Updates this.state if valid
report.transition("publish"); // => Uses report-specific publish logic
// => Updates this.state if valid

// Optimized FSM using transition table (Map) instead of switch
type PlayerState = "Idle" | "Playing" | "Paused" | "Buffering" | "Error"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type PlayerEvent = "play" | "pause" | "buffer" | "error" | "ready"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
// Transition table: Map<currentState, Map<event, nextState>>
const transitionTable = new Map<PlayerState, Map<PlayerEvent, PlayerState>>([
  // => State variable initialization
  // => Create new instance
  // => Create new instance
  // => Initialize transitionTable
  [
    "Idle",
    new Map([
      ["play", "Playing"], // => Idle --[play]--> Playing
      ["error", "Error"], // => Idle --[error]--> Error
    ]),
  ],
  [
    "Playing",
    new Map([
      ["pause", "Paused"], // => Playing --[pause]--> Paused
      ["buffer", "Buffering"], // => Playing --[buffer]--> Buffering
      ["error", "Error"],
    ]),
  ],
  [
    "Paused",
    new Map([
      ["play", "Playing"], // => Paused --[play]--> Playing
      ["error", "Error"],
    ]),
  ],
  [
    "Buffering",
    new Map([
      ["ready", "Playing"], // => Buffering --[ready]--> Playing
      ["error", "Error"],
    ]),
  ],
  ["Error", new Map()], // => Terminal state: no outgoing transitions
]);
 
class OptimizedPlayerFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: PlayerState = "Idle"; // => Initial state
  // => FSM begins execution in Idle state
 
  transition(event: PlayerEvent): void {
    // => Executes validated state transition
    // => Updates this.state if valid
    // O(1) lookup instead of O(n) switch statement
    const stateTransitions = transitionTable.get(this.state); // => State variable initialization
    // => Initialize stateTransitions
    // => Get transitions for current state
 
    if (!stateTransitions) {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log(`No transitions from ${this.state}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      return; // => Terminal state
    }
 
    const nextState = stateTransitions.get(event); // => State variable initialization
    // => Lookup result: target state or undefined
    // => O(1) lookup: event → next state
 
    if (nextState) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      console.log(`${this.state} --[${event}]--> ${nextState}`); // => Output for verification
      // => Modify state data
      // => Modify state data
      // => Debug/audit output
      // => Log for observability
      this.state = nextState; // => Execute transition
    } else {
      // => Fallback branch
      console.log(`Invalid transition: ${event} in ${this.state}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
  }
 
  getState(): PlayerState {
    return this.state; // => Return current state
  }
}
 
// Usage: O(1) transition lookup
const player = new OptimizedPlayerFSM(); // => state: "Idle"
 
player.transition("play"); // => Idle → Playing (O(1) lookup)
// => Updates this.state if valid
player.transition("buffer"); // => Playing → Buffering
// => Updates this.state if valid
player.transition("ready"); // => Buffering → Playing
// => Updates this.state if valid
player.transition("pause"); // => Playing → Paused
// => Updates this.state if valid
 
console.log(player.getState()); // => Output: Paused

// FSM with state result caching
type InventoryState = "Idle" | "CheckingStock" | "Available" | "OutOfStock"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type InventoryEvent = "check" | "found" | "not_found"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
interface CachedResult {
  // => Type declaration defines structure
  value: boolean; // => Stock availability
  timestamp: number; // => Cache timestamp
}
 
class CachedInventoryFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: InventoryState = "Idle"; // => Initial state
  // => FSM begins execution in Idle state
  private cache: Map<string, CachedResult> = new Map(); // => Result cache
  // => Initialized alongside FSM state
  private cacheTTL: number = 5000; // => 5-second TTL
  // => Initialized alongside FSM state
 
  async transition(event: InventoryEvent, productId?: string): Promise<void> {
    // => Ternary: condition ? true_branch : false_branch
    // => Executes validated state transition
    // => Updates this.state if valid
    switch (this.state) {
      case "Idle": // => Case: handles specific value
        if (event === "check" && productId) {
          // => Event type guard condition
          // => Logical AND: both conditions must be true
          // => Event type check
          this.state = "CheckingStock"; // => Idle → CheckingStock
 
          // Check cache first
          const cached = this.cache.get(productId); // => Variable declaration and assignment
          // => Initialize cached
          const now = Date.now(); // => Variable declaration and assignment
          // => Initialize now
 
          if (cached && now - cached.timestamp < this.cacheTTL) {
            // => Conditional branch
            // => Logical AND: both conditions must be true
            // => Conditional check
            // => Branch execution based on condition
            // => Cache hit: use cached result
            console.log(`Cache hit for ${productId}`); // => Output for verification
            // => Debug/audit output
            // => Log for observability
            this.state = cached.value ? "Available" : "OutOfStock"; // => State transition execution
            // => Ternary: condition ? true_branch : false_branch
            return; // => Skip expensive database query
          }
 
          // Cache miss: query database
          console.log(`Cache miss for ${productId}: querying DB`); // => Output for verification
          // => Debug/audit output
          // => Log for observability
          const available = await this.checkStock(productId); // => Variable declaration and assignment
          // => Initialize available
          // => Expensive database query
 
          // Cache result
          this.cache.set(productId, {
            value: available,
            timestamp: now,
          });
 
          this.state = available ? "Available" : "OutOfStock"; // => State transition execution
          // => Ternary: condition ? true_branch : false_branch
        }
        break;
 
      default:
        // => Default case
        // => Default case
        console.log(`Invalid transition: ${event} in ${this.state}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
  }
 
  private async checkStock(productId: string): Promise<boolean> {
    // => Extended state (data beyond FSM state)
    // Simulate expensive database query (100ms latency)
    return new Promise((resolve) => {
      // => Returns value to caller
      // => Constructor creates new object instance
      // => Return computed result
      setTimeout(() => {
        // => Chained method calls or nested operations
        resolve(Math.random() > 0.3); // => 70% available
      }, 100);
    });
  }
 
  getState(): InventoryState {
    return this.state; // => Return current state
  }
}
 
// Usage: Cache reduces redundant queries
const inventory = new CachedInventoryFSM(); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize inventory
 
await inventory.transition("check", "PROD-123");
// => Executes validated state transition
// => Updates this.state if valid
// => First check: cache miss → query DB (100ms)
console.log(inventory.getState()); // => Available or OutOfStock
// => Log for observability
 
await inventory.transition("check", "PROD-123");
// => Executes validated state transition
// => Updates this.state if valid
// => Second check (within 5s): cache hit → no DB query (<1ms)
console.log(inventory.getState()); // => Same result (from cache)
// => Log for observability

// FSM object pooling to reduce GC pressure
type MessageState = "Pending" | "Sent" | "Delivered" | "Read"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type MessageEvent = "send" | "deliver" | "read"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
class MessageFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: MessageState = "Pending"; // => Initial state
  // => FSM begins execution in Pending state
  private messageId: string = ""; // => Message identifier
  // => Initialized alongside FSM state
 
  reset(messageId: string): void {
    // Reset FSM for reuse (instead of creating new instance)
    this.state = "Pending"; // => Reset to initial state
    this.messageId = messageId;
  }
 
  transition(event: MessageEvent): void {
    // => Executes validated state transition
    // => Updates this.state if valid
    switch (this.state) {
      case "Pending": // => Case: handles specific value
        if (event === "send") this.state = "Sent"; // => Event type guard condition
        // => Event type check
        // => Combined (state, event) guard
        break;
      case "Sent": // => Case: handles specific value
        if (event === "deliver") this.state = "Delivered"; // => Event type guard condition
        // => Event type check
        // => Combined (state, event) guard
        break;
      case "Delivered": // => Case: handles specific value
        if (event === "read") this.state = "Read"; // => Event type guard condition
        // => Event type check
        // => Combined (state, event) guard
        break;
    }
  }
 
  getState(): MessageState {
    return this.state; // => Returns value to caller
    // => Return current state value
  }
 
  isTerminal(): boolean {
    return this.state === "Read"; // => Check if FSM done
  }
}
 
class FSMPool {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private pool: MessageFSM[] = []; // => Pool of reusable FSMs
  // => Initialized alongside FSM state
  private maxSize: number = 100; // => Max pool size
  // => Initialized alongside FSM state
  private created: number = 0; // => Total created instances
  // => Initialized alongside FSM state
  private reused: number = 0; // => Total reused instances
  // => Initialized alongside FSM state
 
  acquire(messageId: string): MessageFSM {
    let fsm: MessageFSM; // => Variable declaration with initial value
 
    if (this.pool.length > 0) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      fsm = this.pool.pop()!; // => Reuse from pool
      fsm.reset(messageId); // => Reset state
      this.reused++; // => Count reuse
      console.log(`Pool hit (reused ${this.reused}/${this.created + this.reused})`); // => Output for verification
      // => Chained method calls or nested operations
      // => Debug/audit output
      // => Log for observability
    } else {
      // => Fallback branch
      fsm = new MessageFSM(); // => Create new instance (pool empty)
      fsm.reset(messageId);
      this.created++;
      // => Modify state data
      // => Modify state data
      // => Update extended state data
      console.log(`Pool miss (created ${this.created})`); // => Output for verification
      // => Chained method calls or nested operations
      // => Debug/audit output
      // => Log for observability
    }
 
    return fsm; // => Return FSM ready for use
  }
 
  release(fsm: MessageFSM): void {
    // Return FSM to pool for reuse
    if (this.pool.length < this.maxSize) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      this.pool.push(fsm); // => Add to pool
      console.log(`Returned to pool (size: ${this.pool.length})`); // => Output for verification
      // => Chained method calls or nested operations
      // => Debug/audit output
      // => Log for observability
    } else {
      // => Fallback branch
      console.log(`Pool full (size: ${this.maxSize}), discarding`); // => Output for verification
      // => Chained method calls or nested operations
      // => Debug/audit output
      // => Log for observability
      // => Pool at capacity: let GC collect this instance
    }
  }
 
  getStats(): { created: number; reused: number; hitRate: number } {
    const total = this.created + this.reused; // => Variable declaration and assignment
    // => Initialize total
    const hitRate = total > 0 ? this.reused / total : 0; // => Variable declaration and assignment
    // => Ternary: condition ? true_branch : false_branch
    // => Initialize hitRate
    return { created: this.created, reused: this.reused, hitRate }; // => Returns value to caller
    // => Return computed result
  }
}
 
// Usage: Object pooling reduces allocations
const pool = new FSMPool(); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize pool
 
// Simulate 10 messages (with pooling)
for (let i = 0; i < 10; i++) {
  // => Variable declaration and assignment
  // => Modify state data
  // => Modify state data
  // => Update extended state data
  const fsm = pool.acquire(`MSG-${i}`); // => Get FSM from pool
  // => First iteration: pool miss (create new)
  // => Subsequent: pool hit (reuse existing)
 
  fsm.transition("send");
  // => Executes validated state transition
  // => Updates this.state if valid
  fsm.transition("deliver");
  // => Executes validated state transition
  // => Updates this.state if valid
  fsm.transition("read");
  // => Executes validated state transition
  // => Updates this.state if valid
 
  pool.release(fsm); // => Return to pool when done
}
 
console.log(pool.getStats()); // => Output for verification
// => Chained method calls or nested operations
// => Debug/audit output
// => Log for observability
// => Output: { created: 1, reused: 9, hitRate: 0.9 }
// => 90% hit rate: only 1 allocation instead of 10

// Distributed FSM with event sourcing (event log replay)
type OrderEvent = // => Type declaration defines structure
  // => Defines event alphabet for FSM
  // => Events trigger state transitions
  | { type: "OrderPlaced"; orderId: string; amount: number }
  | { type: "PaymentReceived"; orderId: string }
  | { type: "OrderShipped"; orderId: string }
  | { type: "OrderDelivered"; orderId: string };
 
type OrderState = "Pending" | "Paid" | "Shipped" | "Delivered"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
 
class EventSourcedOrderFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: OrderState = "Pending"; // => Current state (derived from events)
  // => FSM begins execution in Pending state
  private events: OrderEvent[] = []; // => Event log (source of truth)
  // => Initialized alongside FSM state
  private orderId: string; // => Field declaration: class member variable
  // => Extended state (data beyond FSM state)
 
  constructor(orderId: string) {
    this.orderId = orderId;
  }
 
  applyEvent(event: OrderEvent): void {
    // Append event to log (immutable event store)
    this.events.push(event); // => Event log is source of truth
 
    // Update state based on event type
    switch (event.type) {
      case "OrderPlaced": // => Case: handles specific value
        this.state = "Pending"; // => OrderPlaced → Pending
        break;
      case "PaymentReceived": // => Case: handles specific value
        this.state = "Paid"; // => PaymentReceived → Paid
        break;
      case "OrderShipped": // => Case: handles specific value
        this.state = "Shipped"; // => OrderShipped → Shipped
        break;
      case "OrderDelivered": // => Case: handles specific value
        this.state = "Delivered"; // => OrderDelivered → Delivered
        break;
    }
 
    console.log(`Event applied: ${event.type} → State: ${this.state}`); // => Output for verification
    // => Debug/audit output
    // => Log for observability
  }
 
  rebuildFromEvents(events: OrderEvent[]): void {
    // Reconstruct FSM state by replaying events
    this.state = "Pending"; // => Reset to initial state
    this.events = []; // => Clear event log
 
    for (const event of events) {
      // => Iterate collection
      // => Iterate collection
      this.applyEvent(event); // => Replay each event
    }
 
    console.log(`Rebuilt state: ${this.state} from ${events.length} events`); // => Output for verification
    // => Debug/audit output
    // => Log for observability
  }
 
  getState(): OrderState {
    return this.state; // => Current state (derived from events)
  }
 
  getEvents(): OrderEvent[] {
    return [...this.events]; // => Return event log copy
  }
}
 
// Usage: Event sourcing for FSM state reconstruction
const order = new EventSourcedOrderFSM("ORD-123"); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize order
 
order.applyEvent({ type: "OrderPlaced", orderId: "ORD-123", amount: 99.99 });
// => Event: OrderPlaced, State: Pending
 
order.applyEvent({ type: "PaymentReceived", orderId: "ORD-123" });
// => Event: PaymentReceived, State: Paid
 
order.applyEvent({ type: "OrderShipped", orderId: "ORD-123" });
// => Event: OrderShipped, State: Shipped
 
// Simulate system crash and recovery
const eventLog = order.getEvents(); // => Get event log
console.log(`Event log: ${JSON.stringify(eventLog)}`); // => Output for verification
// => Chained method calls or nested operations
// => Debug/audit output
// => Log for observability
 
const recoveredOrder = new EventSourcedOrderFSM("ORD-123"); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize recoveredOrder
recoveredOrder.rebuildFromEvents(eventLog);
// => Rebuild state by replaying events
// => State reconstructed: Shipped
 
console.log(recoveredOrder.getState()); // => Output: Shipped (recovered state)

// Simplified distributed FSM with consensus (majority voting)
type ClusterState = "Follower" | "Candidate" | "Leader"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type ConsensusEvent = "timeout" | "vote_request" | "elected" | "heartbeat"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
interface Node {
  // => Type declaration defines structure
  id: string;
  state: ClusterState;
}
 
class DistributedConsensusFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: ClusterState = "Follower"; // => Initial: all nodes start as followers
  // => FSM begins execution in Follower state
  private nodeId: string; // => Field declaration: class member variable
  // => Extended state (data beyond FSM state)
  private clusterSize: number; // => Field declaration: class member variable
  // => Extended state (data beyond FSM state)
  private votesReceived: Set<string> = new Set(); // => Track votes for leader election
  // => Initialized alongside FSM state
 
  constructor(nodeId: string, clusterSize: number) {
    this.nodeId = nodeId;
    this.clusterSize = clusterSize;
  }
 
  transition(event: ConsensusEvent, voterId?: string): void {
    // => Ternary: condition ? true_branch : false_branch
    // => Executes validated state transition
    // => Updates this.state if valid
    switch (this.state) {
      case "Follower": // => Case: handles specific value
        if (event === "timeout") {
          // => Event type guard condition
          // => Event type check
          // No heartbeat from leader → start election
          this.state = "Candidate"; // => Follower → Candidate
          this.votesReceived.clear();
          this.votesReceived.add(this.nodeId); // => Vote for self
          console.log(`${this.nodeId}: Follower → Candidate (election timeout)`); // => Output for verification
          // => Chained method calls or nested operations
          // => Debug/audit output
          // => Log for observability
        } else if (event === "heartbeat") {
          console.log(`${this.nodeId}: Received leader heartbeat (stay Follower)`); // => Output for verification
          // => Chained method calls or nested operations
          // => Debug/audit output
          // => Log for observability
        }
        break;
 
      case "Candidate": // => Case: handles specific value
        if (event === "vote_request" && voterId) {
          // => Event type guard condition
          // => Logical AND: both conditions must be true
          // => Event type check
          this.votesReceived.add(voterId); // => Collect vote
          console.log(`${this.nodeId}: Received vote from ${voterId} (${this.votesReceived.size}/${this.clusterSize})`); // => Output for verification
          // => Chained method calls or nested operations
          // => Debug/audit output
          // => Log for observability
 
          // Check if majority reached
          const majorityThreshold = Math.floor(this.clusterSize / 2) + 1; // => Variable declaration and assignment
          // => Initialize majorityThreshold
          if (this.votesReceived.size >= majorityThreshold) {
            // => Conditional branch
            // => Conditional check
            // => Branch execution based on condition
            this.transition("elected"); // => Majority → become leader
            // => Updates this.state if valid
          }
        } else if (event === "timeout") {
          console.log(`${this.nodeId}: Election timeout, retrying...`); // => Output for verification
          // => Debug/audit output
          // => Log for observability
          this.votesReceived.clear();
          this.votesReceived.add(this.nodeId); // => Re-vote for self
        }
        break;
 
      case "Leader": // => Case: handles specific value
        if (event === "elected") {
          // => Event type guard condition
          // => Event type check
          this.state = "Leader"; // => Candidate → Leader
          console.log(`${this.nodeId}: Elected as Leader (consensus reached)`); // => Output for verification
          // => Chained method calls or nested operations
          // => Debug/audit output
          // => Log for observability
        } else if (event === "heartbeat") {
          console.log(`${this.nodeId}: Sending heartbeat to followers`); // => Output for verification
          // => Debug/audit output
          // => Log for observability
        }
        break;
    }
  }
 
  getState(): ClusterState {
    return this.state; // => Return current state
  }
}
 
// Usage: Distributed consensus (3-node cluster)
const node1 = new DistributedConsensusFSM("node-1", 3); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize node1
const node2 = new DistributedConsensusFSM("node-2", 3); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize node2
const node3 = new DistributedConsensusFSM("node-3", 3); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize node3
 
// All nodes start as Follower
console.log(`node-1: ${node1.getState()}`); // => Output: Follower
console.log(`node-2: ${node2.getState()}`); // => Output: Follower
 
// Node 1 times out → starts election
node1.transition("timeout");
// => Executes validated state transition
// => Updates this.state if valid
// => node-1: Follower → Candidate
 
// Nodes 2 and 3 vote for node-1
node1.transition("vote_request", "node-2"); // => 2/3 votes
// => Updates this.state if valid
node1.transition("vote_request", "node-3"); // => 3/3 votes (majority!)
// => Updates this.state if valid
// => node-1: Candidate → Leader
 
console.log(`node-1: ${node1.getState()}`); // => Output: Leader

// FSM with distributed locking (simulated Redis lock)
type DeliveryState = "Available" | "Claimed" | "InProgress" | "Completed"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type DeliveryEvent = "claim" | "start" | "complete"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
class DistributedLockManager {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private locks: Map<string, string> = new Map(); // => deliveryId → lockHolder
  // => Initialized alongside FSM state
 
  async acquire(resource: string, holder: string, timeoutMs: number): Promise<boolean> {
    // Simulate distributed lock acquisition (Redis SETNX)
    return new Promise((resolve) => {
      // => Returns value to caller
      // => Constructor creates new object instance
      // => Return computed result
      setTimeout(() => {
        // => Chained method calls or nested operations
        if (!this.locks.has(resource)) {
          // => Conditional branch
          // => Chained method calls or nested operations
          // => Conditional check
          // => Branch execution based on condition
          this.locks.set(resource, holder); // => Lock acquired
          console.log(`${holder} acquired lock on ${resource}`); // => Output for verification
          // => Debug/audit output
          // => Log for observability
          resolve(true);
        } else {
          // => Fallback branch
          console.log(`${holder} failed to acquire lock (held by ${this.locks.get(resource)})`); // => Output for verification
          // => Chained method calls or nested operations
          // => Debug/audit output
          // => Log for observability
          resolve(false); // => Lock held by another process
        }
      }, timeoutMs);
    });
  }
 
  release(resource: string, holder: string): void {
    if (this.locks.get(resource) === holder) {
      // => Conditional branch
      // => Chained method calls or nested operations
      // => Conditional check
      // => Branch execution based on condition
      this.locks.delete(resource); // => Release lock
      console.log(`${holder} released lock on ${resource}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
  }
}
 
class DeliveryFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: DeliveryState = "Available"; // => Initial state
  // => FSM begins execution in Available state
  private deliveryId: string; // => Field declaration: class member variable
  // => Extended state (data beyond FSM state)
  private lockManager: DistributedLockManager; // => Field declaration: class member variable
  // => Extended state (data beyond FSM state)
  private assignedTo?: string; // => Dasher ID
  // => Initialized alongside FSM state
 
  constructor(deliveryId: string, lockManager: DistributedLockManager) {
    this.deliveryId = deliveryId;
    this.lockManager = lockManager;
  }
 
  async transition(event: DeliveryEvent, dasherId: string): Promise<boolean> {
    // => Executes validated state transition
    // => Updates this.state if valid
    // Acquire distributed lock before state change
    const lockAcquired = await this.lockManager.acquire(this.deliveryId, dasherId, 50); // => Variable declaration and assignment
    // => Initialize lockAcquired
    // => Try to acquire lock (50ms timeout)
 
    if (!lockAcquired) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      console.log(`${dasherId} cannot transition ${this.deliveryId}: lock not acquired`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      return false; // => Concurrent modification prevented
    }
 
    // Critical section: state transition (protected by lock)
    try {
      // => Begin error handling
      // => Begin error handling
      switch (this.state) {
        case "Available": // => Case: handles specific value
          if (event === "claim") {
            // => Event type guard condition
            // => Event type check
            this.state = "Claimed"; // => Available → Claimed
            this.assignedTo = dasherId;
            console.log(`${dasherId} claimed delivery ${this.deliveryId}`); // => Output for verification
            // => Debug/audit output
            // => Log for observability
          }
          break;
 
        case "Claimed": // => Case: handles specific value
          if (event === "start" && this.assignedTo === dasherId) {
            // => Event type guard condition
            // => Logical AND: both conditions must be true
            // => Event type check
            this.state = "InProgress"; // => Claimed → InProgress
          }
          break;
 
        case "InProgress": // => Case: handles specific value
          if (event === "complete" && this.assignedTo === dasherId) {
            // => Event type guard condition
            // => Logical AND: both conditions must be true
            // => Event type check
            this.state = "Completed"; // => InProgress → Completed
          }
          break;
      }
 
      return true; // => Transition successful
    } finally {
      // Always release lock after transition
      this.lockManager.release(this.deliveryId, dasherId);
    }
  }
 
  getState(): DeliveryState {
    return this.state; // => Return current state
  }
}
 
// Usage: Distributed locking prevents race conditions
const lockManager = new DistributedLockManager(); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize lockManager
const delivery = new DeliveryFSM("DEL-123", lockManager); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize delivery
 
// Simulate two dashers claiming same delivery concurrently
async function simulateConcurrentClaim() {
  const claim1 = delivery.transition("claim", "dasher-A"); // => First claim attempt
  // => Updates this.state if valid
  const claim2 = delivery.transition("claim", "dasher-B"); // => Concurrent claim attempt
  // => Updates this.state if valid
 
  const results = await Promise.all([claim1, claim2]); // => Variable declaration and assignment
  // => Initialize results
  console.log(`Claim results: ${results}`); // => Output for verification
  // => Debug/audit output
  // => Log for observability
  // => Output: [true, false] (only one succeeds)
 
  console.log(`Final state: ${delivery.getState()}`); // => Claimed
  // => Log for observability
}
 
simulateConcurrentClaim();

// FSM with active-active state replication
type TableState = "Active" | "Creating" | "Updating" | "Deleting"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
type TableEvent = "create" | "update" | "delete"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
interface ReplicatedState {
  // => Type declaration defines structure
  state: TableState;
  timestamp: number; // => Lamport timestamp for conflict resolution
  region: string; // => Source region
}
 
class ReplicatedTableFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: TableState = "Creating"; // => Initial state
  // => FSM begins execution in Creating state
  private timestamp: number = 0; // => Lamport clock
  // => Initialized alongside FSM state
  private region: string; // => Field declaration: class member variable
  // => Extended state (data beyond FSM state)
  private replicas: Map<string, ReplicatedState> = new Map(); // => region → state
  // => Initialized alongside FSM state
 
  constructor(region: string) {
    this.region = region;
    this.replicas.set(region, { state: this.state, timestamp: this.timestamp, region });
  }
 
  transition(event: TableEvent): void {
    // => Executes validated state transition
    // => Updates this.state if valid
    this.timestamp++; // => Increment Lamport clock on each event
 
    switch (this.state) {
      case "Creating": // => Case: handles specific value
        if (event === "create") {
          // => Event type guard condition
          // => Event type check
          this.state = "Active"; // => Creating → Active
        }
        break;
      case "Active": // => Case: handles specific value
        if (event === "update") {
          // => Event type guard condition
          // => Event type check
          this.state = "Updating"; // => Active → Updating
        } else if (event === "delete") {
          this.state = "Deleting"; // => Active → Deleting
        }
        break;
      case "Updating": // => Case: handles specific value
        this.state = "Active"; // => Updating → Active (update complete)
        break;
      case "Deleting": // => Case: handles specific value
        console.log("Table deleted"); // => Output for verification
        // => Debug/audit output
        // => Log for observability
        break;
    }
 
    // Replicate state to all regions
    this.replicas.set(this.region, {
      state: this.state,
      timestamp: this.timestamp,
      region: this.region,
    });
 
    console.log(`[${this.region}] Local state: ${this.state} (t=${this.timestamp})`); // => Output for verification
    // => Chained method calls or nested operations
    // => Debug/audit output
    // => Log for observability
  }
 
  receiveReplicatedState(remoteState: ReplicatedState): void {
    console.log(
      // => Debug/audit output
      // => Log for observability
      `[${this.region}] Received: ${remoteState.state} from ${remoteState.region} (t=${remoteState.timestamp})`,
    );
 
    // Conflict resolution: last-write-wins (higher timestamp)
    const localReplica = this.replicas.get(this.region)!; // => Variable declaration and assignment
    // => Initialize localReplica
 
    if (remoteState.timestamp > localReplica.timestamp) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      // => Remote state is newer: adopt it
      this.state = remoteState.state; // => State transition execution
      this.timestamp = remoteState.timestamp;
      console.log(`[${this.region}] Adopted remote state: ${this.state} (newer timestamp)`); // => Output for verification
      // => Chained method calls or nested operations
      // => Debug/audit output
      // => Log for observability
    } else if (remoteState.timestamp === localReplica.timestamp) {
      // => Concurrent updates: tie-break by region name (deterministic)
      if (remoteState.region > localReplica.region) {
        // => Conditional branch
        // => Conditional check
        // => Branch execution based on condition
        this.state = remoteState.state; // => State transition execution
        console.log(`[${this.region}] Tie-break: adopted ${remoteState.region}'s state`); // => Output for verification
        // => Debug/audit output
        // => Log for observability
      }
    } else {
      // => Fallback branch
      console.log(`[${this.region}] Ignored remote state (older timestamp)`); // => Output for verification
      // => Chained method calls or nested operations
      // => Debug/audit output
      // => Log for observability
    }
 
    // Store remote replica
    this.replicas.set(remoteState.region, remoteState);
  }
 
  getState(): TableState {
    return this.state; // => Return current state
  }
 
  getReplicatedState(): ReplicatedState {
    return {
      // => Returns value to caller
      // => Return computed result
      state: this.state,
      timestamp: this.timestamp,
      region: this.region,
    };
  }
}
 
// Usage: Active-active replication across regions
const usEast = new ReplicatedTableFSM("us-east-1"); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize usEast
const euWest = new ReplicatedTableFSM("eu-west-1"); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize euWest
 
usEast.transition("create");
// => Executes validated state transition
// => Updates this.state if valid
// => [us-east-1] Creating → Active (t=1)
 
// Replicate to EU region
euWest.receiveReplicatedState(usEast.getReplicatedState());
// => Chained method calls or nested operations
// => [eu-west-1] Received: Active from us-east-1 (t=1)
// => [eu-west-1] Adopted remote state: Active
 
// Concurrent updates in both regions
usEast.transition("update"); // => us-east-1: Active → Updating (t=2)
// => Updates this.state if valid
euWest.transition("update"); // => eu-west-1: Active → Updating (t=2)
// => Updates this.state if valid
 
// Cross-region replication
usEast.receiveReplicatedState(euWest.getReplicatedState());
// => Chained method calls or nested operations
// => Conflict: both t=2 → tie-break by region name
euWest.receiveReplicatedState(usEast.getReplicatedState());
// => Chained method calls or nested operations

// FSM with CRDT state merging (G-Counter CRDT)
type EditState = "Idle" | "Editing" | "Syncing" | "Synced"; // => Type declaration defines structure
// => Enum-like union type for state values
// => Type system ensures only valid states used
 
class GCounter {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  // Grow-only counter CRDT (each replica maintains count per node)
  private counts: Map<string, number> = new Map(); // => nodeId → count
  // => Initialized alongside FSM state
 
  increment(nodeId: string, delta: number = 1): void {
    const current = this.counts.get(nodeId) || 0; // => Variable declaration and assignment
    // => Logical OR: either condition can be true
    // => Initialize current
    this.counts.set(nodeId, current + delta); // => Increment local count
  }
 
  merge(other: GCounter): void {
    // Merge two CRDTs by taking max count per node
    for (const [nodeId, count] of other.counts) {
      // => Iterate collection
      // => Iterate collection
      const localCount = this.counts.get(nodeId) || 0; // => Variable declaration and assignment
      // => Logical OR: either condition can be true
      // => Initialize localCount
      this.counts.set(nodeId, Math.max(localCount, count));
      // => Chained method calls or nested operations
      // => Conflict resolution: max wins (grow-only)
    }
  }
 
  value(): number {
    // Total count = sum of all node counts
    return Array.from(this.counts.values()).reduce((sum, count) => sum + count, 0); // => Returns value to caller
    // => Chained method calls or nested operations
    // => Return computed result
  }
 
  getCounts(): Map<string, number> {
    return new Map(this.counts); // => Return counts for replication
  }
}
 
class CRDTEditFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: EditState = "Idle"; // => Initial state
  // => FSM begins execution in Idle state
  private editCount: GCounter = new GCounter(); // => CRDT for edit count
  // => Initialized alongside FSM state
  private nodeId: string; // => Field declaration: class member variable
  // => Extended state (data beyond FSM state)
 
  constructor(nodeId: string) {
    this.nodeId = nodeId;
  }
 
  edit(): void {
    this.state = "Editing"; // => Idle → Editing
    this.editCount.increment(this.nodeId); // => Increment local edit count
    console.log(`[${this.nodeId}] Edit count: ${this.editCount.value()}`); // => Output for verification
    // => Chained method calls or nested operations
    // => Debug/audit output
    // => Log for observability
  }
 
  sync(remoteFSM: CRDTEditFSM): void {
    this.state = "Syncing"; // => Editing → Syncing
 
    // Merge CRDT states (no conflicts!)
    this.editCount.merge(remoteFSM.editCount);
    // => CRDTs converge without coordination
 
    this.state = "Synced"; // => Syncing → Synced
    console.log(`[${this.nodeId}] Synced. Total edits: ${this.editCount.value()}`); // => Output for verification
    // => Chained method calls or nested operations
    // => Debug/audit output
    // => Log for observability
  }
 
  getState(): EditState {
    return this.state; // => Return current state
  }
 
  getEditCount(): number {
    return this.editCount.value(); // => Return merged edit count
  }
}
 
// Usage: CRDT-based state merging
const designer1 = new CRDTEditFSM("designer-1"); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize designer1
const designer2 = new CRDTEditFSM("designer-2"); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize designer2
 
// Concurrent edits while offline
designer1.edit(); // => designer-1: edit count = 1
designer1.edit(); // => designer-1: edit count = 2
designer2.edit(); // => designer-2: edit count = 1
 
// Both designers sync (merge CRDTs)
designer1.sync(designer2);
// => designer-1 merges designer-2's state
// => Total edits: max(2, 0) + max(0, 1) = 2 + 1 = 3
 
designer2.sync(designer1);
// => designer-2 merges designer-1's state
// => Total edits: 3 (same result, convergence!)
 
console.log(`Designer 1 total: ${designer1.getEditCount()}`); // => 3
// => Log for observability
console.log(`Designer 2 total: ${designer2.getEditCount()}`); // => 3
// => Log for observability

// Saga choreography: Event-driven coordination without orchestrator
type OrderSagaEvent = "OrderPlaced" | "PaymentProcessed" | "PaymentFailed" | "FoodPrepared" | "DriverAssigned"; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
class OrderServiceFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: string = "Idle"; // => Order service state
  // => FSM begins execution in Idle state
 
  handleEvent(event: OrderSagaEvent): OrderSagaEvent | null {
    // => Event handler: main FSM dispatch method
    switch (this.state) {
      case "Idle": // => Case: handles specific value
        if (event === "OrderPlaced") {
          // => Event type guard condition
          // => Event type check
          this.state = "Pending"; // => State transition execution
          // => Transition: set state to Pending
          // => State mutation (core FSM operation)
          console.log("[Order] Order placed → Payment"); // => Output for verification
          // => Debug/audit output
          // => Log for observability
          return "OrderPlaced"; // => Publish event for Payment service
        }
        break;
      case "Pending": // => Case: handles specific value
        if (event === "PaymentFailed") {
          // => Event type guard condition
          // => Event type check
          this.state = "Cancelled"; // => State transition execution
          // => Transition: set state to Cancelled
          // => State mutation (core FSM operation)
          console.log("[Order] Payment failed → Cancel order"); // => Output for verification
          // => Debug/audit output
          // => Log for observability
          return null; // => Compensating transaction: cancel order
        }
        break;
    }
    return null; // => Returns value to caller
    // => Return computed result
  }
}
 
class PaymentServiceFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: string = "Idle"; // => Payment service state
  // => FSM begins execution in Idle state
 
  handleEvent(event: OrderSagaEvent): OrderSagaEvent | null {
    // => Event handler: main FSM dispatch method
    switch (this.state) {
      case "Idle": // => Case: handles specific value
        if (event === "OrderPlaced") {
          // => Event type guard condition
          // => Event type check
          this.state = "Processing"; // => State transition execution
          // => Transition: set state to Processing
          // => State mutation (core FSM operation)
          console.log("[Payment] Processing payment..."); // => Output for verification
          // => Debug/audit output
          // => Log for observability
 
          // Simulate payment success/failure
          const success = Math.random() > 0.2; // => 80% success rate
          if (success) {
            // => Conditional branch
            // => Conditional check
            // => Branch execution based on condition
            this.state = "Completed"; // => State transition execution
            // => Transition: set state to Completed
            // => State mutation (core FSM operation)
            console.log("[Payment] Payment successful → Restaurant"); // => Output for verification
            // => Debug/audit output
            // => Log for observability
            return "PaymentProcessed"; // => Publish success event
          } else {
            // => Fallback branch
            this.state = "Failed"; // => State transition execution
            // => Transition: set state to Failed
            // => State mutation (core FSM operation)
            console.log("[Payment] Payment failed → Rollback"); // => Output for verification
            // => Debug/audit output
            // => Log for observability
            return "PaymentFailed"; // => Publish failure event (triggers compensation)
          }
        }
        break;
    }
    return null; // => Returns value to caller
    // => Return computed result
  }
}
 
class RestaurantServiceFSM {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: string = "Idle"; // => Restaurant service state
  // => FSM begins execution in Idle state
 
  handleEvent(event: OrderSagaEvent): OrderSagaEvent | null {
    // => Event handler: main FSM dispatch method
    switch (this.state) {
      case "Idle": // => Case: handles specific value
        if (event === "PaymentProcessed") {
          // => Event type guard condition
          // => Event type check
          this.state = "Preparing"; // => State transition execution
          // => Transition: set state to Preparing
          // => State mutation (core FSM operation)
          console.log("[Restaurant] Preparing food..."); // => Output for verification
          // => Debug/audit output
          // => Log for observability
          this.state = "Ready"; // => State transition execution
          // => Transition: set state to Ready
          // => State mutation (core FSM operation)
          return "FoodPrepared"; // => Publish event for Delivery service
        }
        break;
    }
    return null; // => Returns value to caller
    // => Return computed result
  }
}
 
// Choreography: Event-driven saga (no central orchestrator)
const orderService = new OrderServiceFSM(); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize orderService
const paymentService = new PaymentServiceFSM(); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize paymentService
const restaurantService = new RestaurantServiceFSM(); // => Instance creation via constructor
// => Create new instance
// => Create new instance
// => Initialize restaurantService
 
// Event flow: Order → Payment → Restaurant (event-driven chain)
let event: OrderSagaEvent | null = "OrderPlaced"; // => Variable declaration and assignment
// => Initialize event
 
event = orderService.handleEvent(event);
// => Event handler: main FSM dispatch method
// => [Order] Order placed → Payment
// => Publishes: "OrderPlaced"
 
if (event) {
  // => Event type guard condition
  // => Conditional check
  // => Branch execution based on condition
  event = paymentService.handleEvent(event);
  // => Event handler: main FSM dispatch method
  // => [Payment] Processing payment...
  // => Success: Publishes "PaymentProcessed"
  // => Failure: Publishes "PaymentFailed" → triggers Order compensation
}
 
if (event === "PaymentProcessed") {
  // => Event type guard condition
  // => Event type check
  event = restaurantService.handleEvent(event);
  // => Event handler: main FSM dispatch method
  // => [Restaurant] Preparing food...
  // => Publishes: "FoodPrepared"
} else if (event === "PaymentFailed") {
  orderService.handleEvent(event);
  // => Event handler: main FSM dispatch method
  // => [Order] Payment failed → Cancel order (compensation)
}