@pokertools/engine 1.0.0

package/dist/rules/sidePots.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateSidePots = calculateSidePots;
+exports.calculateUncalledBet = calculateUncalledBet;
+exports.returnUncalledBet = returnUncalledBet;
+exports.recalculatePots = recalculatePots;
+const CriticalStateError_1 = require("../errors/CriticalStateError");
+/**
+ * Calculate side pots using iterative subtraction method
+ *
+ * Algorithm:
+ * 1. Combine all player investments (bets + total invested)
+ * 2. Sort by investment amount (ascending)
+ * 3. For each player from smallest to largest:
+ *    - Create pot = (player investment - previous) × remaining players
+ *    - Add player + all higher investors to eligible list
+ * 4. Return pots array (main + sides)
+ *
+ * @param state Current game state
+ * @returns Array of pots (main pot first, then side pots)
+ */
+function calculateSidePots(state) {
+    // Collect all investments (including folded players - their chips stay in the pot)
+    const investments = [];
+    for (let seat = 0; seat < state.players.length; seat++) {
+        const player = state.players[seat];
+        if (!player)
+            continue;
+        // totalInvestedThisHand already includes all bets (current and previous streets)
+        const totalInvestment = player.totalInvestedThisHand;
+        if (totalInvestment > 0) {
+            investments.push({
+                seat,
+                amount: totalInvestment,
+                folded: player.status === "FOLDED" /* PlayerStatus.FOLDED */,
+            });
+        }
+    }
+    // If no investments, return empty
+    if (investments.length === 0) {
+        return [];
+    }
+    // Sort by investment (ascending)
+    investments.sort((a, b) => a.amount - b.amount);
+    const pots = [];
+    let prevAmount = 0;
+    for (let i = 0; i < investments.length; i++) {
+        const current = investments[i];
+        const allAtThisLevel = investments.slice(i); // Current + all higher investors
+        const increment = current.amount - prevAmount;
+        // Create pot for this level
+        if (increment > 0) {
+            // Pot includes chips from ALL players at this level (including folded)
+            const potAmount = increment * allAtThisLevel.length;
+            // But only non-folded players are eligible to win
+            const eligibleSeats = allAtThisLevel.filter((inv) => !inv.folded).map((inv) => inv.seat);
+            // Must have at least one eligible player
+            // If everyone folded at this level, something went wrong in the game logic
+            if (eligibleSeats.length === 0) {
+                throw new CriticalStateError_1.CriticalStateError(`Side pot has no eligible players - all ${allAtThisLevel.length} players at this level have folded`, {
+                    potAmount,
+                    potLevel: i,
+                    investmentLevel: current.amount,
+                    allInvestors: allAtThisLevel.map((inv) => ({
+                        seat: inv.seat,
+                        amount: inv.amount,
+                        folded: inv.folded,
+                    })),
+                });
+            }
+            pots.push({
+                amount: potAmount,
+                eligibleSeats,
+                type: i === 0 ? "MAIN" : "SIDE",
+                capPerPlayer: current.amount,
+            });
+        }
+        prevAmount = current.amount;
+    }
+    return pots;
+}
+/**
+ * Calculate uncalled bet (when highest better has no callers)
+ *
+ * @param state Current game state
+ * @returns Tuple of [uncalled amount, seat to return to]
+ */
+function calculateUncalledBet(state) {
+    if (state.currentBets.size === 0) {
+        return null;
+    }
+    // Find highest bet
+    let maxBet = 0;
+    let maxBetSeat = -1;
+    let secondMaxBet = 0;
+    for (const [seat, bet] of state.currentBets.entries()) {
+        if (bet > maxBet) {
+            secondMaxBet = maxBet;
+            maxBet = bet;
+            maxBetSeat = seat;
+        }
+        else if (bet > secondMaxBet) {
+            secondMaxBet = bet;
+        }
+    }
+    const uncalled = maxBet - secondMaxBet;
+    if (uncalled > 0 && maxBetSeat >= 0) {
+        return [uncalled, maxBetSeat];
+    }
+    return null;
+}
+/**
+ * Return uncalled bet to player
+ */
+function returnUncalledBet(state) {
+    const uncalled = calculateUncalledBet(state);
+    if (!uncalled) {
+        return state;
+    }
+    const [amount, seat] = uncalled;
+    const player = state.players[seat];
+    if (!player) {
+        return state;
+    }
+    // Return chips to player
+    const newPlayers = [...state.players];
+    newPlayers[seat] = {
+        ...player,
+        stack: player.stack + amount,
+        totalInvestedThisHand: player.totalInvestedThisHand - amount,
+    };
+    // Reduce current bet
+    const newCurrentBets = new Map(state.currentBets);
+    const currentBet = newCurrentBets.get(seat) ?? 0;
+    newCurrentBets.set(seat, currentBet - amount);
+    // Record to action history
+    const actionRecord = {
+        action: {
+            type: "UNCALLED_BET_RETURNED" /* ActionType.UNCALLED_BET_RETURNED */,
+            playerId: player.id,
+            amount,
+            timestamp: state.timestamp,
+        },
+        seat,
+        resultingPot: state.pots.reduce((sum, pot) => sum + pot.amount, 0),
+        resultingStack: player.stack + amount,
+        street: state.street,
+    };
+    return {
+        ...state,
+        players: newPlayers,
+        currentBets: newCurrentBets,
+        actionHistory: [...state.actionHistory, actionRecord],
+    };
+}
+/**
+ * Recalculate pots after street action completes
+ * This is called before progressing to next street
+ */
+function recalculatePots(state) {
+    // First, return any uncalled bet
+    const newState = returnUncalledBet(state);
+    // Calculate side pots based on all investments
+    const pots = calculateSidePots(newState);
+    // Reset betThisStreet for all players (bets collected into pots)
+    const newPlayers = newState.players.map((p) => (p ? { ...p, betThisStreet: 0 } : null));
+    return {
+        ...newState,
+        players: newPlayers,
+        pots,
+        currentBets: new Map(), // Bets collected into pots
+    };
+}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.ts","../src/actions/betting.ts","../src/actions/dealing.ts","../src/actions/management.ts","../src/actions/showdownActions.ts","../src/actions/special.ts","../src/actions/streetProgression.ts","../src/actions/tournament.ts","../src/actions/validation.ts","../src/engine/PokerEngine.ts","../src/engine/gameReducer.ts","../src/errors/ConfigError.ts","../src/errors/CriticalStateError.ts","../src/errors/ErrorCodes.ts","../src/errors/IllegalActionError.ts","../src/errors/PokerEngineError.ts","../src/errors/index.ts","../src/history/exporter.ts","../src/history/handHistoryBuilder.ts","../src/history/types.ts","../src/history/formats/json.ts","../src/history/formats/pokerstars.ts","../src/rules/actionOrder.ts","../src/rules/blinds.ts","../src/rules/headsUp.ts","../src/rules/showdown.ts","../src/rules/sidePots.ts","../src/utils/cardUtils.ts","../src/utils/constants.ts","../src/utils/deck.ts","../src/utils/invariants.ts","../src/utils/positioning.ts","../src/utils/rake.ts","../src/utils/serialization.ts","../src/utils/validation.ts","../src/utils/viewMasking.ts"],"version":"5.9.3"}

package/dist/utils/cardUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert integer card codes to string array
+ */
+export declare function cardCodesToStrings(codes: readonly number[]): string[];
+/**
+ * Convert string card array to integer codes
+ */
+export declare function cardStringsToCards(cards: readonly string[]): number[];
+/**
+ * Validate card string format
+ */
+export declare function isValidCard(card: string): boolean;

package/dist/utils/cardUtils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cardCodesToStrings = cardCodesToStrings;
+exports.cardStringsToCards = cardStringsToCards;
+exports.isValidCard = isValidCard;
+const evaluator_1 = require("@pokertools/evaluator");
+/**
+ * Convert integer card codes to string array
+ */
+function cardCodesToStrings(codes) {
+    return codes.map((code) => (0, evaluator_1.stringifyCardCode)(code));
+}
+/**
+ * Convert string card array to integer codes
+ */
+function cardStringsToCards(cards) {
+    return cards.map((card) => (0, evaluator_1.getCardCode)(card));
+}
+/**
+ * Validate card string format
+ */
+function isValidCard(card) {
+    if (card.length !== 2)
+        return false;
+    const rank = card[0];
+    const suit = card[1];
+    const validRanks = ["2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A"];
+    const validSuits = ["s", "h", "d", "c"];
+    return validRanks.includes(rank) && validSuits.includes(suit);
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Game constants and configuration values
+ * Centralizes magic numbers for maintainability
+ */
+/**
+ * Maximum number of previous states to keep for undo functionality
+ */
+export declare const MAX_UNDO_HISTORY = 50;
+/**
+ * Percentage divisor for converting percentages to decimal
+ * e.g., 5% = 5 / PERCENTAGE_DIVISOR = 0.05
+ */
+export declare const PERCENTAGE_DIVISOR = 100;
+/**
+ * Number of cards to burn before dealing community cards on each street
+ */
+export declare const BURN_CARDS_PER_STREET = 1;
+/**
+ * Number of cards to deal on the flop
+ */
+export declare const FLOP_CARD_COUNT = 3;
+/**
+ * Number of cards to deal on the turn
+ */
+export declare const TURN_CARD_COUNT = 1;
+/**
+ * Number of cards to deal on the river
+ */
+export declare const RIVER_CARD_COUNT = 1;
+/**
+ * Number of hole cards dealt to each player in Texas Hold'em
+ */
+export declare const HOLE_CARDS_PER_PLAYER = 2;
+/**
+ * Maximum clock drift tolerance for timestamp validation (milliseconds)
+ * Allows for small differences in server clocks
+ */
+export declare const TIMESTAMP_FUTURE_TOLERANCE_MS = 1000;

package/dist/utils/constants.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Game constants and configuration values
+ * Centralizes magic numbers for maintainability
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMP_FUTURE_TOLERANCE_MS = exports.HOLE_CARDS_PER_PLAYER = exports.RIVER_CARD_COUNT = exports.TURN_CARD_COUNT = exports.FLOP_CARD_COUNT = exports.BURN_CARDS_PER_STREET = exports.PERCENTAGE_DIVISOR = exports.MAX_UNDO_HISTORY = void 0;
+/**
+ * Maximum number of previous states to keep for undo functionality
+ */
+exports.MAX_UNDO_HISTORY = 50;
+/**
+ * Percentage divisor for converting percentages to decimal
+ * e.g., 5% = 5 / PERCENTAGE_DIVISOR = 0.05
+ */
+exports.PERCENTAGE_DIVISOR = 100;
+/**
+ * Number of cards to burn before dealing community cards on each street
+ */
+exports.BURN_CARDS_PER_STREET = 1;
+/**
+ * Number of cards to deal on the flop
+ */
+exports.FLOP_CARD_COUNT = 3;
+/**
+ * Number of cards to deal on the turn
+ */
+exports.TURN_CARD_COUNT = 1;
+/**
+ * Number of cards to deal on the river
+ */
+exports.RIVER_CARD_COUNT = 1;
+/**
+ * Number of hole cards dealt to each player in Texas Hold'em
+ */
+exports.HOLE_CARDS_PER_PLAYER = 2;
+/**
+ * Maximum clock drift tolerance for timestamp validation (milliseconds)
+ * Allows for small differences in server clocks
+ */
+exports.TIMESTAMP_FUTURE_TOLERANCE_MS = 1000;

package/dist/utils/deck.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Create a standard 52-card deck
+ * Returns array of integer card codes (0-51)
+ */
+export declare function createDeck(): number[];
+/**
+ * Shuffle deck using Fisher-Yates algorithm with injectable RNG
+ *
+ * @param deck - Deck to shuffle (not modified, returns new array)
+ * @param rng - Random number generator function (0-1). MUST be cryptographically
+ *              secure for production use (e.g., use crypto.randomBytes)
+ * @returns New shuffled deck
+ *
+ * @security For production poker games, ALWAYS provide a cryptographically secure RNG.
+ * The default RNG uses Node.js crypto module if available, otherwise falls back to
+ * Math.random() which is NOT suitable for real-money games as it can be predicted.
+ *
+ * @example
+ * ```typescript
+ * // Production: Use crypto for secure shuffling
+ * import { randomBytes } from 'crypto';
+ * const secureRng = () => randomBytes(4).readUInt32BE(0) / 0x100000000;
+ * const deck = shuffle(createDeck(), secureRng);
+ *
+ * // Development/Testing: Default is acceptable
+ * const deck = shuffle(createDeck()); // Uses crypto if available
+ * ```
+ */
+export declare function shuffle(deck: readonly number[], rng?: () => number): number[];
+/**
+ * Deal cards from deck
+ *
+ * @param deck - Deck to deal from
+ * @param count - Number of cards to deal
+ * @returns Tuple of [dealt cards, remaining deck]
+ */
+export declare function dealCards(deck: readonly number[], count: number): [cards: number[], remaining: number[]];
+/**
+ * Burn one card and deal specified number
+ * (Standard poker procedure)
+ *
+ * @param deck - Deck to deal from
+ * @param count - Number of cards to deal after burn
+ * @returns Tuple of [dealt cards, remaining deck]
+ */
+export declare function burnAndDeal(deck: readonly number[], count: number): [cards: number[], remaining: number[]];

package/dist/utils/deck.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeck = createDeck;
+exports.shuffle = shuffle;
+exports.dealCards = dealCards;
+exports.burnAndDeal = burnAndDeal;
+/**
+ * Create a standard 52-card deck
+ * Returns array of integer card codes (0-51)
+ */
+function createDeck() {
+    const deck = [];
+    // For each rank (0-12: 2 through A)
+    for (let rank = 0; rank < 13; rank++) {
+        // For each suit (0-3: spades, hearts, diamonds, clubs)
+        for (let suit = 0; suit < 4; suit++) {
+            // Card code = (rank << 2) | suit
+            deck.push((rank << 2) | suit);
+        }
+    }
+    return deck;
+}
+/**
+ * Cryptographically secure RNG using Node.js crypto module
+ * Falls back to Math.random() only in browser/test environments
+ *
+ * @warning Math.random() is NOT cryptographically secure and should NEVER
+ * be used for production poker games. Always provide a secure RNG.
+ */
+function getSecureRandom() {
+    // Check if we're in Node.js environment
+    if (typeof process !== "undefined" && process.versions?.node) {
+        try {
+            // Use Node.js crypto for production
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
+            const crypto = require("crypto");
+            return () => {
+                // Generate cryptographically secure random number [0, 1)
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                const buffer = crypto.randomBytes(4);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                const value = buffer.readUInt32BE(0);
+                return value / 0x100000000;
+            };
+        }
+        catch (_error) {
+            console.warn("[SECURITY WARNING] crypto module not available. Falling back to Math.random(). " +
+                "DO NOT use in production for real-money games!");
+        }
+    }
+    // Fallback for browser/test environments - emit warning
+    if (process.env.NODE_ENV === "production") {
+        console.error("[CRITICAL SECURITY WARNING] Using Math.random() in production! " +
+            "This is NOT cryptographically secure and games can be predicted. " +
+            "Provide a secure RNG via the rng parameter.");
+    }
+    return Math.random;
+}
+/**
+ * Shuffle deck using Fisher-Yates algorithm with injectable RNG
+ *
+ * @param deck - Deck to shuffle (not modified, returns new array)
+ * @param rng - Random number generator function (0-1). MUST be cryptographically
+ *              secure for production use (e.g., use crypto.randomBytes)
+ * @returns New shuffled deck
+ *
+ * @security For production poker games, ALWAYS provide a cryptographically secure RNG.
+ * The default RNG uses Node.js crypto module if available, otherwise falls back to
+ * Math.random() which is NOT suitable for real-money games as it can be predicted.
+ *
+ * @example
+ * ```typescript
+ * // Production: Use crypto for secure shuffling
+ * import { randomBytes } from 'crypto';
+ * const secureRng = () => randomBytes(4).readUInt32BE(0) / 0x100000000;
+ * const deck = shuffle(createDeck(), secureRng);
+ *
+ * // Development/Testing: Default is acceptable
+ * const deck = shuffle(createDeck()); // Uses crypto if available
+ * ```
+ */
+function shuffle(deck, rng) {
+    const random = rng ?? getSecureRandom();
+    const shuffled = [...deck]; // Create mutable copy
+    // Fisher-Yates shuffle
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(random() * (i + 1));
+        // Swap elements
+        const temp = shuffled[i];
+        shuffled[i] = shuffled[j];
+        shuffled[j] = temp;
+    }
+    return shuffled;
+}
+/**
+ * Deal cards from deck
+ *
+ * @param deck - Deck to deal from
+ * @param count - Number of cards to deal
+ * @returns Tuple of [dealt cards, remaining deck]
+ */
+function dealCards(deck, count) {
+    if (count > deck.length) {
+        throw new Error(`Cannot deal ${count} cards from deck of ${deck.length}`);
+    }
+    const cards = deck.slice(0, count);
+    const remaining = deck.slice(count);
+    return [Array.from(cards), Array.from(remaining)];
+}
+/**
+ * Burn one card and deal specified number
+ * (Standard poker procedure)
+ *
+ * @param deck - Deck to deal from
+ * @param count - Number of cards to deal after burn
+ * @returns Tuple of [dealt cards, remaining deck]
+ */
+function burnAndDeal(deck, count) {
+    if (count + 1 > deck.length) {
+        throw new Error(`Cannot burn and deal ${count} cards from deck of ${deck.length}`);
+    }
+    // Skip first card (burn), deal next 'count' cards
+    const cards = deck.slice(1, count + 1);
+    const remaining = deck.slice(count + 1);
+    return [Array.from(cards), Array.from(remaining)];
+}

package/dist/utils/invariants.d.ts

@@ -0,0 +1,39 @@
+import { GameState } from "@pokertools/types";
+/**
+ * Audit chip conservation
+ * Formula: ∑(player.stack) + ∑(pot.amount) + ∑(currentBets) = initialChips
+ *
+ * @param state Current game state
+ * @param initialChips Total chips that should be in the game
+ * @throws CriticalStateError if chips don't match
+ */
+export declare function auditChipConservation(state: GameState, initialChips: number): void;
+/**
+ * Calculate total chips in the game
+ */
+export declare function calculateTotalChips(state: GameState): number;
+/**
+ * Calculate total chips in player stacks
+ */
+export declare function calculateStackTotal(state: GameState): number;
+/**
+ * Calculate total chips in pots
+ */
+export declare function calculatePotTotal(state: GameState): number;
+/**
+ * Calculate total chips in current bets
+ */
+export declare function calculateBetTotal(state: GameState): number;
+/**
+ * Get initial chips (sum of all starting stacks)
+ * This calculates total chips in the game, which should remain constant (minus rake).
+ *
+ * - During a hand: stack + totalInvestedThisHand (chips in play + chips invested)
+ * - After hand complete: stack + rake (all chips have been distributed, rake removed)
+ */
+export declare function getInitialChips(state: GameState): number;
+/**
+ * Validate game state integrity
+ * Checks multiple invariants beyond just chip conservation
+ */
+export declare function validateGameStateIntegrity(state: GameState): void;

package/dist/utils/invariants.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditChipConservation = auditChipConservation;
+exports.calculateTotalChips = calculateTotalChips;
+exports.calculateStackTotal = calculateStackTotal;
+exports.calculatePotTotal = calculatePotTotal;
+exports.calculateBetTotal = calculateBetTotal;
+exports.getInitialChips = getInitialChips;
+exports.validateGameStateIntegrity = validateGameStateIntegrity;
+const CriticalStateError_1 = require("../errors/CriticalStateError");
+/**
+ * Audit chip conservation
+ * Formula: ∑(player.stack) + ∑(pot.amount) + ∑(currentBets) = initialChips
+ *
+ * @param state Current game state
+ * @param initialChips Total chips that should be in the game
+ * @throws CriticalStateError if chips don't match
+ */
+function auditChipConservation(state, initialChips) {
+    const currentChips = getInitialChips(state);
+    if (currentChips !== initialChips) {
+        throw new CriticalStateError_1.CriticalStateError(`Chip conservation violated: expected ${initialChips}, found ${currentChips}`, {
+            expected: initialChips,
+            actual: currentChips,
+            difference: currentChips - initialChips,
+            stacks: calculateStackTotal(state),
+            pots: calculatePotTotal(state),
+            bets: calculateBetTotal(state),
+            street: state.street,
+            handId: state.handId,
+        });
+    }
+}
+/**
+ * Calculate total chips in the game
+ */
+function calculateTotalChips(state) {
+    return calculateStackTotal(state) + calculatePotTotal(state) + calculateBetTotal(state);
+}
+/**
+ * Calculate total chips in player stacks
+ */
+function calculateStackTotal(state) {
+    let total = 0;
+    for (const player of state.players) {
+        if (player) {
+            total += player.stack;
+        }
+    }
+    return total;
+}
+/**
+ * Calculate total chips in pots
+ */
+function calculatePotTotal(state) {
+    let total = 0;
+    for (const pot of state.pots) {
+        total += pot.amount;
+    }
+    return total;
+}
+/**
+ * Calculate total chips in current bets
+ */
+function calculateBetTotal(state) {
+    let total = 0;
+    for (const bet of state.currentBets.values()) {
+        total += bet;
+    }
+    return total;
+}
+/**
+ * Get initial chips (sum of all starting stacks)
+ * This calculates total chips in the game, which should remain constant (minus rake).
+ *
+ * - During a hand: stack + totalInvestedThisHand (chips in play + chips invested)
+ * - After hand complete: stack + rake (all chips have been distributed, rake removed)
+ */
+function getInitialChips(state) {
+    let total = 0;
+    // Hand is complete if winners are declared AND pots/bets have been distributed
+    // This ensures we don't switch modes mid-hand
+    const handComplete = state.winners !== null && state.pots.length === 0 && state.currentBets.size === 0;
+    for (const player of state.players) {
+        if (player) {
+            if (handComplete) {
+                // Hand complete: only count current stacks
+                total += player.stack;
+            }
+            else {
+                // Hand in progress: stack + invested
+                total += player.stack + player.totalInvestedThisHand;
+            }
+        }
+    }
+    // Add rake back to total after hand is complete (cash games only)
+    // Rake is removed from the game, so we need to account for it
+    if (handComplete) {
+        total += state.rakeThisHand;
+    }
+    return total;
+}
+/**
+ * Validate game state integrity
+ * Checks multiple invariants beyond just chip conservation
+ */
+function validateGameStateIntegrity(state) {
+    // 1. Chip conservation
+    const initialChips = getInitialChips(state);
+    auditChipConservation(state, initialChips);
+    // 2. No negative stacks
+    for (const player of state.players) {
+        if (player && player.stack < 0) {
+            throw new CriticalStateError_1.CriticalStateError(`Player ${player.id} has negative stack: ${player.stack}`, {
+                playerId: player.id,
+                stack: player.stack,
+            });
+        }
+    }
+    // 3. No negative bets
+    for (const [seat, bet] of state.currentBets.entries()) {
+        if (bet < 0) {
+            throw new CriticalStateError_1.CriticalStateError(`Seat ${seat} has negative bet: ${bet}`, {
+                seat,
+                bet,
+            });
+        }
+    }
+    // 4. No negative pots
+    for (let i = 0; i < state.pots.length; i++) {
+        const pot = state.pots[i];
+        if (pot.amount < 0) {
+            throw new CriticalStateError_1.CriticalStateError(`Pot ${i} has negative amount: ${pot.amount}`, {
+                potIndex: i,
+                amount: pot.amount,
+            });
+        }
+    }
+    // 5. ActionTo must be valid seat or null
+    if (state.actionTo !== null) {
+        if (state.actionTo < 0 || state.actionTo >= state.maxPlayers) {
+            throw new CriticalStateError_1.CriticalStateError(`Invalid actionTo: ${state.actionTo}`, {
+                actionTo: state.actionTo,
+                maxPlayers: state.maxPlayers,
+            });
+        }
+        const player = state.players[state.actionTo];
+        if (!player) {
+            throw new CriticalStateError_1.CriticalStateError(`ActionTo points to empty seat: ${state.actionTo}`, {
+                actionTo: state.actionTo,
+            });
+        }
+    }
+    // 6. Button must be valid or null
+    if (state.buttonSeat !== null) {
+        if (state.buttonSeat < 0 || state.buttonSeat >= state.maxPlayers) {
+            throw new CriticalStateError_1.CriticalStateError(`Invalid buttonSeat: ${state.buttonSeat}`, {
+                buttonSeat: state.buttonSeat,
+                maxPlayers: state.maxPlayers,
+            });
+        }
+    }
+}