Beginner

// Minimal FSM: demonstrates states, events, and transitions
type ProcessState = "Idle" | "Processing" | "Complete" | "Failed"; // => Four explicit states: all possible conditions
type ProcessEvent = "start" | "success" | "error"; // => Three events trigger state changes
 
class SimpleProcess {
  private state: ProcessState = "Idle"; // => Initial state: FSM starts here
 
  handleEvent(event: ProcessEvent): void {
    if (this.state === "Idle" && event === "start") {
      this.state = "Processing"; // => Transition: Idle → Processing on start event
    } else if (this.state === "Processing" && event === "success") {
      this.state = "Complete"; // => Transition: Processing → Complete on success
    } else if (this.state === "Processing" && event === "error") {
      this.state = "Failed"; // => Transition: Processing → Failed on error
    }
    // => Invalid event/state combinations ignored: FSM stays in current state
  }
 
  getState(): ProcessState {
    return this.state; // => Read current FSM state
  }
}
 
const process = new SimpleProcess();
console.log(process.getState()); // => Output: Idle
process.handleEvent("start");
console.log(process.getState()); // => Output: Processing (Idle → Processing)
process.handleEvent("success");
console.log(process.getState()); // => Output: Complete (Processing → Complete)

// Simple On/Off FSM
type State = "Off" | "On"; // => Union type defines exactly 2 valid states
// => TypeScript compiler rejects invalid states at compile-time
 
type Event = "toggle"; // => Single event type triggers state transitions
// => Real systems might have: toggle, auto_off, manual_on, etc.
 
class LightSwitch {
  // => Encapsulates state + transition logic
  // => Class provides state isolation and controlled access
  private state: State = "Off"; // => Initial state: Off (constructor initializes here)
  // => Private field prevents external state corruption
 
  getCurrentState(): State {
    // => Read-only access to current FSM state
    return this.state; // => Returns current state without side effects
    // => Allows state inspection without modification
  }
 
  handleEvent(event: Event): void {
    // => Main event dispatcher: processes events, triggers transitions
    // => void return = state change is side effect, not return value
    if (event === "toggle") {
      // => Event type guard condition
      // => Guards transition: only proceed if event type matches
      // => Pattern matching determines which transition to execute
      this.state = this.state === "Off" ? "On" : "Off"; // => Conditional transition: Off→On or On→Off
      // => Binary state toggle logic
      // => Ternary operator implements bidirectional toggle
      // => No invalid states possible (type safety)
    }
  }
}
 
// Usage
const light = new LightSwitch(); // => Creates FSM instance, initializes to Off state
// => Constructor runs, state field set to "Off"
console.log(light.getCurrentState()); // => Output: Off
// => Verifies FSM initialized correctly
 
light.handleEvent("toggle"); // => Dispatches toggle event: Off → On transition executes
// => FSM state changes from "Off" to "On"
console.log(light.getCurrentState()); // => Output: On
// => State query confirms successful transition
 
light.handleEvent("toggle"); // => Dispatches toggle event again: On → Off transition executes
// => Demonstrates bidirectional toggle behavior
console.log(light.getCurrentState()); // => Output: Off
// => FSM returns to initial state (toggle is reversible)

// Three-state traffic light FSM
type TrafficLightState = "Red" | "Green" | "Yellow"; // => Union type defines exactly 3 valid states
// => Compiler enforces: no "Blue" or "Orange" states possible
 
type TrafficEvent = "timer"; // => Single timer event drives state progression
// => Real traffic lights use hardware timer interrupts
 
class TrafficLight {
  // => FSM implementation for sequential state cycling
  // => State progresses: Red → Green → Yellow → Red (loop)
  private state: TrafficLightState = "Red"; // => Initial state: Red (safe default - cars stop)
  // => Private ensures only handleEvent modifies state
 
  getCurrentState(): TrafficLightState {
    // => State accessor for external observation
    return this.state; // => Returns current state snapshot
    // => Read-only: no state modification possible
  }
 
  handleEvent(event: TrafficEvent): void {
    // => Event dispatcher: routes events to state transitions
    // => Void return: state change is side effect
    if (event === "timer") {
      // => Event type guard condition
      // => Event filter: only process timer events
      // => Guards against invalid event types
      if (this.state === "Red") {
        // => State-based guard condition
        // => Guard: check if currently Red
        // => Pattern: current state determines next state
        this.state = "Green"; // => Transition: Red → Green (cars go)
        // => State change atomic, no intermediate states
      } else if (this.state === "Green") {
        // => Alternative guard: check if Green
        // => Sequential if-else chain implements state-based routing
        this.state = "Yellow"; // => Transition: Green → Yellow (caution, prepare to stop)
      } else if (this.state === "Yellow") {
        // => Final alternative: must be Yellow
        // => Exhaustive pattern: all states covered
        this.state = "Red"; // => Transition: Yellow → Red (cycle completes)
        // => Returns to initial state, enabling continuous loop
      }
    }
  }
}
 
// Usage
const light = new TrafficLight(); // => Creates traffic light FSM, initializes to Red
// => Initial state = safest state (cars stopped)
console.log(light.getCurrentState()); // => Output: Red
// => Confirms FSM started in safe initial state
 
light.handleEvent("timer"); // => First timer tick: Red → Green transition
// => State changes from Red to Green
console.log(light.getCurrentState()); // => Output: Green
// => Verifies first transition executed correctly
 
light.handleEvent("timer"); // => Second timer tick: Green → Yellow transition
// => Warns drivers to prepare to stop
console.log(light.getCurrentState()); // => Output: Yellow
// => Confirms second transition in sequence
 
light.handleEvent("timer"); // => Third timer tick: Yellow → Red transition
// => Completes cycle, returns to initial state
console.log(light.getCurrentState()); // => Output: Red
// => FSM has looped back to start (cyclic FSM)

// Media player FSM with multiple events
type PlayerState = "Idle" | "Running" | "Paused" | "Stopped"; // => Four states
// => Type system ensures only valid states used
type PlayerEvent = "start" | "pause" | "resume" | "stop"; // => Four events
// => Events trigger state transitions
 
class MediaPlayer {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: PlayerState = "Idle"; // => Initial: Idle
  // => FSM begins execution in Idle state
 
  getCurrentState(): PlayerState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: PlayerEvent): void {
    // => Event handler: main FSM dispatch method
    if (this.state === "Idle" && event === "start") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.state = "Running"; // => Idle → Running
    } else if (this.state === "Running" && event === "pause") {
      // => Logical AND: both conditions must be true
      this.state = "Paused"; // => Running → Paused
    } else if (this.state === "Paused" && event === "resume") {
      // => Logical AND: both conditions must be true
      this.state = "Running"; // => Paused → Running
    } else if (this.state === "Running" && event === "stop") {
      // => Logical AND: both conditions must be true
      this.state = "Stopped"; // => Running → Stopped
    } else if (this.state === "Paused" && event === "stop") {
      // => Logical AND: both conditions must be true
      this.state = "Stopped"; // => Paused → Stopped
    }
    // => Invalid event/state combinations ignored (no transition)
  }
}
 
// Usage
const player = new MediaPlayer(); // => state: "Idle"
console.log(player.getCurrentState()); // => Output: Idle
 
player.handleEvent("start"); // => Idle → Running
console.log(player.getCurrentState()); // => Output: Running
 
player.handleEvent("pause"); // => Running → Paused
console.log(player.getCurrentState()); // => Output: Paused
 
player.handleEvent("resume"); // => Paused → Running
console.log(player.getCurrentState()); // => Output: Running
 
player.handleEvent("stop"); // => Running → Stopped
console.log(player.getCurrentState()); // => Output: Stopped
 
player.handleEvent("pause"); // => Invalid: Stopped + pause
console.log(player.getCurrentState()); // => Output: Stopped (no change)

// Door lock FSM with self-transition
type LockState = "Locked" | "Unlocked"; // => Two states
// => Type system ensures only valid states used
type LockEvent = "wrong_code" | "correct_code" | "lock"; // => Three events
// => Events trigger state transitions
 
class DoorLock {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: LockState = "Locked"; // => Initial: Locked
  // => FSM begins execution in Locked state
  private failedAttempts = 0; // => Counter for failed attempts
  // => Initialized alongside FSM state
 
  getCurrentState(): LockState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  getFailedAttempts(): number {
    return this.failedAttempts; // => Returns attempt count
  }
 
  handleEvent(event: LockEvent): void {
    // => Event handler: main FSM dispatch method
    if (this.state === "Locked" && event === "wrong_code") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.failedAttempts += 1; // => Increment counter
      // => State remains "Locked" (self-transition)
      console.log(`Failed attempt ${this.failedAttempts}`); // => Log attempt
      // => Log for observability
    } else if (this.state === "Locked" && event === "correct_code") {
      // => Logical AND: both conditions must be true
      this.state = "Unlocked"; // => Locked → Unlocked
      this.failedAttempts = 0; // => Reset counter
    } else if (this.state === "Unlocked" && event === "lock") {
      // => Logical AND: both conditions must be true
      this.state = "Locked"; // => Unlocked → Locked
    }
  }
}
 
// Usage
const lock = new DoorLock(); // => state: "Locked", attempts: 0
console.log(lock.getCurrentState()); // => Output: Locked
 
lock.handleEvent("wrong_code"); // => Locked → Locked, attempts: 1
console.log(lock.getFailedAttempts()); // => Output: 1
 
lock.handleEvent("wrong_code"); // => Locked → Locked, attempts: 2
console.log(lock.getFailedAttempts()); // => Output: 2
 
lock.handleEvent("correct_code"); // => Locked → Unlocked, attempts: 0
console.log(lock.getCurrentState()); // => Output: Unlocked
 
lock.handleEvent("lock"); // => Unlocked → Locked
console.log(lock.getCurrentState()); // => Output: Locked

// Order approval FSM with multiple outcomes
type OrderState = "Pending" | "Approved" | "Rejected" | "Cancelled"; // => Four states
// => Type system ensures only valid states used
type OrderEvent = "approve" | "reject" | "cancel"; // => Three events
// => Events trigger state transitions
 
class OrderApproval {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: OrderState = "Pending"; // => Initial: Pending
  // => FSM begins execution in Pending state
 
  getCurrentState(): OrderState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: OrderEvent): void {
    // => Event handler: main FSM dispatch method
    if (this.state === "Pending") {
      // => State-based guard condition
      // => Guard condition: check current state is Pending
      // => Only execute if condition true
      // => Only valid in Pending
      if (event === "approve") {
        // => Event type guard condition
        // => Event type check
        this.state = "Approved"; // => Pending → Approved
      } else if (event === "reject") {
        this.state = "Rejected"; // => Pending → Rejected
      } else if (event === "cancel") {
        this.state = "Cancelled"; // => Pending → Cancelled
      }
      // => Three possible outcomes from Pending state
    }
    // => Other states ignore events (terminal states)
  }
}
 
// Usage
const order1 = new OrderApproval(); // => state: "Pending"
order1.handleEvent("approve"); // => Pending → Approved
console.log(order1.getCurrentState()); // => Output: Approved
 
const order2 = new OrderApproval(); // => state: "Pending"
order2.handleEvent("reject"); // => Pending → Rejected
console.log(order2.getCurrentState()); // => Output: Rejected
 
const order3 = new OrderApproval(); // => state: "Pending"
order3.handleEvent("cancel"); // => Pending → Cancelled
console.log(order3.getCurrentState()); // => Output: Cancelled

// Order FSM with strict validation
type OrderState = "Draft" | "Submitted" | "Shipped" | "Delivered"; // => Four states
// => Type system ensures only valid states used
type OrderEvent = "submit" | "ship" | "deliver"; // => Three events
// => Events trigger state transitions
 
class Order {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: OrderState = "Draft"; // => Initial: Draft
  // => FSM begins execution in Draft state
 
  getCurrentState(): OrderState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: OrderEvent): void {
    // => Event handler: main FSM dispatch method
    const validTransitions: Record<OrderState, Partial<Record<OrderEvent, OrderState>>> = {
      // => State variable initialization
      // => Type: transition table structure
      // => Maps (currentState, event) -> nextState
      Draft: { submit: "Submitted" }, // => Draft can only submit
      Submitted: { ship: "Shipped" }, // => Submitted can only ship
      Shipped: { deliver: "Delivered" }, // => Shipped can only deliver
      Delivered: {}, // => Delivered is terminal
    };
 
    const nextState = validTransitions[this.state][event]; // => Look up transition
    // => Declarative transition specification
    if (nextState) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      this.state = nextState; // => Valid: transition
      console.log(`Transitioned to ${nextState}`); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    } else {
      // => Fallback branch
      throw new Error( // => Invalid: throw error
        // => Fail fast on FSM violation
        `Invalid transition: ${event} not allowed in ${this.state} state`,
      );
    }
  }
}
 
// Usage
const order = new Order(); // => state: "Draft"
console.log(order.getCurrentState()); // => Output: Draft
 
order.handleEvent("submit"); // => Draft → Submitted
console.log(order.getCurrentState()); // => Output: Submitted
 
try {
  // => Begin error handling
  // => Begin error handling
  order.handleEvent("deliver"); // => Invalid: deliver from Submitted
} catch (error) {
  // => Catch errors
  // => Catch errors
  console.log(error.message); // => Output: Invalid transition: deliver not allowed in Submitted state
}
 
order.handleEvent("ship"); // => Submitted → Shipped
console.log(order.getCurrentState()); // => Output: Shipped

// Document lifecycle FSM with bi-directional transitions
type DocState = "Editing" | "Published" | "Archived"; // => Three states
// => Type system ensures only valid states used
type DocEvent = "publish" | "unpublish" | "archive" | "restore"; // => Four events
// => Events trigger state transitions
 
class Document {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: DocState = "Editing"; // => Initial: Editing
  // => FSM begins execution in Editing state
 
  getCurrentState(): DocState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: DocEvent): void {
    // => Event handler: main FSM dispatch method
    if (this.state === "Editing" && event === "publish") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.state = "Published"; // => Editing → Published
    } else if (this.state === "Published" && event === "unpublish") {
      // => Logical AND: both conditions must be true
      this.state = "Editing"; // => Published → Editing (reverse)
    } else if (this.state === "Published" && event === "archive") {
      // => Logical AND: both conditions must be true
      this.state = "Archived"; // => Published → Archived
    } else if (this.state === "Archived" && event === "restore") {
      // => Logical AND: both conditions must be true
      this.state = "Published"; // => Archived → Published (reverse)
    }
    // => Bi-directional transitions enable undo/redo patterns
  }
}
 
// Usage
const doc = new Document(); // => state: "Editing"
doc.handleEvent("publish"); // => Editing → Published
console.log(doc.getCurrentState()); // => Output: Published
 
doc.handleEvent("unpublish"); // => Published → Editing (undo)
console.log(doc.getCurrentState()); // => Output: Editing
 
doc.handleEvent("publish"); // => Editing → Published
doc.handleEvent("archive"); // => Published → Archived
console.log(doc.getCurrentState()); // => Output: Archived
 
doc.handleEvent("restore"); // => Archived → Published (undo)
console.log(doc.getCurrentState()); // => Output: Published

// Authentication FSM with event payloads
type AuthState = "LoggedOut" | "LoggedIn" | "Locked"; // => Three states
// => Type system ensures only valid states used
 
interface LoginEvent {
  // => Type declaration defines structure
  type: "login"; // => Event type
  username: string; // => Payload: username
  password: string; // => Payload: password
}
 
interface LogoutEvent {
  // => Type declaration defines structure
  type: "logout"; // => Event type (no payload)
}
 
interface FailedLoginEvent {
  // => Type declaration defines structure
  type: "failed_login"; // => Event type
}
 
type AuthEvent = LoginEvent | LogoutEvent | FailedLoginEvent; // => Union type
// => Events trigger state transitions
 
class AuthSystem {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: AuthState = "LoggedOut"; // => Initial: LoggedOut
  // => FSM begins execution in LoggedOut state
  private currentUser: string | null = null; // => Stores logged-in user
  // => Initialized alongside FSM state
  private failedAttempts = 0; // => Tracks failed logins
  // => Initialized alongside FSM state
 
  getCurrentState(): AuthState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  getCurrentUser(): string | null {
    return this.currentUser; // => Returns username or null
  }
 
  handleEvent(event: AuthEvent): void {
    // => Event handler: main FSM dispatch method
    if (event.type === "login" && this.state === "LoggedOut") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Conditional check
      // => Branch execution based on condition
      if (this.authenticateUser(event.username, event.password)) {
        // => Event type guard condition
        // => Chained method calls or nested operations
        // => Conditional check
        // => Branch execution based on condition
        this.state = "LoggedIn"; // => LoggedOut → LoggedIn
        this.currentUser = event.username; // => Store username from payload
        this.failedAttempts = 0; // => Reset counter
      } else {
        // => Fallback branch
        this.failedAttempts += 1; // => Increment failures
        if (this.failedAttempts >= 3) {
          // => Conditional branch
          // => Conditional check
          // => Branch execution based on condition
          this.state = "Locked"; // => LoggedOut → Locked (3 failures)
        }
      }
    } else if (event.type === "logout" && this.state === "LoggedIn") {
      // => Logical AND: both conditions must be true
      this.state = "LoggedOut"; // => LoggedIn → LoggedOut
      this.currentUser = null; // => Clear user
    }
  }
 
  private authenticateUser(username: string, password: string): boolean {
    // => Extended state (data beyond FSM state)
    return username === "admin" && password === "secret"; // => Mock authentication
  }
}
 
// Usage
const auth = new AuthSystem(); // => state: "LoggedOut", user: null
 
auth.handleEvent({
  // => Event handler: main FSM dispatch method
  // => Login attempt with payload
  type: "login",
  username: "admin",
  password: "secret",
});
console.log(auth.getCurrentState()); // => Output: LoggedIn
console.log(auth.getCurrentUser()); // => Output: admin
 
auth.handleEvent({ type: "logout" }); // => Logout
console.log(auth.getCurrentState()); // => Output: LoggedOut
console.log(auth.getCurrentUser()); // => Output: null

// Session timeout FSM with timed transitions
type SessionState = "Active" | "Idle" | "TimedOut"; // => Three states
// => Type system ensures only valid states used
 
class SessionManager {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: SessionState = "Active"; // => Initial: Active
  // => FSM begins execution in Active state
  private lastActivity: Date = new Date(); // => Track last activity time
  // => Initialized alongside FSM state
 
  getCurrentState(): SessionState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  recordActivity(): void {
    this.lastActivity = new Date(); // => Update activity timestamp
    if (this.state === "Idle") {
      // => State-based guard condition
      // => Guard condition: check current state is Idle
      // => Only execute if condition true
      this.state = "Active"; // => Idle → Active (activity detected)
    }
  }
 
  checkTimeout(): void {
    const now = new Date(); // => Current time
    const inactiveMs = now.getTime() - this.lastActivity.getTime(); // => Milliseconds inactive
    const idleThreshold = 5 * 60 * 1000; // => 5 minutes in ms
    const timeoutThreshold = 30 * 60 * 1000; // => 30 minutes in ms
 
    if (this.state === "Active" && inactiveMs > idleThreshold) {
      // => State-based guard condition
      // => Logical AND: both conditions must be true
      // => Conditional check
      // => Branch execution based on condition
      this.state = "Idle"; // => Active → Idle (5min inactive)
      console.log("Session idle after 5 minutes"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    } else if (this.state === "Idle" && inactiveMs > timeoutThreshold) {
      // => Logical AND: both conditions must be true
      this.state = "TimedOut"; // => Idle → TimedOut (30min inactive)
      console.log("Session timed out after 30 minutes"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
    // => Timed transitions checked by periodic timer
  }
}
 
// Usage (simulated with manual time checks)
const session = new SessionManager(); // => state: "Active"
console.log(session.getCurrentState()); // => Output: Active
 
// Simulate 5 minutes passing
session.checkTimeout(); // => Would check: Active → Idle?
 
session.recordActivity(); // => Reset activity timer
console.log(session.getCurrentState()); // => Output: Active (activity prevents timeout)

// Emergency system FSM with event prioritization
type SystemState = "Normal" | "Warning" | "Critical" | "Emergency"; // => Four states
// => Type system ensures only valid states used
 
interface SystemEvent {
  // => Type declaration defines structure
  type: "minor_issue" | "major_issue" | "critical_failure" | "emergency"; // => Event types
  priority: number; // => Priority: 1 (low) to 4 (high)
}
 
class EmergencySystem {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: SystemState = "Normal"; // => Initial: Normal
  // => FSM begins execution in Normal state
  private eventQueue: SystemEvent[] = []; // => Queue for events
  // => Initialized alongside FSM state
 
  getCurrentState(): SystemState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  enqueueEvent(event: SystemEvent): void {
    this.eventQueue.push(event); // => Add event to queue
    this.eventQueue.sort((a, b) => b.priority - a.priority); // => Sort by priority (high first)
  }
 
  processNextEvent(): void {
    if (this.eventQueue.length === 0) return; // => No events to process
    // => Branch execution based on condition
 
    const event = this.eventQueue.shift()!; // => Get highest priority event
    this.handleEvent(event); // => Process event
  }
 
  private handleEvent(event: SystemEvent): void {
    // => Extended state (data beyond FSM state)
    if (event.type === "minor_issue") {
      // => Event type guard condition
      // => Conditional check
      // => Branch execution based on condition
      if (this.state === "Normal") {
        // => State-based guard condition
        // => Guard condition: check current state is Normal
        // => Only execute if condition true
        this.state = "Warning"; // => Normal → Warning
      }
    } else if (event.type === "major_issue") {
      this.state = "Critical"; // => Any → Critical
    } else if (event.type === "emergency") {
      this.state = "Emergency"; // => Any → Emergency (highest priority)
    }
  }
}
 
// Usage
const system = new EmergencySystem(); // => state: "Normal", queue: []
 
system.enqueueEvent({ type: "minor_issue", priority: 1 }); // => Add low-priority event
system.enqueueEvent({ type: "emergency", priority: 4 }); // => Add high-priority event
system.enqueueEvent({ type: "major_issue", priority: 3 }); // => Add medium-priority event
// => Queue after sorting: [emergency(4), major_issue(3), minor_issue(1)]
 
system.processNextEvent(); // => Process emergency (priority 4)
console.log(system.getCurrentState()); // => Output: Emergency (not Warning or Critical)

// Order processing FSM with event history
type OrderState = "Pending" | "Processing" | "Shipped" | "Delivered"; // => Four states
// => Type system ensures only valid states used
type OrderEvent = "start_processing" | "ship" | "deliver"; // => Three events
// => Events trigger state transitions
 
interface HistoryEntry {
  // => Type declaration defines structure
  timestamp: Date; // => When event occurred
  event: OrderEvent; // => What event happened
  previousState: OrderState; // => State before transition
  newState: OrderState; // => State after transition
}
 
class OrderWithHistory {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: OrderState = "Pending"; // => Initial: Pending
  // => FSM begins execution in Pending state
  private history: HistoryEntry[] = []; // => Event history log
  // => Initialized alongside FSM state
 
  getCurrentState(): OrderState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  getHistory(): HistoryEntry[] {
    return this.history; // => Returns full history
  }
 
  handleEvent(event: OrderEvent): void {
    // => Event handler: main FSM dispatch method
    const previousState = this.state; // => Store state before transition
 
    if (this.state === "Pending" && event === "start_processing") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.state = "Processing"; // => Pending → Processing
    } else if (this.state === "Processing" && event === "ship") {
      // => Logical AND: both conditions must be true
      this.state = "Shipped"; // => Processing → Shipped
    } else if (this.state === "Shipped" && event === "deliver") {
      // => Logical AND: both conditions must be true
      this.state = "Delivered"; // => Shipped → Delivered
    }
 
    if (previousState !== this.state) {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      // => Transition occurred
      this.history.push({
        // => Add to collection
        // => Add to collection
        // => Record in history
        timestamp: new Date(),
        event,
        previousState,
        newState: this.state,
      });
    }
  }
}
 
// Usage
const order = new OrderWithHistory(); // => state: "Pending", history: []
 
order.handleEvent("start_processing"); // => Pending → Processing
order.handleEvent("ship"); // => Processing → Shipped
order.handleEvent("deliver"); // => Shipped → Delivered
 
console.log("Current state:", order.getCurrentState()); // => Output: Delivered
 
order.getHistory().forEach((entry, i) => {
  // => Chained method calls or nested operations
  // => Print history
  console.log(`${i + 1}. ${entry.previousState} → ${entry.newState} (${entry.event})`); // => Output for verification
  // => Chained method calls or nested operations
  // => Debug/audit output
  // => Log for observability
});
// => Output:
// 1. Pending → Processing (start_processing)
// 2. Processing → Shipped (ship)
// 3. Shipped → Delivered (deliver)

// Inventory FSM with stock-based event guards
type InventoryState = "Available" | "LowStock" | "OutOfStock"; // => Three states
// => Type system ensures only valid states used
 
interface PurchaseEvent {
  // => Type declaration defines structure
  type: "purchase"; // => Event type
  quantity: number; // => How many units
}
 
interface RestockEvent {
  // => Type declaration defines structure
  type: "restock"; // => Event type
  quantity: number; // => How many units added
}
 
type InventoryEvent = PurchaseEvent | RestockEvent; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
class Inventory {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: InventoryState = "Available"; // => Initial: Available
  // => FSM begins execution in Available state
  private stock = 100; // => Current stock level
  // => Initialized alongside FSM state
  private lowStockThreshold = 20; // => Threshold for LowStock state
  // => Initialized alongside FSM state
 
  getCurrentState(): InventoryState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  getStock(): number {
    return this.stock; // => Returns stock level
  }
 
  handleEvent(event: InventoryEvent): void {
    // => Event handler: main FSM dispatch method
    if (event.type === "purchase") {
      // => Event type guard condition
      // => Conditional check
      // => Branch execution based on condition
      if (this.stock >= event.quantity) {
        // => Event type guard condition
        // => Conditional check
        // => Branch execution based on condition
        // => Guard: sufficient stock?
        this.stock -= event.quantity; // => Deduct stock
        this.updateState(); // => Check state transition
      } else {
        // => Fallback branch
        throw new Error(`Insufficient stock. Available: ${this.stock}, Requested: ${event.quantity}`);
        // => Constructor creates new object instance
        // => Reject invalid operation
        // => Fail fast on FSM violation
      }
    } else if (event.type === "restock") {
      this.stock += event.quantity; // => Add stock
      this.updateState(); // => Check state transition
    }
  }
 
  private updateState(): void {
    // => Extended state (data beyond FSM state)
    if (this.stock === 0) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      this.state = "OutOfStock"; // => → OutOfStock (guard: stock == 0)
    } else if (this.stock <= this.lowStockThreshold) {
      this.state = "LowStock"; // => → LowStock (guard: stock <= 20)
    } else {
      // => Fallback branch
      this.state = "Available"; // => → Available (guard: stock > 20)
    }
    // => State determined by stock level guards
  }
}
 
// Usage
const inventory = new Inventory(); // => state: "Available", stock: 100
 
inventory.handleEvent({ type: "purchase", quantity: 85 }); // => stock: 15
console.log(inventory.getCurrentState()); // => Output: LowStock (15 <= 20)
 
inventory.handleEvent({ type: "purchase", quantity: 15 }); // => stock: 0
console.log(inventory.getCurrentState()); // => Output: OutOfStock (0 == 0)
 
try {
  // => Begin error handling
  // => Begin error handling
  inventory.handleEvent({ type: "purchase", quantity: 1 }); // => Guard fails (stock < quantity)
} catch (error) {
  // => Catch errors
  // => Catch errors
  console.log(error.message); // => Output: Insufficient stock. Available: 0, Requested: 1
}
 
inventory.handleEvent({ type: "restock", quantity: 50 }); // => stock: 50
console.log(inventory.getCurrentState()); // => Output: Available (50 > 20)

// Document approval FSM with role-based guards
type DocApprovalState = "Draft" | "Review" | "Approved" | "Published"; // => Four states
// => Type system ensures only valid states used
type UserRole = "Author" | "Reviewer" | "Publisher"; // => Three roles
 
interface SubmitEvent {
  // => Type declaration defines structure
  type: "submit"; // => Event type
  user: UserRole; // => Who triggered event
}
 
interface ApproveEvent {
  // => Type declaration defines structure
  type: "approve"; // => Event type
  user: UserRole; // => Who triggered event
}
 
interface PublishEvent {
  // => Type declaration defines structure
  type: "publish"; // => Event type
  user: UserRole; // => Who triggered event
}
 
type DocEvent = SubmitEvent | ApproveEvent | PublishEvent; // => Type declaration defines structure
// => Defines event alphabet for FSM
// => Events trigger state transitions
 
class DocumentApproval {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: DocApprovalState = "Draft"; // => Initial: Draft
  // => FSM begins execution in Draft state
 
  getCurrentState(): DocApprovalState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: DocEvent): void {
    // => Event handler: main FSM dispatch method
    if (event.type === "submit" && this.state === "Draft") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Conditional check
      // => Branch execution based on condition
      if (event.user === "Author") {
        // => Event type guard condition
        // => Conditional check
        // => Branch execution based on condition
        // => Guard: only Author can submit
        this.state = "Review"; // => Draft → Review
      } else {
        // => Fallback branch
        throw new Error("Only Authors can submit drafts");
        // => Reject invalid operation
        // => Fail fast on FSM violation
      }
    } else if (event.type === "approve" && this.state === "Review") {
      // => Logical AND: both conditions must be true
      if (event.user === "Reviewer") {
        // => Event type guard condition
        // => Conditional check
        // => Branch execution based on condition
        // => Guard: only Reviewer can approve
        this.state = "Approved"; // => Review → Approved
      } else {
        // => Fallback branch
        throw new Error("Only Reviewers can approve documents");
        // => Reject invalid operation
        // => Fail fast on FSM violation
      }
    } else if (event.type === "publish" && this.state === "Approved") {
      // => Logical AND: both conditions must be true
      if (event.user === "Publisher") {
        // => Event type guard condition
        // => Conditional check
        // => Branch execution based on condition
        // => Guard: only Publisher can publish
        this.state = "Published"; // => Approved → Published
      } else {
        // => Fallback branch
        throw new Error("Only Publishers can publish documents");
        // => Reject invalid operation
        // => Fail fast on FSM violation
      }
    }
  }
}
 
// Usage
const doc = new DocumentApproval(); // => state: "Draft"
 
doc.handleEvent({ type: "submit", user: "Author" }); // => Draft → Review (guard passes)
console.log(doc.getCurrentState()); // => Output: Review
 
try {
  // => Begin error handling
  // => Begin error handling
  doc.handleEvent({ type: "approve", user: "Author" }); // => Guard fails (not Reviewer)
} catch (error) {
  // => Catch errors
  // => Catch errors
  console.log(error.message); // => Output: Only Reviewers can approve documents
}
 
doc.handleEvent({ type: "approve", user: "Reviewer" }); // => Review → Approved (guard passes)
console.log(doc.getCurrentState()); // => Output: Approved

// Trading system FSM with time-based guards
type TradingState = "MarketClosed" | "PreMarket" | "MarketOpen" | "AfterHours"; // => Four states
// => Type system ensures only valid states used
 
class TradingSystem {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: TradingState = "MarketClosed"; // => Initial: MarketClosed
  // => FSM begins execution in MarketClosed state
 
  getCurrentState(): TradingState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  updateState(): void {
    const now = new Date(); // => Current time
    const hour = now.getHours(); // => Current hour (0-23)
    const day = now.getDay(); // => Day of week (0=Sunday, 6=Saturday)
 
    const isWeekday = day >= 1 && day <= 5; // => Guard: Monday-Friday
    const isPreMarketHour = hour >= 4 && hour < 9; // => Guard: 4am-9am
    const isMarketHour = hour >= 9 && hour < 16; // => Guard: 9am-4pm
    const isAfterHoursTime = hour >= 16 && hour < 20; // => Guard: 4pm-8pm
 
    if (!isWeekday) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      this.state = "MarketClosed"; // => Weekend → MarketClosed
    } else if (isPreMarketHour) {
      this.state = "PreMarket"; // => Weekday 4am-9am → PreMarket
    } else if (isMarketHour) {
      this.state = "MarketOpen"; // => Weekday 9am-4pm → MarketOpen
    } else if (isAfterHoursTime) {
      this.state = "AfterHours"; // => Weekday 4pm-8pm → AfterHours
    } else {
      // => Fallback branch
      this.state = "MarketClosed"; // => Other times → MarketClosed
    }
    // => Time-based guards determine state
  }
 
  canPlaceTrade(): boolean {
    return this.state === "MarketOpen" || this.state === "AfterHours"; // => Guard: trading allowed?
  }
}
 
// Usage
const trading = new TradingSystem(); // => state: "MarketClosed"
trading.updateState(); // => Check current time, update state
 
console.log(trading.getCurrentState()); // => Output: depends on current time
console.log(trading.canPlaceTrade()); // => Output: true if MarketOpen/AfterHours

// Job scheduler FSM with resource guards
type JobState = "Queued" | "Running" | "Completed" | "Failed"; // => Four states
// => Type system ensures only valid states used
 
interface Job {
  // => Type declaration defines structure
  id: string; // => Job identifier
  memoryRequired: number; // => Memory in MB
}
 
class JobScheduler {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: JobState = "Queued"; // => Initial: Queued
  // => FSM begins execution in Queued state
  private availableMemory = 1024; // => 1GB available
  // => Initialized alongside FSM state
  private currentJob: Job | null = null; // => Currently running job
  // => Initialized alongside FSM state
 
  getCurrentState(): JobState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  startJob(job: Job): void {
    if (this.state !== "Queued") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      throw new Error("Can only start jobs in Queued state");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    if (job.memoryRequired > this.availableMemory) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      // => Guard: sufficient memory?
      this.state = "Failed"; // => Queued → Failed (insufficient resources)
      throw new Error(`Insufficient memory. Required: ${job.memoryRequired}MB, Available: ${this.availableMemory}MB`);
      // => Constructor creates new object instance
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    this.availableMemory -= job.memoryRequired; // => Allocate memory
    this.currentJob = job; // => Assign job
    this.state = "Running"; // => Queued → Running (guard passed)
    console.log(`Job ${job.id} started, ${this.availableMemory}MB remaining`); // => Output for verification
    // => Debug/audit output
    // => Log for observability
  }
 
  completeJob(): void {
    if (this.state !== "Running") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      throw new Error("No job running");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    this.availableMemory += this.currentJob!.memoryRequired; // => Release memory
    this.state = "Completed"; // => Running → Completed
    console.log(`Job ${this.currentJob!.id} completed, ${this.availableMemory}MB available`); // => Output for verification
    // => Debug/audit output
    // => Log for observability
  }
}
 
// Usage
const scheduler = new JobScheduler(); // => state: "Queued", memory: 1024MB
 
scheduler.startJob({ id: "job1", memoryRequired: 512 }); // => Queued → Running (512MB allocated)
console.log(scheduler.getCurrentState()); // => Output: Running
 
scheduler.completeJob(); // => Running → Completed (512MB released)
console.log(scheduler.getCurrentState()); // => Output: Completed
 
const scheduler2 = new JobScheduler(); // => New scheduler
try {
  // => Begin error handling
  // => Begin error handling
  scheduler2.startJob({ id: "job2", memoryRequired: 2048 }); // => Guard fails (2048MB > 1024MB)
} catch (error) {
  // => Catch errors
  // => Catch errors
  console.log(error.message); // => Output: Insufficient memory. Required: 2048MB, Available: 1024MB
  console.log(scheduler2.getCurrentState()); // => Output: Failed
}

// Payment processing FSM with validation guards
type PaymentState = "Pending" | "Validated" | "Processed" | "Rejected"; // => Four states
// => Type system ensures only valid states used
 
interface PaymentData {
  // => Type declaration defines structure
  amount: number; // => Payment amount
  cardNumber: string; // => Card number
  cvv: string; // => CVV code
}
 
class PaymentProcessor {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: PaymentState = "Pending"; // => Initial: Pending
  // => FSM begins execution in Pending state
  private paymentData: PaymentData | null = null; // => Payment details
  // => Initialized alongside FSM state
 
  getCurrentState(): PaymentState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  validatePayment(data: PaymentData): void {
    if (this.state !== "Pending") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      throw new Error("Can only validate Pending payments");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    this.paymentData = data; // => Store payment data
 
    // Guard: amount validation
    if (data.amount <= 0) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      // => Guard: positive amount?
      this.state = "Rejected"; // => Pending → Rejected (invalid amount)
      throw new Error("Amount must be positive");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    // Guard: card number validation (simple check)
    if (data.cardNumber.length !== 16) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      // => Guard: 16-digit card?
      this.state = "Rejected"; // => Pending → Rejected (invalid card)
      throw new Error("Invalid card number length");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    // Guard: CVV validation
    if (data.cvv.length !== 3 && data.cvv.length !== 4) {
      // => Conditional branch
      // => Logical AND: both conditions must be true
      // => Conditional check
      // => Branch execution based on condition
      // => Guard: valid CVV?
      this.state = "Rejected"; // => Pending → Rejected (invalid CVV)
      throw new Error("Invalid CVV length");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    this.state = "Validated"; // => Pending → Validated (all guards passed)
    console.log("Payment validated successfully"); // => Output for verification
    // => Debug/audit output
    // => Log for observability
  }
 
  processPayment(): void {
    if (this.state !== "Validated") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      throw new Error("Can only process Validated payments");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    this.state = "Processed"; // => Validated → Processed
    console.log(`Processed payment of $${this.paymentData!.amount}`); // => Output for verification
    // => Debug/audit output
    // => Log for observability
  }
}
 
// Usage
const payment1 = new PaymentProcessor(); // => state: "Pending"
payment1.validatePayment({
  // => All guards pass
  amount: 99.99,
  cardNumber: "1234567890123456",
  cvv: "123",
});
console.log(payment1.getCurrentState()); // => Output: Validated
payment1.processPayment(); // => Validated → Processed
console.log(payment1.getCurrentState()); // => Output: Processed
 
const payment2 = new PaymentProcessor(); // => state: "Pending"
try {
  // => Begin error handling
  // => Begin error handling
  payment2.validatePayment({
    // => Guard fails (invalid amount)
    amount: -10,
    cardNumber: "1234567890123456",
    cvv: "123",
  });
} catch (error) {
  // => Catch errors
  // => Catch errors
  console.log(error.message); // => Output: Amount must be positive
  console.log(payment2.getCurrentState()); // => Output: Rejected
}

// Loan approval FSM with composite guards
type LoanState = "Application" | "UnderReview" | "Approved" | "Rejected"; // => Four states
// => Type system ensures only valid states used
 
interface ApplicantData {
  // => Type declaration defines structure
  creditScore: number; // => Credit score (300-850)
  income: number; // => Annual income
  loanAmount: number; // => Requested loan amount
  hasCollateral: boolean; // => Has collateral?
}
 
class LoanApproval {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: LoanState = "Application"; // => Initial: Application
  // => FSM begins execution in Application state
  private applicantData: ApplicantData | null = null; // => Applicant data
  // => Initialized alongside FSM state
 
  getCurrentState(): LoanState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  submitApplication(data: ApplicantData): void {
    if (this.state !== "Application") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      throw new Error("Invalid state for submission");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    this.applicantData = data; // => Store applicant data
    this.state = "UnderReview"; // => Application → UnderReview
  }
 
  reviewApplication(): void {
    if (this.state !== "UnderReview" || !this.applicantData) {
      // => State-based guard condition
      // => Logical OR: either condition can be true
      // => Conditional check
      // => Branch execution based on condition
      throw new Error("Invalid state for review");
      // => Reject invalid operation
      // => Fail fast on FSM violation
    }
 
    const data = this.applicantData; // => Get applicant data
 
    // Composite guard using AND/OR logic
    const hasGoodCredit = data.creditScore >= 700; // => Guard: credit >= 700
    const hasStableIncome = data.income >= 50000; // => Guard: income >= \$50k
    const reasonableDebtRatio = data.loanAmount / data.income <= 3; // => Guard: loan <= 3x income
 
    // Approval logic:
    // (Good credit AND stable income AND reasonable debt ratio) OR has collateral
    const approved = (hasGoodCredit && hasStableIncome && reasonableDebtRatio) || data.hasCollateral; // => Variable declaration and assignment
    // => Logical AND: both conditions must be true
    // => Initialize approved
    // => Composite guard: (A AND B AND C) OR D
 
    if (approved) {
      // => Conditional branch
      // => Conditional check
      // => Branch execution based on condition
      this.state = "Approved"; // => UnderReview → Approved
      console.log("Loan approved"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    } else {
      // => Fallback branch
      this.state = "Rejected"; // => UnderReview → Rejected
      console.log("Loan rejected"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
    }
  }
}
 
// Usage
const loan1 = new LoanApproval(); // => state: "Application"
loan1.submitApplication({
  // => All AND guards pass
  creditScore: 750,
  income: 80000,
  loanAmount: 150000,
  hasCollateral: false,
});
loan1.reviewApplication(); // => UnderReview → Approved
console.log(loan1.getCurrentState()); // => Output: Approved
 
const loan2 = new LoanApproval(); // => state: "Application"
loan2.submitApplication({
  // => AND guards fail, but OR passes
  creditScore: 600,
  income: 40000,
  loanAmount: 200000,
  hasCollateral: true, // => Collateral enables approval
});
loan2.reviewApplication(); // => UnderReview → Approved (via collateral)
console.log(loan2.getCurrentState()); // => Output: Approved
 
const loan3 = new LoanApproval(); // => state: "Application"
loan3.submitApplication({
  // => Both AND and OR fail
  creditScore: 600,
  income: 40000,
  loanAmount: 200000,
  hasCollateral: false,
});
loan3.reviewApplication(); // => UnderReview → Rejected
console.log(loan3.getCurrentState()); // => Output: Rejected

// Game character FSM with entry actions
type CharacterState = "Idle" | "Walking" | "Running" | "Jumping"; // => Four states
// => Type system ensures only valid states used
type CharacterEvent = "walk" | "run" | "jump" | "land" | "stop"; // => Five events
// => Events trigger state transitions
 
class GameCharacter {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: CharacterState = "Idle"; // => Initial: Idle
  // => FSM begins execution in Idle state
 
  getCurrentState(): CharacterState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: CharacterEvent): void {
    // => Event handler: main FSM dispatch method
    const previousState = this.state; // => Store previous state
 
    // Transition logic
    if (this.state === "Idle" && event === "walk") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.state = "Walking"; // => Idle → Walking
    } else if (this.state === "Idle" && event === "run") {
      // => Logical AND: both conditions must be true
      this.state = "Running"; // => Idle → Running
    } else if (this.state === "Walking" && event === "run") {
      // => Logical AND: both conditions must be true
      this.state = "Running"; // => Walking → Running
    } else if (this.state === "Running" && event === "jump") {
      // => Logical AND: both conditions must be true
      this.state = "Jumping"; // => Running → Jumping
    } else if (this.state === "Jumping" && event === "land") {
      // => Logical AND: both conditions must be true
      this.state = "Idle"; // => Jumping → Idle
    } else if (event === "stop") {
      this.state = "Idle"; // => Any → Idle (stop button)
    }
 
    // Entry actions (execute when entering new state)
    if (this.state !== previousState) {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      // => State changed?
      this.onEnter(this.state); // => Execute entry action
    }
  }
 
  private onEnter(state: CharacterState): void {
    // => Extended state (data beyond FSM state)
    if (state === "Walking") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("▶ Entry action: Start walking animation"); // => Entry action for Walking
      // => Log for observability
      this.setAnimationSpeed(1.0); // => Normal speed
    } else if (state === "Running") {
      console.log("▶ Entry action: Start running animation"); // => Entry action for Running
      // => Log for observability
      this.setAnimationSpeed(2.0); // => Double speed
    } else if (state === "Jumping") {
      console.log("▶ Entry action: Play jump sound"); // => Entry action for Jumping
      // => Log for observability
      this.playSound("jump.wav"); // => Trigger sound effect
    } else if (state === "Idle") {
      console.log("▶ Entry action: Start idle animation"); // => Entry action for Idle
      // => Log for observability
      this.setAnimationSpeed(0.5); // => Slow idle breathing
    }
    // => Entry actions run regardless of which transition brought us here
  }
 
  private setAnimationSpeed(speed: number): void {
    // => Extended state (data beyond FSM state)
    console.log(`  Set animation speed: ${speed}x`); // => Mock animation API
    // => Log for observability
  }
 
  private playSound(file: string): void {
    // => Extended state (data beyond FSM state)
    console.log(`  Play sound: ${file}`); // => Mock audio API
    // => Log for observability
  }
}
 
// Usage
const character = new GameCharacter(); // => state: "Idle"
 
character.handleEvent("walk"); // => Idle → Walking
// => Output:
// ▶ Entry action: Start walking animation
//   Set animation speed: 1.0x
 
character.handleEvent("run"); // => Walking → Running
// => Output:
// ▶ Entry action: Start running animation
//   Set animation speed: 2.0x
 
character.handleEvent("jump"); // => Running → Jumping
// => Output:
// ▶ Entry action: Play jump sound
//   Play sound: jump.wav
 
character.handleEvent("land"); // => Jumping → Idle
// => Output:
// ▶ Entry action: Start idle animation
//   Set animation speed: 0.5x

// Database connection FSM with exit actions
type ConnectionState = "Disconnected" | "Connecting" | "Connected" | "Error"; // => Four states
// => Type system ensures only valid states used
type ConnectionEvent = "connect" | "connection_success" | "connection_failed" | "disconnect"; // => Four events
// => Events trigger state transitions
 
class DatabaseConnection {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: ConnectionState = "Disconnected"; // => Initial: Disconnected
  // => FSM begins execution in Disconnected state
  private connectionHandle: string | null = null; // => Mock connection handle
  // => Initialized alongside FSM state
 
  getCurrentState(): ConnectionState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: ConnectionEvent): void {
    // => Event handler: main FSM dispatch method
    const previousState = this.state; // => Store previous state
 
    // Transition logic
    if (this.state === "Disconnected" && event === "connect") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.state = "Connecting"; // => Disconnected → Connecting
    } else if (this.state === "Connecting" && event === "connection_success") {
      // => Logical AND: both conditions must be true
      this.state = "Connected"; // => Connecting → Connected
    } else if (this.state === "Connecting" && event === "connection_failed") {
      // => Logical AND: both conditions must be true
      this.state = "Error"; // => Connecting → Error
    } else if (this.state === "Connected" && event === "disconnect") {
      // => Logical AND: both conditions must be true
      this.state = "Disconnected"; // => Connected → Disconnected
    }
 
    // Exit actions (execute when leaving state)
    if (this.state !== previousState) {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      // => State changed?
      this.onExit(previousState); // => Execute exit action
      this.onEnter(this.state); // => Then entry action
    }
  }
 
  private onExit(state: ConnectionState): void {
    // => Extended state (data beyond FSM state)
    if (state === "Connected") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("◀ Exit action: Close database connection"); // => Exit action for Connected
      // => Log for observability
      this.closeConnection(); // => Cleanup resources
    } else if (state === "Connecting") {
      console.log("◀ Exit action: Cancel connection attempt"); // => Exit action for Connecting
      // => Log for observability
      this.cancelConnection(); // => Abort in-progress connection
    }
    // => Exit actions run regardless of which transition takes us out
  }
 
  private onEnter(state: ConnectionState): void {
    // => Extended state (data beyond FSM state)
    if (state === "Connecting") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("▶ Entry action: Open connection"); // => Entry action for Connecting
      // => Log for observability
      this.connectionHandle = "conn-" + Date.now(); // => Mock connection handle
    } else if (state === "Connected") {
      console.log("▶ Entry action: Connection established"); // => Entry action for Connected
      // => Log for observability
    }
  }
 
  private closeConnection(): void {
    // => Extended state (data beyond FSM state)
    console.log(`  Closing connection: ${this.connectionHandle}`); // => Mock close
    // => Log for observability
    this.connectionHandle = null; // => Release handle
  }
 
  private cancelConnection(): void {
    // => Extended state (data beyond FSM state)
    console.log(`  Cancelling connection: ${this.connectionHandle}`); // => Mock cancel
    // => Log for observability
    this.connectionHandle = null; // => Release handle
  }
}
 
// Usage
const db = new DatabaseConnection(); // => state: "Disconnected"
 
db.handleEvent("connect"); // => Disconnected → Connecting
// => Output:
// ▶ Entry action: Open connection
//   Opening connection: conn-1234567890
 
db.handleEvent("connection_success"); // => Connecting → Connected
// => Output:
// ◀ Exit action: Cancel connection attempt (even though success)
//   Cancelling connection: conn-1234567890
// ▶ Entry action: Connection established
 
db.handleEvent("disconnect"); // => Connected → Disconnected
// => Output:
// ◀ Exit action: Close database connection
//   Closing connection: conn-1234567890

// HTTP request FSM with entry/exit actions
type RequestState = "Idle" | "Pending" | "Success" | "Failed"; // => Four states
// => Type system ensures only valid states used
type RequestEvent = "send" | "response_ok" | "response_error" | "timeout"; // => Four events
// => Events trigger state transitions
 
class HttpRequest {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: RequestState = "Idle"; // => Initial: Idle
  // => FSM begins execution in Idle state
  private timeoutHandle: NodeJS.Timeout | null = null; // => Timeout timer
  // => Initialized alongside FSM state
  private requestStartTime: Date | null = null; // => Track request timing
  // => Initialized alongside FSM state
 
  getCurrentState(): RequestState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: RequestEvent): void {
    // => Event handler: main FSM dispatch method
    const previousState = this.state; // => Store previous state
 
    // Transition logic
    if (this.state === "Idle" && event === "send") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.state = "Pending"; // => Idle → Pending
    } else if (this.state === "Pending" && event === "response_ok") {
      // => Logical AND: both conditions must be true
      this.state = "Success"; // => Pending → Success
    } else if (this.state === "Pending" && event === "response_error") {
      // => Logical AND: both conditions must be true
      this.state = "Failed"; // => Pending → Failed
    } else if (this.state === "Pending" && event === "timeout") {
      // => Logical AND: both conditions must be true
      this.state = "Failed"; // => Pending → Failed (timeout)
    }
 
    // Execute exit then entry actions
    if (this.state !== previousState) {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      this.onExit(previousState); // => Exit action first
      this.onEnter(this.state); // => Entry action second
    }
  }
 
  private onEnter(state: RequestState): void {
    // => Extended state (data beyond FSM state)
    if (state === "Pending") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("▶ Entry: Start request timer"); // => Entry action for Pending
      // => Log for observability
      this.requestStartTime = new Date(); // => Record start time
      this.timeoutHandle = setTimeout(() => {
        // => Chained method calls or nested operations
        // => Start timeout timer
        this.handleEvent("timeout");
        // => Event handler: main FSM dispatch method
      }, 5000);
    } else if (state === "Success") {
      const duration = Date.now() - this.requestStartTime!.getTime(); // => Calculate duration
      console.log(`▶ Entry: Request succeeded (${duration}ms)`); // => Entry action for Success
      // => Log for observability
    } else if (state === "Failed") {
      console.log("▶ Entry: Request failed"); // => Entry action for Failed
      // => Log for observability
    }
  }
 
  private onExit(state: RequestState): void {
    // => Extended state (data beyond FSM state)
    if (state === "Pending") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("◀ Exit: Clear request timer"); // => Exit action for Pending
      // => Log for observability
      if (this.timeoutHandle) {
        // => Conditional check
        // => Branch execution based on condition
        clearTimeout(this.timeoutHandle); // => Cancel timeout timer
        this.timeoutHandle = null; // => Clear handle
      }
    }
    // => Exit action ensures timer cleanup regardless of outcome
  }
}
 
// Usage (simulated)
const request = new HttpRequest(); // => state: "Idle"
 
request.handleEvent("send"); // => Idle → Pending
// => Output:
// ▶ Entry: Start request timer
 
// Simulate successful response
request.handleEvent("response_ok"); // => Pending → Success
// => Output:
// ◀ Exit: Clear request timer
// ▶ Entry: Request succeeded (150ms)

// Authentication FSM comparing entry/exit vs transition actions
type AuthState = "LoggedOut" | "LoggingIn" | "LoggedIn"; // => Three states
// => Type system ensures only valid states used
type AuthEvent = "login" | "login_success" | "logout"; // => Three events
// => Events trigger state transitions
 
class AuthWithActions {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: AuthState = "LoggedOut"; // => Initial: LoggedOut
  // => FSM begins execution in LoggedOut state
 
  getCurrentState(): AuthState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: AuthEvent): void {
    // => Event handler: main FSM dispatch method
    const previousState = this.state; // => Store previous state
 
    // Transition logic with transition-specific actions
    if (this.state === "LoggedOut" && event === "login") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.onTransition_LoggedOut_to_LoggingIn(); // => Transition action (specific)
      this.state = "LoggingIn"; // => Change state
    } else if (this.state === "LoggingIn" && event === "login_success") {
      // => Logical AND: both conditions must be true
      this.state = "LoggedIn"; // => Change state
    } else if (this.state === "LoggedIn" && event === "logout") {
      // => Logical AND: both conditions must be true
      this.state = "LoggedOut"; // => Change state
    }
 
    // Execute exit/entry actions (run for ANY transition)
    if (this.state !== previousState) {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      this.onExit(previousState); // => Exit action (generic)
      this.onEnter(this.state); // => Entry action (generic)
    }
  }
 
  // ENTRY ACTIONS (run for ANY transition INTO this state)
  private onEnter(state: AuthState): void {
    // => Extended state (data beyond FSM state)
    if (state === "LoggingIn") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("▶ Entry: Show loading spinner"); // => Runs for ANY transition into LoggingIn
      // => Log for observability
    } else if (state === "LoggedIn") {
      console.log("▶ Entry: Load user dashboard"); // => Runs for ANY transition into LoggedIn
      // => Log for observability
    }
  }
 
  // EXIT ACTIONS (run for ANY transition OUT OF this state)
  private onExit(state: AuthState): void {
    // => Extended state (data beyond FSM state)
    if (state === "LoggingIn") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("◀ Exit: Hide loading spinner"); // => Runs for ANY transition out of LoggingIn
      // => Log for observability
    }
  }
 
  // TRANSITION ACTIONS (run for SPECIFIC transition only)
  private onTransition_LoggedOut_to_LoggingIn(): void {
    // => Extended state (data beyond FSM state)
    console.log("→ Transition: Validate credentials"); // => Only for LoggedOut → LoggingIn
    // => Log for observability
    console.log("→ Transition: Send API request"); // => Specific to this transition
    // => Log for observability
  }
}
 
// Usage
const auth = new AuthWithActions(); // => state: "LoggedOut"
 
auth.handleEvent("login"); // => LoggedOut → LoggingIn
// => Output:
// → Transition: Validate credentials (transition action)
// → Transition: Send API request (transition action)
// ▶ Entry: Show loading spinner (entry action)
 
auth.handleEvent("login_success"); // => LoggingIn → LoggedIn
// => Output:
// ◀ Exit: Hide loading spinner (exit action)
// ▶ Entry: Load user dashboard (entry action)

// Video streaming FSM with nested entry/exit actions
type VideoState = "Stopped" | "Buffering" | "Playing" | "Paused"; // => Four states
// => Type system ensures only valid states used
type VideoEvent = "play" | "buffer_complete" | "pause" | "stop"; // => Four events
// => Events trigger state transitions
 
class VideoPlayer {
  // => State machine implementation class
  // => Encapsulates state + transition logic
  private state: VideoState = "Stopped"; // => Initial: Stopped
  // => FSM begins execution in Stopped state
  private bufferLevel = 0; // => Buffer percentage
  // => Initialized alongside FSM state
 
  getCurrentState(): VideoState {
    // => Query method: read current FSM state
    return this.state; // => Returns state
  }
 
  handleEvent(event: VideoEvent): void {
    // => Event handler: main FSM dispatch method
    const previousState = this.state; // => Store previous state
 
    // Transition logic
    if (event === "play" && this.state === "Stopped") {
      // => Event type guard condition
      // => Logical AND: both conditions must be true
      // => Event type check
      // => Combined (state, event) guard
      this.state = "Buffering"; // => Stopped → Buffering
    } else if (event === "buffer_complete" && this.state === "Buffering") {
      // => Logical AND: both conditions must be true
      this.state = "Playing"; // => Buffering → Playing
    } else if (event === "pause" && this.state === "Playing") {
      // => Logical AND: both conditions must be true
      this.state = "Paused"; // => Playing → Paused
    } else if (event === "play" && this.state === "Paused") {
      // => Logical AND: both conditions must be true
      this.state = "Playing"; // => Paused → Playing
    } else if (event === "stop") {
      this.state = "Stopped"; // => Any → Stopped
    }
 
    // Execute lifecycle actions
    if (this.state !== previousState) {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      this.onExit(previousState); // => Exit previous state
      this.onEnter(this.state); // => Enter new state
    }
  }
 
  private onEnter(state: VideoState): void {
    // => Extended state (data beyond FSM state)
    if (state === "Buffering") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("▶ Entry: Start buffering"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      this.startBuffering(); // => Nested call: start buffer
      this.showBufferingIndicator(); // => Nested call: show UI
    } else if (state === "Playing") {
      console.log("▶ Entry: Start playback"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      this.resumePlayback(); // => Nested call: play video
      this.hideBufferingIndicator(); // => Nested call: hide UI
      this.trackAnalytics("play"); // => Nested call: analytics
    } else if (state === "Paused") {
      console.log("▶ Entry: Pause playback"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      this.pausePlayback(); // => Nested call: pause
    } else if (state === "Stopped") {
      console.log("▶ Entry: Stop playback"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      this.stopPlayback(); // => Nested call: stop
      this.clearBuffer(); // => Nested call: cleanup buffer
    }
  }
 
  private onExit(state: VideoState): void {
    // => Extended state (data beyond FSM state)
    if (state === "Buffering") {
      // => State-based guard condition
      // => Conditional check
      // => Branch execution based on condition
      console.log("◀ Exit: Buffering complete"); // => Output for verification
      // => Debug/audit output
      // => Log for observability
      this.trackAnalytics("buffer_complete"); // => Nested call: analytics
    }
  }
 
  // Nested helper methods called by entry/exit actions
  private startBuffering(): void {
    // => Extended state (data beyond FSM state)
    console.log("  → Downloading video data"); // => Nested action
    // => Log for observability
    this.bufferLevel = 50; // => Mock buffer
  }
 
  private showBufferingIndicator(): void {
    // => Extended state (data beyond FSM state)
    console.log("  → Display buffering spinner"); // => Nested action
    // => Log for observability
  }
 
  private hideBufferingIndicator(): void {
    // => Extended state (data beyond FSM state)
    console.log("  → Hide buffering spinner"); // => Nested action
    // => Log for observability
  }
 
  private resumePlayback(): void {
    // => Extended state (data beyond FSM state)
    console.log("  → Resume video playback"); // => Nested action
    // => Log for observability
  }
 
  private pausePlayback(): void {
    // => Extended state (data beyond FSM state)
    console.log("  → Pause video"); // => Nested action
    // => Log for observability
  }
 
  private stopPlayback(): void {
    // => Extended state (data beyond FSM state)
    console.log("  → Stop video"); // => Nested action
    // => Log for observability
  }
 
  private clearBuffer(): void {
    // => Extended state (data beyond FSM state)
    console.log("  → Clear buffer memory"); // => Nested action
    // => Log for observability
    this.bufferLevel = 0;
  }
 
  private trackAnalytics(event: string): void {
    // => Extended state (data beyond FSM state)
    console.log(`  → Track analytics: ${event}`); // => Nested action
    // => Log for observability
  }
}
 
// Usage
const video = new VideoPlayer(); // => state: "Stopped"
 
video.handleEvent("play"); // => Stopped → Buffering
// => Output:
// ▶ Entry: Start buffering
//   → Downloading video data
//   → Display buffering spinner
 
video.handleEvent("buffer_complete"); // => Buffering → Playing
// => Output:
// ◀ Exit: Buffering complete
//   → Track analytics: buffer_complete
// ▶ Entry: Start playback
//   → Resume video playback
//   → Hide buffering spinner
//   → Track analytics: play