@pokertools/engine 1.0.8 → 1.0.10

package/dist/rules/showdown.js

@@ -34,8 +34,8 @@ function determineWinners(state) {
         // Distribute pot among winners
         const share = Math.floor(potAfterRake / potWinners.length);
         const remainder = potAfterRake % potWinners.length;
-        // Sort winners by position (worst to best) for odd chip distribution
-        // TDA Rule: Odd chips go to first player(s) clockwise from button
+        // Sort winners by position for odd chip distribution.
+        // TDA Rule: odd chips go to first player(s) clockwise from the button.
         const sortedWinners = [...potWinners].sort((a, b) => {
             if (state.buttonSeat === null)
                 return 0;
@@ -47,20 +47,17 @@ function determineWinners(state) {
         for (let i = 0; i < sortedWinners.length; i++) {
             const evaluation = sortedWinners[i];
             let award = share;
-            // Distribute odd chips one at a time to worst positions
-            // (first N winners in sorted order get the extra chips)
+            // First N winners (worst position) each get one extra chip.
             if (i < remainder) {
                 award += 1;
             }
-            // Track winner seats
             winnerSeats.add(evaluation.seat);
-            // Award chips to player
             const player = newPlayers[evaluation.seat];
             newPlayers[evaluation.seat] = {
                 ...player,
                 stack: player.stack + award,
             };
-            // Record winner
+            // Record winner with hand description.
             winners.push({
                 seat: evaluation.seat,
                 amount: award,
@@ -104,11 +101,10 @@ function determineWinners(state) {
  * Evaluate a single pot and return winner(s)
  */
 function evaluatePot(state, pot) {
-    // Get eligible players (not folded)
     const eligible = pot.eligibleSeats
         .map((seat) => state.players[seat])
         .filter((player) => player && (player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ || player.status === "ALL_IN" /* PlayerStatus.ALL_IN */));
-    // If only one player, they win without showing
+    // Single remaining player wins uncontested.
     if (eligible.length === 1) {
         const player = eligible[0];
         return [
@@ -120,22 +116,17 @@ function evaluatePot(state, pot) {
             },
         ];
     }
-    // Evaluate all hands
     const evaluations = [];
     for (const player of eligible) {
         if (!player?.hand)
             continue;
-        // Skip masked hands (client mode)
+        // Skip masked hands in client mode.
         if (player.hand.some((c) => c === null)) {
             continue;
         }
-        // Combine hole cards + board (7 cards total for river)
         const allCards = [...player.hand, ...state.board];
-        if (allCards.length < 5) {
-            // Not enough cards (shouldn't happen)
+        if (allCards.length < 5)
             continue;
-        }
-        // Evaluate using @pokertools/evaluator
         const cardCodes = (0, evaluator_1.getCardCodes)(allCards);
         const score = (0, evaluator_1.evaluate)(cardCodes);
         const handRank = (0, evaluator_1.rank)(cardCodes);
@@ -143,32 +134,57 @@ function evaluatePot(state, pot) {
         evaluations.push({
             seat: player.seat,
             score,
-            hand: [...player.hand], // Store hole cards (copy to mutable array)
+            hand: getBestFiveCardHand(allCards),
             description,
         });
     }
     if (evaluations.length === 0) {
         return [];
     }
-    // Find best hand(s)
     const bestScore = Math.min(...evaluations.map((e) => e.score));
-    const winners = evaluations.filter((e) => e.score === bestScore);
-    return winners;
+    return evaluations.filter((e) => e.score === bestScore);
+}
+/**
+ * Return the concrete five cards that produce the best evaluator score.
+ * The evaluator score is lower-is-better, so enumerate all 5-card subsets and
+ * keep the first subset with the minimum score. Hold'em has at most 7 cards,
+ * making this deterministic brute-force path only 21 evaluations per player.
+ */
+function getBestFiveCardHand(cards) {
+    if (cards.length === 5) {
+        return [...cards];
+    }
+    let bestHand = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (let a = 0; a < cards.length - 4; a++) {
+        for (let b = a + 1; b < cards.length - 3; b++) {
+            for (let c = b + 1; c < cards.length - 2; c++) {
+                for (let d = c + 1; d < cards.length - 1; d++) {
+                    for (let e = d + 1; e < cards.length; e++) {
+                        const candidate = [cards[a], cards[b], cards[c], cards[d], cards[e]];
+                        const score = (0, evaluator_1.evaluate)((0, evaluator_1.getCardCodes)(candidate));
+                        if (score < bestScore) {
+                            bestScore = score;
+                            bestHand = candidate;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (bestHand === null) {
+        return [...cards.slice(0, 5)];
+    }
+    return bestHand;
 }
 /**
  * Check if hand should go to showdown
  */
 function shouldShowdown(state) {
-    // Showdown if:
-    // 1. We're at SHOWDOWN street
-    // 2. Multiple players remain (not folded)
-    // 3. Winners haven't been determined yet
-    if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */) {
+    if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */)
+        return false;
+    if (state.winners !== null)
         return false;
-    }
-    if (state.winners !== null) {
-        return false; // Already determined winners
-    }
     const activePlayers = state.players.filter((p) => p && (p.status === "ACTIVE" /* PlayerStatus.ACTIVE */ || p.status === "ALL_IN" /* PlayerStatus.ALL_IN */));
     return activePlayers.length >= 2;
 }

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

@@ -4,7 +4,7 @@ exports.calculateSidePots = calculateSidePots;
 exports.calculateUncalledBet = calculateUncalledBet;
 exports.returnUncalledBet = returnUncalledBet;
 exports.recalculatePots = recalculatePots;
-const CriticalStateError_1 = require("../errors/CriticalStateError");
+const critical_state_error_1 = require("../errors/critical-state-error");
 /**
  * Calculate side pots using iterative subtraction method
  *
@@ -36,11 +36,9 @@ function calculateSidePots(state) {
             });
         }
     }
-    // If no investments, return empty
     if (investments.length === 0) {
         return [];
     }
-    // Sort by investment (ascending)
     investments.sort((a, b) => a.amount - b.amount);
     const pots = [];
     let prevAmount = 0;
@@ -48,16 +46,13 @@ function calculateSidePots(state) {
         const current = investments[i];
         const allAtThisLevel = investments.slice(i); // Current + all higher investors
         const increment = current.amount - prevAmount;
-        // Create pot for this level
         if (increment > 0) {
-            // Pot includes chips from ALL players at this level (including folded)
+            // Pot includes ALL players at this level (folded players' chips stay in).
             const potAmount = increment * allAtThisLevel.length;
-            // But only non-folded players are eligible to win
+            // Only non-folded players are eligible to win.
             const eligibleSeats = allAtThisLevel.filter((inv) => !inv.folded).map((inv) => inv.seat);
-            // Must have at least one eligible player
-            // If everyone folded at this level, something went wrong in the game logic
             if (eligibleSeats.length === 0) {
-                throw new CriticalStateError_1.CriticalStateError(`Side pot has no eligible players - all ${allAtThisLevel.length} players at this level have folded`, {
+                throw new critical_state_error_1.CriticalStateError(`Side pot has no eligible players - all ${allAtThisLevel.length} players at this level have folded`, {
                     potAmount,
                     potLevel: i,
                     investmentLevel: current.amount,
@@ -86,10 +81,8 @@ function calculateSidePots(state) {
  * @returns Tuple of [uncalled amount, seat to return to]
  */
 function calculateUncalledBet(state) {
-    if (state.currentBets.size === 0) {
+    if (state.currentBets.size === 0)
         return null;
-    }
-    // Find highest bet
     let maxBet = 0;
     let maxBetSeat = -1;
     let secondMaxBet = 0;
@@ -119,21 +112,17 @@ function returnUncalledBet(state) {
     }
     const [amount, seat] = uncalled;
     const player = state.players[seat];
-    if (!player) {
+    if (!player)
         return state;
-    }
-    // Return chips to player
     const newPlayers = [...state.players];
     newPlayers[seat] = {
         ...player,
         stack: player.stack + amount,
         totalInvestedThisHand: player.totalInvestedThisHand - amount,
     };
-    // Reduce current bet
     const newCurrentBets = new Map(state.currentBets);
     const currentBet = newCurrentBets.get(seat) ?? 0;
     newCurrentBets.set(seat, currentBet - amount);
-    // Record to action history
     const actionRecord = {
         action: {
             type: "UNCALLED_BET_RETURNED" /* ActionType.UNCALLED_BET_RETURNED */,
@@ -158,11 +147,9 @@ function returnUncalledBet(state) {
  * This is called before progressing to next street
  */
 function recalculatePots(state) {
-    // First, return any uncalled bet
     const newState = returnUncalledBet(state);
-    // Calculate side pots based on all investments
     const pots = calculateSidePots(newState);
-    // Reset betThisStreet for all players (bets collected into pots)
+    // Reset betThisStreet after collecting bets into pots.
     const newPlayers = newState.players.map((p) => (p ? { ...p, betThisStreet: 0 } : null));
     return {
         ...newState,

package/dist/utils/deck.js

@@ -28,10 +28,8 @@ function createDeck() {
  * be used for production poker games. Always provide a secure RNG.
  */
 function getSecureRandom() {
-    // Check if we're in Node.js environment
     if (typeof process !== "undefined" && process.versions?.node) {
         try {
-            // Use Node.js crypto for production
             // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
             const crypto = require("crypto");
             return () => {
@@ -81,11 +79,10 @@ function getSecureRandom() {
  */
 function shuffle(deck, rng) {
     const random = rng ?? getSecureRandom();
-    const shuffled = [...deck]; // Create mutable copy
+    const shuffled = [...deck];
     // Fisher-Yates shuffle
     for (let i = shuffled.length - 1; i > 0; i--) {
         const j = Math.floor(random() * (i + 1));
-        // Swap elements
         const temp = shuffled[i];
         shuffled[i] = shuffled[j];
         shuffled[j] = temp;

package/dist/utils/invariants.js

@@ -7,7 +7,7 @@ exports.calculatePotTotal = calculatePotTotal;
 exports.calculateBetTotal = calculateBetTotal;
 exports.getInitialChips = getInitialChips;
 exports.validateGameStateIntegrity = validateGameStateIntegrity;
-const CriticalStateError_1 = require("../errors/CriticalStateError");
+const critical_state_error_1 = require("../errors/critical-state-error");
 /**
  * Audit chip conservation
  * Formula: ∑(player.stack) + ∑(pot.amount) + ∑(currentBets) = initialChips
@@ -17,9 +17,10 @@ const CriticalStateError_1 = require("../errors/CriticalStateError");
  * @throws CriticalStateError if chips don't match
  */
 function auditChipConservation(state, initialChips) {
-    const currentChips = getInitialChips(state);
+    const handComplete = state.winners !== null && state.pots.length === 0 && state.currentBets.size === 0;
+    const currentChips = calculateTotalChips(state) + (handComplete ? state.rakeThisHand : 0);
     if (currentChips !== initialChips) {
-        throw new CriticalStateError_1.CriticalStateError(`Chip conservation violated: expected ${initialChips}, found ${currentChips}`, {
+        throw new critical_state_error_1.CriticalStateError(`Chip conservation violated: expected ${initialChips}, found ${currentChips}`, {
             expected: initialChips,
             actual: currentChips,
             difference: currentChips - initialChips,
@@ -77,6 +78,10 @@ function calculateBetTotal(state) {
  * - After hand complete: stack + rake (all chips have been distributed, rake removed)
  */
 function getInitialChips(state) {
+    const baseline = state.initialChips;
+    if (typeof baseline === "number") {
+        return baseline;
+    }
     let total = 0;
     // Hand is complete if winners are declared AND pots/bets have been distributed
     // This ensures we don't switch modes mid-hand
@@ -110,12 +115,13 @@ function validateGameStateIntegrity(state) {
         return;
     }
     // 1. Chip conservation
-    const initialChips = getInitialChips(state);
+    const baseline = state.initialChips;
+    const initialChips = typeof baseline === "number" ? baseline : getInitialChips(state);
     auditChipConservation(state, initialChips);
     // 2. No negative stacks
     for (const player of state.players) {
         if (player && player.stack < 0) {
-            throw new CriticalStateError_1.CriticalStateError(`Player ${player.id} has negative stack: ${player.stack}`, {
+            throw new critical_state_error_1.CriticalStateError(`Player ${player.id} has negative stack: ${player.stack}`, {
                 playerId: player.id,
                 stack: player.stack,
             });
@@ -124,7 +130,7 @@ function validateGameStateIntegrity(state) {
     // 3. No negative bets
     for (const [seat, bet] of state.currentBets.entries()) {
         if (bet < 0) {
-            throw new CriticalStateError_1.CriticalStateError(`Seat ${seat} has negative bet: ${bet}`, {
+            throw new critical_state_error_1.CriticalStateError(`Seat ${seat} has negative bet: ${bet}`, {
                 seat,
                 bet,
             });
@@ -134,7 +140,7 @@ function validateGameStateIntegrity(state) {
     for (let i = 0; i < state.pots.length; i++) {
         const pot = state.pots[i];
         if (pot.amount < 0) {
-            throw new CriticalStateError_1.CriticalStateError(`Pot ${i} has negative amount: ${pot.amount}`, {
+            throw new critical_state_error_1.CriticalStateError(`Pot ${i} has negative amount: ${pot.amount}`, {
                 potIndex: i,
                 amount: pot.amount,
             });
@@ -143,14 +149,14 @@ function validateGameStateIntegrity(state) {
     // 5. ActionTo must be valid seat or null
     if (state.actionTo !== null) {
         if (state.actionTo < 0 || state.actionTo >= state.maxPlayers) {
-            throw new CriticalStateError_1.CriticalStateError(`Invalid actionTo: ${state.actionTo}`, {
+            throw new critical_state_error_1.CriticalStateError(`Invalid actionTo: ${state.actionTo}`, {
                 actionTo: state.actionTo,
                 maxPlayers: state.maxPlayers,
             });
         }
         const player = state.players[state.actionTo];
         if (!player) {
-            throw new CriticalStateError_1.CriticalStateError(`ActionTo points to empty seat: ${state.actionTo}`, {
+            throw new critical_state_error_1.CriticalStateError(`ActionTo points to empty seat: ${state.actionTo}`, {
                 actionTo: state.actionTo,
             });
         }
@@ -158,7 +164,7 @@ function validateGameStateIntegrity(state) {
     // 6. Button must be valid or null
     if (state.buttonSeat !== null) {
         if (state.buttonSeat < 0 || state.buttonSeat >= state.maxPlayers) {
-            throw new CriticalStateError_1.CriticalStateError(`Invalid buttonSeat: ${state.buttonSeat}`, {
+            throw new critical_state_error_1.CriticalStateError(`Invalid buttonSeat: ${state.buttonSeat}`, {
                 buttonSeat: state.buttonSeat,
                 maxPlayers: state.maxPlayers,
             });

package/dist/utils/rake.js

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

package/dist/utils/serialization.d.ts

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

package/dist/utils/serialization.js

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

package/dist/utils/validation.js

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

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

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

package/package.json

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

package/dist/errors/ErrorCodes.d.ts

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

package/dist/errors/ErrorCodes.js

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