@pokertools/engine 1.0.9 → 1.0.11

package/dist/rules/action-order.js

@@ -11,7 +11,6 @@ const blinds_1 = require("./blinds");
  * Returns seat number or null if action is complete
  */
 function getNextToAct(state) {
-    // Special case: heads-up has different rules
     if ((0, heads_up_1.isHeadsUp)(state)) {
         return getNextToActHeadsUp(state);
     }
@@ -42,12 +41,10 @@ function getNextToActNormal(state) {
         // 2. Current bet is higher than their bet
         const playerBet = state.currentBets.get(seat) ?? 0;
         if (playerBet < currentBet) {
-            return seat; // Player needs to respond to bet
+            return seat;
         }
-        // Player has matched current bet
-        // Check if they've already acted
         if (!hasActedThisStreet(state, seat)) {
-            return seat; // Player hasn't acted yet
+            return seat;
         }
         foundActionable = true;
         seat = (0, positioning_1.getNextSeat)(seat, state.maxPlayers);
@@ -125,7 +122,6 @@ function getFirstToAct(state) {
 function getNextActionableSeat(startSeat, state) {
     let seat = (0, positioning_1.getNextSeat)(startSeat, state.maxPlayers);
     const endSeat = startSeat;
-    // Scan full circle
     while (seat !== endSeat) {
         const player = state.players[seat];
         if (player?.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0 && !player.isSittingOut) {
@@ -183,7 +179,6 @@ function isActionComplete(state) {
  * This is tracked by checking if they appear in the action history for this street
  */
 function hasActedThisStreet(state, seat) {
-    // Find actions from current street
     const streetStartIndex = findStreetStartIndex(state);
     for (let i = streetStartIndex; i < state.actionHistory.length; i++) {
         if (state.actionHistory[i].seat === seat) {

package/dist/rules/blinds.js

@@ -66,7 +66,7 @@ function getNextActiveOrOccupiedSeat(currentSeat, players, maxPlayers, isTournam
         }
         seat = (0, positioning_1.getNextSeat)(seat, maxPlayers);
     }
-    return null; // No eligible seats
+    return null;
 }
 /**
  * Calculate blind amounts for antes
@@ -76,10 +76,11 @@ function calculateAntes(state) {
     if (state.ante === 0) {
         return antes;
     }
-    // All active players post antes
+    const isTournament = !!state.config.blindStructure;
+    // Tournament players blind/ante off while sitting out; cash-game sit-outs do not.
     for (let seat = 0; seat < state.players.length; seat++) {
         const player = state.players[seat];
-        if (player && player.stack > 0) {
+        if (player && player.stack > 0 && (isTournament || !player.isSittingOut)) {
             const anteAmount = Math.min(player.stack, state.ante);
             antes.set(seat, anteAmount);
         }

package/dist/rules/heads-up.js

@@ -25,14 +25,13 @@ function getHeadsUpActionOrder(state, street) {
     const buttonSeat = state.buttonSeat;
     const activePlayers = state.players
         .map((p, seat) => ({ player: p, seat }))
-        .filter(({ player }) => player && (player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ || player.status === "ALL_IN" /* PlayerStatus.ALL_IN */))
+        .filter(({ player }) => player?.status === "ACTIVE" /* PlayerStatus.ACTIVE */)
         .map(({ seat }) => seat);
     if (activePlayers.length !== 2) {
         return activePlayers;
     }
     // Find the two seats
     const [seat1, seat2] = activePlayers.sort((a, b) => a - b);
-    // Check if button is one of the active players
     const isButtonActive = activePlayers.includes(buttonSeat);
     if (!isButtonActive) {
         // Dead button scenario - button is not one of the active players

package/dist/rules/showdown.js

@@ -34,8 +34,8 @@ function determineWinners(state) {
         // Distribute pot among winners
         const share = Math.floor(potAfterRake / potWinners.length);
         const remainder = potAfterRake % potWinners.length;
-        // Sort winners by position (worst to best) for odd chip distribution
-        // TDA Rule: Odd chips go to first player(s) clockwise from button
+        // Sort winners by position for odd chip distribution.
+        // TDA Rule: odd chips go to first player(s) clockwise from the button.
         const sortedWinners = [...potWinners].sort((a, b) => {
             if (state.buttonSeat === null)
                 return 0;
@@ -47,20 +47,17 @@ function determineWinners(state) {
         for (let i = 0; i < sortedWinners.length; i++) {
             const evaluation = sortedWinners[i];
             let award = share;
-            // Distribute odd chips one at a time to worst positions
-            // (first N winners in sorted order get the extra chips)
+            // First N winners (worst position) each get one extra chip.
             if (i < remainder) {
                 award += 1;
             }
-            // Track winner seats
             winnerSeats.add(evaluation.seat);
-            // Award chips to player
             const player = newPlayers[evaluation.seat];
             newPlayers[evaluation.seat] = {
                 ...player,
                 stack: player.stack + award,
             };
-            // Record winner
+            // Record winner with hand description.
             winners.push({
                 seat: evaluation.seat,
                 amount: award,
@@ -77,7 +74,7 @@ function determineWinners(state) {
                 // Winners must show all cards
                 newPlayers[seat] = {
                     ...player,
-                    shownCards: [0, 1], // Show both cards
+                    shownCards: Array.from({ length: player.hand.length }, (_, i) => i),
                 };
             }
             else {
@@ -104,11 +101,10 @@ function determineWinners(state) {
  * Evaluate a single pot and return winner(s)
  */
 function evaluatePot(state, pot) {
-    // Get eligible players (not folded)
     const eligible = pot.eligibleSeats
         .map((seat) => state.players[seat])
         .filter((player) => player && (player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ || player.status === "ALL_IN" /* PlayerStatus.ALL_IN */));
-    // If only one player, they win without showing
+    // Single remaining player wins uncontested.
     if (eligible.length === 1) {
         const player = eligible[0];
         return [
@@ -120,22 +116,17 @@ function evaluatePot(state, pot) {
             },
         ];
     }
-    // Evaluate all hands
     const evaluations = [];
     for (const player of eligible) {
         if (!player?.hand)
             continue;
-        // Skip masked hands (client mode)
+        // Skip masked hands in client mode.
         if (player.hand.some((c) => c === null)) {
             continue;
         }
-        // Combine hole cards + board (7 cards total for river)
         const allCards = [...player.hand, ...state.board];
-        if (allCards.length < 5) {
-            // Not enough cards (shouldn't happen)
+        if (allCards.length < 5)
             continue;
-        }
-        // Evaluate using @pokertools/evaluator
         const cardCodes = (0, evaluator_1.getCardCodes)(allCards);
         const score = (0, evaluator_1.evaluate)(cardCodes);
         const handRank = (0, evaluator_1.rank)(cardCodes);
@@ -150,10 +141,8 @@ function evaluatePot(state, pot) {
     if (evaluations.length === 0) {
         return [];
     }
-    // Find best hand(s)
     const bestScore = Math.min(...evaluations.map((e) => e.score));
-    const winners = evaluations.filter((e) => e.score === bestScore);
-    return winners;
+    return evaluations.filter((e) => e.score === bestScore);
 }
 /**
  * Return the concrete five cards that produce the best evaluator score.
@@ -192,16 +181,10 @@ function getBestFiveCardHand(cards) {
  * Check if hand should go to showdown
  */
 function shouldShowdown(state) {
-    // Showdown if:
-    // 1. We're at SHOWDOWN street
-    // 2. Multiple players remain (not folded)
-    // 3. Winners haven't been determined yet
-    if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */) {
+    if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */)
+        return false;
+    if (state.winners !== null)
         return false;
-    }
-    if (state.winners !== null) {
-        return false; // Already determined winners
-    }
     const activePlayers = state.players.filter((p) => p && (p.status === "ACTIVE" /* PlayerStatus.ACTIVE */ || p.status === "ALL_IN" /* PlayerStatus.ALL_IN */));
     return activePlayers.length >= 2;
 }

package/dist/rules/side-pots.js

@@ -36,11 +36,9 @@ function calculateSidePots(state) {
             });
         }
     }
-    // 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;
@@ -48,14 +46,11 @@ function calculateSidePots(state) {
         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)
+            // Pot includes ALL players at this level (folded players' chips stay in).
             const potAmount = increment * allAtThisLevel.length;
-            // But only non-folded players are eligible to win
+            // 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 critical_state_error_1.CriticalStateError(`Side pot has no eligible players - all ${allAtThisLevel.length} players at this level have folded`, {
                     potAmount,
@@ -86,10 +81,8 @@ function calculateSidePots(state) {
  * @returns Tuple of [uncalled amount, seat to return to]
  */
 function calculateUncalledBet(state) {
-    if (state.currentBets.size === 0) {
+    if (state.currentBets.size === 0)
         return null;
-    }
-    // Find highest bet
     let maxBet = 0;
     let maxBetSeat = -1;
     let secondMaxBet = 0;
@@ -119,21 +112,17 @@ function returnUncalledBet(state) {
     }
     const [amount, seat] = uncalled;
     const player = state.players[seat];
-    if (!player) {
+    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 */,
@@ -158,11 +147,9 @@ function returnUncalledBet(state) {
  * 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)
+    // Reset betThisStreet after collecting bets into pots.
     const newPlayers = newState.players.map((p) => (p ? { ...p, betThisStreet: 0 } : null));
     return {
         ...newState,

package/dist/utils/deck.js

@@ -28,10 +28,8 @@ function createDeck() {
  * 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 () => {
@@ -81,11 +79,10 @@ function getSecureRandom() {
  */
 function shuffle(deck, rng) {
     const random = rng ?? getSecureRandom();
-    const shuffled = [...deck]; // Create mutable copy
+    const shuffled = [...deck];
     // 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;

package/dist/utils/invariants.js

@@ -160,6 +160,14 @@ function validateGameStateIntegrity(state) {
                 actionTo: state.actionTo,
             });
         }
+        if (player.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack <= 0 || player.isSittingOut) {
+            throw new critical_state_error_1.CriticalStateError(`ActionTo points to non-actionable seat: ${state.actionTo}`, {
+                actionTo: state.actionTo,
+                status: player.status,
+                stack: player.stack,
+                isSittingOut: player.isSittingOut,
+            });
+        }
     }
     // 6. Button must be valid or null
     if (state.buttonSeat !== null) {

package/dist/utils/rake.js

@@ -10,25 +10,23 @@ exports.calculateRake = calculateRake;
  * @returns Object with rake amount and whether cap was hit
  */
 function calculateRake(state, potAmount, rakeTakenSoFar = 0) {
-    // No rake for tournaments (identified by presence of blind structure)
+    // No rake for tournaments (identified by presence of blindStructure)
     if (state.config.blindStructure) {
         return { rake: 0, capReached: false };
     }
-    // No rake if not configured
     const rakePercent = state.config.rakePercent ?? 0;
     if (rakePercent === 0) {
         return { rake: 0, capReached: false };
     }
-    // "No Flop, No Drop" rule (standard in most cash games)
-    // If enabled (default true), no rake is taken if no flop was dealt
-    // This applies whether hand ends preflop OR players go all-in preflop without seeing flop
-    const noFlopNoDrop = state.config.noFlopNoDrop !== false; // Default true
+    // "No Flop, No Drop" rule (standard in most cash games).
+    // When enabled (default), no rake is taken if no flop was dealt,
+    // regardless of whether the hand ended preflop or all-in preflop.
+    const noFlopNoDrop = state.config.noFlopNoDrop !== false;
     if (noFlopNoDrop && state.board.length === 0) {
         return { rake: 0, capReached: false };
     }
-    // Calculate rake as percentage
     let rake = Math.floor((potAmount * rakePercent) / 100);
-    // Apply GLOBAL rake cap (per-hand, not per-pot)
+    // Apply per-hand rake cap (not per-pot).
     let capReached = false;
     if (state.config.rakeCap !== undefined) {
         const rakeAllowed = state.config.rakeCap - rakeTakenSoFar;

package/dist/utils/serialization.js

@@ -75,10 +75,10 @@ function restoreFromSnapshot(snapshot) {
         ...snapshot,
         currentBets,
         timeBanks,
-        timeBankActiveSeat: snapshot.timeBankActiveSeat ?? null, // Backward compatibility
+        timeBankActiveSeat: snapshot.timeBankActiveSeat,
         previousStates,
         initialChips: snapshot.initialChips,
-        rakeThisHand: snapshot.rakeThisHand ?? 0, // Add missing field with default
+        rakeThisHand: snapshot.rakeThisHand,
     };
 }
 /**
@@ -99,7 +99,6 @@ function deserializeSnapshot(json) {
  */
 function validateSnapshot(snapshot) {
     try {
-        // Basic validation
         if (!snapshot.handId)
             return false;
         if (snapshot.maxPlayers < 2 || snapshot.maxPlayers > 10)

package/dist/utils/validation.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateChipAmount = validateChipAmount;
 exports.validateTimestamp = validateTimestamp;
 const illegal_action_error_1 = require("../errors/illegal-action-error");
-const error_codes_1 = require("../errors/error-codes");
+const types_1 = require("@pokertools/types");
 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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} is not a valid number`, { amount, context });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} is not a valid number`, { amount, context });
     }
     if (!Number.isInteger(amount)) {
-        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 });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} must be an integer (fractional chips not allowed)`, { amount, context });
     }
     if (amount < 0) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_AMOUNT, `${context}: ${amount} cannot be negative`, { amount, context });
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_TIMESTAMP, `Invalid timestamp: ${timestamp}`, {
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_TIMESTAMP, `Timestamp ${timestamp} is in the future (current: ${Date.now()})`, { timestamp, currentTime: Date.now() });
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_TIMESTAMP, `Timestamp ${timestamp} is before previous action timestamp ${previousTimestamp}`, { timestamp, previousTimestamp });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.INVALID_TIMESTAMP, `Timestamp ${timestamp} is before previous action timestamp ${previousTimestamp}`, { timestamp, previousTimestamp });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pokertools/engine",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Enterprise-grade Texas Hold'em poker engine",
   "author": "A.Aurelius",
   "license": "MIT",
@@ -63,14 +63,14 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=24.0.0"
   },
   "dependencies": {
-    "@pokertools/evaluator": "1.0.9",
-    "@pokertools/types": "1.0.9"
+    "@pokertools/evaluator": "1.0.11",
+    "@pokertools/types": "1.0.11"
   },
   "peerDependencies": {
-    "@pokertools/evaluator": "1.0.9",
-    "@pokertools/types": "1.0.9"
+    "@pokertools/evaluator": "1.0.11",
+    "@pokertools/types": "1.0.11"
   }
 }

package/dist/errors/error-codes.d.ts

@@ -1,7 +0,0 @@
-/**
- * ErrorCodes are now managed in @pokertools/types for consistency across packages.
- * This file re-exports them for backwards compatibility.
- *
- * @deprecated Import from "@pokertools/types" instead
- */
-export { ErrorCodes, type ErrorCode, hasErrorCode } from "@pokertools/types";

package/dist/errors/error-codes.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasErrorCode = exports.ErrorCodes = void 0;
-/**
- * ErrorCodes are now managed in @pokertools/types for consistency across packages.
- * This file re-exports them for backwards compatibility.
- *
- * @deprecated Import from "@pokertools/types" instead
- */
-var types_1 = require("@pokertools/types");
-Object.defineProperty(exports, "ErrorCodes", { enumerable: true, get: function () { return types_1.ErrorCodes; } });
-Object.defineProperty(exports, "hasErrorCode", { enumerable: true, get: function () { return types_1.hasErrorCode; } });