@pokertools/engine 1.0.9 → 1.0.10

package/dist/actions/street-progression.js

@@ -12,32 +12,25 @@ const action_order_1 = require("../rules/action-order");
  * - 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) {
+    if (checkAutoRunout(state)) {
         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
+    // Pots are recalculated by recalculatePots() before progressStreet() is called.
     const newState = {
         ...state,
         street: nextStreet,
         board,
         deck,
-        pots: state.pots, // Keep existing pots (already updated by recalculatePots)
+        pots: state.pots,
         currentBets: new Map(),
         lastAggressorSeat: null,
-        // Keep timestamp from last action (street progression is not a user action)
+        // Street progression is not a user action, keep last timestamp.
     };
-    // Set first to act
     const firstToAct = (0, action_order_1.getFirstToAct)(newState);
     return {
         ...newState,
@@ -106,7 +99,6 @@ function checkAutoRunout(state) {
             allInCount++;
         }
     }
-    // Auto-runout if ≤1 active player with chips (rest are all-in or folded)
     return activeCount <= 1 && allInCount > 0;
 }
 /**
@@ -116,25 +108,21 @@ function checkAutoRunout(state) {
 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
+            currentBets: new Map(),
             lastAggressorSeat: null,
         };
         currentStreet = nextStreet;
     }
-    // Move to showdown
     return {
         ...currentState,
         street: "SHOWDOWN" /* Street.SHOWDOWN */,
@@ -146,12 +134,9 @@ function handleAutoRunout(state) {
  * (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
+    if (state.actionTo !== null)
+        return false;
+    if (state.street === "SHOWDOWN" /* Street.SHOWDOWN */)
+        return false;
     return (0, action_order_1.isActionComplete)(state);
 }

package/dist/actions/tournament.js

@@ -5,17 +5,14 @@ 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
+        return state;
     }
     const blindLevel = state.config.blindStructure[nextLevel];
-    // Record action to history
     const actionRecord = {
         action: {
             type: "NEXT_BLIND_LEVEL" /* ActionType.NEXT_BLIND_LEVEL */,

package/dist/actions/validation.js

@@ -2,14 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAction = validateAction;
 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 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 */:
@@ -44,45 +43,41 @@ function validateAction(state, action) {
 }
 function validateBettingAction(state, action) {
     if (!("playerId" in action)) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_ACTION, "Action missing playerId");
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.INVALID_ACTION, "Action missing playerId");
     }
     const result = (0, positioning_1.getPlayerById)(state, action.playerId);
     if (!result) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.NOT_YOUR_TURN, `Player ${action.playerId} attempted to act, but action is on seat ${state.actionTo}`, {
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.PLAYER_NOT_ACTIVE, `Player ${action.playerId} cannot act with status ${player.status}`, { playerId: action.playerId, status: player.status });
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.NO_CHIPS, `Player ${action.playerId} has no chips`, {
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.CANNOT_CHECK, `Player ${action.playerId} cannot check with ${toCall} to call`, { playerId: action.playerId, toCall });
+                throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.NOTHING_TO_CALL, `Player ${action.playerId} has nothing to call`, { playerId: action.playerId });
+                throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.NOTHING_TO_CALL, `Player ${action.playerId} has nothing to call`, { playerId: action.playerId });
             }
             break;
         case "BET" /* ActionType.BET */:
@@ -95,11 +90,11 @@ function validateBettingAction(state, action) {
                 }
                 // Reject bets below the current bet (string bet exploit)
                 if (action.amount < currentBet) {
-                    throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.BET_TOO_SMALL, `Bet of ${action.amount} is below current bet ${currentBet}`, { amount: action.amount, currentBet });
+                    throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.BET_TOO_SMALL, `Bet of ${action.amount} is below minimum ${state.bigBlind}`, { amount: action.amount, minimum: state.bigBlind });
+                    throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.BET_TOO_SMALL, `Bet of ${action.amount} is below minimum ${state.bigBlind}`, { amount: action.amount, minimum: state.bigBlind });
                 }
             }
             break;
@@ -108,26 +103,26 @@ function validateBettingAction(state, action) {
             // 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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.CANNOT_RERAISE, "Betting has not been re-opened to you (incomplete raise or no action)", {
+                throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.CANNOT_RAISE, `Player ${action.playerId} cannot raise when there's no bet`, { playerId: action.playerId });
+                throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${action.amount} must be greater than current bet ${currentBet}`, { amount: action.amount, currentBet });
+                    throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${action.amount} is below minimum ${state.minRaise}`, {
+                    throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${action.amount} is below minimum ${state.minRaise}`, {
                         amount: action.amount,
                         currentBet,
                         raiseIncrement,
@@ -145,73 +140,72 @@ function validateBetAsRaise(state, action, seat, playerBet, currentBet, playerSt
     if (typeof amount !== "number")
         return;
     if (state.lastAggressorSeat === seat) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.CANNOT_RERAISE, "Betting has not been re-opened to you (incomplete raise or no action)", { playerId: action.playerId, seat, lastAggressor: state.lastAggressorSeat });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.CANNOT_RERAISE, "Betting has not been re-opened to you (incomplete raise or no action)", { playerId: action.playerId, seat, lastAggressor: state.lastAggressorSeat });
     }
     const isAllIn = amount >= playerBet + playerStack;
     if (amount <= currentBet && !isAllIn) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${amount} must be greater than current bet ${currentBet}`, { amount, currentBet });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${amount} must be greater than current bet ${currentBet}`, { amount, currentBet });
     }
     if (!isAllIn && amount < state.minRaise) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${amount} is below minimum ${state.minRaise}`, { amount, currentBet, minRaise: state.minRaise });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${amount} is below minimum ${state.minRaise}`, { amount, currentBet, minRaise: state.minRaise });
     }
 }
 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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.CANNOT_DEAL, "Cannot deal while hand is in progress", { street: state.street });
+            throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.NOT_ENOUGH_PLAYERS, `Need at least 2 players to deal, found ${activePlayers.length}`, { playerCount: activePlayers.length });
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_SEAT, `Seat ${action.seat} is invalid (max: ${state.maxPlayers - 1})`, { seat: action.seat, maxPlayers: state.maxPlayers });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.INVALID_SEAT, `Seat ${action.seat} is invalid (max: ${state.maxPlayers - 1})`, { seat: action.seat, maxPlayers: state.maxPlayers });
     }
     const existingPlayer = state.players[action.seat];
     if (existingPlayer !== null) {
         // Allow claiming the seat if it is RESERVED by THIS player
         const isMyReservation = existingPlayer.status === "RESERVED" /* PlayerStatus.RESERVED */ && existingPlayer.id === action.playerId;
         if (!isMyReservation) {
-            throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.SEAT_OCCUPIED, `Seat ${action.seat} is already occupied`, { seat: action.seat });
+            throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.SEAT_OCCUPIED, `Seat ${action.seat} is already occupied`, { seat: action.seat });
         }
     }
     if (action.stack <= 0) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_STACK, `Stack must be positive, got ${action.stack}`, { stack: action.stack });
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
     }
     const { seat } = result;
     if (state.actionTo !== seat) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.NOT_YOUR_TURN, `Player ${action.playerId} cannot use time action when it's not their turn`, { playerId: action.playerId, actionTo: state.actionTo });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.NOT_YOUR_TURN, `Player ${action.playerId} cannot use time action when it's not their turn`, { playerId: action.playerId, actionTo: state.actionTo });
     }
 }
 function validateAddChipsAction(state, action) {
     const result = (0, positioning_1.getPlayerById)(state, action.playerId);
     if (!result) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
     }
 }
 function validateReserveSeatAction(state, action) {
     if (action.seat < 0 || action.seat >= state.maxPlayers) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.INVALID_SEAT, `Seat ${action.seat} is invalid (max: ${state.maxPlayers - 1})`, { seat: action.seat, maxPlayers: state.maxPlayers });
+        throw new illegal_action_error_1.IllegalActionError(types_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.SEAT_OCCUPIED, `Seat ${action.seat} is already occupied`, { seat: action.seat });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.SEAT_OCCUPIED, `Seat ${action.seat} is already occupied`, { seat: action.seat });
     }
 }
 /**

package/dist/browser.js

@@ -28,7 +28,6 @@ const poker_engine_1 = require("./engine/poker-engine");
  * Falls back to Math.random() only in environments without crypto
  */
 function getBrowserRNG() {
-    // Check for Web Crypto API
     if (typeof window !== "undefined" && window.crypto?.getRandomValues) {
         return () => {
             const buffer = new Uint32Array(1);

package/dist/engine/game-reducer.js

@@ -22,12 +22,9 @@ const constants_1 = require("../utils/constants");
  * @returns New game state
  */
 function gameReducer(state, action) {
-    // Validate action
     (0, validation_1.validateAction)(state, action);
-    // Apply action based on type
     let newState;
     switch (action.type) {
-        // Management actions
         case "SIT" /* ActionType.SIT */:
             newState = (0, management_1.handleSit)(state, action);
             break;
@@ -40,11 +37,9 @@ function gameReducer(state, action) {
         case "RESERVE_SEAT" /* ActionType.RESERVE_SEAT */:
             newState = (0, management_1.handleReserveSeat)(state, action);
             break;
-        // Dealing
         case "DEAL" /* ActionType.DEAL */:
             newState = (0, dealing_1.handleDeal)(state, action);
             break;
-        // Betting actions
         case "FOLD" /* ActionType.FOLD */:
             newState = (0, betting_1.handleFold)(state, action);
             break;
@@ -54,14 +49,12 @@ function gameReducer(state, action) {
         case "CALL" /* ActionType.CALL */:
             newState = (0, betting_1.handleCall)(state, action);
             break;
+        // Auto-convert BET to RAISE/CALL when there's already a wager.
+        // Note: action.amount is the TOTAL bet, not the increment.
         case "BET" /* ActionType.BET */:
-            // Auto-convert BET to appropriate action if there's already a bet
-            // This handles UI implementations that don't distinguish between BET/CALL/RAISE buttons
-            // Note: action.amount is the TOTAL bet size, not the amount to add
             const currentBet = Math.max(...Array.from(state.currentBets.values()), 0);
             if (currentBet > 0 && "amount" in action) {
                 if (action.amount === currentBet) {
-                    // Amount equals current bet -> Convert to CALL
                     const callAction = {
                         type: "CALL" /* ActionType.CALL */,
                         playerId: action.playerId,
@@ -70,7 +63,6 @@ function gameReducer(state, action) {
                     newState = (0, betting_1.handleCall)(state, callAction);
                 }
                 else if (action.amount > currentBet) {
-                    // Amount exceeds current bet -> Convert to RAISE
                     const raiseAction = {
                         type: "RAISE" /* ActionType.RAISE */,
                         playerId: action.playerId,
@@ -80,7 +72,7 @@ function gameReducer(state, action) {
                     newState = (0, betting_1.handleRaise)(state, raiseAction);
                 }
                 else {
-                    // Amount is less than current bet -> Keep as BET (will fail validation)
+                    // amount < currentBet: pass through (will fail validation)
                     newState = (0, betting_1.handleBet)(state, action);
                 }
             }
@@ -91,14 +83,12 @@ function gameReducer(state, action) {
         case "RAISE" /* ActionType.RAISE */:
             newState = (0, betting_1.handleRaise)(state, action);
             break;
-        // Showdown actions
         case "SHOW" /* ActionType.SHOW */:
             newState = (0, showdown_actions_1.handleShow)(state, action);
             break;
         case "MUCK" /* ActionType.MUCK */:
             newState = (0, showdown_actions_1.handleMuck)(state, action);
             break;
-        // Special actions
         case "TIMEOUT" /* ActionType.TIMEOUT */:
             newState = (0, special_1.handleTimeout)(state, action);
             break;
@@ -109,33 +99,24 @@ function gameReducer(state, action) {
             newState = (0, tournament_1.handleNextBlindLevel)(state, action);
             break;
         default:
-            // Unknown action type
             newState = state;
             break;
     }
-    // Check if we should progress to next street
+    // Recalculate pots, then progress street.
     if ((0, street_progression_1.shouldProgressStreet)(newState)) {
-        // Recalculate pots before progressing
         newState = (0, side_pots_1.recalculatePots)(newState);
         newState = (0, street_progression_1.progressStreet)(newState);
     }
-    // Check if we should go to showdown
     if ((0, showdown_1.shouldShowdown)(newState)) {
-        newState = {
-            ...newState,
-            street: newState.street, // Keep current street for showdown
-        };
         newState = (0, showdown_1.determineWinners)(newState);
     }
     if (newState.actionTo !== null && newState.players[newState.actionTo]?.isSittingOut) {
         newState = { ...newState, actionTo: null };
     }
-    // Audit chip conservation (throws on failure)
-    // Enabled by default, can be disabled via config (not recommended for production)
+    // Integrity check; can be disabled via config (not recommended for production).
     if (newState.config.validateIntegrity !== false) {
         (0, invariants_1.validateGameStateIntegrity)(newState);
     }
-    // Add to previous states for undo
     const previousStates = [...newState.previousStates, state].slice(-constants_1.MAX_UNDO_HISTORY);
     return {
         ...newState,

package/dist/engine/poker-engine.js

@@ -12,20 +12,18 @@ const validation_1 = require("../utils/validation");
  * Wraps the pure reducer with a stateful API
  */
 class PokerEngine {
+    currentState;
+    listeners = [];
+    timeProvider;
     constructor(config, timeProvider = () => Date.now()) {
-        this.listeners = [];
-        // Validate config
         this.validateConfig(config);
-        // Initialize time provider
         this.timeProvider = timeProvider;
-        // Initialize state
         this.currentState = this.createInitialState(config);
     }
     /**
      * Add a player to the table
      */
     sit(seat, id, name, stack) {
-        // Validate chip amount is a non-negative integer
         (0, validation_1.validateChipAmount)(stack, "Sit stack");
         const action = {
             type: "SIT" /* ActionType.SIT */,
@@ -63,13 +61,10 @@ class PokerEngine {
      * If action.timestamp is not provided, the engine will automatically set it
      */
     act(action) {
-        // Ensure timestamp is set
         const timestamp = action.timestamp ?? this.timeProvider();
-        // Validate timestamp if provided by caller
         if (action.timestamp !== undefined) {
             (0, validation_1.validateTimestamp)(timestamp, this.currentState.timestamp);
         }
-        // Validate chip amounts for betting actions
         if ("amount" in action && typeof action.amount === "number") {
             (0, validation_1.validateChipAmount)(action.amount, `${action.type} amount`);
         }
@@ -86,9 +81,7 @@ class PokerEngine {
      */
     validate(action) {
         try {
-            // Dry-run the reducer
-            // We don't need to deep clone state because reducer is immutable
-            // and pure, and we discard the result.
+            // Dry-run the reducer; we discard the result since it's immutable and pure.
             (0, game_reducer_1.gameReducer)(this.currentState, action);
             return { valid: true };
         }
@@ -110,11 +103,8 @@ class PokerEngine {
         // Hydrate PublicState into GameState if needed
         const newState = {
             ...serverState,
-            // Ensure deck exists (empty for client/public state)
             deck: "deck" in serverState ? serverState.deck : [],
-            // Ensure players map correctly (PublicPlayer.hand is compatible with Player.hand)
-            players: serverState.players, // Type assertion needed due to deep readonly/mutable mismatch potential
-            // Ensure config carries isClient flag if set locally
+            players: serverState.players,
             config: {
                 ...serverState.config,
                 isClient: this.currentState.config.isClient,
@@ -174,7 +164,6 @@ class PokerEngine {
      */
     on(callback) {
         this.listeners.push(callback);
-        // Return unsubscribe function
         return () => {
             const index = this.listeners.indexOf(callback);
             if (index > -1) {
@@ -191,9 +180,8 @@ class PokerEngine {
         }
         const nextLevel = this.currentState.blindLevel + 1;
         if (nextLevel >= this.currentState.config.blindStructure.length) {
-            return; // At max level
+            return;
         }
-        // Dispatch NEXT_BLIND_LEVEL action to notify listeners
         this.dispatch({
             type: "NEXT_BLIND_LEVEL" /* ActionType.NEXT_BLIND_LEVEL */,
             timestamp: this.timeProvider(),
@@ -223,13 +211,11 @@ class PokerEngine {
         const oldState = this.currentState;
         try {
             this.currentState = (0, game_reducer_1.gameReducer)(this.currentState, action);
-            // Notify listeners
             for (const listener of this.listeners) {
                 listener(action, oldState, this.currentState);
             }
         }
         catch (error) {
-            // Re-throw error but keep old state
             throw error;
         }
     }

package/dist/errors/illegal-action-error.d.ts

@@ -1,5 +1,5 @@
 import { PokerEngineError } from "./poker-engine-error";
-import { ErrorCode } from "./error-codes";
+import { ErrorCode } from "@pokertools/types";
 /**
  * Error indicating an illegal or invalid action
  * Action should be rejected and error sent to client

package/dist/errors/index.js

@@ -14,9 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// Export all errors
 __exportStar(require("./poker-engine-error"), exports);
 __exportStar(require("./critical-state-error"), exports);
 __exportStar(require("./illegal-action-error"), exports);
 __exportStar(require("./config-error"), exports);
-// ErrorCodes now exported from @pokertools/types

package/dist/errors/poker-engine-error.js

@@ -5,6 +5,8 @@ exports.PokerEngineError = void 0;
  * Base error class for all poker engine errors
  */
 class PokerEngineError extends Error {
+    code;
+    context;
     constructor(code, message, context = {}) {
         super(message);
         this.name = "PokerEngineError";

package/dist/history/formats/pokerstars.js

@@ -11,25 +11,19 @@ exports.exportToPokerStars = exportToPokerStars;
  */
 function exportToPokerStars(history, options = { format: "pokerstars" }) {
     const lines = [];
-    // Header line
     lines.push(buildHeader(history));
     lines.push(buildTableInfo(history));
-    // Button and seats
     lines.push(`Button: seat #${history.buttonSeat + 1}`);
     lines.push("");
-    // Player stacks
     for (const player of history.players) {
         lines.push(`Seat ${player.seat + 1}: ${player.name} ($${player.startingStack.toFixed(2)} in chips)`);
     }
     lines.push("");
-    // Blinds and antes
     lines.push(buildBlindsLine(history));
     if (history.stakes.ante > 0) {
         lines.push(buildAntesLine(history));
     }
-    // Hole cards (dealt to)
     lines.push(buildHoleCardsLine(history, options));
-    // Each street
     for (const street of history.streets) {
         lines.push("");
         lines.push(buildStreetHeader(street));
@@ -37,7 +31,6 @@ function exportToPokerStars(history, options = { format: "pokerstars" }) {
             lines.push(buildActionLine(action, history));
         }
     }
-    // Summary
     lines.push("");
     lines.push(buildSummary(history));
     return lines.join("\n");
@@ -61,7 +54,6 @@ function buildTableInfo(history) {
  */
 function buildBlindsLine(history) {
     const lines = [];
-    // Find SB and BB seats (button+1 and button+2)
     const sbSeat = (history.buttonSeat + 1) % history.maxPlayers;
     const bbSeat = (history.buttonSeat + 2) % history.maxPlayers;
     const sbPlayer = history.players.find((p) => p.seat === sbSeat);

package/dist/history/hand-history-builder.js

@@ -84,10 +84,9 @@ function groupActionsByStreet(state) {
     grouped.set("TURN" /* Street.TURN */, []);
     grouped.set("RIVER" /* Street.RIVER */, []);
     grouped.set("SHOWDOWN" /* Street.SHOWDOWN */, []);
-    // Group action history by street
     for (const record of state.actionHistory) {
         if (record.seat === null)
-            continue; // Skip table-level actions
+            continue;
         const street = record.street ?? state.street;
         const existing = grouped.get(street) ?? [];
         const actionRecord = {

package/dist/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exportMultipleHands = exports.getHandHistory = exports.exportHandHistory = exports.auditChipConservation = exports.calculateTotalChips = exports.createPublicView = exports.restoreFromSnapshot = exports.createSnapshot = exports.PokerEngine = void 0;
-// Main Engine Class
 var poker_engine_1 = require("./engine/poker-engine");
 Object.defineProperty(exports, "PokerEngine", { enumerable: true, get: function () { return poker_engine_1.PokerEngine; } });
 // Types (re-exported from @pokertools/types for convenience)