@pokertools/engine 1.0.8 → 1.0.10

package/dist/actions/{showdownActions.js → showdown-actions.js}

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

package/dist/actions/special.js

@@ -3,7 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleTimeout = handleTimeout;
 exports.handleTimeBank = handleTimeBank;
 const positioning_1 = require("../utils/positioning");
-const actionOrder_1 = require("../rules/actionOrder");
+const action_order_1 = require("../rules/action-order");
+function getTotalPot(state) {
+    let total = 0;
+    for (const pot of state.pots)
+        total += pot.amount;
+    for (const bet of state.currentBets.values())
+        total += bet;
+    return total;
+}
 /**
  * Handle TIMEOUT action
  * - Folds player if they have bet to call
@@ -16,13 +24,11 @@ function handleTimeout(state, action) {
         return state;
     }
     const { player, seat } = result;
-    // Determine if player needs to call
     const currentBet = getCurrentBet(state);
     const playerBet = state.currentBets.get(seat) ?? 0;
     const needsToCall = currentBet > playerBet;
     const newPlayers = [...state.players];
     if (needsToCall) {
-        // Player must fold
         newPlayers[seat] = {
             ...player,
             status: "FOLDED" /* PlayerStatus.FOLDED */,
@@ -30,7 +36,6 @@ function handleTimeout(state, action) {
         };
     }
     else {
-        // Player can check, but mark as sitting out
         newPlayers[seat] = {
             ...player,
             isSittingOut: true,
@@ -39,17 +44,25 @@ function handleTimeout(state, action) {
     const newActivePlayers = needsToCall
         ? state.activePlayers.filter((s) => s !== seat)
         : state.activePlayers;
+    const actionRecord = {
+        action,
+        seat,
+        resultingPot: getTotalPot(state),
+        resultingStack: newPlayers[seat]?.stack ?? 0,
+        street: state.street,
+    };
     const newState = {
         ...state,
         players: newPlayers,
         activePlayers: newActivePlayers,
+        actionHistory: [...state.actionHistory, actionRecord],
         timestamp: action.timestamp,
     };
-    // Move to next player
-    const nextToAct = (0, actionOrder_1.getNextToAct)(newState);
+    const nextToAct = (0, action_order_1.getNextToAct)(newState);
+    const actionableNext = nextToAct !== null && !newPlayers[nextToAct]?.isSittingOut ? nextToAct : null;
     return {
         ...newState,
-        actionTo: nextToAct,
+        actionTo: actionableNext === seat ? null : actionableNext,
     };
 }
 /**

package/dist/actions/{streetProgression.js → street-progression.js}

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.progressStreet = progressStreet;
 exports.shouldProgressStreet = shouldProgressStreet;
 const deck_1 = require("../utils/deck");
-const cardUtils_1 = require("../utils/cardUtils");
-const actionOrder_1 = require("../rules/actionOrder");
+const card_utils_1 = require("../utils/card-utils");
+const action_order_1 = require("../rules/action-order");
 /**
  * Progress to next street
  * - Collects bets into pots
@@ -12,33 +12,26 @@ const actionOrder_1 = require("../rules/actionOrder");
  * - 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, actionOrder_1.getFirstToAct)(newState);
+    const firstToAct = (0, action_order_1.getFirstToAct)(newState);
     return {
         ...newState,
         actionTo: firstToAct,
@@ -69,21 +62,21 @@ function dealCommunityCards(state, street) {
             // Burn 1, deal 3
             const [flopCards, flopDeck] = (0, deck_1.burnAndDeal)(deck, 3);
             return {
-                board: [...currentBoard, ...(0, cardUtils_1.cardCodesToStrings)(flopCards)],
+                board: [...currentBoard, ...(0, card_utils_1.cardCodesToStrings)(flopCards)],
                 deck: flopDeck,
             };
         case "TURN" /* Street.TURN */:
             // Burn 1, deal 1
             const [turnCards, turnDeck] = (0, deck_1.burnAndDeal)(deck, 1);
             return {
-                board: [...currentBoard, ...(0, cardUtils_1.cardCodesToStrings)(turnCards)],
+                board: [...currentBoard, ...(0, card_utils_1.cardCodesToStrings)(turnCards)],
                 deck: turnDeck,
             };
         case "RIVER" /* Street.RIVER */:
             // Burn 1, deal 1
             const [riverCards, riverDeck] = (0, deck_1.burnAndDeal)(deck, 1);
             return {
-                board: [...currentBoard, ...(0, cardUtils_1.cardCodesToStrings)(riverCards)],
+                board: [...currentBoard, ...(0, card_utils_1.cardCodesToStrings)(riverCards)],
                 deck: riverDeck,
             };
         default:
@@ -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
-    return (0, actionOrder_1.isActionComplete)(state);
+    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

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAction = validateAction;
-const IllegalActionError_1 = require("../errors/IllegalActionError");
-const ErrorCodes_1 = require("../errors/ErrorCodes");
+const illegal_action_error_1 = require("../errors/illegal-action-error");
+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,58 +43,58 @@ function validateAction(state, action) {
 }
 function validateBettingAction(state, action) {
     if (!("playerId" in action)) {
-        throw new IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 */:
             // Note: We allow BET even when currentBet > 0 because the reducer will auto-convert it to RAISE or CALL
             // This handles UI implementations that don't distinguish between BET and RAISE buttons
             if ("amount" in action) {
+                if (currentBet > 0) {
+                    validateBetAsRaise(state, action, seat, playerBet, currentBet, player.stack);
+                    break;
+                }
                 // Reject bets below the current bet (string bet exploit)
-                if (currentBet > 0 && action.amount < currentBet) {
-                    throw new IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.BET_TOO_SMALL, `Bet of ${action.amount} is below current bet ${currentBet}`, { amount: action.amount, currentBet });
+                if (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 IllegalActionError_1.IllegalActionError(ErrorCodes_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;
@@ -104,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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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,
@@ -134,63 +133,79 @@ function validateBettingAction(state, action) {
             break;
     }
 }
+function validateBetAsRaise(state, action, seat, playerBet, currentBet, playerStack) {
+    if (!("amount" in action))
+        return;
+    const amount = action.amount;
+    if (typeof amount !== "number")
+        return;
+    if (state.lastAggressorSeat === seat) {
+        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(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(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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_1.ErrorCodes.NOT_YOUR_TURN, `Player ${action.playerId} cannot use time action when it's not their turn`, { playerId: action.playerId, actionTo: state.actionTo });
+        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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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 IllegalActionError_1.IllegalActionError(ErrorCodes_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.d.ts

@@ -4,7 +4,7 @@
  * This file provides a browser-safe RNG using Web Crypto API
  * and re-exports all engine functionality for use in web applications.
  */
-import { PokerEngine } from "./engine/PokerEngine";
+import { PokerEngine } from "./engine/poker-engine";
 import type { TableConfig } from "@pokertools/types";
 /**
  * Browser-compatible RNG using Web Crypto API
@@ -15,13 +15,13 @@ export declare function getBrowserRNG(): () => number;
  * Create a PokerEngine instance with browser-compatible RNG
  */
 export declare function createBrowserEngine(config: TableConfig): PokerEngine;
-export * from "./engine/PokerEngine";
+export * from "./engine/poker-engine";
 export * from "./actions/betting";
 export * from "./actions/dealing";
 export * from "./actions/management";
-export * from "./actions/showdownActions";
+export * from "./actions/showdown-actions";
 export * from "./actions/special";
-export * from "./utils/viewMasking";
+export * from "./utils/view-masking";
 export * from "./utils/serialization";
-export * from "./utils/cardUtils";
+export * from "./utils/card-utils";
 export * from "./history/exporter";

package/dist/browser.js

@@ -22,13 +22,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBrowserRNG = getBrowserRNG;
 exports.createBrowserEngine = createBrowserEngine;
-const PokerEngine_1 = require("./engine/PokerEngine");
+const poker_engine_1 = require("./engine/poker-engine");
 /**
  * Browser-compatible RNG using Web Crypto API
  * 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);
@@ -55,19 +54,19 @@ function getBrowserRNG() {
  * Create a PokerEngine instance with browser-compatible RNG
  */
 function createBrowserEngine(config) {
-    return new PokerEngine_1.PokerEngine({
+    return new poker_engine_1.PokerEngine({
         ...config,
         randomProvider: getBrowserRNG(),
     });
 }
 // Re-export everything from main engine
-__exportStar(require("./engine/PokerEngine"), exports);
+__exportStar(require("./engine/poker-engine"), exports);
 __exportStar(require("./actions/betting"), exports);
 __exportStar(require("./actions/dealing"), exports);
 __exportStar(require("./actions/management"), exports);
-__exportStar(require("./actions/showdownActions"), exports);
+__exportStar(require("./actions/showdown-actions"), exports);
 __exportStar(require("./actions/special"), exports);
-__exportStar(require("./utils/viewMasking"), exports);
+__exportStar(require("./utils/view-masking"), exports);
 __exportStar(require("./utils/serialization"), exports);
-__exportStar(require("./utils/cardUtils"), exports);
+__exportStar(require("./utils/card-utils"), exports);
 __exportStar(require("./history/exporter"), exports);