@pokertools/engine 1.0.0

package/dist/actions/showdownActions.d.ts

@@ -0,0 +1,9 @@
+import { GameState, ShowAction, MuckAction } from "@pokertools/types";
+/**
+ * Handle SHOW action - player reveals their cards at showdown
+ */
+export declare function handleShow(state: GameState, action: ShowAction): GameState;
+/**
+ * Handle MUCK action - player hides their cards at showdown
+ */
+export declare function handleMuck(state: GameState, action: MuckAction): GameState;

package/dist/actions/showdownActions.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleShow = handleShow;
+exports.handleMuck = handleMuck;
+const IllegalActionError_1 = require("../errors/IllegalActionError");
+const ErrorCodes_1 = require("../errors/ErrorCodes");
+/**
+ * Handle SHOW action - player reveals their cards at showdown
+ */
+function handleShow(state, action) {
+    // Find player
+    const player = state.players.find((p) => p?.id === action.playerId);
+    if (!player) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+    }
+    // Can only show at showdown
+    if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_ACTION, `Can only show cards at showdown (current street: ${state.street})`, { playerId: action.playerId, street: state.street });
+    }
+    // Player must not have folded
+    if (player.status === "FOLDED" /* PlayerStatus.FOLDED */) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_ACTION, `Cannot show cards after folding`, {
+            playerId: action.playerId,
+            status: player.status,
+        });
+    }
+    // Player must have cards
+    if (!player.hand) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_ACTION, `Player has no cards to show`, {
+            playerId: action.playerId,
+        });
+    }
+    // Determine which cards to show
+    let cardIndices;
+    if (action.cardIndices && action.cardIndices.length > 0) {
+        // Validate indices are within bounds
+        cardIndices = action.cardIndices.filter((i) => i >= 0 && i < player.hand.length);
+        if (cardIndices.length === 0) {
+            return state; // Invalid indices
+        }
+    }
+    else {
+        // Default: show all cards
+        cardIndices = Array.from({ length: player.hand.length }, (_, i) => i);
+    }
+    // Update player's shown cards
+    const newPlayers = [...state.players];
+    newPlayers[player.seat] = {
+        ...player,
+        shownCards: cardIndices,
+    };
+    const actionRecord = {
+        action: {
+            type: "SHOW" /* ActionType.SHOW */,
+            playerId: action.playerId,
+            cardIndices: action.cardIndices,
+            timestamp: action.timestamp,
+        },
+        seat: player.seat,
+        resultingPot: state.pots.reduce((sum, pot) => sum + pot.amount, 0),
+        resultingStack: player.stack,
+        street: state.street,
+    };
+    return {
+        ...state,
+        players: newPlayers,
+        actionHistory: [...state.actionHistory, actionRecord],
+        timestamp: action.timestamp,
+    };
+}
+/**
+ * Handle MUCK action - player hides their cards at showdown
+ */
+function handleMuck(state, action) {
+    // Find player
+    const player = state.players.find((p) => p?.id === action.playerId);
+    if (!player) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+    }
+    // Can only muck at showdown
+    if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_ACTION, `Can only muck cards at showdown (current street: ${state.street})`, { playerId: action.playerId, street: state.street });
+    }
+    // Player must not have folded
+    if (player.status === "FOLDED" /* PlayerStatus.FOLDED */) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_ACTION, `Cannot muck cards after folding`, {
+            playerId: action.playerId,
+            status: player.status,
+        });
+    }
+    // Cannot muck if you're a winner (winners must show)
+    const isWinner = state.winners?.some((w) => w.seat === player.seat);
+    if (isWinner) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_ACTION, `Winners cannot muck - cards must be shown`, { playerId: action.playerId });
+    }
+    // Set shown cards to null (mucked) - hand is preserved in player.hand
+    const newPlayers = [...state.players];
+    newPlayers[player.seat] = {
+        ...player,
+        shownCards: null, // Muck cards (hide them, but preserve hand data)
+    };
+    const actionRecord = {
+        action: {
+            type: "MUCK" /* ActionType.MUCK */,
+            playerId: action.playerId,
+            timestamp: action.timestamp,
+        },
+        seat: player.seat,
+        resultingPot: state.pots.reduce((sum, pot) => sum + pot.amount, 0),
+        resultingStack: player.stack,
+        street: state.street,
+    };
+    return {
+        ...state,
+        players: newPlayers,
+        actionHistory: [...state.actionHistory, actionRecord],
+        timestamp: action.timestamp,
+    };
+}

package/dist/actions/special.d.ts

@@ -0,0 +1,14 @@
+import { GameState, TimeoutAction, TimeBankAction } from "@pokertools/types";
+/**
+ * Handle TIMEOUT action
+ * - Folds player if they have bet to call
+ * - Checks if allowed, otherwise folds
+ * - Marks player as sitting out
+ */
+export declare function handleTimeout(state: GameState, action: TimeoutAction): GameState;
+/**
+ * Handle TIME_BANK action
+ * - Deducts time from player's time bank
+ * - Keeps action on same player
+ */
+export declare function handleTimeBank(state: GameState, action: TimeBankAction): GameState;

package/dist/actions/special.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTimeout = handleTimeout;
+exports.handleTimeBank = handleTimeBank;
+const positioning_1 = require("../utils/positioning");
+const actionOrder_1 = require("../rules/actionOrder");
+/**
+ * Handle TIMEOUT action
+ * - Folds player if they have bet to call
+ * - Checks if allowed, otherwise folds
+ * - Marks player as sitting out
+ */
+function handleTimeout(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        return state;
+    }
+    const { player, seat } = result;
+    // Determine if player needs to call
+    const currentBet = getCurrentBet(state);
+    const playerBet = state.currentBets.get(seat) ?? 0;
+    const needsToCall = currentBet > playerBet;
+    const newPlayers = [...state.players];
+    if (needsToCall) {
+        // Player must fold
+        newPlayers[seat] = {
+            ...player,
+            status: "FOLDED" /* PlayerStatus.FOLDED */,
+            isSittingOut: true,
+        };
+    }
+    else {
+        // Player can check, but mark as sitting out
+        newPlayers[seat] = {
+            ...player,
+            isSittingOut: true,
+        };
+    }
+    const newActivePlayers = needsToCall
+        ? state.activePlayers.filter((s) => s !== seat)
+        : state.activePlayers;
+    const newState = {
+        ...state,
+        players: newPlayers,
+        activePlayers: newActivePlayers,
+        timestamp: action.timestamp,
+    };
+    // Move to next player
+    const nextToAct = (0, actionOrder_1.getNextToAct)(newState);
+    return {
+        ...newState,
+        actionTo: nextToAct,
+    };
+}
+/**
+ * Handle TIME_BANK action
+ * - Deducts time from player's time bank
+ * - Keeps action on same player
+ */
+function handleTimeBank(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        return state;
+    }
+    const { seat } = result;
+    const currentTimeBank = state.timeBanks.get(seat) ?? 0;
+    if (currentTimeBank <= 0) {
+        // No time bank left, force timeout
+        return handleTimeout(state, {
+            type: "TIMEOUT" /* ActionType.TIMEOUT */,
+            playerId: action.playerId,
+            timestamp: action.timestamp,
+        });
+    }
+    // Deduct time from player's time bank (configurable, default 10 seconds)
+    const deduction = state.config.timeBankDeductionSeconds ?? 10;
+    const newTimeBank = Math.max(0, currentTimeBank - deduction);
+    const newTimeBanks = new Map(state.timeBanks);
+    newTimeBanks.set(seat, newTimeBank);
+    return {
+        ...state,
+        timeBanks: newTimeBanks,
+        timestamp: action.timestamp,
+        // Keep actionTo the same (extends player's turn)
+    };
+}
+/**
+ * Get current highest bet
+ */
+function getCurrentBet(state) {
+    let maxBet = 0;
+    for (const bet of state.currentBets.values()) {
+        if (bet > maxBet) {
+            maxBet = bet;
+        }
+    }
+    return maxBet;
+}

package/dist/actions/streetProgression.d.ts

@@ -0,0 +1,13 @@
+import { GameState } from "@pokertools/types";
+/**
+ * Progress to next street
+ * - Collects bets into pots
+ * - Deals community cards
+ * - Resets action
+ */
+export declare function progressStreet(state: GameState): GameState;
+/**
+ * Check if we should progress to next street
+ * (All players have acted and matched bets)
+ */
+export declare function shouldProgressStreet(state: GameState): boolean;

package/dist/actions/streetProgression.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressStreet = progressStreet;
+exports.shouldProgressStreet = shouldProgressStreet;
+const deck_1 = require("../utils/deck");
+const cardUtils_1 = require("../utils/cardUtils");
+const actionOrder_1 = require("../rules/actionOrder");
+/**
+ * Progress to next street
+ * - Collects bets into pots
+ * - Deals community cards
+ * - Resets action
+ */
+function progressStreet(state) {
+    // Determine next street
+    const nextStreet = getNextStreet(state.street);
+    if (nextStreet === null) {
+        // Already at showdown or beyond
+        return state;
+    }
+    // Check if we should auto-runout (all remaining players all-in)
+    const shouldAutoRunout = checkAutoRunout(state);
+    if (shouldAutoRunout) {
+        return handleAutoRunout(state);
+    }
+    // Deal community cards
+    const { board, deck } = dealCommunityCards(state, nextStreet);
+    // Reset for new street
+    // Note: Pots are calculated by recalculatePots() before progressStreet() is called
+    const newState = {
+        ...state,
+        street: nextStreet,
+        board,
+        deck,
+        pots: state.pots, // Keep existing pots (already updated by recalculatePots)
+        currentBets: new Map(),
+        lastAggressorSeat: null,
+        // Keep timestamp from last action (street progression is not a user action)
+    };
+    // Set first to act
+    const firstToAct = (0, actionOrder_1.getFirstToAct)(newState);
+    return {
+        ...newState,
+        actionTo: firstToAct,
+    };
+}
+/**
+ * Get next street in sequence
+ * Uses exhaustive mapping for type safety
+ */
+function getNextStreet(current) {
+    const nextStreetMap = {
+        ["PREFLOP" /* Street.PREFLOP */]: "FLOP" /* Street.FLOP */,
+        ["FLOP" /* Street.FLOP */]: "TURN" /* Street.TURN */,
+        ["TURN" /* Street.TURN */]: "RIVER" /* Street.RIVER */,
+        ["RIVER" /* Street.RIVER */]: "SHOWDOWN" /* Street.SHOWDOWN */,
+        ["SHOWDOWN" /* Street.SHOWDOWN */]: null,
+    };
+    return nextStreetMap[current];
+}
+/**
+ * Deal community cards for the given street
+ */
+function dealCommunityCards(state, street) {
+    const currentBoard = [...state.board];
+    const deck = [...state.deck];
+    switch (street) {
+        case "FLOP" /* Street.FLOP */:
+            // Burn 1, deal 3
+            const [flopCards, flopDeck] = (0, deck_1.burnAndDeal)(deck, 3);
+            return {
+                board: [...currentBoard, ...(0, cardUtils_1.cardCodesToStrings)(flopCards)],
+                deck: flopDeck,
+            };
+        case "TURN" /* Street.TURN */:
+            // Burn 1, deal 1
+            const [turnCards, turnDeck] = (0, deck_1.burnAndDeal)(deck, 1);
+            return {
+                board: [...currentBoard, ...(0, cardUtils_1.cardCodesToStrings)(turnCards)],
+                deck: turnDeck,
+            };
+        case "RIVER" /* Street.RIVER */:
+            // Burn 1, deal 1
+            const [riverCards, riverDeck] = (0, deck_1.burnAndDeal)(deck, 1);
+            return {
+                board: [...currentBoard, ...(0, cardUtils_1.cardCodesToStrings)(riverCards)],
+                deck: riverDeck,
+            };
+        default:
+            return { board: currentBoard, deck };
+    }
+}
+/**
+ * Check if all remaining players are all-in (auto-runout condition)
+ */
+function checkAutoRunout(state) {
+    let activeCount = 0;
+    let allInCount = 0;
+    for (const player of state.players) {
+        if (!player)
+            continue;
+        if (player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
+            activeCount++;
+        }
+        else if (player.status === "ALL_IN" /* PlayerStatus.ALL_IN */) {
+            allInCount++;
+        }
+    }
+    // Auto-runout if ≤1 active player with chips (rest are all-in or folded)
+    return activeCount <= 1 && allInCount > 0;
+}
+/**
+ * Handle auto-runout: deal all remaining streets at once
+ * This manually deals cards without calling progressStreet to avoid infinite recursion
+ */
+function handleAutoRunout(state) {
+    let currentState = state;
+    let currentStreet = state.street;
+    // Deal remaining streets manually (FLOP -> TURN -> RIVER)
+    while (currentStreet !== "RIVER" /* Street.RIVER */) {
+        const nextStreet = getNextStreet(currentStreet);
+        if (nextStreet === null || nextStreet === "SHOWDOWN" /* Street.SHOWDOWN */)
+            break;
+        // Deal community cards for this street
+        const { board, deck } = dealCommunityCards(currentState, nextStreet);
+        // Update state with new street and board
+        currentState = {
+            ...currentState,
+            street: nextStreet,
+            board,
+            deck,
+            currentBets: new Map(), // Clear bets between streets
+            lastAggressorSeat: null,
+        };
+        currentStreet = nextStreet;
+    }
+    // Move to showdown
+    return {
+        ...currentState,
+        street: "SHOWDOWN" /* Street.SHOWDOWN */,
+        actionTo: null,
+    };
+}
+/**
+ * Check if we should progress to next street
+ * (All players have acted and matched bets)
+ */
+function shouldProgressStreet(state) {
+    if (state.actionTo !== null) {
+        return false; // Action still in progress
+    }
+    if (state.street === "SHOWDOWN" /* Street.SHOWDOWN */) {
+        return false; // Already at showdown
+    }
+    // Check if all active players have acted
+    return (0, actionOrder_1.isActionComplete)(state);
+}

package/dist/actions/tournament.d.ts

@@ -0,0 +1,5 @@
+import { GameState, NextBlindLevelAction } from "@pokertools/types";
+/**
+ * Handle NEXT_BLIND_LEVEL action - advance to next blind level in tournament
+ */
+export declare function handleNextBlindLevel(state: GameState, action: NextBlindLevelAction): GameState;

package/dist/actions/tournament.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleNextBlindLevel = handleNextBlindLevel;
+/**
+ * Handle NEXT_BLIND_LEVEL action - advance to next blind level in tournament
+ */
+function handleNextBlindLevel(state, action) {
+    // Only applicable for tournaments
+    if (!state.config.blindStructure) {
+        return state;
+    }
+    const nextLevel = state.blindLevel + 1;
+    // Check if we're at max level
+    if (nextLevel >= state.config.blindStructure.length) {
+        return state; // At max level, no change
+    }
+    const blindLevel = state.config.blindStructure[nextLevel];
+    // Record action to history
+    const actionRecord = {
+        action: {
+            type: "NEXT_BLIND_LEVEL" /* ActionType.NEXT_BLIND_LEVEL */,
+            timestamp: action.timestamp,
+        },
+        seat: null, // Table-level action
+        resultingPot: state.pots.reduce((sum, pot) => sum + pot.amount, 0),
+        resultingStack: 0, // Not applicable
+        street: state.street,
+    };
+    return {
+        ...state,
+        blindLevel: nextLevel,
+        smallBlind: blindLevel.smallBlind,
+        bigBlind: blindLevel.bigBlind,
+        ante: blindLevel.ante,
+        actionHistory: [...state.actionHistory, actionRecord],
+        timestamp: action.timestamp,
+    };
+}

package/dist/actions/validation.d.ts

@@ -0,0 +1,6 @@
+import { GameState, Action } from "@pokertools/types";
+/**
+ * Validate that an action is legal in the current game state
+ * Throws IllegalActionError if action is invalid
+ */
+export declare function validateAction(state: GameState, action: Action): void;

package/dist/actions/validation.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAction = validateAction;
+const IllegalActionError_1 = require("../errors/IllegalActionError");
+const ErrorCodes_1 = require("../errors/ErrorCodes");
+const positioning_1 = require("../utils/positioning");
+/**
+ * Validate that an action is legal in the current game state
+ * Throws IllegalActionError if action is invalid
+ */
+function validateAction(state, action) {
+    // Type-specific validation
+    switch (action.type) {
+        case "FOLD" /* ActionType.FOLD */:
+        case "CHECK" /* ActionType.CHECK */:
+        case "CALL" /* ActionType.CALL */:
+        case "BET" /* ActionType.BET */:
+        case "RAISE" /* ActionType.RAISE */:
+            validateBettingAction(state, action);
+            break;
+        case "DEAL" /* ActionType.DEAL */:
+            validateDealAction(state);
+            break;
+        case "SIT" /* ActionType.SIT */:
+            validateSitAction(state, action);
+            break;
+        case "STAND" /* ActionType.STAND */:
+            validateStandAction(state, action);
+            break;
+        case "TIMEOUT" /* ActionType.TIMEOUT */:
+        case "TIME_BANK" /* ActionType.TIME_BANK */:
+            validateTimeAction(state, action);
+            break;
+        default:
+            // Other actions don't need validation
+            break;
+    }
+}
+function validateBettingAction(state, action) {
+    if (!("playerId" in action)) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_ACTION, "Action missing playerId");
+    }
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+    }
+    const { player, seat } = result;
+    // Check if it's player's turn
+    if (state.actionTo !== seat) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.NOT_YOUR_TURN, `Player ${action.playerId} attempted to act, but action is on seat ${state.actionTo}`, {
+            playerId: action.playerId,
+            playerSeat: seat,
+            actionTo: state.actionTo,
+            street: state.street,
+        });
+    }
+    // Check player status
+    if (player.status !== "ACTIVE" /* PlayerStatus.ACTIVE */) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.PLAYER_NOT_ACTIVE, `Player ${action.playerId} cannot act with status ${player.status}`, { playerId: action.playerId, status: player.status });
+    }
+    // Check player has chips
+    if (player.stack === 0 && action.type !== "FOLD" /* ActionType.FOLD */) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.NO_CHIPS, `Player ${action.playerId} has no chips`, {
+            playerId: action.playerId,
+        });
+    }
+    // Action-specific validation
+    const currentBet = getCurrentBet(state);
+    const playerBet = state.currentBets.get(seat) ?? 0;
+    const toCall = currentBet - playerBet;
+    switch (action.type) {
+        case "CHECK" /* ActionType.CHECK */:
+            if (toCall > 0) {
+                throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.CANNOT_CHECK, `Player ${action.playerId} cannot check with ${toCall} to call`, { playerId: action.playerId, toCall });
+            }
+            break;
+        case "CALL" /* ActionType.CALL */:
+            if (toCall === 0) {
+                throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.NOTHING_TO_CALL, `Player ${action.playerId} has nothing to call`, { playerId: action.playerId });
+            }
+            break;
+        case "BET" /* ActionType.BET */:
+            // Note: We allow BET even when currentBet > 0 because the reducer will auto-convert it to RAISE or CALL
+            // This handles UI implementations that don't distinguish between BET and RAISE buttons
+            if ("amount" in action) {
+                // Reject bets below the current bet (string bet exploit)
+                if (currentBet > 0 && action.amount < currentBet) {
+                    throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.BET_TOO_SMALL, `Bet of ${action.amount} is below current bet ${currentBet}`, { amount: action.amount, currentBet });
+                }
+                // Reject bets below big blind (when no current bet)
+                if (action.amount < state.bigBlind && action.amount < player.stack) {
+                    throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.BET_TOO_SMALL, `Bet of ${action.amount} is below minimum ${state.bigBlind}`, { amount: action.amount, minimum: state.bigBlind });
+                }
+            }
+            break;
+        case "RAISE" /* ActionType.RAISE */:
+            // If the current player is still marked as the last aggressor, it means
+            // intermediate actions (like calls or incomplete all-in raises) did NOT
+            // reopen the betting. Therefore, they cannot re-raise their own bet.
+            if (state.lastAggressorSeat === seat) {
+                throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.CANNOT_RERAISE, "Betting has not been re-opened to you (incomplete raise or no action)", {
+                    playerId: action.playerId,
+                    seat,
+                    lastAggressor: state.lastAggressorSeat,
+                });
+            }
+            if (currentBet === 0) {
+                throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.CANNOT_RAISE, `Player ${action.playerId} cannot raise when there's no bet`, { playerId: action.playerId });
+            }
+            if ("amount" in action) {
+                // Check if player is going all-in (incomplete raise exception)
+                const isAllIn = action.amount >= playerBet + player.stack;
+                // Reject raises that don't exceed current bet (unless all-in)
+                if (action.amount <= currentBet && !isAllIn) {
+                    throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${action.amount} must be greater than current bet ${currentBet}`, { amount: action.amount, currentBet });
+                }
+                // Check minimum raise requirement (unless player is going all-in)
+                const raiseIncrement = action.amount - currentBet;
+                if (!isAllIn && action.amount < state.minRaise) {
+                    throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${action.amount} is below minimum ${state.minRaise}`, {
+                        amount: action.amount,
+                        currentBet,
+                        raiseIncrement,
+                        minRaise: state.minRaise,
+                    });
+                }
+            }
+            break;
+    }
+}
+function validateDealAction(state) {
+    if (state.street !== "PREFLOP" /* Street.PREFLOP */ || state.handNumber > 0) {
+        // Allow dealing if we're at showdown (hand complete) or haven't started
+        if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */ && state.handNumber > 0) {
+            throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.CANNOT_DEAL, "Cannot deal while hand is in progress", { street: state.street });
+        }
+    }
+    // Check we have enough players
+    const activePlayers = state.players.filter((p) => p && p.stack > 0 && !p.isSittingOut);
+    if (activePlayers.length < 2) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.NOT_ENOUGH_PLAYERS, `Need at least 2 players to deal, found ${activePlayers.length}`, { playerCount: activePlayers.length });
+    }
+}
+function validateSitAction(state, action) {
+    if (action.seat < 0 || action.seat >= state.maxPlayers) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_SEAT, `Seat ${action.seat} is invalid (max: ${state.maxPlayers - 1})`, { seat: action.seat, maxPlayers: state.maxPlayers });
+    }
+    if (state.players[action.seat] !== null) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.SEAT_OCCUPIED, `Seat ${action.seat} is already occupied`, { seat: action.seat });
+    }
+    if (action.stack <= 0) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_STACK, `Stack must be positive, got ${action.stack}`, { stack: action.stack });
+    }
+}
+function validateStandAction(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+    }
+}
+function validateTimeAction(state, action) {
+    const result = (0, positioning_1.getPlayerById)(state, action.playerId);
+    if (!result) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+    }
+    const { seat } = result;
+    if (state.actionTo !== seat) {
+        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.NOT_YOUR_TURN, `Player ${action.playerId} cannot use time action when it's not their turn`, { playerId: action.playerId, actionTo: state.actionTo });
+    }
+}
+/**
+ * Get current highest bet this street
+ */
+function getCurrentBet(state) {
+    let maxBet = 0;
+    for (const bet of state.currentBets.values()) {
+        if (bet > maxBet) {
+            maxBet = bet;
+        }
+    }
+    return maxBet;
+}