ATM
 ├── state: ATMState (Idle, CardInserted, Authenticated, SelectingOp, Dispensing, ...)
 ├── currentCard, currentAccount
 ├── cashDispenser: CashDispenser
 └── bank: BankService

Card
 ├── number, expiry, holderName
 └── isValid(): boolean

BankAccount
 ├── id, holderId, balance
 ├── dailyWithdrawn (with reset at midnight)
 ├── withdraw(amount), deposit(amount), getBalance()
 └── transactions: Transaction[]

Transaction
 ├── id, accountId, type, amount, status, ts
 └── status: PENDING | SUCCESS | FAILED

CashDispenser
 ├── inventory: { 100: count, 50: count, 20: count, 10: count }
 └── dispense(amount): { 100: n, 50: n, ... } | error

BankService
 ├── authenticate(cardNumber, pin)
 ├── getAccountForCard(card)
 ├── recordTransaction(transaction)
 └── (in real life, the remote backend; mock here)

Idle
  → CardInserted (on card)
    → Authenticated (on correct PIN)        |  Idle (on cancel / 3 wrong PINs → card eat)
    → SelectingOp (after auth)
      → CheckingBalance | Depositing | Withdrawing | Transferring
        → Dispensing (if withdrawing)
          → CompletingTransaction
            → Ejecting (card out)
              → Idle

class ATM {
  constructor(bank, dispenser) {
    this.bank = bank;
    this.dispenser = dispenser;
    this.state = "Idle";
    this.card = null;
    this.account = null;
  }

  insertCard(card) {
    if (this.state !== "Idle") throw new Error("Cannot insert card now");
    if (!card.isValid()) { this.state = "Idle"; return { error: "Invalid card" }; }
    this.card = card;
    this.state = "CardInserted";
  }

  enterPin(pin) {
    if (this.state !== "CardInserted") throw new Error("PIN not expected");
    const auth = this.bank.authenticate(this.card.number, pin);
    if (!auth.ok) { /* track attempts, eat card after 3 */ return; }
    this.account = this.bank.getAccountForCard(this.card);
    this.state = "Authenticated";
  }

  withdraw(amount) {
    if (this.state !== "Authenticated") throw new Error("Not authenticated");
    if (amount > this.account.balance) return { error: "Insufficient funds" };
    if (this.account.dailyLimitExceeded(amount)) return { error: "Daily limit" };

    const dispense = this.dispenser.preview(amount);
    if (dispense.error) return dispense;

    // transactional: deduct + dispense atomically
    const tx = this.account.withdraw(amount);             // status PENDING
    try {
      this.dispenser.commit(dispense.plan);
      tx.markSuccess();
      this.bank.recordTransaction(tx);
      return { dispensed: dispense.plan };
    } catch (e) {
      this.account.refund(amount);                        // compensate
      tx.markFailed();
      this.bank.recordTransaction(tx);
      return { error: "Dispense failed" };
    }
  }

  ejectCard() {
    this.card = null; this.account = null; this.state = "Idle";
  }
}

class CashDispenser {
  constructor(inventory) { this.inventory = inventory; }

  preview(amount) {
    const denoms = [100, 50, 20, 10];
    const inv = { ...this.inventory };
    const plan = {};
    for (const d of denoms) {
      const n = Math.min(Math.floor(amount / d), inv[d]);
      if (n > 0) { plan[d] = n; amount -= n * d; inv[d] -= n; }
    }
    if (amount > 0) return { error: "Cannot dispense — denominations" };
    return { plan };
  }

  commit(plan) {
    for (const [d, n] of Object.entries(plan)) {
      if (this.inventory[d] < n) throw new Error("Inventory changed");
      this.inventory[d] -= n;
    }
  }
}