@pokertools/engine 1.0.7 → 1.0.9

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
@@ -38,7 +38,7 @@ function progressStreet(state) {
         // Keep timestamp from last action (street progression is not a user action)
     };
     // 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 +69,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:
@@ -153,5 +153,5 @@ function shouldProgressStreet(state) {
         return false; // Already at showdown
     }
     // Check if all active players have acted
-    return (0, actionOrder_1.isActionComplete)(state);
+    return (0, action_order_1.isActionComplete)(state);
 }

package/dist/actions/validation.js

@@ -1,8 +1,8 @@
 "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 error_codes_1 = require("../errors/error-codes");
 const positioning_1 = require("../utils/positioning");
 /**
  * Validate that an action is legal in the current game state
@@ -44,16 +44,16 @@ 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(error_codes_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(error_codes_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(error_codes_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,
@@ -62,11 +62,11 @@ function validateBettingAction(state, action) {
     }
     // 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(error_codes_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(error_codes_1.ErrorCodes.NO_CHIPS, `Player ${action.playerId} has no chips`, {
             playerId: action.playerId,
         });
     }
@@ -77,25 +77,29 @@ function validateBettingAction(state, action) {
     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(error_codes_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(error_codes_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(error_codes_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(error_codes_1.ErrorCodes.BET_TOO_SMALL, `Bet of ${action.amount} is below minimum ${state.bigBlind}`, { amount: action.amount, minimum: state.bigBlind });
                 }
             }
             break;
@@ -104,26 +108,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(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,
                 });
             }
             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(error_codes_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(error_codes_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(error_codes_1.ErrorCodes.RAISE_TOO_SMALL, `Raise to ${action.amount} is below minimum ${state.minRaise}`, {
                         amount: action.amount,
                         currentBet,
                         raiseIncrement,
@@ -134,63 +138,80 @@ 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(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 });
+    }
+    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 });
+    }
+    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 });
+    }
+}
 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(error_codes_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(error_codes_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(error_codes_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(error_codes_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(error_codes_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(error_codes_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(error_codes_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(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 });
     }
 }
 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(error_codes_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(error_codes_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(error_codes_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,7 +22,7 @@ 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
@@ -55,19 +55,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);

package/dist/engine/{gameReducer.js → game-reducer.js}

@@ -5,11 +5,11 @@ const validation_1 = require("../actions/validation");
 const dealing_1 = require("../actions/dealing");
 const betting_1 = require("../actions/betting");
 const management_1 = require("../actions/management");
-const showdownActions_1 = require("../actions/showdownActions");
+const showdown_actions_1 = require("../actions/showdown-actions");
 const tournament_1 = require("../actions/tournament");
 const special_1 = require("../actions/special");
-const streetProgression_1 = require("../actions/streetProgression");
-const sidePots_1 = require("../rules/sidePots");
+const street_progression_1 = require("../actions/street-progression");
+const side_pots_1 = require("../rules/side-pots");
 const showdown_1 = require("../rules/showdown");
 const invariants_1 = require("../utils/invariants");
 const constants_1 = require("../utils/constants");
@@ -93,10 +93,10 @@ function gameReducer(state, action) {
             break;
         // Showdown actions
         case "SHOW" /* ActionType.SHOW */:
-            newState = (0, showdownActions_1.handleShow)(state, action);
+            newState = (0, showdown_actions_1.handleShow)(state, action);
             break;
         case "MUCK" /* ActionType.MUCK */:
-            newState = (0, showdownActions_1.handleMuck)(state, action);
+            newState = (0, showdown_actions_1.handleMuck)(state, action);
             break;
         // Special actions
         case "TIMEOUT" /* ActionType.TIMEOUT */:
@@ -114,10 +114,10 @@ function gameReducer(state, action) {
             break;
     }
     // Check if we should progress to next street
-    if ((0, streetProgression_1.shouldProgressStreet)(newState)) {
+    if ((0, street_progression_1.shouldProgressStreet)(newState)) {
         // Recalculate pots before progressing
-        newState = (0, sidePots_1.recalculatePots)(newState);
-        newState = (0, streetProgression_1.progressStreet)(newState);
+        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)) {
@@ -127,6 +127,9 @@ function gameReducer(state, action) {
         };
         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)
     if (newState.config.validateIntegrity !== false) {

package/dist/engine/{PokerEngine.js → poker-engine.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PokerEngine = void 0;
-const gameReducer_1 = require("./gameReducer");
-const viewMasking_1 = require("../utils/viewMasking");
+const game_reducer_1 = require("./game-reducer");
+const view_masking_1 = require("../utils/view-masking");
 const serialization_1 = require("../utils/serialization");
-const ConfigError_1 = require("../errors/ConfigError");
+const config_error_1 = require("../errors/config-error");
 const exporter_1 = require("../history/exporter");
 const validation_1 = require("../utils/validation");
 /**
@@ -89,7 +89,7 @@ class PokerEngine {
             // Dry-run the reducer
             // We don't need to deep clone state because reducer is immutable
             // and pure, and we discard the result.
-            (0, gameReducer_1.gameReducer)(this.currentState, action);
+            (0, game_reducer_1.gameReducer)(this.currentState, action);
             return { valid: true };
         }
         catch (err) {
@@ -129,7 +129,7 @@ class PokerEngine {
     optimisticAct(action) {
         const timestamp = action.timestamp ?? this.timeProvider();
         const actionWithTimestamp = { ...action, timestamp };
-        return (0, gameReducer_1.gameReducer)(this.currentState, actionWithTimestamp);
+        return (0, game_reducer_1.gameReducer)(this.currentState, actionWithTimestamp);
     }
     /**
      * Undo last action
@@ -152,7 +152,7 @@ class PokerEngine {
      * Get player view (masked)
      */
     view(playerId, version) {
-        return (0, viewMasking_1.createPublicView)(this.currentState, playerId ?? null, version ?? 0);
+        return (0, view_masking_1.createPublicView)(this.currentState, playerId ?? null, version ?? 0);
     }
     /**
      * Get snapshot for serialization
@@ -222,7 +222,7 @@ class PokerEngine {
     dispatch(action) {
         const oldState = this.currentState;
         try {
-            this.currentState = (0, gameReducer_1.gameReducer)(this.currentState, action);
+            this.currentState = (0, game_reducer_1.gameReducer)(this.currentState, action);
             // Notify listeners
             for (const listener of this.listeners) {
                 listener(action, oldState, this.currentState);
@@ -238,19 +238,19 @@ class PokerEngine {
      */
     validateConfig(config) {
         if (config.smallBlind <= 0) {
-            throw new ConfigError_1.ConfigError("Small blind must be positive", {
+            throw new config_error_1.ConfigError("Small blind must be positive", {
                 smallBlind: config.smallBlind,
             });
         }
         if (config.bigBlind <= config.smallBlind) {
-            throw new ConfigError_1.ConfigError("Big blind must be greater than small blind", {
+            throw new config_error_1.ConfigError("Big blind must be greater than small blind", {
                 smallBlind: config.smallBlind,
                 bigBlind: config.bigBlind,
             });
         }
         const maxPlayers = config.maxPlayers ?? 9;
         if (maxPlayers < 2 || maxPlayers > 10) {
-            throw new ConfigError_1.ConfigError("Max players must be between 2 and 10", {
+            throw new config_error_1.ConfigError("Max players must be between 2 and 10", {
                 maxPlayers,
             });
         }

package/dist/errors/{ConfigError.d.ts → config-error.d.ts}

@@ -1,4 +1,4 @@
-import { PokerEngineError } from "./PokerEngineError";
+import { PokerEngineError } from "./poker-engine-error";
 /**
  * Error indicating invalid configuration
  * Should fail at engine initialization

package/dist/errors/{ConfigError.js → config-error.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigError = void 0;
-const PokerEngineError_1 = require("./PokerEngineError");
+const poker_engine_error_1 = require("./poker-engine-error");
 /**
  * Error indicating invalid configuration
  * Should fail at engine initialization
  */
-class ConfigError extends PokerEngineError_1.PokerEngineError {
+class ConfigError extends poker_engine_error_1.PokerEngineError {
     constructor(message, context = {}) {
         super("INVALID_CONFIG", message, context);
         this.name = "ConfigError";

package/dist/errors/{CriticalStateError.d.ts → critical-state-error.d.ts}

@@ -1,4 +1,4 @@
-import { PokerEngineError } from "./PokerEngineError";
+import { PokerEngineError } from "./poker-engine-error";
 /**
  * Critical error indicating state corruption or invariant violation
  * When this occurs, the table should be FROZEN immediately

package/dist/errors/{CriticalStateError.js → critical-state-error.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CriticalStateError = void 0;
-const PokerEngineError_1 = require("./PokerEngineError");
+const poker_engine_error_1 = require("./poker-engine-error");
 /**
  * Critical error indicating state corruption or invariant violation
  * When this occurs, the table should be FROZEN immediately
  */
-class CriticalStateError extends PokerEngineError_1.PokerEngineError {
+class CriticalStateError extends poker_engine_error_1.PokerEngineError {
     constructor(message, context = {}) {
         super("CRITICAL_INVARIANT_FAILURE", message, context);
         this.name = "CriticalStateError";

package/dist/errors/{IllegalActionError.d.ts → illegal-action-error.d.ts}

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

package/dist/errors/{IllegalActionError.js → illegal-action-error.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IllegalActionError = void 0;
-const PokerEngineError_1 = require("./PokerEngineError");
+const poker_engine_error_1 = require("./poker-engine-error");
 /**
  * Error indicating an illegal or invalid action
  * Action should be rejected and error sent to client
  */
-class IllegalActionError extends PokerEngineError_1.PokerEngineError {
+class IllegalActionError extends poker_engine_error_1.PokerEngineError {
     constructor(code, message, context = {}) {
         super(code, message, context);
         this.name = "IllegalActionError";

package/dist/errors/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./PokerEngineError";
-export * from "./CriticalStateError";
-export * from "./IllegalActionError";
-export * from "./ConfigError";
+export * from "./poker-engine-error";
+export * from "./critical-state-error";
+export * from "./illegal-action-error";
+export * from "./config-error";

package/dist/errors/index.js

@@ -15,8 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // Export all errors
-__exportStar(require("./PokerEngineError"), exports);
-__exportStar(require("./CriticalStateError"), exports);
-__exportStar(require("./IllegalActionError"), exports);
-__exportStar(require("./ConfigError"), exports);
+__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/history/exporter.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.exportHandHistory = exportHandHistory;
 exports.getHandHistory = getHandHistory;
 exports.exportMultipleHands = exportMultipleHands;
-const handHistoryBuilder_1 = require("./handHistoryBuilder");
+const hand_history_builder_1 = require("./hand-history-builder");
 const pokerstars_1 = require("./formats/pokerstars");
 const json_1 = require("./formats/json");
 /**
@@ -18,7 +18,7 @@ const json_1 = require("./formats/json");
  */
 function exportHandHistory(state, options = { format: "json" }) {
     // Build structured history
-    const history = (0, handHistoryBuilder_1.buildHandHistory)(state);
+    const history = (0, hand_history_builder_1.buildHandHistory)(state);
     // Export to requested format
     switch (options.format) {
         case "pokerstars":
@@ -38,7 +38,7 @@ function exportHandHistory(state, options = { format: "json" }) {
  * @returns Structured hand history object
  */
 function getHandHistory(state) {
-    return (0, handHistoryBuilder_1.buildHandHistory)(state);
+    return (0, hand_history_builder_1.buildHandHistory)(state);
 }
 /**
  * Export multiple hands to a single file
@@ -54,7 +54,7 @@ function exportMultipleHands(states, options = { format: "json" }) {
     }
     else {
         // JSON format: array of hands
-        const histories = states.map((state) => (0, handHistoryBuilder_1.buildHandHistory)(state));
+        const histories = states.map((state) => (0, hand_history_builder_1.buildHandHistory)(state));
         return JSON.stringify(histories, null, options.format === "compact" ? 0 : 2);
     }
 }

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { PokerEngine } from "./engine/PokerEngine";
+export { PokerEngine } from "./engine/poker-engine";
 export * from "@pokertools/types";
 export * from "./errors";
 export { createSnapshot, restoreFromSnapshot, Snapshot } from "./utils/serialization";
-export { createPublicView } from "./utils/viewMasking";
+export { createPublicView } from "./utils/view-masking";
 export { calculateTotalChips, auditChipConservation } from "./utils/invariants";
 export { exportHandHistory, getHandHistory, exportMultipleHands } from "./history/exporter";
 export { HandHistory, HandHistoryPlayer, StreetHistory, ExportOptions } from "@pokertools/types";

package/dist/index.js

@@ -16,8 +16,8 @@ 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 PokerEngine_1 = require("./engine/PokerEngine");
-Object.defineProperty(exports, "PokerEngine", { enumerable: true, get: function () { return PokerEngine_1.PokerEngine; } });
+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)
 __exportStar(require("@pokertools/types"), exports);
 // Errors
@@ -26,8 +26,8 @@ __exportStar(require("./errors"), exports);
 var serialization_1 = require("./utils/serialization");
 Object.defineProperty(exports, "createSnapshot", { enumerable: true, get: function () { return serialization_1.createSnapshot; } });
 Object.defineProperty(exports, "restoreFromSnapshot", { enumerable: true, get: function () { return serialization_1.restoreFromSnapshot; } });
-var viewMasking_1 = require("./utils/viewMasking");
-Object.defineProperty(exports, "createPublicView", { enumerable: true, get: function () { return viewMasking_1.createPublicView; } });
+var view_masking_1 = require("./utils/view-masking");
+Object.defineProperty(exports, "createPublicView", { enumerable: true, get: function () { return view_masking_1.createPublicView; } });
 var invariants_1 = require("./utils/invariants");
 Object.defineProperty(exports, "calculateTotalChips", { enumerable: true, get: function () { return invariants_1.calculateTotalChips; } });
 Object.defineProperty(exports, "auditChipConservation", { enumerable: true, get: function () { return invariants_1.auditChipConservation; } });