@pokertools/engine 1.0.0

package/dist/actions/betting.js

@@ -0,0 +1,410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFold = handleFold;
+exports.handleCheck = handleCheck;
+exports.handleCall = handleCall;
+exports.handleBet = handleBet;
+exports.handleRaise = handleRaise;
+const positioning_1 = require("../utils/positioning");
+const actionOrder_1 = require("../rules/actionOrder");
+const CriticalStateError_1 = require("../errors/CriticalStateError");
+const rake_1 = require("../utils/rake");
+/**
+ * Handle FOLD action
+ */
+function handleFold(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        return state; // Should have been caught by validation
+    }
+    const { seat } = result;
+    const newPlayers = [...state.players];
+    // Set player status to FOLDED
+    newPlayers[seat] = {
+        ...newPlayers[seat],
+        status: "FOLDED" /* PlayerStatus.FOLDED */,
+    };
+    // Remove from active players
+    const newActivePlayers = state.activePlayers.filter((s) => s !== seat);
+    // Add to action history
+    const actionRecord = {
+        action,
+        seat,
+        resultingPot: getTotalPot(state),
+        resultingStack: newPlayers[seat].stack,
+        street: state.street,
+    };
+    const currentState = {
+        ...state,
+        players: newPlayers,
+        activePlayers: newActivePlayers,
+        actionHistory: [...state.actionHistory, actionRecord],
+        timestamp: action.timestamp,
+    };
+    // Check if only one player with a live hand remains
+    // Count players who have not folded (Active + All-In)
+    const playersWithLiveHands = currentState.players.filter((p) => p && p.status !== "FOLDED" /* PlayerStatus.FOLDED */);
+    // Only end the hand if exactly one player has cards
+    if (playersWithLiveHands.length === 1 && playersWithLiveHands[0]) {
+        // Award remaining pots to last player with live hand
+        return awardPotToLastPlayer(currentState, playersWithLiveHands[0].seat);
+    }
+    // If we have 1 Active player but multiple Live players (others are All-In),
+    // the game should naturally progress to Showdown via progressStreet/checkAutoRunout
+    // Move to next player
+    const nextToAct = (0, actionOrder_1.getNextToAct)(currentState);
+    return {
+        ...currentState,
+        actionTo: nextToAct,
+    };
+}
+/**
+ * Handle CHECK action
+ */
+function handleCheck(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        return state;
+    }
+    const { seat } = result;
+    // Add to action history
+    const actionRecord = {
+        action,
+        seat,
+        resultingPot: getTotalPot(state),
+        resultingStack: state.players[seat].stack,
+        street: state.street,
+    };
+    const newState = {
+        ...state,
+        actionHistory: [...state.actionHistory, actionRecord],
+        timestamp: action.timestamp,
+    };
+    // Move to next player
+    const nextToAct = (0, actionOrder_1.getNextToAct)(newState);
+    return {
+        ...newState,
+        actionTo: nextToAct,
+    };
+}
+/**
+ * Handle CALL action
+ */
+function handleCall(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        return state;
+    }
+    const { player, seat } = result;
+    // Calculate amount to call
+    const currentBet = getCurrentBet(state);
+    const playerBet = state.currentBets.get(seat) ?? 0;
+    const toCall = currentBet - playerBet;
+    // Determine actual call amount (may be all-in)
+    const callAmount = Math.min(toCall, player.stack);
+    const isAllIn = callAmount === player.stack;
+    // Update player
+    const newPlayers = [...state.players];
+    newPlayers[seat] = {
+        ...player,
+        stack: player.stack - callAmount,
+        betThisStreet: playerBet + callAmount,
+        totalInvestedThisHand: player.totalInvestedThisHand + callAmount,
+        status: isAllIn ? "ALL_IN" /* PlayerStatus.ALL_IN */ : "ACTIVE" /* PlayerStatus.ACTIVE */,
+    };
+    // Update current bets
+    const newCurrentBets = new Map(state.currentBets);
+    newCurrentBets.set(seat, playerBet + callAmount);
+    // Add to action history
+    const actionRecord = {
+        action,
+        seat,
+        resultingPot: getTotalPot(state) + callAmount,
+        resultingStack: newPlayers[seat].stack,
+        street: state.street,
+    };
+    const newState = {
+        ...state,
+        players: newPlayers,
+        currentBets: newCurrentBets,
+        actionHistory: [...state.actionHistory, actionRecord],
+        timestamp: action.timestamp,
+    };
+    // Move to next player
+    const nextToAct = (0, actionOrder_1.getNextToAct)(newState);
+    return {
+        ...newState,
+        actionTo: nextToAct,
+    };
+}
+/**
+ * Handle BET action
+ */
+function handleBet(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        return state;
+    }
+    const { player, seat } = result;
+    const betAmount = Math.min(action.amount, player.stack);
+    const isAllIn = betAmount === player.stack;
+    // Update player
+    const newPlayers = [...state.players];
+    newPlayers[seat] = {
+        ...player,
+        stack: player.stack - betAmount,
+        betThisStreet: betAmount,
+        totalInvestedThisHand: player.totalInvestedThisHand + betAmount,
+        status: isAllIn ? "ALL_IN" /* PlayerStatus.ALL_IN */ : "ACTIVE" /* PlayerStatus.ACTIVE */,
+    };
+    // Update current bets
+    const newCurrentBets = new Map(state.currentBets);
+    newCurrentBets.set(seat, betAmount);
+    // Add to action history
+    const actionRecord = {
+        action,
+        seat,
+        resultingPot: getTotalPot(state) + betAmount,
+        resultingStack: newPlayers[seat].stack,
+        street: state.street,
+    };
+    const newState = {
+        ...state,
+        players: newPlayers,
+        currentBets: newCurrentBets,
+        minRaise: betAmount + betAmount, // Min raise is current bet + raise increment
+        lastRaiseAmount: betAmount,
+        lastAggressorSeat: seat,
+        actionHistory: [...state.actionHistory, actionRecord],
+        timestamp: action.timestamp,
+    };
+    // Move to next player
+    const nextToAct = (0, actionOrder_1.getNextToAct)(newState);
+    return {
+        ...newState,
+        actionTo: nextToAct,
+    };
+}
+/**
+ * Handle RAISE action
+ */
+function handleRaise(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        return state;
+    }
+    const { player, seat } = result;
+    const currentBet = getCurrentBet(state);
+    const playerBet = state.currentBets.get(seat) ?? 0;
+    const raiseAmount = Math.min(action.amount, playerBet + player.stack);
+    const addedChips = raiseAmount - playerBet;
+    const isAllIn = addedChips === player.stack;
+    // Calculate raise increment
+    const raiseIncrement = raiseAmount - currentBet;
+    // Update player
+    const newPlayers = [...state.players];
+    newPlayers[seat] = {
+        ...player,
+        stack: player.stack - addedChips,
+        betThisStreet: raiseAmount,
+        totalInvestedThisHand: player.totalInvestedThisHand + addedChips,
+        status: isAllIn ? "ALL_IN" /* PlayerStatus.ALL_IN */ : "ACTIVE" /* PlayerStatus.ACTIVE */,
+    };
+    // Update current bets
+    const newCurrentBets = new Map(state.currentBets);
+    newCurrentBets.set(seat, raiseAmount);
+    // Add to action history
+    const actionRecord = {
+        action,
+        seat,
+        resultingPot: getTotalPot(state) + addedChips,
+        resultingStack: newPlayers[seat].stack,
+        street: state.street,
+    };
+    // Determine if this reopens betting (incomplete raise rule)
+    const reopensBetting = raiseIncrement >= state.lastRaiseAmount;
+    // Min-raise calculation:
+    // - If reopens betting: new currentBet + new increment
+    // - If incomplete raise: new currentBet + old increment (TDA/WSOP rule)
+    //   Example: P1 bets 100, P2 all-in 120, P3 must raise to 120+100=220 minimum
+    const newMinRaise = reopensBetting
+        ? raiseAmount + raiseIncrement
+        : raiseAmount + state.lastRaiseAmount;
+    const newState = {
+        ...state,
+        players: newPlayers,
+        currentBets: newCurrentBets,
+        minRaise: newMinRaise,
+        lastRaiseAmount: reopensBetting ? raiseIncrement : state.lastRaiseAmount,
+        lastAggressorSeat: reopensBetting ? seat : state.lastAggressorSeat,
+        actionHistory: [...state.actionHistory, actionRecord],
+        timestamp: action.timestamp,
+    };
+    // Move to next player
+    const nextToAct = (0, actionOrder_1.getNextToAct)(newState);
+    return {
+        ...newState,
+        actionTo: nextToAct,
+    };
+}
+/**
+ * Get current highest bet
+ */
+function getCurrentBet(state) {
+    let maxBet = 0;
+    for (const bet of state.currentBets.values()) {
+        if (bet > maxBet) {
+            maxBet = bet;
+        }
+    }
+    return maxBet;
+}
+/**
+ * Get total pot size
+ */
+function getTotalPot(state) {
+    let total = 0;
+    for (const pot of state.pots) {
+        total += pot.amount;
+    }
+    for (const bet of state.currentBets.values()) {
+        total += bet;
+    }
+    return total;
+}
+/**
+ * Award pots to remaining eligible players when hand ends by folds
+ * Properly handles side pot eligibility and uncontested pots
+ */
+function awardPotToLastPlayer(state, winningSeat) {
+    const newPlayers = [...state.players];
+    const winners = [];
+    // Process each pot separately, checking eligibility
+    let totalRakeFromPots = 0;
+    for (const pot of state.pots) {
+        // Find all non-folded players eligible for this pot
+        const eligibleNonFolded = pot.eligibleSeats.filter((seat) => {
+            const player = state.players[seat];
+            return player && player.status !== "FOLDED" /* PlayerStatus.FOLDED */;
+        });
+        // Calculate rake for this pot - GLOBAL cap applied across all pots
+        const { rake: potRake } = (0, rake_1.calculateRake)(state, pot.amount, totalRakeFromPots);
+        totalRakeFromPots += potRake;
+        const potAfterRake = pot.amount - potRake;
+        if (eligibleNonFolded.length === 0) {
+            // No eligible players remain - should not happen, but defensive
+            // Award to last player to fold from eligible seats (fallback)
+            const lastEligible = pot.eligibleSeats[pot.eligibleSeats.length - 1];
+            const player = newPlayers[lastEligible];
+            if (player) {
+                newPlayers[lastEligible] = {
+                    ...player,
+                    stack: player.stack + potAfterRake,
+                };
+                winners.push({
+                    seat: lastEligible,
+                    amount: potAfterRake,
+                    hand: null,
+                    handRank: null,
+                });
+            }
+        }
+        else if (eligibleNonFolded.length === 1) {
+            // Exactly one eligible player - they win this pot
+            const winnerSeat = eligibleNonFolded[0];
+            const player = newPlayers[winnerSeat];
+            newPlayers[winnerSeat] = {
+                ...player,
+                stack: player.stack + potAfterRake,
+            };
+            winners.push({
+                seat: winnerSeat,
+                amount: potAfterRake,
+                hand: null,
+                handRank: null,
+            });
+        }
+        else {
+            // Multiple eligible players remain - this means awardPotToLastPlayer was called incorrectly
+            // The hand should have gone to showdown instead
+            throw new CriticalStateError_1.CriticalStateError("awardPotToLastPlayer called with multiple eligible players remaining", {
+                potAmount: pot.amount,
+                eligibleSeats: pot.eligibleSeats,
+                eligibleNonFolded,
+                winningSeat,
+            });
+        }
+    }
+    // Award current bets to last active player
+    // Note: We need to subtract the winner's own bet since that's just a refund, not winnings
+    let currentBetsTotal = 0;
+    for (const bet of state.currentBets.values()) {
+        currentBetsTotal += bet;
+    }
+    const newActionHistory = [...state.actionHistory];
+    let totalRake = 0;
+    if (currentBetsTotal > 0) {
+        const player = newPlayers[winningSeat];
+        const winnersBet = state.currentBets.get(winningSeat) ?? 0;
+        // Calculate rake on the pot (before awarding) - GLOBAL cap applied
+        const { rake } = (0, rake_1.calculateRake)(state, currentBetsTotal, totalRakeFromPots);
+        totalRake = totalRakeFromPots + rake;
+        const potAfterRake = currentBetsTotal - rake;
+        // Award the pot after rake deduction
+        newPlayers[winningSeat] = {
+            ...player,
+            stack: player.stack + potAfterRake,
+        };
+        // Record uncalled bet refund if winner had a bet
+        if (winnersBet > 0) {
+            const uncalledBetAction = {
+                action: {
+                    type: "UNCALLED_BET_RETURNED" /* ActionType.UNCALLED_BET_RETURNED */,
+                    playerId: player.id,
+                    amount: winnersBet,
+                    timestamp: state.timestamp,
+                },
+                seat: winningSeat,
+                resultingPot: 0, // Pot will be empty after this
+                resultingStack: player.stack + winnersBet,
+                street: state.street,
+            };
+            newActionHistory.push(uncalledBetAction);
+        }
+        // Record only the actual winnings (opponents' bets, not their own bet refund, after rake)
+        // Winnings = potAfterRake - winnersBet (refund doesn't count as winnings)
+        const actualWinnings = potAfterRake - winnersBet;
+        if (actualWinnings > 0) {
+            // Add to winners if not already there, or update amount
+            const existingIndex = winners.findIndex((w) => w.seat === winningSeat);
+            if (existingIndex >= 0) {
+                // Update existing winner's amount
+                winners[existingIndex] = {
+                    ...winners[existingIndex],
+                    amount: winners[existingIndex].amount + actualWinnings,
+                };
+            }
+            else {
+                winners.push({
+                    seat: winningSeat,
+                    amount: actualWinnings,
+                    hand: null,
+                    handRank: null,
+                });
+            }
+        }
+    }
+    // NOTE: We do NOT reset totalInvestedThisHand here because it's used by getInitialChips()
+    // to calculate total chips in the game. It will be reset when a new hand is dealt.
+    return {
+        ...state,
+        players: newPlayers,
+        street: "SHOWDOWN" /* Street.SHOWDOWN */, // Mark hand as complete
+        pots: [],
+        currentBets: new Map(),
+        winners,
+        actionTo: null,
+        actionHistory: newActionHistory,
+        rakeThisHand: state.rakeThisHand + totalRake, // totalRake already includes rake from both pots and currentBets
+    };
+}

package/dist/actions/dealing.d.ts

@@ -0,0 +1,9 @@
+import { GameState, DealAction } from "@pokertools/types";
+/**
+ * Deal a new hand
+ * - Shuffles deck
+ * - Posts blinds and antes
+ * - Deals 2 cards to each active player
+ * - Sets action to first to act
+ */
+export declare function handleDeal(state: GameState, action: DealAction): GameState;

package/dist/actions/dealing.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDeal = handleDeal;
+const deck_1 = require("../utils/deck");
+const cardUtils_1 = require("../utils/cardUtils");
+const blinds_1 = require("../rules/blinds");
+const actionOrder_1 = require("../rules/actionOrder");
+const positioning_1 = require("../utils/positioning");
+/**
+ * Deal a new hand
+ * - Shuffles deck
+ * - Posts blinds and antes
+ * - Deals 2 cards to each active player
+ * - Sets action to first to act
+ */
+function handleDeal(state, action) {
+    // Move button (Dead Button logic: moves to next seat index regardless of occupancy)
+    const newButtonSeat = moveButton(state);
+    // Determine if this is a tournament
+    const isTournament = !!state.config.blindStructure;
+    // Create and shuffle deck
+    const rng = state.config.randomProvider ?? Math.random;
+    const deck = (0, deck_1.shuffle)((0, deck_1.createDeck)(), rng);
+    // Get players who will be dealt in
+    const playersToReceive = [];
+    for (let seat = 0; seat < state.players.length; seat++) {
+        const player = state.players[seat];
+        if (player && player.stack > 0 && !player.isSittingOut) {
+            playersToReceive.push(seat);
+        }
+    }
+    // Deal 2 cards to each player
+    let remainingDeck = deck;
+    const newPlayers = [...state.players];
+    // Initialize hands for receiving players (active, not sitting out)
+    for (const seat of playersToReceive) {
+        newPlayers[seat] = {
+            ...newPlayers[seat],
+            hand: [], // Initialize empty array
+            shownCards: null, // Reset from previous hand
+            status: "ACTIVE" /* PlayerStatus.ACTIVE */,
+            betThisStreet: 0,
+            totalInvestedThisHand: 0,
+        };
+    }
+    // In tournaments, initialize sitting-out players too (they must post blinds/antes)
+    if (isTournament) {
+        for (let seat = 0; seat < newPlayers.length; seat++) {
+            const player = newPlayers[seat];
+            if (player && player.stack > 0 && player.isSittingOut && !playersToReceive.includes(seat)) {
+                newPlayers[seat] = {
+                    ...player,
+                    hand: null, // No cards dealt
+                    shownCards: null,
+                    status: "FOLDED" /* PlayerStatus.FOLDED */, // Start as folded
+                    betThisStreet: 0,
+                    totalInvestedThisHand: 0,
+                };
+            }
+        }
+    }
+    // Deal 2 cards, one by one, in circle (standard poker procedure)
+    for (let round = 0; round < 2; round++) {
+        for (const seat of playersToReceive) {
+            // Deal 1 card
+            const [cards, nextDeck] = (0, deck_1.dealCards)(remainingDeck, 1);
+            remainingDeck = nextDeck;
+            const cardStrings = (0, cardUtils_1.cardCodesToStrings)(cards);
+            // Append to existing hand
+            const currentPlayer = newPlayers[seat];
+            const currentHand = currentPlayer.hand ?? []; // Should be [] from initialization
+            newPlayers[seat] = {
+                ...currentPlayer,
+                hand: [...currentHand, ...cardStrings],
+            };
+        }
+    }
+    // Post blinds and antes
+    const blindPositions = (0, blinds_1.getBlindPositions)({
+        ...state,
+        buttonSeat: newButtonSeat,
+        players: newPlayers,
+    });
+    const currentBets = new Map();
+    if (blindPositions) {
+        const { smallBlindSeat, bigBlindSeat } = blindPositions;
+        // Post small blind
+        // In tournaments: sitting-out players MUST post to prevent "blinding off" exploit
+        // In cash games: sitting-out SB is treated as "Dead Small Blind" (no post)
+        const sbPlayer = newPlayers[smallBlindSeat];
+        if (sbPlayer && sbPlayer.stack > 0) {
+            const shouldPostSB = isTournament || !sbPlayer.isSittingOut;
+            if (shouldPostSB) {
+                const sbAmount = Math.min(sbPlayer.stack, state.smallBlind);
+                currentBets.set(smallBlindSeat, sbAmount);
+                newPlayers[smallBlindSeat] = {
+                    ...sbPlayer,
+                    stack: sbPlayer.stack - sbAmount,
+                    betThisStreet: sbAmount,
+                    totalInvestedThisHand: sbAmount,
+                    status: sbAmount === sbPlayer.stack
+                        ? "ALL_IN" /* PlayerStatus.ALL_IN */
+                        : sbPlayer.isSittingOut
+                            ? "FOLDED" /* PlayerStatus.FOLDED */
+                            : "ACTIVE" /* PlayerStatus.ACTIVE */,
+                };
+            }
+        }
+        // If sbPlayer is null or (cash game && sitting out), Dead Small Blind applies
+        // Post big blind (Must exist for hand to start)
+        const bbPlayer = newPlayers[bigBlindSeat];
+        if (bbPlayer) {
+            const bbAmount = Math.min(bbPlayer.stack, state.bigBlind);
+            currentBets.set(bigBlindSeat, bbAmount);
+            newPlayers[bigBlindSeat] = {
+                ...bbPlayer,
+                stack: bbPlayer.stack - bbAmount,
+                betThisStreet: bbAmount,
+                totalInvestedThisHand: bbAmount,
+                status: bbAmount === bbPlayer.stack
+                    ? "ALL_IN" /* PlayerStatus.ALL_IN */
+                    : bbPlayer.isSittingOut
+                        ? "FOLDED" /* PlayerStatus.FOLDED */
+                        : "ACTIVE" /* PlayerStatus.ACTIVE */,
+            };
+        }
+    }
+    // Post antes if configured
+    // In tournaments: ALL players with chips must post (including sitting-out)
+    // In cash games: Only active players post
+    if (state.ante > 0) {
+        const playersToAnteFrom = isTournament
+            ? state.players.map((p, idx) => (p && p.stack > 0 ? idx : -1)).filter((idx) => idx >= 0)
+            : playersToReceive;
+        for (const seat of playersToAnteFrom) {
+            const player = newPlayers[seat];
+            const anteAmount = Math.min(player.stack, state.ante);
+            if (anteAmount > 0) {
+                const currentBet = currentBets.get(seat) ?? 0;
+                currentBets.set(seat, currentBet + anteAmount);
+                const newStack = player.stack - anteAmount;
+                newPlayers[seat] = {
+                    ...player,
+                    stack: newStack,
+                    betThisStreet: player.betThisStreet + anteAmount,
+                    totalInvestedThisHand: player.totalInvestedThisHand + anteAmount,
+                    status: newStack === 0
+                        ? "ALL_IN" /* PlayerStatus.ALL_IN */
+                        : player.isSittingOut && isTournament
+                            ? "FOLDED" /* PlayerStatus.FOLDED */
+                            : player.status,
+                };
+            }
+        }
+    }
+    // Start with empty pots (bets will be collected when street progresses)
+    const pots = [];
+    // Get active players
+    const activePlayers = playersToReceive.filter((seat) => {
+        const player = newPlayers[seat];
+        return player.status === "ACTIVE" /* PlayerStatus.ACTIVE */;
+    });
+    const newState = {
+        ...state,
+        handNumber: state.handNumber + 1,
+        handId: `hand-${action.timestamp}-${Math.floor(rng() * 1000000)}`,
+        buttonSeat: newButtonSeat,
+        deck: remainingDeck,
+        board: [],
+        street: "PREFLOP" /* Street.PREFLOP */,
+        players: newPlayers,
+        pots,
+        currentBets,
+        minRaise: state.bigBlind,
+        lastRaiseAmount: state.bigBlind,
+        activePlayers,
+        winners: null,
+        rakeThisHand: 0,
+        actionHistory: [],
+        timestamp: action.timestamp,
+    };
+    // Set first to act
+    const firstToAct = (0, actionOrder_1.getFirstToAct)(newState);
+    return {
+        ...newState,
+        actionTo: firstToAct,
+    };
+}
+/**
+ * Move button to next seat
+ * Dead Button Rule: Moves to next index regardless of player presence
+ */
+function moveButton(state) {
+    if (state.buttonSeat === null) {
+        // First hand, find first seated player
+        for (let seat = 0; seat < state.maxPlayers; seat++) {
+            if (state.players[seat] !== null) {
+                return seat;
+            }
+        }
+        return 0;
+    }
+    // Simply increment seat index (Dead Button)
+    // We do not skip empty seats here.
+    return (0, positioning_1.getNextSeat)(state.buttonSeat, state.maxPlayers);
+}

package/dist/actions/management.d.ts

@@ -0,0 +1,9 @@
+import { GameState, SitAction, StandAction } from "@pokertools/types";
+/**
+ * Handle SIT action - add player to table
+ */
+export declare function handleSit(state: GameState, action: SitAction): GameState;
+/**
+ * Handle STAND action - remove player from table
+ */
+export declare function handleStand(state: GameState, action: StandAction): GameState;

package/dist/actions/management.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSit = handleSit;
+exports.handleStand = handleStand;
+const positioning_1 = require("../utils/positioning");
+/**
+ * Handle SIT action - add player to table
+ */
+function handleSit(state, action) {
+    const newPlayer = {
+        id: action.playerId,
+        name: action.playerName,
+        seat: action.seat,
+        stack: action.stack,
+        hand: null,
+        shownCards: null,
+        status: "WAITING" /* PlayerStatus.WAITING */,
+        betThisStreet: 0,
+        totalInvestedThisHand: 0,
+        isSittingOut: false,
+        timeBank: state.config.timeBankSeconds ?? 30,
+    };
+    const newPlayers = [...state.players];
+    newPlayers[action.seat] = newPlayer;
+    // Add to time banks
+    const newTimeBanks = new Map(state.timeBanks);
+    newTimeBanks.set(action.seat, newPlayer.timeBank);
+    return {
+        ...state,
+        players: newPlayers,
+        timeBanks: newTimeBanks,
+        timestamp: action.timestamp,
+    };
+}
+/**
+ * Handle STAND action - remove player from table
+ */
+function handleStand(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        return state;
+    }
+    const { seat } = result;
+    const newPlayers = [...state.players];
+    newPlayers[seat] = null;
+    // Remove from time banks
+    const newTimeBanks = new Map(state.timeBanks);
+    newTimeBanks.delete(seat);
+    // Remove from active players if present
+    const newActivePlayers = state.activePlayers.filter((s) => s !== seat);
+    return {
+        ...state,
+        players: newPlayers,
+        activePlayers: newActivePlayers,
+        timeBanks: newTimeBanks,
+        timestamp: action.timestamp,
+    };
+}