@pokertools/engine 1.0.9 → 1.0.11

package/dist/actions/betting.js

@@ -15,18 +15,15 @@ const rake_1 = require("../utils/rake");
 function handleFold(state, action) {
     const result = (0, positioning_1.getPlayerById)(state, action.playerId);
     if (!result) {
-        return state; // Should have been caught by validation
+        return state;
     }
     const { seat } = result;
     const newPlayers = [...state.players];
-    // Set player status to FOLDED
     newPlayers[seat] = {
         ...newPlayers[seat],
         status: "FOLDED" /* PlayerStatus.FOLDED */,
     };
-    // Remove from active players
     const newActivePlayers = state.activePlayers.filter((s) => s !== seat);
-    // Add to action history
     const actionRecord = {
         action,
         seat,
@@ -39,20 +36,13 @@ function handleFold(state, action) {
         players: newPlayers,
         activePlayers: newActivePlayers,
         actionHistory: [...state.actionHistory, actionRecord],
-        timeBankActiveSeat: null, // Clear time bank flag on any action
+        timeBankActiveSeat: null,
         timestamp: action.timestamp,
     };
-    // Check if only one player with a live hand remains
-    // Count players who have not folded (Active + All-In)
     const playersWithLiveHands = currentState.players.filter((p) => p && p.status !== "FOLDED" /* PlayerStatus.FOLDED */);
-    // Only end the hand if exactly one player has cards
     if (playersWithLiveHands.length === 1 && playersWithLiveHands[0]) {
-        // Award remaining pots to last player with live hand
         return awardPotToLastPlayer(currentState, playersWithLiveHands[0].seat);
     }
-    // If we have 1 Active player but multiple Live players (others are All-In),
-    // the game should naturally progress to Showdown via progressStreet/checkAutoRunout
-    // Move to next player
     const nextToAct = (0, action_order_1.getNextToAct)(currentState);
     return {
         ...currentState,
@@ -68,7 +58,6 @@ function handleCheck(state, action) {
         return state;
     }
     const { seat } = result;
-    // Add to action history
     const actionRecord = {
         action,
         seat,
@@ -79,10 +68,8 @@ function handleCheck(state, action) {
     const newState = {
         ...state,
         actionHistory: [...state.actionHistory, actionRecord],
-        timeBankActiveSeat: null, // Clear time bank flag on any action
         timestamp: action.timestamp,
     };
-    // Move to next player
     const nextToAct = (0, action_order_1.getNextToAct)(newState);
     return {
         ...newState,
@@ -98,14 +85,11 @@ function handleCall(state, action) {
         return state;
     }
     const { player, seat } = result;
-    // Calculate amount to call
     const currentBet = getCurrentBet(state);
     const playerBet = state.currentBets.get(seat) ?? 0;
     const toCall = currentBet - playerBet;
-    // Determine actual call amount (may be all-in)
     const callAmount = Math.min(toCall, player.stack);
     const isAllIn = callAmount === player.stack;
-    // Update player
     const newPlayers = [...state.players];
     newPlayers[seat] = {
         ...player,
@@ -114,12 +98,10 @@ function handleCall(state, action) {
         totalInvestedThisHand: player.totalInvestedThisHand + callAmount,
         status: isAllIn ? "ALL_IN" /* PlayerStatus.ALL_IN */ : "ACTIVE" /* PlayerStatus.ACTIVE */,
     };
-    // Update current bets
     const newCurrentBets = new Map(state.currentBets);
     newCurrentBets.set(seat, playerBet + callAmount);
-    // Add to action history (include actual call amount in the action)
     const actionRecord = {
-        action: { ...action, amount: callAmount }, // Populate amount field for history
+        action: { ...action, amount: callAmount },
         seat,
         resultingPot: getTotalPot(state) + callAmount,
         resultingStack: newPlayers[seat].stack,
@@ -130,10 +112,8 @@ function handleCall(state, action) {
         players: newPlayers,
         currentBets: newCurrentBets,
         actionHistory: [...state.actionHistory, actionRecord],
-        timeBankActiveSeat: null, // Clear time bank flag on any action
         timestamp: action.timestamp,
     };
-    // Move to next player
     const nextToAct = (0, action_order_1.getNextToAct)(newState);
     return {
         ...newState,
@@ -151,7 +131,6 @@ function handleBet(state, action) {
     const { player, seat } = result;
     const betAmount = Math.min(action.amount, player.stack);
     const isAllIn = betAmount === player.stack;
-    // Update player
     const newPlayers = [...state.players];
     newPlayers[seat] = {
         ...player,
@@ -160,10 +139,8 @@ function handleBet(state, action) {
         totalInvestedThisHand: player.totalInvestedThisHand + betAmount,
         status: isAllIn ? "ALL_IN" /* PlayerStatus.ALL_IN */ : "ACTIVE" /* PlayerStatus.ACTIVE */,
     };
-    // Update current bets
     const newCurrentBets = new Map(state.currentBets);
     newCurrentBets.set(seat, betAmount);
-    // Add to action history
     const actionRecord = {
         action,
         seat,
@@ -175,14 +152,12 @@ function handleBet(state, action) {
         ...state,
         players: newPlayers,
         currentBets: newCurrentBets,
-        minRaise: betAmount + betAmount, // Min raise is current bet + raise increment
+        minRaise: betAmount + betAmount,
         lastRaiseAmount: betAmount,
         lastAggressorSeat: seat,
         actionHistory: [...state.actionHistory, actionRecord],
-        timeBankActiveSeat: null, // Clear time bank flag on any action
         timestamp: action.timestamp,
     };
-    // Move to next player
     const nextToAct = (0, action_order_1.getNextToAct)(newState);
     return {
         ...newState,
@@ -203,9 +178,7 @@ function handleRaise(state, action) {
     const raiseAmount = Math.min(action.amount, playerBet + player.stack);
     const addedChips = raiseAmount - playerBet;
     const isAllIn = addedChips === player.stack;
-    // Calculate raise increment
     const raiseIncrement = raiseAmount - currentBet;
-    // Update player
     const newPlayers = [...state.players];
     newPlayers[seat] = {
         ...player,
@@ -214,10 +187,8 @@ function handleRaise(state, action) {
         totalInvestedThisHand: player.totalInvestedThisHand + addedChips,
         status: isAllIn ? "ALL_IN" /* PlayerStatus.ALL_IN */ : "ACTIVE" /* PlayerStatus.ACTIVE */,
     };
-    // Update current bets
     const newCurrentBets = new Map(state.currentBets);
     newCurrentBets.set(seat, raiseAmount);
-    // Add to action history
     const actionRecord = {
         action,
         seat,
@@ -225,15 +196,10 @@ function handleRaise(state, action) {
         resultingStack: newPlayers[seat].stack,
         street: state.street,
     };
-    // Determine if this reopens betting (incomplete raise rule)
+    // Incomplete-raise rule: does this raise reopen the betting?
     const reopensBetting = raiseIncrement >= state.lastRaiseAmount;
-    // Min-raise calculation:
-    // - If reopens betting: new currentBet + new increment
-    // - If incomplete raise: new currentBet + old increment (TDA/WSOP rule)
-    //   Example: P1 bets 100, P2 all-in 120, P3 must raise to 120+100=220 minimum
-    const newMinRaise = reopensBetting
-        ? raiseAmount + raiseIncrement
-        : raiseAmount + state.lastRaiseAmount;
+    // Incomplete all-in raises do not change the next minimum full raise.
+    const newMinRaise = reopensBetting ? raiseAmount + raiseIncrement : state.minRaise;
     const newState = {
         ...state,
         players: newPlayers,
@@ -242,10 +208,8 @@ function handleRaise(state, action) {
         lastRaiseAmount: reopensBetting ? raiseIncrement : state.lastRaiseAmount,
         lastAggressorSeat: reopensBetting ? seat : state.lastAggressorSeat,
         actionHistory: [...state.actionHistory, actionRecord],
-        timeBankActiveSeat: null, // Clear time bank flag on any action
         timestamp: action.timestamp,
     };
-    // Move to next player
     const nextToAct = (0, action_order_1.getNextToAct)(newState);
     return {
         ...newState,
@@ -278,31 +242,26 @@ function getTotalPot(state) {
     return total;
 }
 /**
- * Award pots to remaining eligible players when hand ends by folds
- * Properly handles side pot eligibility and uncalled bets
+ * Award pots to remaining eligible players when hand ends by folds.
  *
  * Key principle: Uncalled bets are NOT raked and are returned to the bettor immediately.
- * Only the contested portion of the pot (money actually at risk) is subject to rake.
+ * Only the contested portion is subject to rake.
  */
 function awardPotToLastPlayer(state, winningSeat) {
     const newPlayers = [...state.players];
     const newActionHistory = [...state.actionHistory];
     const winners = [];
-    // Process each pot separately, checking eligibility
     let totalRakeFromPots = 0;
     for (const pot of state.pots) {
-        // Find all non-folded players eligible for this pot
         const eligibleNonFolded = pot.eligibleSeats.filter((seat) => {
             const player = state.players[seat];
             return player && player.status !== "FOLDED" /* PlayerStatus.FOLDED */;
         });
-        // Calculate rake for this pot - GLOBAL cap applied across all pots
         const { rake: potRake } = (0, rake_1.calculateRake)(state, pot.amount, totalRakeFromPots);
         totalRakeFromPots += potRake;
         const potAfterRake = pot.amount - potRake;
         if (eligibleNonFolded.length === 0) {
-            // No eligible players remain - should not happen, but defensive
-            // Award to last player to fold from eligible seats (fallback)
+            // Defensive fallback: no eligible players remain.
             const lastEligible = pot.eligibleSeats[pot.eligibleSeats.length - 1];
             const player = newPlayers[lastEligible];
             if (player) {
@@ -319,7 +278,6 @@ function awardPotToLastPlayer(state, winningSeat) {
             }
         }
         else if (eligibleNonFolded.length === 1) {
-            // Exactly one eligible player - they win this pot
             const winnerSeat = eligibleNonFolded[0];
             const player = newPlayers[winnerSeat];
             newPlayers[winnerSeat] = {
@@ -334,8 +292,6 @@ function awardPotToLastPlayer(state, winningSeat) {
             });
         }
         else {
-            // Multiple eligible players remain - this means awardPotToLastPlayer was called incorrectly
-            // The hand should have gone to showdown instead
             throw new critical_state_error_1.CriticalStateError("awardPotToLastPlayer called with multiple eligible players remaining", {
                 potAmount: pot.amount,
                 eligibleSeats: pot.eligibleSeats,
@@ -344,28 +300,25 @@ function awardPotToLastPlayer(state, winningSeat) {
             });
         }
     }
-    // Handle current bets with proper uncalled bet logic
+    // Uncalled bet logic: three-step process.
     if (state.currentBets.size > 0) {
         const winnersBet = state.currentBets.get(winningSeat) ?? 0;
-        // Find the second-highest bet (highest opponent bet)
-        // This determines how much of the winner's bet was actually "called"
+        // Second-highest bet determines how much of winner's bet was actually "called".
         let maxOpponentBet = 0;
         for (const [seat, amount] of state.currentBets.entries()) {
             if (seat !== winningSeat && amount > maxOpponentBet) {
                 maxOpponentBet = amount;
             }
         }
-        // Calculate uncalled and called portions
         const uncalledAmount = winnersBet > maxOpponentBet ? winnersBet - maxOpponentBet : 0;
         const calledPortion = winnersBet > maxOpponentBet ? maxOpponentBet : winnersBet;
-        // Step 1: Return uncalled bet immediately (NO RAKE on uncalled bets)
+        // Step 1: Return uncalled bet immediately (NO RAKE on uncalled bets).
         if (uncalledAmount > 0) {
             const player = newPlayers[winningSeat];
             newPlayers[winningSeat] = {
                 ...player,
                 stack: player.stack + uncalledAmount,
             };
-            // Record the uncalled bet return
             newActionHistory.push({
                 action: {
                     type: "UNCALLED_BET_RETURNED" /* ActionType.UNCALLED_BET_RETURNED */,
@@ -379,14 +332,14 @@ function awardPotToLastPlayer(state, winningSeat) {
                 street: state.street,
             });
         }
-        // Step 2: Calculate contested pot (winner's called portion + all opponent bets)
+        // Step 2: Contested pot = winner's called portion + all opponent bets.
         let contestedPot = calledPortion;
         for (const [seat, amount] of state.currentBets.entries()) {
             if (seat !== winningSeat) {
                 contestedPot += amount;
             }
         }
-        // Step 3: Rake and award the contested portion only
+        // Step 3: Rake and award the contested portion only.
         if (contestedPot > 0) {
             const { rake } = (0, rake_1.calculateRake)(state, contestedPot, totalRakeFromPots);
             const totalRake = totalRakeFromPots + rake;
@@ -396,8 +349,6 @@ function awardPotToLastPlayer(state, winningSeat) {
                 ...player,
                 stack: player.stack + winnings,
             };
-            // Update winners array
-            // Only count actual winnings (contested pot after rake, minus winner's own contribution)
             const actualWinnings = winnings - calledPortion;
             if (actualWinnings > 0) {
                 const existingIndex = winners.findIndex((w) => w.seat === winningSeat);
@@ -416,16 +367,13 @@ function awardPotToLastPlayer(state, winningSeat) {
                     });
                 }
             }
-            // Update total rake for the hand
             totalRakeFromPots = totalRake;
         }
     }
-    // NOTE: We do NOT reset totalInvestedThisHand here because it's used by getInitialChips()
-    // to calculate total chips in the game. It will be reset when a new hand is dealt.
     return {
         ...state,
         players: newPlayers,
-        street: "SHOWDOWN" /* Street.SHOWDOWN */, // Mark hand as complete
+        street: "SHOWDOWN" /* Street.SHOWDOWN */,
         pots: [],
         currentBets: new Map(),
         winners,

package/dist/actions/dealing.js

@@ -14,66 +14,56 @@ const positioning_1 = require("../utils/positioning");
  * - Sets action to first to act
  */
 function handleDeal(state, action) {
-    // Move button (Dead Button logic: moves to next seat index regardless of occupancy)
+    // Dead Button rule: advances to next seat index regardless of occupancy.
     let newButtonSeat = moveButton(state);
-    // Determine if this is a tournament
     const isTournament = !!state.config.blindStructure;
     const isClient = !!state.config.isClient;
-    // Create and shuffle deck (server only)
-    // In client mode, we use an empty deck and deal masked cards
+    // Client mode: empty deck, cards dealt as masked (null).
     const rng = state.config.randomProvider ?? Math.random;
     const deck = isClient ? [] : (0, deck_1.shuffle)((0, deck_1.createDeck)(), rng);
-    // Create a copy of timeBanks to modify
     const newTimeBanks = new Map(state.timeBanks);
-    // First, merge pendingAddOn into stack for all players
+    // Merge pending add-ons; expire stale reservations.
     const newPlayers = state.players.map((player) => {
         if (!player)
             return null;
-        // Skip reserved players (they haven't confirmed yet)
         if (player.status === "RESERVED" /* PlayerStatus.RESERVED */) {
-            // Check if reservation has expired
             if (player.reservationExpiry && action.timestamp >= player.reservationExpiry) {
-                // Reservation expired, remove player
                 newTimeBanks.delete(player.seat);
                 return null;
             }
-            // Keep reserved player as-is
             return player;
         }
-        // Merge pendingAddOn into stack
         const newStack = player.stack + player.pendingAddOn;
         return {
             ...player,
             stack: newStack,
-            pendingAddOn: 0, // Clear pending add-on
+            pendingAddOn: 0,
         };
     });
     newButtonSeat = moveHeadsUpButtonToOccupiedSeat(newButtonSeat, {
         ...state,
         players: newPlayers,
     });
-    // Get blind positions for this hand
+    // Recompute blind positions with updated button/players.
     const blindPositions = (0, blinds_1.getBlindPositions)({
         ...state,
         buttonSeat: newButtonSeat,
         players: newPlayers,
     });
-    // Get players who will be dealt in
+    // Determine which players receive cards.
     const playersToReceive = [];
     for (let seat = 0; seat < newPlayers.length; seat++) {
         const player = newPlayers[seat];
-        // Basic eligibility checks
         if (!player || player.stack <= 0 || player.status === "RESERVED" /* PlayerStatus.RESERVED */) {
             continue;
         }
-        // We check WAIT_FOR_BB *before* checking isSittingOut.
-        // This allows us to "unsit" a player if they hit the Big Blind.
+        // WAIT_FOR_BB check: sit player IN when they reach the Big Blind,
+        // sit player OUT when they haven't reached it yet.
         let shouldPlay = true;
         if (!isTournament && player.sitInOption === "WAIT_FOR_BB" /* SitInOption.WAIT_FOR_BB */) {
             const isInBigBlind = blindPositions?.bigBlindSeat === seat;
             if (isInBigBlind) {
-                // PLAYER RE-ENTRY: They are in the Big Blind. Force them active.
-                // We must update the player object in newPlayers to reflect they are back.
+                // PLAYER RE-ENTRY: Force them active when they are in the Big Blind.
                 newPlayers[seat] = {
                     ...player,
                     isSittingOut: false,
@@ -81,8 +71,7 @@ function handleDeal(state, action) {
                 shouldPlay = true;
             }
             else {
-                // Not in BB yet. Force them to sit out.
-                // Only update if not already sitting out to avoid object churn
+                // Not yet in BB; force sit-out (avoids object churn if already sitting out).
                 if (!player.isSittingOut) {
                     newPlayers[seat] = {
                         ...player,
@@ -93,67 +82,60 @@ function handleDeal(state, action) {
             }
         }
         else if (player.isSittingOut) {
-            // Standard sitting out check
             shouldPlay = false;
         }
         if (shouldPlay) {
             playersToReceive.push(seat);
         }
     }
-    // Deal 2 cards to each player
     let remainingDeck = deck;
-    // Initialize hands for receiving players (active, not sitting out)
     for (const seat of playersToReceive) {
         newPlayers[seat] = {
             ...newPlayers[seat],
-            hand: [], // Initialize empty array
-            shownCards: null, // Reset from previous hand
+            hand: [],
+            shownCards: null,
             status: "ACTIVE" /* PlayerStatus.ACTIVE */,
             betThisStreet: 0,
             totalInvestedThisHand: 0,
         };
     }
-    // In tournaments, initialize sitting-out players too (they must post blinds/antes)
+    // Tournament: sitting-out players initialized as FOLDED (must post blinds/antes).
     if (isTournament) {
         for (let seat = 0; seat < newPlayers.length; seat++) {
             const player = newPlayers[seat];
             if (player && player.stack > 0 && player.isSittingOut && !playersToReceive.includes(seat)) {
                 newPlayers[seat] = {
                     ...player,
-                    hand: null, // No cards dealt
+                    hand: null,
                     shownCards: null,
-                    status: "FOLDED" /* PlayerStatus.FOLDED */, // Start as folded
+                    status: "FOLDED" /* PlayerStatus.FOLDED */,
                     betThisStreet: 0,
                     totalInvestedThisHand: 0,
                 };
             }
         }
     }
-    // Deal 2 cards, one by one, in circle (standard poker procedure)
+    // Deal 2 hole cards, one at a time, clockwise.
     for (let round = 0; round < 2; round++) {
         for (const seat of playersToReceive) {
             let cardStrings;
             if (isClient) {
-                // Client mode: Deal masked cards
                 cardStrings = [null];
             }
             else {
-                // Server mode: Deal from deck
                 const [cards, nextDeck] = (0, deck_1.dealCards)(remainingDeck, 1);
                 remainingDeck = nextDeck;
                 cardStrings = (0, card_utils_1.cardCodesToStrings)(cards);
             }
-            // Append to existing hand
             const currentPlayer = newPlayers[seat];
-            const currentHand = currentPlayer.hand ?? []; // Should be [] from initialization
+            const currentHand = currentPlayer.hand ?? [];
             newPlayers[seat] = {
                 ...currentPlayer,
                 hand: [...currentHand, ...cardStrings],
             };
         }
     }
-    // Post blinds and antes
-    // Recalculate blind positions with the new button seat
+    // Post blinds and antes.
     const finalBlindPositions = (0, blinds_1.getBlindPositions)({
         ...state,
         buttonSeat: newButtonSeat,
@@ -162,9 +144,6 @@ function handleDeal(state, action) {
     const currentBets = new Map();
     if (finalBlindPositions) {
         const { smallBlindSeat, bigBlindSeat } = finalBlindPositions;
-        // Post small blind
-        // In tournaments: sitting-out players MUST post to prevent "blinding off" exploit
-        // In cash games: sitting-out SB is treated as "Dead Small Blind" (no post)
         const sbPlayer = newPlayers[smallBlindSeat];
         if (sbPlayer && sbPlayer.stack > 0) {
             const shouldPostSB = isTournament || !sbPlayer.isSittingOut;
@@ -184,12 +163,11 @@ function handleDeal(state, action) {
                 };
             }
         }
-        // If sbPlayer is null or (cash game && sitting out), Dead Small Blind applies
-        // Post big blind (Must exist for hand to start)
+        // Dead Small Blind: sbPlayer is null or (cash game && sitting out).
         const bbPlayer = newPlayers[bigBlindSeat];
         if (bbPlayer) {
-            // In Cash Games: sitting-out players should NEVER post blinds (they are skipped by getBlindPositions)
-            // In Tournaments: sitting-out players MUST post blinds to prevent "blinding off" exploit
+            // In cash games sitting-out players are skipped by getBlindPositions.
+            // In tournaments sitting-out players MUST post blinds (anti-blinding-off).
             const shouldPostBB = isTournament || !bbPlayer.isSittingOut;
             if (shouldPostBB) {
                 const bbAmount = Math.min(bbPlayer.stack, state.bigBlind);
@@ -208,9 +186,7 @@ function handleDeal(state, action) {
             }
         }
     }
-    // Post antes if configured
-    // In tournaments: ALL players with chips must post (including sitting-out)
-    // In cash games: Only active players post
+    // Antes: tournament — all players with chips (incl. sitting-out); cash — active only.
     if (state.ante > 0) {
         const playersToAnteFrom = isTournament
             ? state.players.map((p, idx) => (p && p.stack > 0 ? idx : -1)).filter((idx) => idx >= 0)
@@ -236,9 +212,7 @@ function handleDeal(state, action) {
             }
         }
     }
-    // Start with empty pots (bets will be collected when street progresses)
     const pots = [];
-    // Get active players
     const activePlayers = playersToReceive.filter((seat) => {
         const player = newPlayers[seat];
         return player.status === "ACTIVE" /* PlayerStatus.ACTIVE */;
@@ -258,13 +232,13 @@ function handleDeal(state, action) {
             Array.from(currentBets.values()).reduce((sum, amount) => sum + amount, 0),
         minRaise: state.bigBlind,
         lastRaiseAmount: state.bigBlind,
+        lastAggressorSeat: null,
         activePlayers,
         winners: null,
         rakeThisHand: 0,
         actionHistory: [],
         timestamp: action.timestamp,
     };
-    // Set first to act
     const firstToAct = (0, action_order_1.getFirstToAct)(newState);
     return {
         ...newState,
@@ -277,7 +251,6 @@ function handleDeal(state, action) {
  */
 function moveButton(state) {
     if (state.buttonSeat === null) {
-        // First hand, find first seated player
         for (let seat = 0; seat < state.maxPlayers; seat++) {
             if (state.players[seat] !== null) {
                 return seat;
@@ -285,8 +258,7 @@ function moveButton(state) {
         }
         return 0;
     }
-    // Simply increment seat index (Dead Button)
-    // We do not skip empty seats here.
+    // Dead Button: advance to next seat index regardless of occupancy.
     return (0, positioning_1.getNextSeat)(state.buttonSeat, state.maxPlayers);
 }
 function moveHeadsUpButtonToOccupiedSeat(buttonSeat, state) {

package/dist/actions/management.js

@@ -28,7 +28,6 @@ function handleSit(state, action) {
     };
     const newPlayers = [...state.players];
     newPlayers[action.seat] = newPlayer;
-    // Add to time banks
     const newTimeBanks = new Map(state.timeBanks);
     newTimeBanks.set(action.seat, newPlayer.timeBank);
     return {

package/dist/actions/showdown-actions.js

@@ -3,47 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleShow = handleShow;
 exports.handleMuck = handleMuck;
 const illegal_action_error_1 = require("../errors/illegal-action-error");
-const error_codes_1 = require("../errors/error-codes");
+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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
     }
-    // Can only show at showdown
     if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_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 illegal_action_error_1.IllegalActionError(error_codes_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 illegal_action_error_1.IllegalActionError(error_codes_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 illegal_action_error_1.IllegalActionError(error_codes_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
+        throw new illegal_action_error_1.IllegalActionError(types_1.ErrorCodes.PLAYER_NOT_FOUND, `Player ${action.playerId} not found`, { playerId: action.playerId });
     }
-    // Can only muck at showdown
     if (state.street !== "SHOWDOWN" /* Street.SHOWDOWN */) {
-        throw new illegal_action_error_1.IllegalActionError(error_codes_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 illegal_action_error_1.IllegalActionError(error_codes_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 illegal_action_error_1.IllegalActionError(error_codes_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: {