@pokertools/engine 1.0.1 → 1.0.4

package/dist/browser.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Browser-compatible entry point for PokerEngine
+ *
+ * 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 type { TableConfig } from "@pokertools/types";
+/**
+ * Browser-compatible RNG using Web Crypto API
+ * Falls back to Math.random() only in environments without crypto
+ */
+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 "./actions/betting";
+export * from "./actions/dealing";
+export * from "./actions/management";
+export * from "./actions/showdownActions";
+export * from "./actions/special";
+export * from "./utils/viewMasking";
+export * from "./utils/serialization";
+export * from "./utils/cardUtils";
+export * from "./history/exporter";

package/dist/browser.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Browser-compatible entry point for PokerEngine
+ *
+ * This file provides a browser-safe RNG using Web Crypto API
+ * and re-exports all engine functionality for use in web applications.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserRNG = getBrowserRNG;
+exports.createBrowserEngine = createBrowserEngine;
+const PokerEngine_1 = require("./engine/PokerEngine");
+/**
+ * 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);
+            window.crypto.getRandomValues(buffer);
+            return buffer[0] / 0x100000000;
+        };
+    }
+    // Check for Node.js crypto (for SSR/testing)
+    if (typeof globalThis !== "undefined" && globalThis.crypto?.getRandomValues) {
+        return () => {
+            const buffer = new Uint32Array(1);
+            globalThis.crypto.getRandomValues(buffer);
+            return buffer[0] / 0x100000000;
+        };
+    }
+    // Fallback (warn in development)
+    if (process.env.NODE_ENV !== "production") {
+        console.warn("[PokerEngine Browser] Web Crypto API not available, using Math.random(). " +
+            "This is NOT cryptographically secure.");
+    }
+    return Math.random;
+}
+/**
+ * Create a PokerEngine instance with browser-compatible RNG
+ */
+function createBrowserEngine(config) {
+    return new PokerEngine_1.PokerEngine({
+        ...config,
+        randomProvider: getBrowserRNG(),
+    });
+}
+// Re-export everything from main engine
+__exportStar(require("./engine/PokerEngine"), exports);
+__exportStar(require("./actions/betting"), exports);
+__exportStar(require("./actions/dealing"), exports);
+__exportStar(require("./actions/management"), exports);
+__exportStar(require("./actions/showdownActions"), exports);
+__exportStar(require("./actions/special"), exports);
+__exportStar(require("./utils/viewMasking"), exports);
+__exportStar(require("./utils/serialization"), exports);
+__exportStar(require("./utils/cardUtils"), exports);
+__exportStar(require("./history/exporter"), exports);

package/dist/engine/PokerEngine.d.ts

@@ -1,6 +1,6 @@
 import { GameState, TableConfig, Action, PublicState } from "@pokertools/types";
 import { Snapshot } from "../utils/serialization";
-import { HandHistory, ExportOptions } from "../history/types";
+import { HandHistory, ExportOptions } from "@pokertools/types";
 /**
  * Event listener callback type
  */
@@ -35,6 +35,27 @@ export declare class PokerEngine {
      * If action.timestamp is not provided, the engine will automatically set it
      */
     act(action: Action): GameState;
+    /**
+     * Validate an action without executing it
+     * Useful for UI state (enabling/disabling buttons)
+     */
+    validate(action: Action): {
+        valid: true;
+    } | {
+        valid: false;
+        error: string;
+        code?: string;
+    };
+    /**
+     * Reconcile local state with server state
+     * Smoothly merges server updates into client engine
+     */
+    reconcile(serverState: PublicState | GameState): void;
+    /**
+     * Optimistically execute an action and return the provisional state
+     * Does not modify the engine's actual state
+     */
+    optimisticAct(action: Action): GameState;
     /**
      * Undo last action
      */
@@ -46,7 +67,7 @@ export declare class PokerEngine {
     /**
      * Get player view (masked)
      */
-    view(playerId?: string): PublicState;
+    view(playerId?: string, version?: number): PublicState;
     /**
      * Get snapshot for serialization
      */

package/dist/engine/PokerEngine.js

@@ -80,6 +80,57 @@ class PokerEngine {
         this.dispatch(actionWithTimestamp);
         return this.currentState;
     }
+    /**
+     * Validate an action without executing it
+     * Useful for UI state (enabling/disabling buttons)
+     */
+    validate(action) {
+        try {
+            // Dry-run the reducer
+            // We don't need to deep clone state because reducer is immutable
+            // and pure, and we discard the result.
+            (0, gameReducer_1.gameReducer)(this.currentState, action);
+            return { valid: true };
+        }
+        catch (err) {
+            const message = err?.message ?? "Invalid action";
+            const code = err?.code;
+            return {
+                valid: false,
+                error: message,
+                code,
+            };
+        }
+    }
+    /**
+     * Reconcile local state with server state
+     * Smoothly merges server updates into client engine
+     */
+    reconcile(serverState) {
+        // Hydrate PublicState into GameState if needed
+        const newState = {
+            ...serverState,
+            // Ensure deck exists (empty for client/public state)
+            deck: "deck" in serverState ? serverState.deck : [],
+            // Ensure players map correctly (PublicPlayer.hand is compatible with Player.hand)
+            players: serverState.players, // Type assertion needed due to deep readonly/mutable mismatch potential
+            // Ensure config carries isClient flag if set locally
+            config: {
+                ...serverState.config,
+                isClient: this.currentState.config.isClient,
+            },
+        };
+        this.currentState = newState;
+    }
+    /**
+     * Optimistically execute an action and return the provisional state
+     * Does not modify the engine's actual state
+     */
+    optimisticAct(action) {
+        const timestamp = action.timestamp ?? this.timeProvider();
+        const actionWithTimestamp = { ...action, timestamp };
+        return (0, gameReducer_1.gameReducer)(this.currentState, actionWithTimestamp);
+    }
     /**
      * Undo last action
      */
@@ -100,8 +151,8 @@ class PokerEngine {
     /**
      * Get player view (masked)
      */
-    view(playerId) {
-        return (0, viewMasking_1.createPublicView)(this.currentState, playerId ?? null);
+    view(playerId, version) {
+        return (0, viewMasking_1.createPublicView)(this.currentState, playerId ?? null, version ?? 0);
     }
     /**
      * Get snapshot for serialization
@@ -236,6 +287,7 @@ class PokerEngine {
             ante: initialBlinds?.ante ?? config.ante ?? 0,
             blindLevel: 0,
             timeBanks: new Map(),
+            timeBankActiveSeat: null,
             actionHistory: [],
             previousStates: [],
             timestamp: Date.now(),

package/dist/errors/ErrorCodes.d.ts

@@ -1,38 +1,7 @@
 /**
- * Standardized error codes for IllegalActionError
+ * ErrorCodes are now managed in @pokertools/types for consistency across packages.
+ * This file re-exports them for backwards compatibility.
  *
- * Using a const enum pattern for:
- * - Type safety at compile time
- * - Autocomplete in IDEs
- * - Documentation of all possible error codes
- * - Easy refactoring
+ * @deprecated Import from "@pokertools/types" instead
  */
-export declare const ErrorCodes: {
-    readonly INVALID_ACTION: "INVALID_ACTION";
-    readonly PLAYER_NOT_FOUND: "PLAYER_NOT_FOUND";
-    readonly PLAYER_NOT_ACTIVE: "PLAYER_NOT_ACTIVE";
-    readonly NOT_YOUR_TURN: "NOT_YOUR_TURN";
-    readonly NO_CHIPS: "NO_CHIPS";
-    readonly CANNOT_CHECK: "CANNOT_CHECK";
-    readonly NOTHING_TO_CALL: "NOTHING_TO_CALL";
-    readonly CANNOT_BET: "CANNOT_BET";
-    readonly BET_TOO_SMALL: "BET_TOO_SMALL";
-    readonly CANNOT_RAISE: "CANNOT_RAISE";
-    readonly CANNOT_RERAISE: "CANNOT_RERAISE";
-    readonly RAISE_TOO_SMALL: "RAISE_TOO_SMALL";
-    readonly CANNOT_DEAL: "CANNOT_DEAL";
-    readonly NOT_ENOUGH_PLAYERS: "NOT_ENOUGH_PLAYERS";
-    readonly INVALID_SEAT: "INVALID_SEAT";
-    readonly SEAT_OCCUPIED: "SEAT_OCCUPIED";
-    readonly INVALID_STACK: "INVALID_STACK";
-    readonly INVALID_AMOUNT: "INVALID_AMOUNT";
-    readonly INVALID_TIMESTAMP: "INVALID_TIMESTAMP";
-};
-/**
- * Type representing all valid error codes
- */
-export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
-/**
- * Helper to check if an error message contains a specific error code
- */
-export declare function hasErrorCode(error: Error, code: ErrorCode): boolean;
+export { ErrorCodes, type ErrorCode, hasErrorCode } from "@pokertools/types";

package/dist/errors/ErrorCodes.js

@@ -1,46 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorCodes = void 0;
-exports.hasErrorCode = hasErrorCode;
+exports.hasErrorCode = exports.ErrorCodes = void 0;
 /**
- * Standardized error codes for IllegalActionError
+ * ErrorCodes are now managed in @pokertools/types for consistency across packages.
+ * This file re-exports them for backwards compatibility.
  *
- * Using a const enum pattern for:
- * - Type safety at compile time
- * - Autocomplete in IDEs
- * - Documentation of all possible error codes
- * - Easy refactoring
+ * @deprecated Import from "@pokertools/types" instead
  */
-exports.ErrorCodes = {
-    // Generic errors
-    INVALID_ACTION: "INVALID_ACTION",
-    // Player errors
-    PLAYER_NOT_FOUND: "PLAYER_NOT_FOUND",
-    PLAYER_NOT_ACTIVE: "PLAYER_NOT_ACTIVE",
-    NOT_YOUR_TURN: "NOT_YOUR_TURN",
-    NO_CHIPS: "NO_CHIPS",
-    // Betting action errors
-    CANNOT_CHECK: "CANNOT_CHECK",
-    NOTHING_TO_CALL: "NOTHING_TO_CALL",
-    CANNOT_BET: "CANNOT_BET",
-    BET_TOO_SMALL: "BET_TOO_SMALL",
-    CANNOT_RAISE: "CANNOT_RAISE",
-    CANNOT_RERAISE: "CANNOT_RERAISE",
-    RAISE_TOO_SMALL: "RAISE_TOO_SMALL",
-    // Deal errors
-    CANNOT_DEAL: "CANNOT_DEAL",
-    NOT_ENOUGH_PLAYERS: "NOT_ENOUGH_PLAYERS",
-    // Seat errors
-    INVALID_SEAT: "INVALID_SEAT",
-    SEAT_OCCUPIED: "SEAT_OCCUPIED",
-    INVALID_STACK: "INVALID_STACK",
-    // Validation errors
-    INVALID_AMOUNT: "INVALID_AMOUNT",
-    INVALID_TIMESTAMP: "INVALID_TIMESTAMP",
-};
-/**
- * Helper to check if an error message contains a specific error code
- */
-function hasErrorCode(error, code) {
-    return error.message.includes(code);
-}
+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; } });

package/dist/errors/index.d.ts

@@ -2,4 +2,3 @@ export * from "./PokerEngineError";
 export * from "./CriticalStateError";
 export * from "./IllegalActionError";
 export * from "./ConfigError";
-export * from "./ErrorCodes";

package/dist/errors/index.js

@@ -19,4 +19,4 @@ __exportStar(require("./PokerEngineError"), exports);
 __exportStar(require("./CriticalStateError"), exports);
 __exportStar(require("./IllegalActionError"), exports);
 __exportStar(require("./ConfigError"), exports);
-__exportStar(require("./ErrorCodes"), exports);
+// ErrorCodes now exported from @pokertools/types

package/dist/history/exporter.d.ts

@@ -1,8 +1,7 @@
 /**
  * Main hand history exporter
  */
-import { GameState } from "@pokertools/types";
-import { HandHistory, ExportOptions } from "./types";
+import { GameState, HandHistory, ExportOptions } from "@pokertools/types";
 /**
  * Export hand history from game state
  *

package/dist/history/formats/json.d.ts

@@ -3,7 +3,7 @@
  *
  * Machine-readable format for analysis and storage
  */
-import { HandHistory, ExportOptions } from "../types";
+import { HandHistory, ExportOptions } from "@pokertools/types";
 /**
  * Export hand history to JSON format
  */

package/dist/history/formats/pokerstars.d.ts

@@ -3,7 +3,7 @@
  *
  * Format specification based on PokerStars hand history text format
  */
-import { HandHistory, ExportOptions } from "../types";
+import { HandHistory, ExportOptions } from "@pokertools/types";
 /**
  * Export hand history to PokerStars format
  */

package/dist/history/handHistoryBuilder.d.ts

@@ -1,8 +1,7 @@
 /**
  * Build hand history from game state and action history
  */
-import { GameState } from "@pokertools/types";
-import { HandHistory } from "./types";
+import { GameState, HandHistory } from "@pokertools/types";
 /**
  * Build complete hand history from final game state
  * Call this after a hand is complete (winners determined)

package/dist/history/handHistoryBuilder.js

@@ -41,12 +41,15 @@ function buildPlayerHistory(state) {
             continue;
         // Calculate starting stack (current + invested)
         const startingStack = player.stack + player.totalInvestedThisHand;
+        // Only include cards if they are fully visible (no masked/null cards)
+        const hasMaskedCards = player.hand?.some((c) => c === null);
+        const cards = player.hand && !hasMaskedCards ? player.hand : undefined;
         players.push({
             seat: player.seat,
             name: player.name,
             startingStack,
             endingStack: player.stack,
-            cards: player.hand ? [...player.hand] : undefined,
+            cards,
         });
     }
     return players;

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { createSnapshot, restoreFromSnapshot, Snapshot } from "./utils/serializa
 export { createPublicView } from "./utils/viewMasking";
 export { calculateTotalChips, auditChipConservation } from "./utils/invariants";
 export { exportHandHistory, getHandHistory, exportMultipleHands } from "./history/exporter";
-export type { HandHistory, HandHistoryPlayer, StreetHistory, ExportOptions } from "./history/types";
+export { HandHistory, HandHistoryPlayer, StreetHistory, ExportOptions } from "@pokertools/types";

package/dist/rules/actionOrder.js

@@ -33,7 +33,7 @@ function getNextToActNormal(state) {
     while (seat !== startSeat) {
         const player = state.players[seat];
         // Skip if: no player, folded, all-in, or busted
-        if (!player || player.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack === 0) {
+        if (player?.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack === 0) {
             seat = (0, positioning_1.getNextSeat)(seat, state.maxPlayers);
             continue;
         }
@@ -77,7 +77,7 @@ function getNextToActHeadsUp(state) {
     // Check both players
     for (const seat of actionOrder) {
         const player = state.players[seat];
-        if (!player || player.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack === 0) {
+        if (player?.status !== "ACTIVE" /* PlayerStatus.ACTIVE */ || player.stack === 0) {
             continue;
         }
         const playerBet = state.currentBets.get(seat) ?? 0;
@@ -128,7 +128,7 @@ function getNextActionableSeat(startSeat, state) {
     // Scan full circle
     while (seat !== endSeat) {
         const player = state.players[seat];
-        if (player && player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
+        if (player?.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
             return seat;
         }
         seat = (0, positioning_1.getNextSeat)(seat, state.maxPlayers);
@@ -173,7 +173,7 @@ function isActionComplete(state) {
     if (activeCount === 0) {
         // Only return true if we're in a hand (not pre-deal)
         // Check: Are there all-in players with bets?
-        const allInPlayers = state.players.filter((p) => p && p.status === "ALL_IN" /* PlayerStatus.ALL_IN */);
+        const allInPlayers = state.players.filter((p) => p?.status === "ALL_IN" /* PlayerStatus.ALL_IN */);
         return allInPlayers.length > 0 && state.currentBets.size > 0;
     }
     return activeCount > 0 && activeCount === actedCount;

package/dist/rules/blinds.d.ts

@@ -16,6 +16,8 @@ export interface BlindPositions {
  * Normal (Dead Button Rule):
  * - SB = Button + 1 (Can be empty -> Dead Small Blind)
  * - BB = Next Occupied Seat after SB
+ *
+ * For cash games: Skips sitting-out players (unless they are in tournament mode)
  */
 export declare function getBlindPositions(state: GameState): BlindPositions | null;
 /**

package/dist/rules/blinds.js

@@ -14,15 +14,18 @@ const headsUp_1 = require("./headsUp");
  * Normal (Dead Button Rule):
  * - SB = Button + 1 (Can be empty -> Dead Small Blind)
  * - BB = Next Occupied Seat after SB
+ *
+ * For cash games: Skips sitting-out players (unless they are in tournament mode)
  */
 function getBlindPositions(state) {
     if (state.buttonSeat === null) {
         return null;
     }
     const buttonSeat = state.buttonSeat;
+    const isTournament = !!state.config.blindStructure;
     // Heads-up specific logic (Button is SB)
     if ((0, headsUp_1.isHeadsUp)(state)) {
-        const bbSeat = (0, positioning_1.getNextOccupiedSeat)(buttonSeat, state.players, state.maxPlayers);
+        const bbSeat = getNextActiveOrOccupiedSeat(buttonSeat, state.players, state.maxPlayers, isTournament);
         if (bbSeat === null) {
             return null;
         }
@@ -34,8 +37,10 @@ function getBlindPositions(state) {
     // Normal Play (Dead Button / Dead Small Blind Logic)
     // 1. SB is ALWAYS the immediate next seat, even if empty
     const sbSeat = (0, positioning_1.getNextSeat)(buttonSeat, state.maxPlayers);
-    // 2. BB is the next ACTIVE/OCCUPIED player after the SB position
-    const bbSeat = (0, positioning_1.getNextOccupiedSeat)(sbSeat, state.players, state.maxPlayers);
+    // 2. BB is the next ACTIVE player after the SB position
+    // In cash games, skip sitting-out players
+    // In tournaments, include sitting-out players (they must post blinds)
+    const bbSeat = getNextActiveOrOccupiedSeat(sbSeat, state.players, state.maxPlayers, isTournament);
     if (bbSeat === null) {
         return null;
     }
@@ -44,6 +49,25 @@ function getBlindPositions(state) {
         bigBlindSeat: bbSeat,
     };
 }
+/**
+ * Get next seat that is occupied and (if cash game) not sitting out
+ */
+function getNextActiveOrOccupiedSeat(currentSeat, players, maxPlayers, isTournament) {
+    let seat = (0, positioning_1.getNextSeat)(currentSeat, maxPlayers);
+    const startSeat = currentSeat;
+    while (seat !== startSeat) {
+        const player = players[seat];
+        if (player !== null && player.stack > 0) {
+            // In tournaments, include sitting-out players (they must blind off)
+            // In cash games, skip sitting-out players
+            if (isTournament || !player.isSittingOut) {
+                return seat;
+            }
+        }
+        seat = (0, positioning_1.getNextSeat)(seat, maxPlayers);
+    }
+    return null; // No eligible seats
+}
 /**
  * Calculate blind amounts for antes
  */

package/dist/rules/headsUp.js

@@ -32,6 +32,24 @@ function getHeadsUpActionOrder(state, street) {
     }
     // Find the two seats
     const [seat1, seat2] = activePlayers.sort((a, b) => a - b);
+    // Check if button is one of the active players
+    const isButtonActive = activePlayers.includes(buttonSeat);
+    if (!isButtonActive) {
+        // Dead button scenario - button is not one of the active players
+        // In this case, the "button" for action purposes is the first active player
+        // after the actual button position
+        const effectiveButton = seat1 > buttonSeat || seat2 < buttonSeat ? seat1 : seat2;
+        const otherSeat = effectiveButton === seat1 ? seat2 : seat1;
+        if (street === "PREFLOP" /* Street.PREFLOP */) {
+            // Effective button acts first preflop
+            return [effectiveButton, otherSeat];
+        }
+        else {
+            // Effective button acts last postflop
+            return [otherSeat, effectiveButton];
+        }
+    }
+    // Normal case: button is one of the active players
     const otherSeat = seat1 === buttonSeat ? seat2 : seat1;
     if (street === "PREFLOP" /* Street.PREFLOP */) {
         // Button acts first preflop

package/dist/rules/showdown.js

@@ -23,6 +23,9 @@ function determineWinners(state) {
     });
     for (const pot of sortedPots) {
         const potWinners = evaluatePot(state, pot);
+        if (potWinners.length === 0) {
+            continue;
+        }
         // Calculate and deduct rake (cash games only)
         // Apply GLOBAL rake cap across all pots (per-hand, not per-pot)
         const { rake } = (0, rake_1.calculateRake)(state, pot.amount, totalRake);
@@ -122,6 +125,10 @@ function evaluatePot(state, pot) {
     for (const player of eligible) {
         if (!player?.hand)
             continue;
+        // Skip masked hands (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) {
@@ -140,6 +147,9 @@ function evaluatePot(state, pot) {
             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);

package/dist/utils/cardUtils.d.ts

@@ -4,8 +4,9 @@
 export declare function cardCodesToStrings(codes: readonly number[]): string[];
 /**
  * Convert string card array to integer codes
+ * Filters out null (masked) cards
  */
-export declare function cardStringsToCards(cards: readonly string[]): number[];
+export declare function cardStringsToCards(cards: ReadonlyArray<string | null>): number[];
 /**
  * Validate card string format
  */

package/dist/utils/cardUtils.js

@@ -12,9 +12,10 @@ function cardCodesToStrings(codes) {
 }
 /**
  * Convert string card array to integer codes
+ * Filters out null (masked) cards
  */
 function cardStringsToCards(cards) {
-    return cards.map((card) => (0, evaluator_1.getCardCode)(card));
+    return cards.filter((c) => c !== null).map((card) => (0, evaluator_1.getCardCode)(card));
 }
 /**
  * Validate card string format

package/dist/utils/invariants.js

@@ -105,6 +105,10 @@ function getInitialChips(state) {
  * Checks multiple invariants beyond just chip conservation
  */
 function validateGameStateIntegrity(state) {
+    // Skip strict integrity checks in client mode to prevent UI crashes on minor sync issues
+    if (state.config.isClient) {
+        return;
+    }
     // 1. Chip conservation
     const initialChips = getInitialChips(state);
     auditChipConservation(state, initialChips);

package/dist/utils/positioning.js

@@ -30,7 +30,7 @@ function getActivePlayers(state) {
     const active = [];
     for (let i = 0; i < state.players.length; i++) {
         const player = state.players[i];
-        if (player && player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
+        if (player?.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
             active.push(i);
         }
     }
@@ -70,7 +70,7 @@ function getNextActionableSeat(currentSeat, state) {
     const startSeat = currentSeat;
     while (seat !== startSeat) {
         const player = state.players[seat];
-        if (player && player.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
+        if (player?.status === "ACTIVE" /* PlayerStatus.ACTIVE */ && player.stack > 0) {
             return seat;
         }
         seat = getNextSeat(seat, state.maxPlayers);

package/dist/utils/serialization.d.ts

@@ -25,6 +25,7 @@ export interface Snapshot {
     readonly ante: number;
     readonly blindLevel: number;
     readonly timeBanks: Record<number, number>;
+    readonly timeBankActiveSeat: number | null;
     readonly actionHistory: ActionRecord[];
     readonly previousStates: Snapshot[];
     readonly timestamp: number;

package/dist/utils/serialization.js

@@ -44,6 +44,7 @@ function createSnapshot(state) {
         ante: state.ante,
         blindLevel: state.blindLevel,
         timeBanks,
+        timeBankActiveSeat: state.timeBankActiveSeat,
         actionHistory: Array.from(state.actionHistory),
         previousStates,
         timestamp: state.timestamp,
@@ -69,6 +70,7 @@ function restoreFromSnapshot(snapshot) {
         ...snapshot,
         currentBets,
         timeBanks,
+        timeBankActiveSeat: snapshot.timeBankActiveSeat ?? null, // Backward compatibility
         previousStates,
         rakeThisHand: snapshot.rakeThisHand || 0, // Add missing field with default
     };

package/dist/utils/viewMasking.d.ts

@@ -6,9 +6,10 @@ import { GameState, PublicState } from "@pokertools/types";
  *
  * @param state Full game state
  * @param playerId Player requesting view (null = spectator)
+ * @param version State version number (defaults to 0 if not provided)
  * @returns Masked public state
  */
-export declare function createPublicView(state: GameState, playerId?: string | null): PublicState;
+export declare function createPublicView(state: GameState, playerId?: string | null, version?: number): PublicState;
 /**
  * Create spectator view (no player-specific information)
  */