@pokertools/engine 1.0.8 → 1.0.9

package/dist/rules/{actionOrder.js → action-order.js}

@@ -4,7 +4,7 @@ exports.getNextToAct = getNextToAct;
 exports.getFirstToAct = getFirstToAct;
 exports.isActionComplete = isActionComplete;
 const positioning_1 = require("../utils/positioning");
-const headsUp_1 = require("./headsUp");
+const heads_up_1 = require("./heads-up");
 const blinds_1 = require("./blinds");
 /**
  * Determine the next player to act
@@ -12,7 +12,7 @@ const blinds_1 = require("./blinds");
  */
 function getNextToAct(state) {
     // Special case: heads-up has different rules
-    if ((0, headsUp_1.isHeadsUp)(state)) {
+    if ((0, heads_up_1.isHeadsUp)(state)) {
         return getNextToActHeadsUp(state);
     }
     return getNextToActNormal(state);
@@ -32,8 +32,8 @@ function getNextToActNormal(state) {
     // Search for next player who can act
     while (seat !== startSeat) {
         const player = state.players[seat];
-        // Skip if: no player, folded, all-in, or busted
-        if (player?.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack === 0) {
+        // Skip if: no player, folded, all-in, busted, or sitting out
+        if (player?.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack === 0 || player.isSittingOut) {
             seat = (0, positioning_1.getNextSeat)(seat, state.maxPlayers);
             continue;
         }
@@ -65,7 +65,7 @@ function getNextToActHeadsUp(state) {
     if (state.buttonSeat === null) {
         return null;
     }
-    const actionOrder = (0, headsUp_1.getHeadsUpActionOrder)(state, state.street);
+    const actionOrder = (0, heads_up_1.getHeadsUpActionOrder)(state, state.street);
     if (actionOrder.length === 0) {
         return null;
     }
@@ -77,7 +77,7 @@ function getNextToActHeadsUp(state) {
     // Check both players
     for (const seat of actionOrder) {
         const player = state.players[seat];
-        if (player?.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack === 0) {
+        if (player?.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack === 0 || player.isSittingOut) {
             continue;
         }
         const playerBet = state.currentBets.get(seat) ?? 0;
@@ -94,8 +94,8 @@ function getFirstToAct(state) {
     if (state.buttonSeat === null) {
         return null;
     }
-    if ((0, headsUp_1.isHeadsUp)(state)) {
-        const order = (0, headsUp_1.getHeadsUpActionOrder)(state, state.street);
+    if ((0, heads_up_1.isHeadsUp)(state)) {
+        const order = (0, heads_up_1.getHeadsUpActionOrder)(state, state.street);
         if (order.length > 0) {
             return order[0];
         }
@@ -128,7 +128,7 @@ function getNextActionableSeat(startSeat, state) {
     // Scan full circle
     while (seat !== endSeat) {
         const player = state.players[seat];
-        if (player?.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
+        if (player?.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0 && !player.isSittingOut) {
             return seat;
         }
         seat = (0, positioning_1.getNextSeat)(seat, state.maxPlayers);
@@ -159,7 +159,7 @@ function isActionComplete(state) {
         if (!player)
             continue;
         // Count active players who can still act
-        if (player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
+        if (player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0 && !player.isSittingOut) {
             activeCount++;
             const playerBet = state.currentBets.get(seat) ?? 0;
             // Player has matched bet and acted

package/dist/rules/blinds.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBlindPositions = getBlindPositions;
 exports.calculateAntes = calculateAntes;
 const positioning_1 = require("../utils/positioning");
-const headsUp_1 = require("./headsUp");
+const heads_up_1 = require("./heads-up");
 /**
  * Determine which seats should post blinds
  *
@@ -24,7 +24,7 @@ function getBlindPositions(state) {
     const buttonSeat = state.buttonSeat;
     const isTournament = !!state.config.blindStructure;
     // Heads-up specific logic (Button is SB)
-    if ((0, headsUp_1.isHeadsUp)(state)) {
+    if ((0, heads_up_1.isHeadsUp)(state)) {
         const bbSeat = getNextActiveOrOccupiedSeat(buttonSeat, state.players, state.maxPlayers, isTournament);
         if (bbSeat === null) {
             return null;

package/dist/rules/showdown.js

@@ -143,7 +143,7 @@ function evaluatePot(state, pot) {
         evaluations.push({
             seat: player.seat,
             score,
-            hand: [...player.hand], // Store hole cards (copy to mutable array)
+            hand: getBestFiveCardHand(allCards),
             description,
         });
     }
@@ -155,6 +155,39 @@ function evaluatePot(state, pot) {
     const winners = evaluations.filter((e) => e.score === bestScore);
     return winners;
 }
+/**
+ * Return the concrete five cards that produce the best evaluator score.
+ * The evaluator score is lower-is-better, so enumerate all 5-card subsets and
+ * keep the first subset with the minimum score. Hold'em has at most 7 cards,
+ * making this deterministic brute-force path only 21 evaluations per player.
+ */
+function getBestFiveCardHand(cards) {
+    if (cards.length === 5) {
+        return [...cards];
+    }
+    let bestHand = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (let a = 0; a < cards.length - 4; a++) {
+        for (let b = a + 1; b < cards.length - 3; b++) {
+            for (let c = b + 1; c < cards.length - 2; c++) {
+                for (let d = c + 1; d < cards.length - 1; d++) {
+                    for (let e = d + 1; e < cards.length; e++) {
+                        const candidate = [cards[a], cards[b], cards[c], cards[d], cards[e]];
+                        const score = (0, evaluator_1.evaluate)((0, evaluator_1.getCardCodes)(candidate));
+                        if (score < bestScore) {
+                            bestScore = score;
+                            bestHand = candidate;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (bestHand === null) {
+        return [...cards.slice(0, 5)];
+    }
+    return bestHand;
+}
 /**
  * Check if hand should go to showdown
  */

package/dist/rules/{sidePots.js → side-pots.js}

@@ -4,7 +4,7 @@ exports.calculateSidePots = calculateSidePots;
 exports.calculateUncalledBet = calculateUncalledBet;
 exports.returnUncalledBet = returnUncalledBet;
 exports.recalculatePots = recalculatePots;
-const CriticalStateError_1 = require("../errors/CriticalStateError");
+const critical_state_error_1 = require("../errors/critical-state-error");
 /**
  * Calculate side pots using iterative subtraction method
  *
@@ -57,7 +57,7 @@ function calculateSidePots(state) {
             // 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`, {
+                throw new critical_state_error_1.CriticalStateError(`Side pot has no eligible players - all ${allAtThisLevel.length} players at this level have folded`, {
                     potAmount,
                     potLevel: i,
                     investmentLevel: current.amount,

package/dist/utils/invariants.js

@@ -7,7 +7,7 @@ exports.calculatePotTotal = calculatePotTotal;
 exports.calculateBetTotal = calculateBetTotal;
 exports.getInitialChips = getInitialChips;
 exports.validateGameStateIntegrity = validateGameStateIntegrity;
-const CriticalStateError_1 = require("../errors/CriticalStateError");
+const critical_state_error_1 = require("../errors/critical-state-error");
 /**
  * Audit chip conservation
  * Formula: ∑(player.stack) + ∑(pot.amount) + ∑(currentBets) = initialChips
@@ -17,9 +17,10 @@ const CriticalStateError_1 = require("../errors/CriticalStateError");
  * @throws CriticalStateError if chips don't match
  */
 function auditChipConservation(state, initialChips) {
-    const currentChips = getInitialChips(state);
+    const handComplete = state.winners !== null && state.pots.length === 0 && state.currentBets.size === 0;
+    const currentChips = calculateTotalChips(state) + (handComplete ? state.rakeThisHand : 0);
     if (currentChips !== initialChips) {
-        throw new CriticalStateError_1.CriticalStateError(`Chip conservation violated: expected ${initialChips}, found ${currentChips}`, {
+        throw new critical_state_error_1.CriticalStateError(`Chip conservation violated: expected ${initialChips}, found ${currentChips}`, {
             expected: initialChips,
             actual: currentChips,
             difference: currentChips - initialChips,
@@ -77,6 +78,10 @@ function calculateBetTotal(state) {
  * - After hand complete: stack + rake (all chips have been distributed, rake removed)
  */
 function getInitialChips(state) {
+    const baseline = state.initialChips;
+    if (typeof baseline === "number") {
+        return baseline;
+    }
     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
@@ -110,12 +115,13 @@ function validateGameStateIntegrity(state) {
         return;
     }
     // 1. Chip conservation
-    const initialChips = getInitialChips(state);
+    const baseline = state.initialChips;
+    const initialChips = typeof baseline === "number" ? baseline : 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}`, {
+            throw new critical_state_error_1.CriticalStateError(`Player ${player.id} has negative stack: ${player.stack}`, {
                 playerId: player.id,
                 stack: player.stack,
             });
@@ -124,7 +130,7 @@ function validateGameStateIntegrity(state) {
     // 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}`, {
+            throw new critical_state_error_1.CriticalStateError(`Seat ${seat} has negative bet: ${bet}`, {
                 seat,
                 bet,
             });
@@ -134,7 +140,7 @@ function validateGameStateIntegrity(state) {
     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}`, {
+            throw new critical_state_error_1.CriticalStateError(`Pot ${i} has negative amount: ${pot.amount}`, {
                 potIndex: i,
                 amount: pot.amount,
             });
@@ -143,14 +149,14 @@ function validateGameStateIntegrity(state) {
     // 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}`, {
+            throw new critical_state_error_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}`, {
+            throw new critical_state_error_1.CriticalStateError(`ActionTo points to empty seat: ${state.actionTo}`, {
                 actionTo: state.actionTo,
             });
         }
@@ -158,7 +164,7 @@ function validateGameStateIntegrity(state) {
     // 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}`, {
+            throw new critical_state_error_1.CriticalStateError(`Invalid buttonSeat: ${state.buttonSeat}`, {
                 buttonSeat: state.buttonSeat,
                 maxPlayers: state.maxPlayers,
             });

package/dist/utils/serialization.d.ts

@@ -28,6 +28,7 @@ export interface Snapshot {
     readonly timeBankActiveSeat: number | null;
     readonly actionHistory: ActionRecord[];
     readonly previousStates: Snapshot[];
+    readonly initialChips?: number;
     readonly timestamp: number;
     readonly handId: string;
 }

package/dist/utils/serialization.js

@@ -19,8 +19,12 @@ function createSnapshot(state) {
     for (const [seat, time] of state.timeBanks.entries()) {
         timeBanks[seat] = time;
     }
-    // Truncate previous states (keep last 10 only)
-    const previousStates = state.previousStates.slice(-10).map((s) => createSnapshot(s));
+    // Truncate previous states and do not recursively serialize nested undo
+    // histories, avoiding exponential snapshot growth.
+    const previousStates = state.previousStates.slice(-10).map((s) => createSnapshot({
+        ...s,
+        previousStates: [],
+    }));
     return {
         config: state.config,
         players: [...state.players],
@@ -47,6 +51,7 @@ function createSnapshot(state) {
         timeBankActiveSeat: state.timeBankActiveSeat,
         actionHistory: Array.from(state.actionHistory),
         previousStates,
+        initialChips: state.initialChips,
         timestamp: state.timestamp,
         handId: state.handId,
     };
@@ -72,7 +77,8 @@ function restoreFromSnapshot(snapshot) {
         timeBanks,
         timeBankActiveSeat: snapshot.timeBankActiveSeat ?? null, // Backward compatibility
         previousStates,
-        rakeThisHand: snapshot.rakeThisHand || 0, // Add missing field with default
+        initialChips: snapshot.initialChips,
+        rakeThisHand: snapshot.rakeThisHand ?? 0, // Add missing field with default
     };
 }
 /**

package/dist/utils/validation.js

@@ -5,8 +5,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateChipAmount = validateChipAmount;
 exports.validateTimestamp = validateTimestamp;
-const IllegalActionError_1 = require("../errors/IllegalActionError");
-const ErrorCodes_1 = require("../errors/ErrorCodes");
+const illegal_action_error_1 = require("../errors/illegal-action-error");
+const error_codes_1 = require("../errors/error-codes");
 const constants_1 = require("./constants");
 /**
  * Validate that a chip amount is a non-negative integer
@@ -18,13 +18,13 @@ const constants_1 = require("./constants");
  */
 function validateChipAmount(amount, context) {
     if (!Number.isFinite(amount)) {
-        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} is not a valid number`, { amount, context });
+        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} is not a valid number`, { amount, context });
     }
     if (!Number.isInteger(amount)) {
-        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} must be an integer (fractional chips not allowed)`, { amount, context });
+        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} must be an integer (fractional chips not allowed)`, { amount, context });
     }
     if (amount < 0) {
-        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} cannot be negative`, { amount, context });
+        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} cannot be negative`, { amount, context });
     }
 }
 /**
@@ -36,17 +36,17 @@ function validateChipAmount(amount, context) {
  */
 function validateTimestamp(timestamp, previousTimestamp) {
     if (!Number.isFinite(timestamp) || timestamp < 0) {
-        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_TIMESTAMP, `Invalid timestamp: ${timestamp}`, {
+        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_TIMESTAMP, `Invalid timestamp: ${timestamp}`, {
             timestamp,
         });
     }
     // Allow some clock drift tolerance for "future" timestamps
     const now = Date.now() + constants_1.TIMESTAMP_FUTURE_TOLERANCE_MS;
     if (timestamp > now) {
-        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_TIMESTAMP, `Timestamp ${timestamp} is in the future (current: ${Date.now()})`, { timestamp, currentTime: Date.now() });
+        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_TIMESTAMP, `Timestamp ${timestamp} is in the future (current: ${Date.now()})`, { timestamp, currentTime: Date.now() });
     }
     // Ensure timestamps are monotonically increasing (or equal for same-time actions)
     if (previousTimestamp !== undefined && timestamp < previousTimestamp) {
-        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.INVALID_TIMESTAMP, `Timestamp ${timestamp} is before previous action timestamp ${previousTimestamp}`, { timestamp, previousTimestamp });
+        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_TIMESTAMP, `Timestamp ${timestamp} is before previous action timestamp ${previousTimestamp}`, { timestamp, previousTimestamp });
     }
 }

package/dist/utils/{viewMasking.js → view-masking.js}

@@ -24,20 +24,30 @@ function createPublicView(state, playerId = null, version = 0) {
             hand: visibleHand,
         };
     });
-    // Convert Map to plain object for JSON serialization
-    const currentBetsObj = {};
-    for (const [seat, amount] of state.currentBets.entries()) {
-        currentBetsObj[seat] = amount;
-    }
+    const currentBets = createSerializableReadonlyMap(state.currentBets);
     return {
         ...state,
         deck: [], // Always hide deck
         players: maskedPlayers,
-        currentBets: currentBetsObj, // Serializable record
+        currentBets,
         viewingPlayerId: playerId,
         version,
     };
 }
+function createSerializableReadonlyMap(source) {
+    const map = new Map(source);
+    Object.defineProperty(map, "toJSON", {
+        value: () => {
+            const record = {};
+            for (const [seat, amount] of map.entries()) {
+                record[seat] = amount;
+            }
+            return record;
+        },
+        enumerable: false,
+    });
+    return map;
+}
 /**
  * Get visible cards for a player based on shownCards and viewer permissions
  * Returns null (all hidden), full hand, or partial hand with positional context preserved

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pokertools/engine",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Enterprise-grade Texas Hold'em poker engine",
   "author": "A.Aurelius",
   "license": "MIT",
@@ -66,11 +66,11 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@pokertools/evaluator": "1.0.8",
-    "@pokertools/types": "1.0.8"
+    "@pokertools/evaluator": "1.0.9",
+    "@pokertools/types": "1.0.9"
   },
   "peerDependencies": {
-    "@pokertools/evaluator": "1.0.8",
-    "@pokertools/types": "1.0.8"
+    "@pokertools/evaluator": "1.0.9",
+    "@pokertools/types": "1.0.9"
   }
 }