Give the odd chip to the player the rule says gets it

Quick Split tells the dealer a leftover chip goes "to the first player left of
the button". The pot wizard, on the same tool, handed it to whoever the dealer
happened to tick first. Two screens, same split, different answer.

The wizard now orders the winners around the table from the button before the
calculator shares the pot out, so the leftover lands where the instruction says
it does. The calculator itself is unchanged — it already gave leftovers to the
front of the list, it was just being handed the list in the order the checkboxes
were clicked.

It's pennies, but it's pennies in front of the person who didn't get them, and a
dealer who has just read the other screen's instruction out loud looks wrong.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb

JoshHeaps.Net/Pages/Casino/TexasHoldem.cshtml

@@ -31,9 +31,13 @@
                         <span id="potBadgeAmount">$0</span>
                     </div>
                 </div>
+                <div id="betsLayer" aria-hidden="true"></div>
                 <div id="seatsLayer"></div>
             </div>
             <p id="tableHint" class="tableHint"></p>
+            <p class="tableHintActions">
+                <button type="button" id="openRulingsBtn" class="linkBtn">Common rulings</button>
+            </p>
         </section>
 
         <aside id="holdemSidebar">
@@ -67,33 +71,39 @@
                         <input type="checkbox" id="dedicatedDealerToggle" />
                     </label>
                     <p class="fieldHint">Turn this on if a person outside the game deals — no seat shows the dealer button, but blinds still rotate automatically each hand.</p>
+                    <div class="blindsRow">
+                        <label class="fieldRow">
+                            <span>Small blind</span>
+                            <input type="number" id="smallBlindInput" min="0" step="0.5" />
+                        </label>
+                        <label class="fieldRow">
+                            <span>Big blind</span>
+                            <input type="number" id="bigBlindInput" min="0" step="0.5" />
+                        </label>
+                    </div>
                     <label class="fieldRow">
-                        <span>Base pot amount ($)</span>
-                        <input type="number" id="basePotInput" min="0" step="1" placeholder="e.g. 500" />
+                        <span>Starting stack ($)</span>
+                        <input type="number" id="defaultStackInput" min="0" step="1" placeholder="e.g. 200" />
                     </label>
-                    <p class="fieldHint">Every player who didn't go all-in short is assumed to have put in this amount. Enter a smaller amount on a seat only if that player is all-in for less.</p>
+                    <p class="fieldHint">Blinds post themselves each hand. Seats without their own stack start here.</p>
+
+                    <details class="subPanel">
+                        <summary>Without live betting</summary>
+                        <div class="subPanelBody">
+                            <label class="fieldRow">
+                                <span>Base pot amount ($)</span>
+                                <input type="number" id="basePotInput" min="0" step="1" placeholder="e.g. 500" />
+                            </label>
+                            <p class="fieldHint">For tracking a hand by hand instead of tapping the action: everyone is assumed to have put in this much, unless their seat says otherwise.</p>
+                        </div>
+                    </details>
                 </div>
             </details>
 
             <details class="sidebarPanel">
-                <summary>Chip Legend</summary>
-                <div class="panelBody">
-                    <div id="chipLegendList"></div>
-                    <button id="addChipColorBtn" class="holdemBtn holdemBtnSmall">+ Add chip color</button>
-                    <p class="fieldHint">Give each chip color a dollar value, then count chips per seat instead of typing a total.</p>
-                </div>
-            </details>
-
-            <details class="sidebarPanel">
-                <summary>Table Notes</summary>
-                <div class="panelBody">
-                    <textarea id="tableNotes" rows="4" placeholder="Anything else worth tracking — side bets, IOUs, running totals..."></textarea>
-                </div>
-            </details>
-
-            <details class="sidebarPanel">
-                <summary>Session Standings</summary>
+                <summary>Session</summary>
                 <div class="panelBody">
+                    <h3 class="panelSubhead">Standings</h3>
                     <div id="standingsTable">
                         <div class="standingsRow standingsHeader">
                             <span>Player</span>
@@ -104,20 +114,33 @@
                         <div id="standingsList"></div>
                     </div>
                     <p id="standingsEmptyHint" class="fieldHint">Once you resolve a pot, everyone's running total for the night shows up here.</p>
-                </div>
-            </details>
 
-            <details class="sidebarPanel">
-                <summary>Hand History</summary>
-                <div class="panelBody">
+                    <h3 class="panelSubhead">Hands</h3>
                     <div id="handHistoryList"></div>
-                    <p id="handHistoryEmptyHint" class="fieldHint">Resolved pots show up here as you play, in case a chip count is disputed later.</p>
+                    <p id="handHistoryEmptyHint" class="fieldHint">Resolved pots are logged here, in case a chip count is disputed later.</p>
+
                     <div class="handHistoryActions">
                         <button id="exportHistoryBtn" class="holdemBtn holdemBtnSmall">Export CSV</button>
                         <button id="clearHistoryBtn" class="holdemBtn holdemBtnSmall holdemBtnDanger">Clear history</button>
                     </div>
                 </div>
             </details>
+
+            <details class="sidebarPanel">
+                <summary>Chip Legend</summary>
+                <div class="panelBody">
+                    <div id="chipLegendList"></div>
+                    <button id="addChipColorBtn" class="holdemBtn holdemBtnSmall">+ Add chip color</button>
+                    <p class="fieldHint">Give each chip color a value, then count chips on a seat instead of typing a total.</p>
+                </div>
+            </details>
+
+            <details class="sidebarPanel">
+                <summary>Table Notes</summary>
+                <div class="panelBody">
+                    <textarea id="tableNotes" rows="4" placeholder="Anything else worth tracking — side bets, IOUs, running totals..."></textarea>
+                </div>
+            </details>
         </aside>
     </div>
 </div>
@@ -131,6 +154,7 @@
         <div class="seatPuckName"></div>
         <div class="seatPuckCards"></div>
         <div class="seatPuckTotal"></div>
+        <div class="seatPuckStack"></div>
     </div>
 </template>
 
@@ -151,9 +175,14 @@
             </label>
         </div>
         <div class="seatCards">
-            <input type="text" class="cardInput card1Input" maxlength="2" placeholder="__" />
-            <input type="text" class="cardInput card2Input" maxlength="2" placeholder="__" />
+            <button type="button" class="cardSlot card1Slot" aria-label="Choose first card"></button>
+            <button type="button" class="cardSlot card2Slot" aria-label="Choose second card"></button>
         </div>
+        <label class="fieldRow stackRow">
+            <span>Stack</span>
+            <input type="number" class="stackInput" min="0" step="1" placeholder="table default" />
+        </label>
+        <div class="seatBuyIns" hidden></div>
         <div class="seatContribution">
             <div class="chipCounts"></div>
             <label class="fieldRow amountOverrideRow">
@@ -210,6 +239,100 @@
     </div>
 </template>
 
+<div id="addChipsOverlay" hidden>
+    <div id="addChipsSheet" role="dialog" aria-labelledby="addChipsTitle">
+        <div class="seatSheetGrip" aria-hidden="true"></div>
+        <div class="addChipsHeader">
+            <h2 id="addChipsTitle"></h2>
+            <span id="addChipsSubtitle"></span>
+        </div>
+        <div id="addChipsQuick"></div>
+        <div class="addChipsEntry">
+            <span class="addChipsCurrency">$</span>
+            <input type="text" id="addChipsInput" inputmode="decimal" autocomplete="off" aria-label="Amount to add" />
+        </div>
+        <div class="addChipsActions">
+            <button id="addChipsConfirmBtn" class="holdemBtn holdemBtnAccent" type="button">Add to stack</button>
+            <button id="addChipsCancelBtn" class="holdemBtn holdemBtnGhost" type="button">Cancel</button>
+        </div>
+    </div>
+</div>
+
+<div id="rulingsOverlay" hidden>
+    <div id="rulingsSheet" role="dialog" aria-labelledby="rulingsTitle">
+        <div class="seatSheetGrip" aria-hidden="true"></div>
+        <div class="rulingsHeader">
+            <h2 id="rulingsTitle">Common rulings</h2>
+            <button id="closeRulingsBtn" class="holdemBtn holdemBtnSmall holdemBtnGhost" type="button">Done</button>
+        </div>
+
+        <p class="rulingsIntro">
+            The conventions most rooms follow, for the calls that come up mid-hand.
+            Your house rules always win — and settle a dispute before the next hand,
+            not during it.
+        </p>
+
+        <section class="ruling">
+            <h3>Redeal it — misdeal</h3>
+            <ul>
+                <li>The first card goes to the wrong seat.</li>
+                <li>A seat entitled to a hand gets dealt out, or a seat that isn't entitled gets dealt in.</li>
+                <li>Two or more boxed cards turn up on the initial deal.</li>
+                <li>Either of the first two cards is exposed by dealer error.</li>
+            </ul>
+        </section>
+
+        <section class="ruling">
+            <h3>A board card turned too early</h3>
+            <p>
+                If the fourth board card gets turned before the betting round is finished,
+                that card is out of play for the round. Finish the betting, then burn and
+                turn what would have been the fifth card in the fourth card's place.
+            </p>
+        </section>
+
+        <section class="ruling">
+            <h3>Acting out of turn</h3>
+            <p>
+                A one-off is usually just backed up if no one has acted behind them.
+                Doing it repeatedly is what earns a penalty.
+            </p>
+        </section>
+
+        <p class="rulingsSource">
+            Follows the Tournament Directors Association rules, which most rooms and
+            home games take their lead from.
+        </p>
+    </div>
+</div>
+
+<div id="seatMenuOverlay" hidden>
+    <div id="seatMenuSheet" role="dialog" aria-labelledby="seatMenuTitle">
+        <div class="seatSheetGrip" aria-hidden="true"></div>
+        <div class="seatMenuHeader">
+            <h2 id="seatMenuTitle"></h2>
+            <span id="seatMenuSubtitle"></span>
+        </div>
+        <div id="seatMenuActions"></div>
+        <button id="seatMenuCancelBtn" class="holdemBtn holdemBtnGhost" type="button">Cancel</button>
+    </div>
+</div>
+
+<div id="cardPickerOverlay" hidden>
+    <div id="cardPickerSheet" role="dialog" aria-labelledby="cardPickerTitle">
+        <div class="seatSheetGrip" aria-hidden="true"></div>
+        <div class="cardPickerHeader">
+            <h2 id="cardPickerTitle"></h2>
+            <button id="cardPickerClearBtn" class="holdemBtn holdemBtnSmall" type="button">Clear</button>
+            <button id="cardPickerCloseBtn" class="holdemBtn holdemBtnSmall holdemBtnGhost" type="button">Done</button>
+        </div>
+        <div id="cardPickerSlots"></div>
+        <div id="cardPickerGrid"></div>
+    </div>
+</div>
+
+<div id="actionBar" aria-live="polite" hidden></div>
+
 <div id="toastHost" aria-live="polite"></div>
 
 <div id="confirmOverlay" hidden>
@@ -243,6 +366,12 @@
     <script src="~/js/casino/holdem/potCalculator.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/state.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/render.js?v=@ViewData["cssVersion"]"></script>
+    <script src="~/js/casino/holdem/cardPicker.js?v=@ViewData["cssVersion"]"></script>
+    <script src="~/js/casino/holdem/seatMenu.js?v=@ViewData["cssVersion"]"></script>
+    <script src="~/js/casino/holdem/addChips.js?v=@ViewData["cssVersion"]"></script>
+    <script src="~/js/casino/holdem/betting.js?v=@ViewData["cssVersion"]"></script>
+    <script src="~/js/casino/holdem/actionBar.js?v=@ViewData["cssVersion"]"></script>
+    <script src="~/js/casino/holdem/shortcuts.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/potWizard.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/handHistoryExport.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/main.js?v=@ViewData["cssVersion"]"></script>

JoshHeaps.Net/wwwroot/js/casino/holdem/actionBar.js

@@ -0,0 +1,380 @@
+// The bar a dealer's thumb lives on while a hand is running: who's to act, what it
+// costs them, and one tap per decision. Sits at the bottom of the screen on a phone
+// so it's reachable without looking, and re-renders after every action because the
+// next player's numbers are different.
+const ActionBar = {
+    state: null,
+    hooks: null,
+    raiseOpen: false,
+    raiseDraft: null,
+
+    mount(state, hooks) {
+        this.state = state;
+        this.hooks = hooks;
+        this.render();
+    },
+
+    // Anything to act on? A hand with nobody dealt in doesn't get a bar.
+    isRunning() {
+        return Betting.liveSeats(this.state).length > 0;
+    },
+
+    render() {
+        const host = document.getElementById("actionBar");
+        if (!host) return;
+        host.innerHTML = "";
+
+        if (!this.isRunning()) {
+            host.hidden = true;
+            document.body.classList.remove("hasActionBar");
+            this.stopTankTimer();
+            this.tankSeatIndex = null;
+            return;
+        }
+        host.hidden = false;
+        document.body.classList.add("hasActionBar");
+
+        host.appendChild(this.renderStatus());
+
+        const breakdown = this.renderPotBreakdown();
+        if (breakdown) host.appendChild(breakdown);
+
+        if (Betting.isHandOver(this.state)) {
+            host.appendChild(this.renderHandOver());
+        } else if (this.state.actingSeatIndex === null || this.state.actingSeatIndex === undefined) {
+            host.appendChild(this.renderStreetDone());
+        } else if (this.raiseOpen) {
+            host.appendChild(this.renderRaisePad());
+        } else {
+            host.appendChild(this.renderActions());
+        }
+
+        this.syncTankTimer();
+    },
+
+    renderStatus() {
+        const row = document.createElement("div");
+        row.className = "actionStatus";
+
+        const street = document.createElement("span");
+        street.className = "actionStreet";
+        street.textContent = Betting.streetLabel(this.state.street);
+        row.appendChild(street);
+
+        const pot = document.createElement("span");
+        pot.className = "actionPot";
+        pot.textContent = `Pot ${Money.format(Betting.potSoFar(this.state))}`;
+        row.appendChild(pot);
+
+        // How many are still in the hand — part of the standard per-street
+        // announcement, and the number a dealer is asked for most often.
+        const remaining = Betting.liveSeats(this.state).length;
+        const players = document.createElement("span");
+        players.className = "actionPlayers";
+        players.textContent = `${remaining} ${remaining === 1 ? "player" : "players"}`;
+        row.appendChild(players);
+
+        const index = this.state.actingSeatIndex;
+        if (index !== null && index !== undefined && !Betting.isHandOver(this.state)) {
+            const player = this.state.seats[index];
+            const who = document.createElement("span");
+            who.className = "actionWho";
+            who.textContent = `${HoldemState.displayName(player, index)} · ${Money.format(Betting.stackOf(this.state, player))} behind`;
+            row.appendChild(who);
+
+            const tank = document.createElement("span");
+            tank.className = "actionTank";
+            tank.id = "actionTank";
+            tank.title = "How long this player has been thinking";
+            tank.textContent = "0:00";
+            row.appendChild(tank);
+        }
+
+        // A standing control rather than a toast per action: a dealer taps this bar
+        // constantly, and a toast after every fold would be noise they'd learn to
+        // ignore — which is exactly when they'd miss the one that mattered.
+        const undoLabel = this.hooks.lastActionLabel();
+        if (undoLabel) {
+            const undo = document.createElement("button");
+            undo.type = "button";
+            undo.className = "actionUndo";
+            undo.title = `Undo ${undoLabel}`;
+            undo.textContent = `↶ ${undoLabel}`;
+            undo.addEventListener("click", () => this.hooks.undoLast());
+            row.appendChild(undo);
+        }
+
+        return row;
+    },
+
+    // ---- Think timer ----
+    //
+    // A player who hasn't noticed the action is on them costs more time than anything
+    // else a dealer does, so the bar shows how long the current player has been in the
+    // tank. It's a stopwatch, not a shot clock: nothing happens when it grows, it just
+    // tells the dealer when it's worth a nudge.
+    NUDGE_AFTER_S: 30,
+    SLOW_AFTER_S: 60,
+
+    tankSeatIndex: null,
+    tankStartedAt: null,
+    tankInterval: null,
+
+    // Restarts only when the action actually moves — a re-render for any other reason
+    // (a chip edit, a name change) must not put a thinking player back to zero.
+    syncTankTimer() {
+        const index = this.state.actingSeatIndex;
+        const running = index !== null && index !== undefined && !Betting.isHandOver(this.state);
+
+        if (!running) {
+            this.stopTankTimer();
+            this.tankSeatIndex = null;
+            return;
+        }
+
+        if (this.tankSeatIndex !== index) {
+            this.tankSeatIndex = index;
+            this.tankStartedAt = Date.now();
+        }
+
+        if (!this.tankInterval) {
+            this.tankInterval = setInterval(() => this.paintTank(), 1000);
+        }
+        this.paintTank();
+    },
+
+    stopTankTimer() {
+        if (this.tankInterval) {
+            clearInterval(this.tankInterval);
+            this.tankInterval = null;
+        }
+    },
+
+    // Updates only the timer's own text, so the seconds ticking over never rebuilds the
+    // buttons under the dealer's thumb.
+    paintTank() {
+        const el = document.getElementById("actionTank");
+        if (!el || this.tankStartedAt === null) return;
+
+        const seconds = Math.floor((Date.now() - this.tankStartedAt) / 1000);
+        const mins = Math.floor(seconds / 60);
+        el.textContent = `${mins}:${String(seconds % 60).padStart(2, "0")}`;
+        el.classList.toggle("tankNudge", seconds >= this.NUDGE_AFTER_S && seconds < this.SLOW_AFTER_S);
+        el.classList.toggle("tankSlow", seconds >= this.SLOW_AFTER_S);
+    },
+
+    // Shown only once someone is all-in and the money has actually split — a single
+    // undivided pot needs no announcement, and a line that's always there stops being
+    // read.
+    renderPotBreakdown() {
+        // Only worth showing once someone is actually all-in. Mid-street the amounts in
+        // front of players are unequal all the time — the blinds alone are unequal —
+        // and layering that would announce a side pot on every hand before anyone had
+        // even acted.
+        const someoneAllIn = this.state.seats.some(
+            player => player.inHand && Betting.handTotal(player) > 0 && Betting.stackOf(this.state, player) <= 0
+        );
+        if (!someoneAllIn) return null;
+
+        const contributions = this.state.seats.map((player, index) => ({
+            id: player.id,
+            index,
+            contribution: Betting.handTotal(player),
+            folded: player.folded,
+        }));
+
+        const nameById = new Map(
+            this.state.seats.map((player, index) => [player.id, HoldemState.displayName(player, index)])
+        );
+
+        return Render.buildPotBreakdown(
+            PotCalculator.layers(contributions),
+            PotCalculator.uncalledReturns(contributions),
+            id => nameById.get(id)
+        );
+    },
+
+    // Which key presses each button. Shown on the button itself and hidden on touch
+    // devices — a shortcut nobody can discover may as well not exist, and a key badge
+    // on a phone is just clutter.
+    KEY_HINTS: {
+        actionFold: "F",
+        actionCheck: "C",
+        actionCall: "C",
+        actionRaise: "R",
+        actionAdvance: "↵",
+        raiseConfirm: "↵",
+        raiseCancel: "esc",
+    },
+
+    button(label, className, onClick, sublabel) {
+        const btn = document.createElement("button");
+        btn.type = "button";
+        btn.className = `actionBtn ${className}`;
+
+        const main = document.createElement("span");
+        main.className = "actionBtnLabel";
+        main.textContent = label;
+        btn.appendChild(main);
+
+        const hint = this.KEY_HINTS[className];
+        if (hint) {
+            const kbd = document.createElement("kbd");
+            kbd.className = "actionKey";
+            kbd.textContent = hint;
+            btn.appendChild(kbd);
+        }
+
+        if (sublabel) {
+            const sub = document.createElement("span");
+            sub.className = "actionBtnSub";
+            sub.textContent = sublabel;
+            btn.appendChild(sub);
+        }
+
+        btn.addEventListener("click", onClick);
+        return btn;
+    },
+
+    // Every action taken from the bar goes through here, which is also where it gets
+    // recorded so it can be taken back. A misclick on Fold is the one mistake in this
+    // tool a dealer can't talk their way out of.
+    commit(label, mutate) {
+        this.hooks.beginAction(label);
+        mutate();
+        this.hooks.save(this.state);
+        this.hooks.rerender();
+    },
+
+    renderActions() {
+        const index = this.state.actingSeatIndex;
+        const player = this.state.seats[index];
+        const owed = Betting.toCall(this.state, player);
+        const stack = Betting.stackOf(this.state, player);
+        const who = HoldemState.displayName(player, index);
+
+        const row = document.createElement("div");
+        row.className = "actionButtons";
+
+        row.appendChild(this.button("Fold", "actionFold", () => this.commit(`${who}'s fold`, () => Betting.fold(this.state, index))));
+
+        if (owed <= 0) {
+            row.appendChild(this.button("Check", "actionCheck", () => this.commit(`${who}'s check`, () => Betting.check(this.state, index))));
+        } else if (owed >= stack) {
+            // Calling would put them all-in, so say that rather than quoting a number
+            // they can't cover.
+            row.appendChild(this.button("Call all-in", "actionCall", () => this.commit(`${who}'s all-in`, () => Betting.allIn(this.state, index)), Money.format(stack)));
+        } else {
+            row.appendChild(this.button("Call", "actionCall", () => this.commit(`${who}'s call`, () => Betting.call(this.state, index)), Money.format(owed)));
+        }
+
+        if (stack > owed) {
+            row.appendChild(this.button(owed > 0 ? "Raise" : "Bet", "actionRaise", () => {
+                this.raiseOpen = true;
+                this.raiseDraft = Math.min(Betting.minRaiseTo(this.state), Betting.committed(player) + stack);
+                this.render();
+            }));
+        }
+
+        return row;
+    },
+
+    // Quick amounts first, keypad second — a dealer calling "raise to sixty" wants a
+    // button, and only reaches for digits when the table does something odd.
+    renderRaisePad() {
+        const index = this.state.actingSeatIndex;
+        const player = this.state.seats[index];
+        const stack = Betting.stackOf(this.state, player);
+        const maxTo = Betting.round(Betting.committed(player) + stack);
+        const pot = Betting.potSoFar(this.state);
+        const minTo = Math.min(Betting.minRaiseTo(this.state), maxTo);
+
+        const wrap = document.createElement("div");
+        wrap.className = "raisePad";
+
+        const quick = document.createElement("div");
+        quick.className = "raiseQuick";
+
+        const options = [
+            { label: "Min", value: minTo },
+            { label: "½ pot", value: Betting.round(this.state.currentBet + pot / 2) },
+            { label: "Pot", value: Betting.round(this.state.currentBet + pot) },
+            { label: "All-in", value: maxTo },
+        ];
+        options.forEach(option => {
+            const value = Math.max(minTo, Math.min(option.value, maxTo));
+            const btn = this.button(option.label, "raiseQuickBtn", () => {
+                this.raiseDraft = value;
+                this.render();
+            }, Money.format(value));
+            if (Betting.round(this.raiseDraft) === value) btn.classList.add("selected");
+            quick.appendChild(btn);
+        });
+        wrap.appendChild(quick);
+
+        const entry = document.createElement("div");
+        entry.className = "raiseEntry";
+
+        const input = document.createElement("input");
+        input.type = "text";
+        input.inputMode = "decimal";
+        input.className = "raiseInput";
+        input.value = this.raiseDraft ?? minTo;
+        input.setAttribute("aria-label", "Raise to amount");
+        input.addEventListener("input", () => {
+            this.raiseDraft = input.value.replace(/[^0-9.]/g, "");
+        });
+        entry.appendChild(input);
+
+        entry.appendChild(this.button("Cancel", "raiseCancel", () => {
+            this.raiseOpen = false;
+            this.render();
+        }));
+
+        entry.appendChild(this.button("Raise to", "raiseConfirm", () => {
+            const target = Math.max(0, Math.min(Number(this.raiseDraft) || 0, maxTo));
+            this.raiseOpen = false;
+            const who = HoldemState.displayName(player, index);
+            this.commit(`${who}'s raise to ${Money.format(target)}`, () => Betting.raiseTo(this.state, index, target));
+        }));
+
+        wrap.appendChild(entry);
+        return wrap;
+    },
+
+    renderStreetDone() {
+        const row = document.createElement("div");
+        row.className = "actionButtons";
+
+        const isRiver = this.state.street === "river";
+        const label = isRiver ? "Showdown — resolve pot" : `Deal ${Betting.streetLabel(Betting.STREETS[Betting.STREETS.indexOf(this.state.street) + 1])}`;
+
+        row.appendChild(this.button(label, "actionAdvance", () => {
+            if (isRiver) {
+                this.hooks.resolvePot();
+                return;
+            }
+            this.commit(`dealing the ${Betting.streetLabel(Betting.STREETS[Betting.STREETS.indexOf(this.state.street) + 1]).toLowerCase()}`, () => Betting.closeStreet(this.state));
+        }));
+
+        return row;
+    },
+
+    renderHandOver() {
+        const row = document.createElement("div");
+        row.className = "actionButtons";
+        const live = Betting.liveSeats(this.state);
+        const winner = live.length === 1 ? HoldemState.displayName(live[0].player, live[0].index) : null;
+
+        row.appendChild(this.button(
+            winner ? `Award pot to ${winner}` : "Resolve pot",
+            "actionAdvance",
+            () => this.hooks.resolvePot()
+        ));
+        return row;
+    },
+};
+
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = ActionBar;
+}

JoshHeaps.Net/wwwroot/js/casino/holdem/addChips.js

@@ -0,0 +1,92 @@
+// "Add chips" — a rebuy, a top-up, or the first buy-in of the night.
+//
+// Quick amounts come off the table's starting stack, because a rebuy is almost
+// always one buy-in, sometimes half or two. The keypad is there for the times it
+// isn't. Recorded as cash in as well as chips, so at the end of the night the
+// dealer can say what each player actually handed over.
+const AddChips = {
+    state: null,
+    onConfirm: null,
+    seatIndex: null,
+    draft: "",
+
+    open(state, seatIndex, onConfirm) {
+        this.state = state;
+        this.seatIndex = seatIndex;
+        this.onConfirm = onConfirm;
+        this.draft = String(this.baseAmount());
+        this.render();
+        document.getElementById("addChipsOverlay").hidden = false;
+    },
+
+    close() {
+        document.getElementById("addChipsOverlay").hidden = true;
+    },
+
+    // The table's starting stack if there is one, otherwise something sane to nudge
+    // rather than an empty box.
+    baseAmount() {
+        const configured = Number(this.state.defaultStack);
+        if (!Number.isNaN(configured) && configured > 0) return configured;
+        const bb = Number(this.state.bigBlind) || 0;
+        return bb > 0 ? bb * 100 : 100;
+    },
+
+    quickAmounts() {
+        const base = this.baseAmount();
+        return [
+            { label: "½ buy-in", value: Math.round(base / 2 * 100) / 100 },
+            { label: "Buy-in", value: base },
+            { label: "2 buy-ins", value: base * 2 },
+        ];
+    },
+
+    render() {
+        const player = this.state.seats[this.seatIndex];
+        document.getElementById("addChipsTitle").textContent =
+            `Add chips — ${HoldemState.displayName(player, this.seatIndex)}`;
+
+        const stack = Betting.stackOf(this.state, player);
+        const boughtIn = Number(player.buyIns) || 0;
+        document.getElementById("addChipsSubtitle").textContent = boughtIn > 0
+            ? `${Money.format(stack)} in front · ${Money.format(boughtIn)} in so far`
+            : `${Money.format(stack)} in front`;
+
+        const quick = document.getElementById("addChipsQuick");
+        quick.innerHTML = "";
+        this.quickAmounts().forEach(option => {
+            const btn = document.createElement("button");
+            btn.type = "button";
+            btn.className = "addChipsQuickBtn";
+            btn.classList.toggle("selected", Number(this.draft) === option.value);
+
+            const label = document.createElement("span");
+            label.className = "addChipsQuickLabel";
+            label.textContent = option.label;
+            const amount = document.createElement("span");
+            amount.className = "addChipsQuickAmount";
+            amount.textContent = Money.format(option.value);
+
+            btn.appendChild(label);
+            btn.appendChild(amount);
+            btn.addEventListener("click", () => {
+                this.draft = String(option.value);
+                this.render();
+            });
+            quick.appendChild(btn);
+        });
+
+        const input = document.getElementById("addChipsInput");
+        input.value = this.draft;
+    },
+
+    confirm() {
+        const amount = Math.max(0, Number(document.getElementById("addChipsInput").value) || 0);
+        this.close();
+        if (amount > 0) this.onConfirm(this.seatIndex, Math.round(amount * 100) / 100);
+    },
+};
+
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = AddChips;
+}

JoshHeaps.Net/wwwroot/js/casino/holdem/betting.js

@@ -0,0 +1,233 @@
+// Live betting: who's to act, what it costs them, and where the money goes.
+//
+// This is bookkeeping, not a game — the dealer taps what the humans at the table
+// actually did, and the tool keeps the arithmetic straight. It deliberately never
+// blocks an action it thinks is "illegal"; a dealer overruling the maths is right
+// more often than the maths is.
+//
+// Money model: `player.committed` is what a seat has put in on the current street.
+// When a street closes it sweeps into `player.amountOverride`, which is the seat's
+// total for the hand — the same field the pot badge, the pot wizard, the standings
+// and the CSV already read. So the betting bar is a fast way to fill in a field
+// that already existed, and nothing downstream had to change.
+const Betting = {
+    STREETS: ["preflop", "flop", "turn", "river"],
+
+    streetLabel(street) {
+        return { preflop: "Pre-flop", flop: "Flop", turn: "Turn", river: "River" }[street] || "Pre-flop";
+    },
+
+    round(amount) {
+        return Math.round((Number(amount) || 0) * 100) / 100;
+    },
+
+    // ---- Reading the table ----
+
+    liveSeats(state) {
+        return state.seats
+            .map((player, index) => ({ player, index }))
+            .filter(s => s.player.inHand && !s.player.folded);
+    },
+
+    committed(player) {
+        return this.round(player.committed || 0);
+    },
+
+    // Everything this seat has put in across the whole hand, including the street
+    // still in progress.
+    handTotal(player) {
+        return this.round((Number(player.amountOverride) || 0) + this.committed(player));
+    },
+
+    stackOf(state, player) {
+        const own = player.stack;
+        if (own !== null && own !== undefined && String(own).trim() !== "") return this.round(own);
+        const fallback = Number(state.defaultStack);
+        return Number.isNaN(fallback) ? 0 : this.round(fallback);
+    },
+
+    toCall(state, player) {
+        return Math.max(0, this.round((state.currentBet || 0) - this.committed(player)));
+    },
+
+    // A raise has to at least match the last one; before any raise, the big blind
+    // is the yardstick.
+    minRaiseTo(state) {
+        const increment = this.round(state.lastRaiseSize || state.bigBlind || 0);
+        return this.round((state.currentBet || 0) + (increment || 1));
+    },
+
+    potSoFar(state) {
+        return this.round(
+            state.seats.reduce((sum, p) => sum + this.handTotal(p), 0)
+        );
+    },
+
+    // ---- Moving the action ----
+
+    nextLiveIndex(state, fromIndex) {
+        const count = state.seatCount;
+        for (let step = 1; step <= count; step++) {
+            const index = this.seatAt(state, fromIndex, step);
+            const player = state.seats[index];
+            if (player.inHand && !player.folded && this.stackOf(state, player) >= 0) return index;
+        }
+        return null;
+    },
+
+    seatAt(state, fromIndex, step) {
+        const count = state.seatCount;
+        const delta = state.direction === "counterclockwise" ? -step : step;
+        return ((fromIndex + delta) % count + count) % count;
+    },
+
+    // A street is done when everyone still live has either matched the bet or has
+    // no chips left to argue with, and everyone has had a turn since the last raise.
+    isStreetComplete(state) {
+        const live = this.liveSeats(state);
+        if (live.length <= 1) return true;
+
+        const unsettled = live.filter(s => {
+            const allIn = this.stackOf(state, s.player) <= 0;
+            const matched = this.toCall(state, s.player) <= 0;
+            return !allIn && (!matched || !s.player.hasActed);
+        });
+        return unsettled.length === 0;
+    },
+
+    // ---- Actions ----
+
+    // Moves `amount` from a seat's stack into the middle for this street. Returns
+    // what actually moved, which is less than asked for if it puts them all-in.
+    putIn(state, index, amount) {
+        const player = state.seats[index];
+        const stack = this.stackOf(state, player);
+        const moved = this.round(Math.min(Math.max(0, amount), stack));
+
+        player.stack = this.round(stack - moved);
+        player.committed = this.round(this.committed(player) + moved);
+        return moved;
+    },
+
+    fold(state, index) {
+        state.seats[index].folded = true;
+        state.seats[index].hasActed = true;
+        this.passAction(state, index);
+    },
+
+    check(state, index) {
+        state.seats[index].hasActed = true;
+        this.passAction(state, index);
+    },
+
+    call(state, index) {
+        const player = state.seats[index];
+        this.putIn(state, index, this.toCall(state, player));
+        player.hasActed = true;
+        this.passAction(state, index);
+    },
+
+    // `total` is what the seat's street commitment becomes — "raise to", the way a
+    // dealer says it out loud, not "raise by".
+    raiseTo(state, index, total) {
+        const player = state.seats[index];
+        const target = this.round(total);
+        const delta = this.round(target - this.committed(player));
+        const moved = this.putIn(state, index, delta);
+        const newBet = this.committed(player);
+
+        if (newBet > (state.currentBet || 0)) {
+            state.lastRaiseSize = this.round(newBet - (state.currentBet || 0));
+            state.currentBet = newBet;
+            // A raise reopens the action: everyone else owes a response again.
+            state.seats.forEach((p, i) => {
+                if (i !== index && p.inHand && !p.folded) p.hasActed = false;
+            });
+        }
+
+        player.hasActed = true;
+        this.passAction(state, index);
+        return moved;
+    },
+
+    allIn(state, index) {
+        const player = state.seats[index];
+        return this.raiseTo(state, index, this.round(this.committed(player) + this.stackOf(state, player)));
+    },
+
+    passAction(state, index) {
+        state.actingSeatIndex = this.isStreetComplete(state) ? null : this.nextLiveIndex(state, index);
+    },
+
+    // ---- Street and hand boundaries ----
+
+    // Pulls whatever is in front of the players into their hand totals. Anything that
+    // reads a seat's contribution — the pot wizard above all — has to run after this,
+    // or it will price the pot without the chips sitting on the current street.
+    sweepToHandTotals(state) {
+        state.seats.forEach(player => {
+            const moved = this.committed(player);
+            if (moved > 0) {
+                player.amountOverride = this.round((Number(player.amountOverride) || 0) + moved);
+            }
+            player.committed = 0;
+            player.hasActed = false;
+        });
+    },
+
+    // Sweeps the street's chips into each seat's hand total and opens the next one.
+    closeStreet(state) {
+        this.sweepToHandTotals(state);
+
+        state.currentBet = 0;
+        state.lastRaiseSize = 0;
+
+        const nextStreetIndex = this.STREETS.indexOf(state.street || "preflop") + 1;
+        state.street = this.STREETS[nextStreetIndex] || "river";
+        state.actingSeatIndex = this.liveSeats(state).length > 1
+            ? this.nextLiveIndex(state, state.dealerSeatIndex)
+            : null;
+    },
+
+    isHandOver(state) {
+        return this.liveSeats(state).length <= 1;
+    },
+
+    // Deals a fresh betting round: blinds posted, action to the seat after the big
+    // blind, which is where a dealer expects to be looking when the cards go out.
+    beginHand(state) {
+        state.street = "preflop";
+        state.currentBet = 0;
+        state.lastRaiseSize = 0;
+
+        state.seats.forEach(player => {
+            player.committed = 0;
+            player.hasActed = false;
+        });
+
+        const sb = Number(state.smallBlind) || 0;
+        const bb = Number(state.bigBlind) || 0;
+        const sbIndex = this.seatAt(state, state.dealerSeatIndex, 1);
+        const bbIndex = this.seatAt(state, state.dealerSeatIndex, 2);
+
+        if (sb > 0 && state.seats[sbIndex].inHand) this.putIn(state, sbIndex, sb);
+        if (bb > 0 && state.seats[bbIndex].inHand) this.putIn(state, bbIndex, bb);
+
+        state.currentBet = this.round(Math.max(this.committed(state.seats[sbIndex]), this.committed(state.seats[bbIndex])));
+        state.lastRaiseSize = bb || 0;
+        state.actingSeatIndex = this.nextLiveIndex(state, bbIndex);
+    },
+
+    // Winners get their share put back in front of them.
+    creditWinnings(state, payouts) {
+        payouts.forEach(payout => {
+            const player = state.seats.find(p => p.id === payout.id);
+            if (!player) return;
+            player.stack = this.round(this.stackOf(state, player) + payout.amount);
+        });
+    },
+};
+
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = Betting;
+}

JoshHeaps.Net/wwwroot/js/casino/holdem/cardPicker.js

@@ -0,0 +1,131 @@
+// Tap a card instead of typing it.
+//
+// Typing "AH" into a two-character box is fine at a desk and miserable at a table:
+// it needs a keyboard, it accepts nonsense like "ZZ", and it happily lets the same
+// card land in two players' hands. The picker is one tap per card, greys out cards
+// already dealt somewhere else at the table, and stores exactly the same two-character
+// string the rest of the tool has always read.
+const CardPicker = {
+    RANKS: ["A", "K", "Q", "J", "T", "9", "8", "7", "6", "5", "4", "3", "2"],
+    SUITS: [
+        { code: "S", symbol: "♠", red: false },
+        { code: "H", symbol: "♥", red: true },
+        { code: "D", symbol: "♦", red: true },
+        { code: "C", symbol: "♣", red: false },
+    ],
+
+    state: null,
+    hooks: null,
+    seatIndex: null,
+    cardIndex: 0,
+
+    open(state, hooks, seatIndex, cardIndex) {
+        this.state = state;
+        this.hooks = hooks;
+        this.seatIndex = seatIndex;
+        this.cardIndex = cardIndex;
+        this.render();
+        document.getElementById("cardPickerOverlay").hidden = false;
+    },
+
+    close() {
+        document.getElementById("cardPickerOverlay").hidden = true;
+    },
+
+    // Every card sitting in front of anyone else. The slot being edited is excluded,
+    // so re-picking the card that's already there isn't treated as a duplicate.
+    cardsInUse() {
+        const used = new Map();
+        this.state.seats.forEach((player, seat) => {
+            (player.cards || []).forEach((card, slot) => {
+                if (!card) return;
+                if (seat === this.seatIndex && slot === this.cardIndex) return;
+                used.set(card.toUpperCase(), HoldemState.displayName(player, seat));
+            });
+        });
+        return used;
+    },
+
+    assign(card) {
+        const player = this.state.seats[this.seatIndex];
+        player.cards[this.cardIndex] = card;
+        this.hooks.onPick(this.seatIndex, this.cardIndex, card);
+
+        // Straight on to the second card — a dealer picking hole cards is always
+        // picking two, and making them re-open the picker doubles the taps.
+        if (this.cardIndex === 0 && !player.cards[1]) {
+            this.cardIndex = 1;
+            this.render();
+            return;
+        }
+        this.close();
+    },
+
+    clearSlot() {
+        const player = this.state.seats[this.seatIndex];
+        player.cards[this.cardIndex] = "";
+        this.hooks.onPick(this.seatIndex, this.cardIndex, "");
+        this.render();
+    },
+
+    render() {
+        const player = this.state.seats[this.seatIndex];
+        const used = this.cardsInUse();
+
+        document.getElementById("cardPickerTitle").textContent =
+            `${HoldemState.displayName(player, this.seatIndex)} — card ${this.cardIndex + 1}`;
+
+        // Which slot the next tap fills, switchable without closing the sheet.
+        const slots = document.getElementById("cardPickerSlots");
+        slots.innerHTML = "";
+        [0, 1].forEach(slot => {
+            const btn = document.createElement("button");
+            btn.type = "button";
+            btn.className = "pickerSlot";
+            btn.classList.toggle("active", slot === this.cardIndex);
+            const value = player.cards[slot] || "";
+            btn.textContent = value || "—";
+            btn.classList.toggle("cardRed", /[HD]$/i.test(value));
+            btn.addEventListener("click", () => {
+                this.cardIndex = slot;
+                this.render();
+            });
+            slots.appendChild(btn);
+        });
+
+        const grid = document.getElementById("cardPickerGrid");
+        grid.innerHTML = "";
+        this.RANKS.forEach(rank => {
+            this.SUITS.forEach(suit => {
+                const card = `${rank}${suit.code}`;
+                const takenBy = used.get(card);
+
+                const btn = document.createElement("button");
+                btn.type = "button";
+                btn.className = "pickerCard";
+                btn.classList.toggle("cardRed", suit.red);
+                btn.disabled = !!takenBy;
+                if (takenBy) btn.title = `Already dealt to ${takenBy}`;
+                if ((player.cards[this.cardIndex] || "").toUpperCase() === card) {
+                    btn.classList.add("selected");
+                }
+
+                const rankEl = document.createElement("span");
+                rankEl.className = "pickerRank";
+                rankEl.textContent = rank;
+                const suitEl = document.createElement("span");
+                suitEl.className = "pickerSuit";
+                suitEl.textContent = suit.symbol;
+                btn.appendChild(rankEl);
+                btn.appendChild(suitEl);
+
+                btn.addEventListener("click", () => this.assign(card));
+                grid.appendChild(btn);
+            });
+        });
+    },
+};
+
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = CardPicker;
+}

JoshHeaps.Net/wwwroot/js/casino/holdem/handHistoryExport.js

@@ -35,9 +35,19 @@ const HandHistoryExport = {
         if (standings.length > 0) {
             rows.push([]);
             rows.push(["Session Standings"]);
-            rows.push(["Player", "Paid In", "Won", "Net"]);
+            // Bought in and chips now are what a cash-out is settled from; paid in and
+            // won describe the hands. Both belong in the file the dealer hands over.
+            rows.push(["Player", "Paid In", "Won", "Net", "Bought In", "Chips Now", "Up/Down"]);
             standings.forEach(row => {
-                rows.push([row.name, Money.format(row.in), Money.format(row.won), Money.formatSigned(row.net)]);
+                rows.push([
+                    row.name,
+                    Money.format(row.in),
+                    Money.format(row.won),
+                    Money.formatSigned(row.net),
+                    Money.format(row.boughtIn || 0),
+                    Money.format(row.chipsNow || 0),
+                    Money.formatSigned(row.cashPosition || 0),
+                ]);
             });
         }
 

JoshHeaps.Net/wwwroot/js/casino/holdem/main.js

@@ -1,13 +1,162 @@
 document.addEventListener("DOMContentLoaded", () => {
     const state = HoldemState.load();
 
+    // A gesture on a seat is a shortcut for something the dealer could do the long
+    // way, so each one is undoable the same way the header buttons are.
+    const seatAction = (index, message, mutate) => {
+        const snapshot = JSON.parse(JSON.stringify(state));
+        mutate(state.seats[index], index);
+        HoldemState.save(state);
+        Render.renderAll();
+
+        Toast.show(message, {
+            actionLabel: "Undo",
+            onAction: () => {
+                Object.keys(state).forEach(key => delete state[key]);
+                Object.assign(state, snapshot);
+                HoldemState.save(state);
+                Render.renderAll();
+                Toast.show("Undone.", { duration: 2500 });
+            },
+            duration: 6000,
+        });
+    };
+
+    const nameOf = index => HoldemState.displayName(state.seats[index], index);
+
     const hooks = {
         save: s => HoldemState.save(s),
         rerender: () => Render.renderAll(),
+
+        onSeatDoubleTap: index => {
+            const player = state.seats[index];
+            if (!player.inHand) return;
+            if (player.folded) {
+                seatAction(index, `${nameOf(index)} is back in the hand.`, p => { p.folded = false; });
+                return;
+            }
+            seatAction(index, `${nameOf(index)} folds.`, () => {
+                if (state.actingSeatIndex === index) Betting.fold(state, index);
+                else player.folded = true;
+            });
+        },
+
+        onSeatLongPress: index => SeatMenu.open(state, seatMenuHooks, index),
+    };
+
+    const seatMenuHooks = {
+        fold: index => hooks.onSeatDoubleTap(index),
+        unfold: index => seatAction(index, `${nameOf(index)} is back in the hand.`, p => { p.folded = false; }),
+        allIn: index => seatAction(index, `${nameOf(index)} is all-in.`, () => Betting.allIn(state, index)),
+        toggleDealtIn: index => {
+            const dealtIn = state.seats[index].inHand;
+            seatAction(index, dealtIn ? `${nameOf(index)} sits out.` : `${nameOf(index)} is dealt in.`, p => {
+                p.inHand = !dealtIn;
+                if (!p.inHand) p.folded = false;
+            });
+        },
+        makeDealer: index => seatAction(index, `Button on ${nameOf(index)}.`, () => { state.dealerSeatIndex = index; }),
+        editSeat: index => Render.toggleSeatEditor(index),
+
+        addChips: index => AddChips.open(state, index, (seatIndex, amount) => {
+            seatAction(seatIndex, `${nameOf(seatIndex)} added ${Money.format(amount)}.`, player => {
+                // Chips in front and cash in are different questions — the stack moves
+                // every hand, what they've handed over only moves when they buy.
+                player.stack = Math.round((Betting.stackOf(state, player) + amount) * 100) / 100;
+                player.buyIns = Math.round(((Number(player.buyIns) || 0) + amount) * 100) / 100;
+            });
+        }),
     };
 
     Render.mount(state, hooks);
 
+    const openPotWizard = () => {
+        // Chips still in front of players belong in the pot being priced, so bank them
+        // before the wizard reads anyone's contribution.
+        Betting.sweepToHandTotals(state);
+        hooks.save(state);
+        Render.renderAll();
+
+        PotWizard.open(state, payouts => {
+            const paid = payouts.map(p => `${p.label} ${Money.format(p.amount)}`).join(", ");
+            runUndoable(paid ? `Paid ${paid}.` : "Hand closed with nothing to pay out.", () => {
+                if (payouts.length > 0) {
+                    HoldemState.recordHand(state, payouts);
+                    // Winnings go straight back in front of the player, so the next
+                    // hand's stacks are already right.
+                    Betting.creditWinnings(state, payouts);
+                }
+                HoldemState.startNextHand(state);
+                Betting.beginHand(state);
+            });
+        });
+    };
+
+    // A short history of actions taken from the bar, so a misclicked Fold can be taken
+    // back — and the one before it, since a dealer usually notices a beat late. Kept in
+    // memory only: this is for the mistake you just made, not last night's hand.
+    const MAX_UNDO_STEPS = 12;
+    const actionHistory = [];
+
+    ActionBar.mount(state, {
+        save: hooks.save,
+        rerender: hooks.rerender,
+        resolvePot: openPotWizard,
+
+        beginAction: label => {
+            actionHistory.push({ label, snapshot: JSON.parse(JSON.stringify(state)) });
+            if (actionHistory.length > MAX_UNDO_STEPS) actionHistory.shift();
+        },
+
+        lastActionLabel: () => (actionHistory.length ? actionHistory[actionHistory.length - 1].label : null),
+
+        undoLast: () => {
+            const step = actionHistory.pop();
+            if (!step) return;
+            Object.keys(state).forEach(key => delete state[key]);
+            Object.assign(state, step.snapshot);
+            hooks.save(state);
+            Render.renderAll();
+            Toast.show(`Took back ${step.label}.`, { duration: 2500 });
+        },
+    });
+
+    // Anything that ends the hand makes the per-action history meaningless — the
+    // snapshots refer to a hand that no longer exists.
+    const clearActionHistory = () => { actionHistory.length = 0; };
+
+    // Keyboard shortcuts press the very same buttons a dealer would tap, rather than
+    // calling the betting engine themselves — there's no second code path to drift out
+    // of step with what the bar is actually offering right now.
+    const pressInBar = selector => {
+        const btn = document.querySelector(`#actionBar ${selector}`);
+        if (!btn || btn.disabled) return false;
+        btn.click();
+        return true;
+    };
+
+    const quickRaiseButton = label =>
+        [...document.querySelectorAll("#actionBar .raiseQuickBtn")]
+            .find(b => b.querySelector(".actionBtnLabel").textContent === label);
+
+    Shortcuts.mount({
+        fold: () => pressInBar(".actionFold"),
+        checkOrCall: () => pressInBar(".actionCheck") || pressInBar(".actionCall"),
+        raise: () => pressInBar(".actionRaise"),
+        allIn: () => {
+            // Open the raise pad first if it isn't already, then take its All-in amount.
+            if (!document.querySelector("#actionBar .raisePad") && !pressInBar(".actionRaise")) return false;
+            const quick = quickRaiseButton("All-in");
+            if (!quick) return false;
+            quick.click();
+            return true;
+        },
+        // Enter confirms a raise if one is being entered, otherwise moves the hand on.
+        advance: () => pressInBar(".raiseConfirm") || pressInBar(".actionAdvance"),
+        undo: () => pressInBar(".actionUndo"),
+        cancel: () => pressInBar(".raiseCancel"),
+    });
+
     // Moving to the next hand used to ask "are you sure?" every single time —
     // the most-pressed button in a session, gated behind a system dialog. It now
     // just happens, and the toast offers the way back for the few seconds anyone
@@ -16,6 +165,9 @@ document.addEventListener("DOMContentLoaded", () => {
     const runUndoable = (message, mutate) => {
         const snapshot = JSON.parse(JSON.stringify(state));
         mutate();
+        // Starting or settling a hand invalidates the per-action history: those
+        // snapshots describe a hand that's over. The whole-step Undo below replaces it.
+        clearActionHistory();
         hooks.save(state);
         Render.renderAll();
 
@@ -79,9 +231,10 @@ document.addEventListener("DOMContentLoaded", () => {
             ? `small blind on seat ${HoldemState.nextSeatIndex(state, nextDealer, 1) + 1}`
             : `button on seat ${nextDealer + 1}`;
 
-        runUndoable(`Next hand — ${where}. Cards and chip counts cleared.`, () =>
-            HoldemState.startNextHand(state)
-        );
+        runUndoable(`Next hand — ${where}. Blinds posted.`, () => {
+            HoldemState.startNextHand(state);
+            Betting.beginHand(state);
+        });
     });
 
     document.getElementById("resetTableBtn").addEventListener("click", async () => {
@@ -95,22 +248,58 @@ document.addEventListener("DOMContentLoaded", () => {
 
         HoldemState.clear();
         Object.assign(state, HoldemState.createDefault());
+        clearActionHistory();
         Render.mount(state, hooks);
         Toast.show("Table reset.", { duration: 2500 });
     });
 
-    document.getElementById("resolvePotBtn").addEventListener("click", () => {
-        PotWizard.open(state, payouts => {
-            const paid = payouts.map(p => `${p.label} ${Money.format(p.amount)}`).join(", ");
-            runUndoable(paid ? `Paid ${paid}.` : "Hand closed with nothing to pay out.", () => {
-                if (payouts.length > 0) HoldemState.recordHand(state, payouts);
-                HoldemState.startNextHand(state);
-            });
+    document.getElementById("resolvePotBtn").addEventListener("click", openPotWizard);
+
+    [
+        ["smallBlindInput", "smallBlind"],
+        ["bigBlindInput", "bigBlind"],
+        ["defaultStackInput", "defaultStack"],
+    ].forEach(([id, key]) => {
+        document.getElementById(id).addEventListener("input", e => {
+            state[key] = e.target.value === "" ? null : Number(e.target.value);
+            hooks.save(state);
+            Render.renderAll();
         });
     });
 
     document.getElementById("closeSeatEditorBtn").addEventListener("click", () => Render.closeSeatEditor());
 
+    document.getElementById("addChipsConfirmBtn").addEventListener("click", () => AddChips.confirm());
+    document.getElementById("addChipsCancelBtn").addEventListener("click", () => AddChips.close());
+    document.getElementById("addChipsOverlay").addEventListener("click", e => {
+        if (e.target.id === "addChipsOverlay") AddChips.close();
+    });
+    document.getElementById("addChipsInput").addEventListener("keydown", e => {
+        if (e.key === "Enter") AddChips.confirm();
+    });
+
+    const rulingsOverlay = document.getElementById("rulingsOverlay");
+    const closeRulings = () => { rulingsOverlay.hidden = true; };
+    document.getElementById("openRulingsBtn").addEventListener("click", () => { rulingsOverlay.hidden = false; });
+    document.getElementById("closeRulingsBtn").addEventListener("click", closeRulings);
+    rulingsOverlay.addEventListener("click", e => {
+        if (e.target === rulingsOverlay) closeRulings();
+    });
+    document.addEventListener("keydown", e => {
+        if (e.key === "Escape" && !rulingsOverlay.hidden) closeRulings();
+    });
+
+    document.getElementById("seatMenuCancelBtn").addEventListener("click", () => SeatMenu.close());
+    document.getElementById("seatMenuOverlay").addEventListener("click", e => {
+        if (e.target.id === "seatMenuOverlay") SeatMenu.close();
+    });
+
+    document.getElementById("cardPickerCloseBtn").addEventListener("click", () => CardPicker.close());
+    document.getElementById("cardPickerClearBtn").addEventListener("click", () => CardPicker.clearSlot());
+    document.getElementById("cardPickerOverlay").addEventListener("click", e => {
+        if (e.target.id === "cardPickerOverlay") CardPicker.close();
+    });
+
     document.getElementById("closePotWizardBtn").addEventListener("click", () => PotWizard.close());
     document.getElementById("potWizardOverlay").addEventListener("click", e => {
         if (e.target.id === "potWizardOverlay") PotWizard.close();

JoshHeaps.Net/wwwroot/js/casino/holdem/potCalculator.js

@@ -24,6 +24,79 @@ const PotCalculator = {
         return entries.filter(e => !e.folded && e.remaining > this.EPSILON);
     },
 
+    // Splits the money on the table into the main pot and any side pots, with who can
+    // win each. Read-only — this is what a dealer says out loud before the showdown
+    // ("main pot four-eighty, side pot ninety between seats 3 and 5"), which is the
+    // announcement that goes missing far more often than the arithmetic goes wrong.
+    //
+    // Every distinct all-in amount opens a new layer: each player pays into a layer up
+    // to their own contribution, and only players who reached that height can win it.
+    // Folded money stays in — it's dead money owed to whoever wins the layer it fell in.
+    layers(players) {
+        const live = players.filter(p => p.contribution > this.EPSILON);
+        if (live.length === 0) return [];
+
+        const heights = [...new Set(live.map(p => Math.round(p.contribution * 100)))].sort((a, b) => a - b);
+
+        const layers = [];
+        let floor = 0;
+        heights.forEach(height => {
+            const band = height - floor;
+            const payers = live.filter(p => Math.round(p.contribution * 100) >= height);
+            const amount = band * payers.length;
+            const eligible = payers.filter(p => !p.folded).map(p => p.id);
+
+            // A band nobody can win isn't a pot — it's an overbet that never got
+            // called, and it goes back to whoever put it in. Announcing it as a side
+            // pot would overstate what's actually being played for.
+            if (amount > 0 && eligible.length > 0) {
+                layers.push({ amount: amount / 100, eligible });
+            }
+            floor = height;
+        });
+
+        // Consecutive layers with the same set of eligible players are one pot to a
+        // dealer — nobody announces two side pots between the same two people.
+        const merged = [];
+        layers.forEach(layer => {
+            const previous = merged[merged.length - 1];
+            const sameEligibility =
+                previous &&
+                previous.eligible.length === layer.eligible.length &&
+                previous.eligible.every(id => layer.eligible.includes(id));
+
+            if (sameEligibility) {
+                previous.amount = Math.round((previous.amount + layer.amount) * 100) / 100;
+            } else {
+                merged.push({ ...layer });
+            }
+        });
+
+        return merged.map((layer, index) => ({
+            ...layer,
+            label: index === 0 ? "Main pot" : `Side pot ${index}`,
+        }));
+    },
+
+    // Chips nobody could call, which the dealer pushes back rather than into the pot.
+    // Anything above the biggest live contribution was never contested — most often an
+    // overbet by someone who then folded.
+    uncalledReturns(players) {
+        const contributing = players.filter(p => p.contribution > this.EPSILON);
+        const liveCents = contributing.filter(p => !p.folded).map(p => Math.round(p.contribution * 100));
+
+        // Nobody live at all means the fold flags are wrong, not that every chip on
+        // the table was uncalled. That's a correction for the dealer to make, so say
+        // nothing here and let the wizard ask them to fix it.
+        if (liveCents.length === 0) return [];
+
+        const cap = Math.max(...liveCents);
+
+        return contributing
+            .map(p => ({ id: p.id, amount: (Math.round(p.contribution * 100) - cap) / 100 }))
+            .filter(r => r.amount > this.EPSILON);
+    },
+
     // Awards the current pot layer to `winnerIds` (one id, or several for a split/tie).
     // The payout is capped at the smallest remaining contribution among the winners —
     // that's the classic side-pot rule: an all-in player can only win what everyone at

JoshHeaps.Net/wwwroot/js/casino/holdem/potWizard.js

@@ -18,13 +18,17 @@ const PotWizard = {
         this.playerLabelById = new Map(
             players.map(p => [p.id, this.labelFor(p, state.seats.indexOf(p))])
         );
-        this.entries = PotCalculator.buildEntries(
-            players.map(p => ({
-                id: p.id,
-                contribution: HoldemState.computeContribution(p, state.chipLegend, state.basePotAmount),
-                folded: p.folded,
-            }))
-        );
+        this.seatIndexById = new Map(players.map(p => [p.id, state.seats.indexOf(p)]));
+        const contributions = players.map(p => ({
+            id: p.id,
+            contribution: HoldemState.computeContribution(p, state.chipLegend, state.basePotAmount),
+            folded: p.folded,
+        }));
+        this.entries = PotCalculator.buildEntries(contributions);
+        // Kept so the wizard can show the whole breakdown up front, not just the layer
+        // it happens to be asking about.
+        this.layers = PotCalculator.layers(contributions);
+        this.returns = PotCalculator.uncalledReturns(contributions);
         this.log = [];
         this.totals = new Map();
 
@@ -38,7 +42,7 @@ const PotWizard = {
 
     labelFor(player, seatIndex) {
         const name = HoldemState.displayName(player, seatIndex);
-        const cards = (player.cards || []).filter(Boolean).join(" ");
+        const cards = (player.cards || []).filter(Boolean).map(c => Render.formatCard(c)).join(" ");
         return cards ? `${name} (${cards})` : name;
     },
 
@@ -46,6 +50,20 @@ const PotWizard = {
         this.totals.set(id, (this.totals.get(id) || 0) + amount);
     },
 
+    // A chopped pot rarely divides exactly, and the odd chip goes to the first player
+    // left of the button — not to whoever the dealer happened to tick first. The
+    // calculator hands leftovers out in the order it's given the winners, so ordering
+    // them here is what makes the payout match the rule.
+    orderFromButton(ids) {
+        const distance = new Map();
+        for (let step = 1; step <= this.state.seatCount; step++) {
+            distance.set(HoldemState.nextSeatIndex(this.state, this.state.dealerSeatIndex, step), step);
+        }
+        return [...ids].sort((a, b) =>
+            (distance.get(this.seatIndexById.get(a)) ?? 0) - (distance.get(this.seatIndexById.get(b)) ?? 0)
+        );
+    },
+
     renderStep() {
         // Auto-resolve any round where only one player is left standing — nothing to ask.
         let contenders = PotCalculator.getContenders(this.entries);
@@ -58,6 +76,7 @@ const PotWizard = {
 
         const body = document.getElementById("potWizardBody");
         body.innerHTML = "";
+        if (this.log.length === 0) body.appendChild(this.renderBreakdown());
         body.appendChild(this.renderLog());
 
         const remaining = PotCalculator.totalPot(this.entries.filter(e => e.remaining > PotCalculator.EPSILON));
@@ -65,7 +84,17 @@ const PotWizard = {
         if (contenders.length === 0 && remaining > PotCalculator.EPSILON) {
             const warning = document.createElement("p");
             warning.className = "potWizardPrompt";
-            warning.textContent = `${Money.format(remaining)} is still unassigned, but every remaining player is marked Folded. Uncheck Fold on whoever should win it.`;
+
+            // Money left over because nobody could call it isn't a pot anyone won —
+            // it goes back to whoever put it in. Telling the dealer to un-fold someone
+            // to "win" it would be wrong.
+            const returned = (this.returns || []).reduce((sum, r) => sum + r.amount, 0);
+            if (Math.abs(returned - remaining) <= PotCalculator.EPSILON && returned > 0) {
+                const who = this.returns.map(r => this.playerLabelById.get(r.id)).join(", ");
+                warning.textContent = `${Money.format(remaining)} was never called — push it back to ${who} rather than paying it out.`;
+            } else {
+                warning.textContent = `${Money.format(remaining)} is still unassigned, but every remaining player is marked Folded. Uncheck Fold on whoever should win it.`;
+            }
             body.appendChild(warning);
             body.appendChild(this.renderSummary());
             return;
@@ -113,7 +142,7 @@ const PotWizard = {
         confirmBtn.addEventListener("click", () => {
             const selected = Array.from(choices.querySelectorAll("input:checked")).map(i => i.value);
             if (selected.length === 0) return;
-            const result = PotCalculator.resolveRound(this.entries, selected);
+            const result = PotCalculator.resolveRound(this.entries, this.orderFromButton(selected));
             this.recordRound(result);
             this.entries = result.updatedEntries;
             this.renderStep();
@@ -131,6 +160,20 @@ const PotWizard = {
         });
     },
 
+    // The announcement, spelled out before anyone is asked to pick a winner: what the
+    // main pot is worth, what each side pot is worth, and who can win each.
+    renderBreakdown() {
+        const node = Render.buildPotBreakdown(
+            this.layers || [],
+            this.returns || [],
+            id => this.playerLabelById.get(id),
+            "Announce before the showdown"
+        );
+        if (!node) return document.createDocumentFragment();
+        node.classList.add("potBreakdownWizard");
+        return node;
+    },
+
     renderLog() {
         const wrap = document.createElement("div");
         wrap.className = "potWizardLog";

JoshHeaps.Net/wwwroot/js/casino/holdem/render.js

@@ -32,6 +32,7 @@ const Render = {
         this.renderTableHint();
         this.renderStandings();
         this.renderHandHistory();
+        if (typeof ActionBar !== "undefined" && ActionBar.state) ActionBar.render();
     },
 
     renderSetupFields() {
@@ -39,13 +40,16 @@ const Render = {
         document.getElementById("directionSelect").value = this.state.direction;
         document.getElementById("basePotInput").value = this.state.basePotAmount ?? "";
         document.getElementById("dedicatedDealerToggle").checked = !!this.state.dedicatedDealer;
+        document.getElementById("smallBlindInput").value = this.state.smallBlind ?? "";
+        document.getElementById("bigBlindInput").value = this.state.bigBlind ?? "";
+        document.getElementById("defaultStackInput").value = this.state.defaultStack ?? "";
     },
 
     renderTableHint() {
         const hint = document.getElementById("tableHint");
-        hint.textContent = this.state.dedicatedDealer
-            ? "Drag a seat onto another seat to swap players."
-            : "Drag a seat onto another seat to swap players. Click the dealer chip on a seat to make it the button.";
+        // Gestures are invisible until someone tells you about them, and this is the
+        // only place on the table with room to say so.
+        hint.textContent = "Tap a seat to edit · double-tap to fold · press and hold for quick actions · drag to swap seats.";
     },
 
     renderNotes() {
@@ -54,20 +58,96 @@ const Render = {
     },
 
     updatePotBadge() {
-        const total = HoldemState.totalPot(this.state);
-        document.getElementById("potBadgeAmount").textContent = Money.format(total);
+        // Chips still sitting in front of players on the current street are part of
+        // the pot as far as anyone at the table is concerned, so count them — waiting
+        // until the street closes would show a stale number for most of every hand.
+        const swept = HoldemState.totalPot(this.state);
+        const onStreet = this.state.seats.reduce((sum, p) => sum + Betting.committed(p), 0);
+        document.getElementById("potBadgeAmount").textContent = Money.format(swept + onStreet);
     },
 
     // ---- Seats around the table (compact pucks) ----
 
     seatPosition(index, count) {
+        return this.positionOnRing(index, count, 44, 42);
+    },
+
+    // Bets sit on the felt between their player and the pot, the way chips actually
+    // do — closer in than the seats, on the same spoke. The bets layer is inset to
+    // match the seat ring (see the CSS), so this one radius holds at every size.
+    betPosition(index, count) {
+        return this.positionOnRing(index, count, 27, 25);
+    },
+
+    positionOnRing(index, count, rx, ry) {
         const angle = -90 + (360 / count) * index;
         const radians = (angle * Math.PI) / 180;
-        const rx = 44;
-        const ry = 42;
-        const left = 50 + rx * Math.cos(radians);
-        const top = 50 + ry * Math.sin(radians);
-        return { left, top };
+        return {
+            left: 50 + rx * Math.cos(radians),
+            top: 50 + ry * Math.sin(radians),
+        };
+    },
+
+    // Colour a bet by the biggest chip that fits it, so a table with a chip legend
+    // gets bets that look like the chips actually being pushed out.
+    chipColorFor(amount) {
+        const legend = [...(this.state.chipLegend || [])]
+            .filter(chip => Number(chip.value) > 0)
+            .sort((a, b) => Number(b.value) - Number(a.value));
+        const match = legend.find(chip => amount >= Number(chip.value));
+        return (match || legend[legend.length - 1] || {}).color || "#8a8a8a";
+    },
+
+    // ---- Bets on the felt ----
+
+    makeBetChip(bet) {
+        const chip = document.createElement("div");
+        chip.className = "betChip";
+
+        const disc = document.createElement("span");
+        disc.className = "betChipDisc";
+        disc.style.background = this.chipColorFor(bet);
+
+        const amount = document.createElement("span");
+        amount.className = "betChipAmount";
+        amount.textContent = Money.format(bet);
+
+        chip.appendChild(disc);
+        chip.appendChild(amount);
+        return chip;
+    },
+
+    // A phone's felt has no room for a third ring: measured every radius between the
+    // seats and the pot badge and each one collides with one or the other. So on a
+    // narrow screen the bet clings to its own puck instead — same chip, no ring —
+    // sitting on whichever side faces the middle of the table.
+    renderBets() {
+        const layer = document.getElementById("betsLayer");
+        if (!layer) return;
+        layer.innerHTML = "";
+
+        const anchorToSeat = window.matchMedia("(max-width: 700px)").matches;
+
+        this.state.seats.forEach((player, index) => {
+            const bet = Betting.committed(player);
+            if (bet <= 0) return;
+
+            const chip = this.makeBetChip(bet);
+            const pos = this.betPosition(index, this.state.seatCount);
+
+            if (anchorToSeat) {
+                const seat = document.querySelector(`.seat[data-seat-index="${index}"]`);
+                if (!seat) return;
+                const seatPos = this.seatPosition(index, this.state.seatCount);
+                chip.classList.add("betChipAnchored", seatPos.top > 50 ? "betChipAbove" : "betChipBelow");
+                seat.appendChild(chip);
+                return;
+            }
+
+            chip.style.left = `${pos.left}%`;
+            chip.style.top = `${pos.top}%`;
+            layer.appendChild(chip);
+        });
     },
 
     puckLabel(player, seatIndex) {
@@ -105,40 +185,82 @@ const Render = {
             this.updatePuckContent(node, player, index);
             node.classList.toggle("seatSelected", index === this.selectedSeatIndex);
 
-            node.addEventListener("click", () => {
-                // Tapping the open seat again closes it — on a phone the editor is a
-                // sheet over the table, and the seat you just tapped is the closest
-                // thing to hand for dismissing it.
-                this.selectedSeatIndex = this.selectedSeatIndex === index ? null : index;
-                this.renderSeats();
-                this.renderSeatEditor();
-            });
-
+            this.wireSeatGestures(node, index);
             this.wireDragAndDrop(node, index);
 
             layer.appendChild(node);
         });
+
+        this.renderBets();
     },
 
     isRedSuit(card) {
         return /[HD]$/i.test(card || "");
     },
 
+    SUIT_SYMBOLS: { S: "♠", H: "♥", D: "♦", C: "♣" },
+
+    // "KD" -> "K♦". Stored cards stay two plain characters so every existing reader
+    // keeps working; the suit only becomes a symbol on its way to a human.
+    formatCard(card) {
+        const value = (card || "").toUpperCase();
+        if (!value) return "";
+        return `${value[0]}${this.SUIT_SYMBOLS[value[1]] || value[1] || ""}`;
+    },
+
+    // An empty slot has to look like something you can tap, so it gets a placeholder
+    // rather than going blank.
+    paintCardSlot(slot, card) {
+        const value = (card || "").toUpperCase();
+        slot.classList.toggle("cardRed", this.isRedSuit(value));
+        slot.classList.toggle("cardSlotEmpty", !value);
+        slot.textContent = value ? this.formatCard(value) : "＋";
+    },
+
+    // A chair nobody has claimed: no name typed, not dealt in, nothing in the pot.
+    // Worth calling out, because at a short-handed table the open seats are what
+    // the dealer is looking for.
+    isEmptySeat(player) {
+        const named = !!(player.name && player.name.trim());
+        const contributing =
+            HoldemState.computeContribution(player, this.state.chipLegend, this.state.basePotAmount) > 0;
+        return !named && !player.inHand && !contributing;
+    },
+
     updatePuckContent(node, player, index) {
-        node.querySelector(".seatPuckName").textContent = player.name && player.name.trim() ? player.name.trim() : "";
+        const empty = this.isEmptySeat(player);
+        const nameEl = node.querySelector(".seatPuckName");
+        nameEl.textContent = empty ? "Empty" : (player.name || "").trim();
+        nameEl.classList.toggle("seatEmptyLabel", empty);
+
         const cardsEl = node.querySelector(".seatPuckCards");
         cardsEl.innerHTML = "";
         (player.cards || []).filter(Boolean).forEach((card, i) => {
             if (i > 0) cardsEl.appendChild(document.createTextNode(" "));
             const span = document.createElement("span");
             if (this.isRedSuit(card)) span.className = "cardRed";
-            span.textContent = card;
+            span.textContent = this.formatCard(card);
             cardsEl.appendChild(span);
         });
-        const total = HoldemState.computeContribution(player, this.state.chipLegend, this.state.basePotAmount);
+        // Always this player's total for the hand. What they've just pushed out on this
+        // street is shown as a chip on the felt instead — the puck used to flip between
+        // the two meanings depending on the moment, which is a bad thing for a number
+        // sitting next to a stack size to do.
+        const handTotal = Betting.handTotal(player);
+        const total = handTotal > 0
+            ? handTotal
+            : HoldemState.computeContribution(player, this.state.chipLegend, this.state.basePotAmount);
         node.querySelector(".seatPuckTotal").textContent = total > 0 ? Money.format(total) : "";
-        node.classList.toggle("seatInactive", !player.inHand);
+
+        const stackEl = node.querySelector(".seatPuckStack");
+        const stack = Betting.stackOf(this.state, player);
+        stackEl.textContent = !empty && stack > 0 ? Money.format(stack) : "";
+
+        node.classList.toggle("seatActing", index === this.state.actingSeatIndex);
+        node.classList.toggle("seatEmpty", empty);
+        node.classList.toggle("seatInactive", !player.inHand && !empty);
         node.classList.toggle("seatFolded", player.folded);
+        node.classList.toggle("seatLive", player.inHand && !player.folded);
     },
 
     // Cheaper than a full renderSeats() — used after edits so the seat editor's inputs
@@ -148,6 +270,109 @@ const Render = {
         if (node) this.updatePuckContent(node, this.state.seats[index], index);
     },
 
+    // ---- Seat gestures ----
+    //
+    // One puck, three intents: tap to edit, double-tap to fold, press and hold for
+    // the quick menu. The single tap waits out the double-tap window before it
+    // fires — a fifth of a second of latency on opening a form, in exchange for a
+    // fold that doesn't also fling a sheet up over the table.
+
+    LONG_PRESS_MS: 500,
+    DOUBLE_TAP_MS: 220,
+    DRAG_SLOP_PX: 8,
+    pendingTap: null,
+
+    wireSeatGestures(node, index) {
+        let longPressTimer = null;
+        let longPressFired = false;
+        let startX = 0;
+        let startY = 0;
+
+        const cancelLongPress = () => {
+            if (longPressTimer) {
+                clearTimeout(longPressTimer);
+                longPressTimer = null;
+            }
+        };
+
+        node.addEventListener("pointerdown", e => {
+            longPressFired = false;
+            startX = e.clientX;
+            startY = e.clientY;
+            cancelLongPress();
+            longPressTimer = setTimeout(() => {
+                longPressTimer = null;
+                longPressFired = true;
+                this.cancelPendingTap();
+                node.classList.remove("seatPressing");
+                this.hooks.onSeatLongPress(index);
+            }, this.LONG_PRESS_MS);
+            node.classList.add("seatPressing");
+        });
+
+        // Moving means they're dragging the seat, not holding it.
+        node.addEventListener("pointermove", e => {
+            if (Math.abs(e.clientX - startX) > this.DRAG_SLOP_PX || Math.abs(e.clientY - startY) > this.DRAG_SLOP_PX) {
+                cancelLongPress();
+                node.classList.remove("seatPressing");
+            }
+        });
+
+        ["pointerup", "pointercancel", "pointerleave"].forEach(type => {
+            node.addEventListener(type, () => {
+                cancelLongPress();
+                node.classList.remove("seatPressing");
+            });
+        });
+        node.addEventListener("dragstart", () => {
+            cancelLongPress();
+            this.cancelPendingTap();
+            node.classList.remove("seatPressing");
+        });
+
+        node.addEventListener("click", e => {
+            // The long press already did something; don't also treat the release as a tap.
+            if (longPressFired) {
+                longPressFired = false;
+                e.preventDefault();
+                e.stopPropagation();
+                return;
+            }
+            this.handleSeatTap(index);
+        });
+    },
+
+    cancelPendingTap() {
+        if (this.pendingTap) {
+            clearTimeout(this.pendingTap.timer);
+            this.pendingTap = null;
+        }
+    },
+
+    handleSeatTap(index) {
+        if (this.pendingTap && this.pendingTap.index === index) {
+            this.cancelPendingTap();
+            this.hooks.onSeatDoubleTap(index);
+            return;
+        }
+
+        this.cancelPendingTap();
+        const timer = setTimeout(() => {
+            this.pendingTap = null;
+            this.toggleSeatEditor(index);
+        }, this.DOUBLE_TAP_MS);
+        this.pendingTap = { index, timer };
+    },
+
+    // Tapping the open seat again closes it — on a phone the editor is a sheet over
+    // the table, and the seat you just tapped is the closest thing to hand for
+    // dismissing it.
+    toggleSeatEditor(index) {
+        this.selectedSeatIndex = this.selectedSeatIndex === index ? null : index;
+        this.renderSeats();
+        this.renderSeatEditor();
+    },
+
     wireDragAndDrop(node, index) {
         node.addEventListener("dragstart", e => {
             e.dataTransfer.setData("text/plain", String(index));
@@ -253,20 +478,33 @@ const Render = {
             this.commitSeatChange(form, player, index);
         });
 
-        const card1 = form.querySelector(".card1Input");
-        const card2 = form.querySelector(".card2Input");
-        card1.value = player.cards[0] || "";
-        card2.value = player.cards[1] || "";
-        [card1, card2].forEach((input, cardIdx) => {
-            input.classList.toggle("cardRed", this.isRedSuit(input.value));
-            input.addEventListener("input", () => {
-                input.value = input.value.toUpperCase();
-                input.classList.toggle("cardRed", this.isRedSuit(input.value));
-                player.cards[cardIdx] = input.value;
-                this.commitSeatChange(form, player, index);
+        const slots = [form.querySelector(".card1Slot"), form.querySelector(".card2Slot")];
+        slots.forEach((slot, cardIdx) => {
+            this.paintCardSlot(slot, player.cards[cardIdx]);
+            slot.addEventListener("click", () => {
+                CardPicker.open(this.state, {
+                    onPick: (seatIndex, pickedIdx, card) => {
+                        this.paintCardSlot(slots[pickedIdx], card);
+                        this.commitSeatChange(form, player, seatIndex);
+                    },
+                }, index, cardIdx);
             });
         });
 
+        // What they've handed over tonight, shown next to what's in front of them so a
+        // cash-out is one subtraction rather than a memory test.
+        const boughtIn = Number(player.buyIns) || 0;
+        const boughtInEl = form.querySelector(".seatBuyIns");
+        boughtInEl.textContent = boughtIn > 0 ? `Bought in ${Money.format(boughtIn)}` : "";
+        boughtInEl.hidden = boughtIn <= 0;
+
+        const stackInput = form.querySelector(".stackInput");
+        stackInput.value = player.stack ?? "";
+        stackInput.addEventListener("input", () => {
+            player.stack = stackInput.value === "" ? null : Number(stackInput.value);
+            this.commitSeatChange(form, player, index);
+        });
+
         const amountInput = form.querySelector(".amountOverrideInput");
         amountInput.value = player.amountOverride ?? "";
         amountInput.addEventListener("input", () => {
@@ -365,6 +603,51 @@ const Render = {
         });
     },
 
+    // ---- Pot breakdown ----
+
+    // Shared by the action bar (live, mid-hand) and the pot wizard (before winners are
+    // picked), because both are showing the dealer the same announcement.
+    buildPotBreakdown(pots, returns, nameFor, heading) {
+        if (pots.length < 2 && returns.length === 0) return null;
+
+        const wrap = document.createElement("div");
+        wrap.className = "potBreakdown";
+
+        if (heading) {
+            const title = document.createElement("p");
+            title.className = "potBreakdownHeading";
+            title.textContent = heading;
+            wrap.appendChild(title);
+        }
+
+        const addRow = (label, amount, who, className) => {
+            const row = document.createElement("div");
+            row.className = `potLayer ${className || ""}`;
+
+            const labelEl = document.createElement("span");
+            labelEl.className = "potLayerLabel";
+            labelEl.textContent = label;
+
+            const amountEl = document.createElement("span");
+            amountEl.className = "potLayerAmount";
+            amountEl.textContent = Money.format(amount);
+
+            const whoEl = document.createElement("span");
+            whoEl.className = "potLayerWho";
+            whoEl.textContent = who;
+
+            row.appendChild(labelEl);
+            row.appendChild(amountEl);
+            row.appendChild(whoEl);
+            wrap.appendChild(row);
+        };
+
+        pots.forEach(pot => addRow(pot.label, pot.amount, pot.eligible.map(nameFor).join(", ")));
+        returns.forEach(ret => addRow("Uncalled", ret.amount, `back to ${nameFor(ret.id)}`, "potLayerReturn"));
+
+        return wrap;
+    },
+
     // ---- Session standings ----
 
     renderStandings() {

JoshHeaps.Net/wwwroot/js/casino/holdem/seatMenu.js

@@ -0,0 +1,81 @@
+// The long-press menu on a seat. Everything a dealer does to one player mid-hand,
+// one press and one tap away, without opening the full editor and without hunting
+// for whose turn it is in the action bar.
+const SeatMenu = {
+    state: null,
+    hooks: null,
+    seatIndex: null,
+
+    open(state, hooks, seatIndex) {
+        this.state = state;
+        this.hooks = hooks;
+        this.seatIndex = seatIndex;
+        this.render();
+        document.getElementById("seatMenuOverlay").hidden = false;
+    },
+
+    close() {
+        document.getElementById("seatMenuOverlay").hidden = true;
+    },
+
+    // Only the actions that make sense for this seat right now — a folded player has
+    // nothing to go all-in with, and an empty chair has nothing to fold.
+    actionsFor(player, index) {
+        const actions = [];
+        const dealtIn = player.inHand;
+        const live = dealtIn && !player.folded;
+
+        if (live) {
+            actions.push({ label: "Fold", className: "menuDanger", run: () => this.hooks.fold(index) });
+            actions.push({ label: "All-in", className: "menuAccent", run: () => this.hooks.allIn(index) });
+        } else if (dealtIn && player.folded) {
+            actions.push({ label: "Un-fold", run: () => this.hooks.unfold(index) });
+        }
+
+        // The most common interruption in a cash game, and until now it meant opening
+        // the editor and retyping a stack from memory.
+        actions.push({ label: "Add chips…", run: () => this.hooks.addChips(index) });
+
+        actions.push({
+            label: dealtIn ? "Sit out" : "Deal in",
+            run: () => this.hooks.toggleDealtIn(index),
+        });
+
+        if (!this.state.dedicatedDealer && index !== this.state.dealerSeatIndex) {
+            actions.push({ label: "Give the button", run: () => this.hooks.makeDealer(index) });
+        }
+
+        actions.push({ label: "Edit seat…", run: () => this.hooks.editSeat(index) });
+        return actions;
+    },
+
+    render() {
+        const player = this.state.seats[this.seatIndex];
+        document.getElementById("seatMenuTitle").textContent = HoldemState.displayName(player, this.seatIndex);
+
+        const stack = Betting.stackOf(this.state, player);
+        const owed = Betting.toCall(this.state, player);
+        const bits = [];
+        if (stack > 0) bits.push(`${Money.format(stack)} behind`);
+        if (owed > 0) bits.push(`${Money.format(owed)} to call`);
+        document.getElementById("seatMenuSubtitle").textContent = bits.join(" · ");
+
+        const list = document.getElementById("seatMenuActions");
+        list.innerHTML = "";
+        this.actionsFor(player, this.seatIndex).forEach(action => {
+            const btn = document.createElement("button");
+            btn.type = "button";
+            btn.className = `seatMenuBtn ${action.className || ""}`;
+            btn.textContent = action.label;
+            btn.addEventListener("click", () => {
+                this.close();
+                action.run();
+            });
+            list.appendChild(btn);
+        });
+    },
+};
+
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = SeatMenu;
+}

JoshHeaps.Net/wwwroot/js/casino/holdem/shortcuts.js

@@ -0,0 +1,64 @@
+// Keyboard control for a dealer running this on a laptop.
+//
+// The phone has gestures; the desktop had a mouse and nothing else. These are the
+// same actions the bar already offers, reachable without moving a hand to the
+// trackpad between every decision — which is the whole point when the bar is being
+// tapped thirty times a hand.
+const Shortcuts = {
+    // Deliberately single letters with no modifier: a dealer's spare hand rests on
+    // the keyboard, and a chord is slower than reaching for the button would be.
+    KEYS: {
+        f: "fold",
+        c: "checkOrCall",
+        r: "raise",
+        a: "allIn",
+        " ": "advance",
+        enter: "advance",
+        u: "undo",
+        escape: "cancel",
+    },
+
+    mount(handlers) {
+        this.handlers = handlers;
+        document.addEventListener("keydown", e => this.onKey(e));
+    },
+
+    // Nothing fires while the dealer is typing a name, an amount, or a note — the
+    // "c" in "Cass" must not fold the table.
+    isTyping() {
+        const el = document.activeElement;
+        if (!el) return false;
+        const tag = el.tagName;
+        return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || el.isContentEditable;
+    },
+
+    // An overlay owns the keyboard while it's up: the confirm dialog already binds
+    // Enter and Escape, and the card picker and seat menu are modal.
+    overlayOpen() {
+        return ["confirmOverlay", "potWizardOverlay", "cardPickerOverlay", "seatMenuOverlay", "rulingsOverlay", "addChipsOverlay"]
+            .some(id => {
+                const el = document.getElementById(id);
+                return el && !el.hidden;
+            });
+    },
+
+    onKey(e) {
+        if (e.metaKey || e.ctrlKey || e.altKey) return;
+
+        const key = e.key.length === 1 ? e.key.toLowerCase() : e.key.toLowerCase();
+        const action = this.KEYS[key];
+        if (!action) return;
+
+        // Escape is the exception: it should still close the raise pad even if focus
+        // happens to be sitting in its amount field.
+        if (this.isTyping() && !(action === "cancel")) return;
+        if (this.overlayOpen()) return;
+
+        const handled = this.handlers[action] && this.handlers[action]();
+        if (handled) e.preventDefault();
+    },
+};
+
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = Shortcuts;
+}

JoshHeaps.Net/wwwroot/js/casino/holdem/state.js

@@ -26,6 +26,13 @@ const HoldemState = {
             chipCounts: {},
             amountOverride: null,
             customFields: [],
+            // Live-betting fields: chips in front of the player, chips they've put in
+            // on the current street, and whether they've answered the current bet.
+            stack: null,
+            committed: 0,
+            hasActed: false,
+            // Cash handed over tonight, which only moves when they buy chips.
+            buyIns: 0,
         };
     },
 
@@ -44,6 +51,13 @@ const HoldemState = {
             notes: "",
             handNumber: 1,
             handHistory: [],
+            smallBlind: 1,
+            bigBlind: 2,
+            defaultStack: null,
+            street: "preflop",
+            currentBet: 0,
+            lastRaiseSize: 0,
+            actingSeatIndex: null,
         };
     },
 
@@ -55,6 +69,21 @@ const HoldemState = {
             if (!parsed || !Array.isArray(parsed.seats)) return this.createDefault();
             if (typeof parsed.handNumber !== "number" || parsed.handNumber < 1) parsed.handNumber = 1;
             if (!Array.isArray(parsed.handHistory)) parsed.handHistory = [];
+
+            // Tables saved before live betting existed are missing its fields; fill
+            // them in rather than making the dealer reset a table mid-session.
+            const defaults = this.createDefault();
+            ["smallBlind", "bigBlind", "defaultStack", "street", "currentBet", "lastRaiseSize", "actingSeatIndex"]
+                .forEach(key => {
+                    if (parsed[key] === undefined) parsed[key] = defaults[key];
+                });
+            parsed.seats.forEach(player => {
+                if (player.stack === undefined) player.stack = null;
+                if (player.committed === undefined) player.committed = 0;
+                if (player.hasActed === undefined) player.hasActed = false;
+                if (player.buyIns === undefined) player.buyIns = 0;
+            });
+
             return parsed;
         } catch {
             return this.createDefault();
@@ -147,6 +176,8 @@ const HoldemState = {
             p.cards = ["", ""];
             p.chipCounts = {};
             p.amountOverride = null;
+            p.committed = 0;
+            p.hasActed = false;
         });
     },
 
@@ -208,13 +239,32 @@ const HoldemState = {
             });
         });
 
+        // Cash bought in and chips currently in front don't come from the hand log at
+        // all, so they're read off the seat rather than summed — a rebuy isn't a hand.
+        const seatById = new Map(state.seats.map(p => [p.id, p]));
+
         return Array.from(totals.values())
-            .map(t => ({
-                ...t,
-                in: Math.round(t.in * 100) / 100,
-                won: Math.round(t.won * 100) / 100,
-                net: Math.round((t.won - t.in) * 100) / 100,
-            }))
+            .map(t => {
+                const seat = seatById.get(t.id);
+                const boughtIn = seat ? Math.round((Number(seat.buyIns) || 0) * 100) / 100 : 0;
+                const chipsNow = seat ? Math.round((Number(seat.stack) || 0) * 100) / 100 : 0;
+                // Chips already pushed into the hand in progress are still this
+                // player's money until it's won. Leaving them out makes the cash
+                // position disagree with the hand log for as long as a hand is open —
+                // and blinds are posted the instant the previous one settles, so that
+                // window is almost always.
+                const inFrontOfThem = seat ? (Number(seat.amountOverride) || 0) + (Number(seat.committed) || 0) : 0;
+
+                return {
+                    ...t,
+                    in: Math.round(t.in * 100) / 100,
+                    won: Math.round(t.won * 100) / 100,
+                    net: Math.round((t.won - t.in) * 100) / 100,
+                    boughtIn,
+                    chipsNow,
+                    cashPosition: Math.round((chipsNow + inFrontOfThem - boughtIn) * 100) / 100,
+                };
+            })
             .sort((a, b) => b.net - a.net);
     },
 };