Chop a side pot on the screen that worked it out, and fix Quick Split's contrast

Quick Split lists the pots when somebody is all-in — main, sides, uncalled — and then
leaves the dealer there. Two players tying for a side pot is ordinary, and working out
each one's share meant switching to the other mode and retyping an amount the screen
had just calculated. Retyping a number with money on it is a transcription error
waiting to happen, and the number was already on screen.

Each pot with two or more people who can win it now carries a Chop, opening underneath
its own row: as many ways as there are contenders by default, a stepper for a chop
between fewer of them, and the same odd-chip and dust wording the main split uses,
because it is the same rule and the dealer shouldn't have to notice they are reading a
different screen. Per-row state, so opening the main pot's chop doesn't disturb what
the side pot below it says. Not offered on the uncalled row, which goes back to one
player, nor on the total.

Separately, this page had never been through the layout audit the dealer table gets
every round, and it was carrying nine contrast failures:

    .unevenCurrency   4.11:1   the $ beside every amount typed
    .unevenRemoveBtn  3.66:1   the ✕ that deletes a player's entry
    .splitFootnote    3.94:1   the instruction for what to do with the pot list

All under the 4.5:1 small-text minimum, the worst of them on a destructive control.
Lifted to pass. The large $ on the even-mode pot input is left alone: at 1.6rem it is
large text, where 3:1 is the bar and 4.11:1 clears it.

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

JoshHeaps.Net/Pages/Casino/TexasHoldem.cshtml

@@ -110,8 +110,9 @@
                                 <span>Player</span>
                                 <span class="standingsInHead">In</span>
                                 <span class="standingsWonHead">Won</span>
-                                <span>Net</span>
-                                <span title="Chips in front of them, less the cash they handed over">Cash out</span>
+                                <span class="standingsNetHead">Net</span>
+                                <span class="standingsChipsHead" title="What they are holding — the cash to count out if they leave now">Chips</span>
+                                <span title="Those chips, less the cash they handed over">Up/down</span>
                             </div>
                             <div id="standingsList"></div>
                         </div>
@@ -270,6 +271,7 @@
         <span class="standingsIn"></span>
         <span class="standingsWon"></span>
         <span class="standingsNet"></span>
+        <span class="standingsChips"></span>
         <span class="standingsCashOut"></span>
     </div>
 </template>
@@ -399,6 +401,22 @@
             </p>
         </section>
 
+        <section class="ruling" data-short="Who shows first">
+            <h3>Who turns their hand over first</h3>
+            <p>
+                If there was a bet on the river, the last player to bet or raise shows
+                first. If the river was checked all the way round, it's the first live
+                player left of the button. Nobody has to be asked twice — a player may
+                always turn their hand over early if they want to.
+            </p>
+            <p>
+                When everyone is all-in before the river there was no final round to
+                lead, so it falls to whoever last put money in, on whichever street that
+                was. The action bar names the seat and the reason at every showdown, so
+                the call is already made before anyone asks.
+            </p>
+        </section>
+
         <section class="ruling" data-short="Odd chip">
             <h3>The odd chip in a split pot</h3>
             <p>

JoshHeaps.Net/wwwroot/css/casino/holdem.css

@@ -1816,31 +1816,44 @@ button,
     white-space: nowrap;
 }
 
-/* The per-hand columns are detail: how the night's swings happened. They're the
-   first thing to go when there isn't room, because Net and Cash out are what the
-   banker is actually reading. */
+/* The per-hand columns are detail: how the night's swings happened. They're the first
+   to go when there isn't room, and Net goes with them — it only moves when a pot is
+   resolved through the wizard, so on a table where the dealer settles pots by hand it
+   reads $0 all night beside two columns that don't.
+
+   What survives at every width is the pair the banker actually works from: what the
+   player is holding, and whether that leaves them up or down. */
 .standingsIn,
 .standingsWon,
+.standingsNet,
 .standingsInHead,
-.standingsWonHead {
+.standingsWonHead,
+.standingsNetHead {
     display: none;
 }
 
 @container (min-width: 30rem) {
     .standingsRow {
-        grid-template-columns: minmax(5rem, 1fr) auto auto auto auto;
+        grid-template-columns: minmax(5rem, 1fr) auto auto auto auto auto;
     }
 
     .standingsIn,
     .standingsWon,
+    .standingsNet,
     .standingsInHead,
-    .standingsWonHead {
+    .standingsWonHead,
+    .standingsNetHead {
         display: block;
     }
 }
 
-/* The settle-up column is the one a banker reads while counting out cash, so it
-   carries the weight the per-hand columns don't. */
+/* The chips column is the one a banker's hands follow while counting money onto the
+   table, so it carries the weight. Up/down is read once, at the end. */
+.standingsChips {
+    font-weight: 600;
+    color: #e6e6e6;
+}
+
 .standingsCashOut {
     font-weight: 600;
 }
@@ -1957,6 +1970,16 @@ button,
     color: #e07b7b;
 }
 
+/* The showdown call, sat above the resolve button. Loud enough to be read across a
+   table at a glance — this is something the dealer says out loud — but not so loud it
+   competes with the button underneath it. */
+.showdownCall {
+    margin: 0 0 0.45rem;
+    text-align: center;
+    font-size: 0.82rem;
+    color: #f0d98c;
+}
+
 .handHistoryFilterRow {
     display: flex;
     align-items: center;

JoshHeaps.Net/wwwroot/css/casino/quicksplit.css

@@ -143,7 +143,9 @@ button,
 }
 
 .unevenCurrency {
-    color: #777;
+    /* Was #777 — 4.11:1 on this background, under the 4.5:1 small text needs. It sits
+       against every amount a dealer types, so it is read constantly. */
+    color: #8f8f8f;
 }
 
 .unevenAmount {
@@ -184,7 +186,9 @@ button,
     height: 44px;
     border: none;
     background: none;
-    color: #6a6a6a;
+    /* Was #6a6a6a — 3.66:1, the worst on the page, on a control that deletes a
+       player's entry. A destructive action should not be the faintest thing in view. */
+    color: #9a9a9a;
     font-size: 0.85rem;
     cursor: pointer;
 }
@@ -209,11 +213,86 @@ button,
 .unevenPot {
     display: flex;
     align-items: baseline;
+    /* Wraps so a chop opens underneath its own pot rather than squeezing in beside the
+       eligible-players list and pushing it off the row. */
+    flex-wrap: wrap;
     gap: 0.6rem;
     padding: 0.3rem 0;
     font-size: 0.85rem;
 }
 
+.unevenChopToggle {
+    flex: none;
+    order: 3;
+    /* 44px on touch: it moves money, like everything else that does. */
+    min-height: 32px;
+    padding: 0.2rem 0.6rem;
+    border: 1px solid rgba(216, 180, 106, 0.45);
+    border-radius: 999px;
+    background: rgba(216, 180, 106, 0.1);
+    color: #e3c887;
+    font: inherit;
+    font-size: 0.74rem;
+    cursor: pointer;
+}
+
+.unevenChopToggle:hover {
+    background: rgba(216, 180, 106, 0.18);
+}
+
+.unevenChopToggle:focus-visible {
+    outline: 2px solid #d8b46a;
+    outline-offset: 2px;
+}
+
+.unevenChopDetail {
+    order: 4;
+    flex: 0 0 100%;
+    /* Or the padding is added on top of the 100% basis and the panel sits wider than
+       the row it belongs to — measured 328px inside a 309px row on a phone. */
+    box-sizing: border-box;
+    margin: 0.15rem 0 0.2rem;
+    padding: 0.45rem 0.6rem;
+    border-radius: 8px;
+    background: rgba(255, 255, 255, 0.04);
+}
+
+.unevenChopWays {
+    display: flex;
+    align-items: center;
+    gap: 0.45rem;
+    margin-bottom: 0.3rem;
+}
+
+.unevenChopWaysLabel {
+    color: #cfcfcf;
+    font-size: 0.78rem;
+    font-variant-numeric: tabular-nums;
+}
+
+.unevenChopEach {
+    margin: 0;
+    color: #f2f2f2;
+    font-weight: 600;
+}
+
+.unevenChopNote {
+    margin: 0.2rem 0 0;
+    color: #9a9a9a;
+    font-size: 0.76rem;
+}
+
+.unevenChopDust {
+    color: #e0b169;
+}
+
+@media (max-width: 700px), (pointer: coarse) {
+    .unevenChopToggle {
+        min-height: 44px;
+        padding: 0.4rem 0.9rem;
+    }
+}
+
 .unevenPot + .unevenPot {
     border-top: 1px solid rgba(255, 255, 255, 0.06);
 }
@@ -510,7 +589,9 @@ button,
 
 .splitFootnote {
     margin-top: 1.5rem;
-    color: #6f6f6f;
+    /* Was #6f6f6f — 3.94:1. It carries the instruction for what to do with the pot
+       list, which is not a decorative line. */
+    color: #8d8d8d;
     font-size: 0.78rem;
     line-height: 1.5;
     text-align: center;

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

@@ -79,8 +79,14 @@ const ActionBar = {
     // Anything to act on? A hand with nobody dealt in doesn't get a bar — and that
     // still holds during setup, because a seated player is a live seat whether or not
     // the betting has been opened. An empty table stays uncluttered.
+    //
+    // A *named* table is not an empty one, though, and that was the hole: name six
+    // people without dealing any of them in and the bar hid itself, leaving a screen
+    // with six players on it, no way forward and nothing saying why. Anyone with a
+    // name on the felt is somebody the dealer has to be told about.
     isRunning() {
-        return Betting.liveSeats(this.state).length > 0;
+        return Betting.liveSeats(this.state).length > 0 ||
+            this.state.seats.some(p => (p.name || "").trim());
     },
 
     render() {
@@ -424,7 +430,6 @@ const ActionBar = {
         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);
         // Two different minimums, and conflating them was a bug. `minTo` is clamped to
         // what this player can actually put in, which is what the Min button should
         // offer. `legalMin` is what the rules require — for a short stack the two are
@@ -440,10 +445,16 @@ const ActionBar = {
         const quick = document.createElement("div");
         quick.className = "raiseQuick";
 
+        // The pot amounts come from Betting, which knows that a pot raise is measured
+        // off the pot as it stands *after* the caller's own call goes in. The pad used
+        // to work it out here as "the bet plus the pot", which left the call out and
+        // made both amounts short: pre-flop at 1/2 it offered "Pot $5" where a pot
+        // raise is $7, and a half-pot that clamped up to the minimum and sat next to
+        // the Min button showing the same $4 twice.
         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: "½ pot", value: Betting.potRaiseTo(this.state, index, 0.5) },
+            { label: "Pot", value: Betting.potRaiseTo(this.state, index, 1) },
             { label: "All-in", value: maxTo },
         ];
         options.forEach(option => {
@@ -587,10 +598,19 @@ const ActionBar = {
             // thing: "only one player is dealt in" is wrong when four are sitting there
             // and three of them are just out of chips.
             const withChips = seated - broke.length;
+            // "Nobody has chips left" is the wrong story for a table that never had
+            // any. A dealer who has just named six people and not yet said what a
+            // buy-in is gets told their players are busted, which sends them looking
+            // for a rebuy button instead of the one field that fixes it.
+            const nobodyHasEverBoughtIn = this.state.seats.every(p =>
+                !(Number(p.buyIns) > 0) && !(Number(p.stack) > 0));
+
             if (broke.length > 0 && withChips < 2) {
                 line.textContent = withChips === 1
                     ? `Only ${listNames(Betting.liveSeats(this.state).map(s => s.index).filter(i => !broke.includes(i)))} has chips — ${listNames(broke)} ${broke.length === 1 ? "needs" : "need"} to buy in.`
-                    : "Nobody at the table has chips left. Add a buy-in to deal.";
+                    : nobodyHasEverBoughtIn
+                        ? "Nobody has bought in yet. Set what everyone starts with, or give each seat their chips."
+                        : "Nobody at the table has chips left. Add a buy-in to deal.";
             } else {
                 line.textContent = seated === 0
                     ? "Nobody is dealt in yet. Tap a seat to add a player."
@@ -598,6 +618,56 @@ const ActionBar = {
             }
             line.classList.add("dealPromptBlocked");
             wrap.appendChild(line);
+
+            // A blocked prompt with nothing to press is a dead end, and this was the
+            // one a first-time dealer hits: six players named, a sentence saying they
+            // have no chips, and no button anywhere on the bar. The starting stack is a
+            // single field in the sidebar and the message never pointed at it.
+            if (nobodyHasEverBoughtIn && seated > 0) {
+                const row = document.createElement("div");
+                row.className = "actionButtons";
+                row.appendChild(this.button("Set starting stack", "actionDeal", () => {
+                    const field = document.getElementById("defaultStackInput");
+                    if (!field) return;
+                    const panel = field.closest("details");
+                    if (panel) panel.open = true;
+                    field.scrollIntoView({ block: "center", behavior: "smooth" });
+                    field.focus();
+                    field.select();
+                }));
+                wrap.appendChild(row);
+                return wrap;
+            }
+
+            // Named seats that aren't in the hand. Naming a chair now seats whoever is
+            // in it, so reaching this takes something else — a table where everyone was
+            // sat out, or a save from before that was true — but the way out of it
+            // should still be one tap rather than a hunt through six seat editors.
+            const benched = this.state.seats
+                .map((player, index) => ({ player, index }))
+                .filter(({ player }) => (player.name || "").trim() && !player.inHand)
+                .map(({ index }) => index);
+
+            if (benched.length > 0) {
+                const aside = document.createElement("p");
+                aside.className = "dealPromptLine dealPromptAside dealPromptDebt";
+                const text = document.createElement("span");
+                text.textContent = benched.length === 1
+                    ? `${listNames(benched)} is sitting out.`
+                    : `${listNames(benched)} are sitting out.`;
+                aside.appendChild(text);
+                aside.appendChild(this.button(
+                    benched.length === 1 ? "Deal them in" : `Deal in all ${benched.length}`,
+                    "dealPromptDebtBtn",
+                    () => this.commit("dealing everybody in", () => {
+                        benched.forEach(index => {
+                            this.state.seats[index].inHand = true;
+                            this.state.seats[index].folded = false;
+                        });
+                    })
+                ));
+                wrap.appendChild(aside);
+            }
             return wrap;
         }
 
@@ -691,13 +761,41 @@ const ActionBar = {
         return wrap;
     },
 
+    // "Dee shows first — last to raise." The call the dealer has to make at every
+    // showdown and that nobody at the table volunteers for, said out loud with the
+    // reason attached so it can be repeated to whoever argues with it.
+    showdownCall() {
+        const call = Betting.showdownOrder(this.state);
+        if (!call) return null;
+
+        const who = HoldemState.displayName(this.state.seats[call.index], call.index);
+        const because = {
+            aggressor: "last to bet or raise",
+            // Semicolon, not a second dash: the sentence already spends its dash on
+            // "shows first —", and two of them in one line reads as a stutter.
+            allInAggressor: "last to put money in; nobody could bet the river",
+            leftOfButton: "checked round, first left of the button",
+        }[call.reason];
+
+        const line = document.createElement("p");
+        line.className = "showdownCall";
+        line.textContent = `${who} shows first — ${because}.`;
+        return line;
+    },
+
     renderStreetDone() {
-        const row = document.createElement("div");
-        row.className = "actionButtons";
+        const wrap = document.createElement("div");
 
         const isRiver = this.state.street === "river";
         const label = isRiver ? "Showdown — resolve pot" : `Deal ${Betting.streetLabel(Betting.STREETS[Betting.STREETS.indexOf(this.state.street) + 1])}`;
 
+        if (isRiver) {
+            const call = this.showdownCall();
+            if (call) wrap.appendChild(call);
+        }
+
+        const row = document.createElement("div");
+        row.className = "actionButtons";
         row.appendChild(this.button(label, "actionAdvance", () => {
             if (isRiver) {
                 this.hooks.resolvePot();
@@ -705,22 +803,33 @@ const ActionBar = {
             }
             this.commit(`dealing the ${Betting.streetLabel(Betting.STREETS[Betting.STREETS.indexOf(this.state.street) + 1]).toLowerCase()}`, () => Betting.closeStreet(this.state));
         }));
+        wrap.appendChild(row);
 
-        return row;
+        return wrap;
     },
 
     renderHandOver() {
-        const row = document.createElement("div");
-        row.className = "actionButtons";
+        const wrap = document.createElement("div");
         const live = Betting.liveSeats(this.state);
         const winner = live.length === 1 ? HoldemState.displayName(live[0].player, live[0].index) : null;
 
+        // Two or more still in with the betting finished is a showdown however it was
+        // arrived at — including everyone all-in on the flop, where the cards go on
+        // their backs and the order still decides who turns over first.
+        if (!winner) {
+            const call = this.showdownCall();
+            if (call) wrap.appendChild(call);
+        }
+
+        const row = document.createElement("div");
+        row.className = "actionButtons";
         row.appendChild(this.button(
             winner ? `Award pot to ${winner}` : "Resolve pot",
             "actionAdvance",
             () => this.hooks.resolvePot()
         ));
-        return row;
+        wrap.appendChild(row);
+        return wrap;
     },
 };
 

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

@@ -276,6 +276,11 @@ const Betting = {
 
         if (newBet > previousBet) {
             const increase = this.round(newBet - previousBet);
+            // Aggression, whether or not it was a full raise — a short all-in doesn't
+            // reopen the betting, but the player who made it is still the last one who
+            // put money in, and at the showdown they are still the one who shows first.
+            state.streetAggressorIndex = index;
+            state.handAggressorIndex = index;
             // What a full raise would have had to be: at least as much again as the
             // last one, or the big blind if there hasn't been a raise yet.
             const fullRaise = this.round(state.lastRaiseSize || state.bigBlind || 0);
@@ -337,6 +342,10 @@ const Betting = {
 
         state.currentBet = 0;
         state.lastRaiseSize = 0;
+        // Whoever led this street stops being the answer the moment the next one opens.
+        // The hand's aggressor is deliberately left alone: it's the fallback for a
+        // river nobody could bet on.
+        state.streetAggressorIndex = null;
 
         const nextStreetIndex = this.STREETS.indexOf(state.street || "preflop") + 1;
         state.street = this.STREETS[nextStreetIndex] || "river";
@@ -424,6 +433,11 @@ const Betting = {
         state.street = "preflop";
         state.currentBet = 0;
         state.lastRaiseSize = 0;
+        // Posting a blind isn't aggression — a hand limped and checked all the way
+        // down has no aggressor at all, which is exactly the case the showdown rule
+        // sends to the seat left of the button.
+        state.streetAggressorIndex = null;
+        state.handAggressorIndex = null;
 
         // Deal around anyone with no chips, before anything else reads the table.
         //
@@ -504,6 +518,81 @@ const Betting = {
             : this.nextToAct(state, bbIndex);
     },
 
+    // What a pot-sized raise actually is, as a "raise to" total.
+    //
+    // Not "the bet plus the pot as it stands". The raiser calls first, and their call
+    // is in the pot before the raise is measured off it, so the pot being matched is
+    // the one that exists after the call:
+    //
+    //     raise to = the current bet + (pot + what they owe) × fraction
+    //
+    // Pre-flop at 1/2 that gives $7, not $5: call the $2, which makes the pot $5, then
+    // raise $5. Leaving the call out understates every one of these, and players say
+    // "pot" out loud meaning a definite number.
+    //
+    // Facing no bet this is a plain pot-sized bet — toCall is zero and currentBet is
+    // zero, so it comes out as the pot, which is the right answer there too.
+    // Rounded up to something the table's chips can actually build. Half the pot is
+    // constantly a half-chip amount — pre-flop at 1/2 it is $4.50, and the smallest
+    // chip in the default legend is a dollar, so the button offered a number the
+    // dealer would have to round themselves every single time.
+    //
+    // Only when the legend describes this game. A smallest chip *larger* than the big
+    // blind means the denominations were never set for these stakes, and rounding a
+    // 5c/10c table up to whole dollars would be the tool doing real damage on the
+    // strength of a field somebody forgot to fill in. Left exact there, and the wrong
+    // legend stays visible rather than being quietly applied.
+    potRaiseTo(state, index, fraction = 1) {
+        const player = state.seats[index];
+        if (!player) return 0;
+        const potAfterCall = this.round(this.potSoFar(state) + this.toCall(state, player));
+        const exact = this.round((state.currentBet || 0) + potAfterCall * fraction);
+
+        const step = Money.fromCents(Money.chipStepCents(state.chipLegend));
+        const bigBlind = Number(state.bigBlind) || 0;
+        if (step <= 0 || (bigBlind > 0 && step > bigBlind)) return exact;
+        return Money.upToChip(exact, state.chipLegend);
+    },
+
+    // Who turns their hand over first.
+    //
+    // A call the dealer makes at every showdown that isn't a fold, and one nobody at
+    // the table volunteers for — everyone would rather see a hand than show one. The
+    // tool knew who last raised and who sits left of the button and said neither, so
+    // the dealer was working it out from memory while five people waited.
+    //
+    // Three cases, in the order the rule asks them:
+    //   * somebody bet or raised on the final round — they show first;
+    //   * the round was checked through — first live player left of the button;
+    //   * nobody could bet, because the chips were already in — the last player who
+    //     did put money in, on whichever round that was.
+    //
+    // Returns null when there's nothing to call: one player left, or none.
+    showdownOrder(state) {
+        const live = this.liveSeats(state);
+        if (live.length < 2) return null;
+
+        const seatOf = index =>
+            Number.isInteger(index) && live.some(s => s.index === index) ? index : null;
+
+        const streetAggressor = seatOf(state.streetAggressorIndex);
+        if (streetAggressor !== null) {
+            return { index: streetAggressor, reason: "aggressor" };
+        }
+
+        // Nobody could have bet this round, so "no bet on the final round" isn't a
+        // choice anybody made and the seat left of the button hasn't earned the
+        // obligation. It falls to whoever last put money in.
+        if (!this.canStillBet(state)) {
+            const handAggressor = seatOf(state.handAggressorIndex);
+            if (handAggressor !== null) return { index: handAggressor, reason: "allInAggressor" };
+        }
+
+        const order = HoldemState.liveOrderFromButton(state)
+            .filter(index => live.some(s => s.index === index));
+        return order.length > 0 ? { index: order[0], reason: "leftOfButton" } : null;
+    },
+
     // Winners get their share put back in front of them.
     creditWinnings(state, payouts) {
         payouts.forEach(payout => {

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

@@ -63,6 +63,29 @@ const Money = {
     // Anything the smallest chip can't make comes back as `remainder` rather than being
     // rounded away: a 50c share in a game whose smallest chip is a dollar is a real
     // problem for the dealer to solve, not a rounding error to hide.
+    // The smallest chip the table has said it plays with, in cents. Zero when no
+    // denominations are set, which means the tool has been told nothing about what
+    // chips exist and shouldn't pretend otherwise.
+    chipStepCents(legend) {
+        const values = (legend || [])
+            .map(chip => this.toCents(chip.value))
+            .filter(cents => cents > 0);
+        return values.length > 0 ? Math.min(...values) : 0;
+    },
+
+    // Rounds an amount up to something the table can actually build out of its chips.
+    //
+    // Up rather than down or nearest: these are bet sizes, and a pot-sized bet that
+    // has been shaved is no longer a pot-sized bet. Rounding up also can't drop an
+    // amount below a legal minimum, which rounding the other way can.
+    upToChip(amount, legend) {
+        const step = this.chipStepCents(legend);
+        if (step <= 0) return this.round(amount);
+        const cents = this.toCents(amount);
+        if (cents <= 0) return this.round(amount);
+        return this.fromCents(Math.ceil(cents / step) * step);
+    },
+
     chipBreakdown(amount, legend) {
         let cents = this.toCents(amount);
         if (cents <= 0) return { chips: [], remainder: 0 };

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

@@ -197,6 +197,80 @@ const QuickSplit = {
         });
     },
 
+    // Chopping one of the pots listed above, without leaving the screen that worked it
+    // out. Starts closed and at as many ways as there are players who can win the pot,
+    // which is the common case; the stepper covers a chop between fewer of them, which
+    // is the other one.
+    //
+    // The per-pot ways live on the row rather than in `this.ways`, so opening a chop on
+    // the main pot doesn't change what the side pot below it is saying.
+    addChopControl(row, amount, contenderCount) {
+        let ways = contenderCount;
+        let open = false;
+
+        const toggle = document.createElement("button");
+        toggle.type = "button";
+        toggle.className = "unevenChopToggle";
+
+        const detail = document.createElement("div");
+        detail.className = "unevenChopDetail";
+        detail.hidden = true;
+
+        const draw = () => {
+            toggle.textContent = open ? "Hide chop" : "Chop";
+            toggle.setAttribute("aria-expanded", String(open));
+            detail.hidden = !open;
+            if (!open) return;
+
+            const result = SplitCalculator.split(amount, ways, this.chip);
+            detail.innerHTML = "";
+
+            const stepper = document.createElement("div");
+            stepper.className = "unevenChopWays";
+            stepper.appendChild(this.makeStepButton("−", () => {
+                if (ways > 2) { ways -= 1; draw(); }
+            }));
+            const label = document.createElement("span");
+            label.className = "unevenChopWaysLabel";
+            label.textContent = `${ways} ways`;
+            stepper.appendChild(label);
+            stepper.appendChild(this.makeStepButton("+", () => {
+                if (ways < Math.max(contenderCount, this.MAX_WAYS)) { ways += 1; draw(); }
+            }));
+            detail.appendChild(stepper);
+
+            const each = document.createElement("p");
+            each.className = "unevenChopEach";
+            each.textContent = `${Money.format(result.each)} each`;
+            detail.appendChild(each);
+
+            // Same wording as the main split, because it is the same rule and a dealer
+            // shouldn't have to notice they're reading a different screen.
+            if (result.valid && result.oddChips > 0) {
+                const odd = document.createElement("p");
+                odd.className = "unevenChopNote";
+                odd.textContent = result.oddChips === 1
+                    ? `plus one odd ${Money.format(result.chip)} chip to the first player left of the button`
+                    : `plus ${result.oddChips} odd ${Money.format(result.chip)} chips — one each to the ` +
+                      `first ${result.oddChips} players left of the button`;
+                detail.appendChild(odd);
+            }
+            if (result.valid && result.dust > 0) {
+                const dust = document.createElement("p");
+                dust.className = "unevenChopNote unevenChopDust";
+                dust.textContent =
+                    `${Money.format(result.dust)} doesn't divide into ${Money.format(result.chip)} chips — ` +
+                    `pick a smaller denomination.`;
+                detail.appendChild(dust);
+            }
+        };
+
+        toggle.addEventListener("click", () => { open = !open; draw(); });
+        draw();
+        row.appendChild(toggle);
+        row.appendChild(detail);
+    },
+
     updateUneven() {
         const players = this.entries
             .map((entry, index) => ({ id: `P${index + 1}`, contribution: Number(entry.amount) || 0, folded: entry.folded }))
@@ -218,7 +292,7 @@ const QuickSplit = {
         }
         empty.hidden = true;
 
-        const addRow = (label, amount, who, className) => {
+        const addRow = (label, amount, who, className, chopWays) => {
             const row = document.createElement("div");
             row.className = `unevenPot ${className || ""}`;
             const name = document.createElement("span");
@@ -234,9 +308,19 @@ const QuickSplit = {
             row.appendChild(value);
             row.appendChild(eligible);
             host.appendChild(row);
+
+            // Two players tying for a side pot is ordinary, and working out each one's
+            // share meant copying the amount into the other mode by hand — retyping a
+            // number the screen had just worked out, which is a transcription error
+            // waiting to happen with money on it. The chop happens here instead.
+            //
+            // Only offered where it means something: a pot with at least two people
+            // who can win it. Not the uncalled row, which goes back to one player, and
+            // not the total.
+            if (chopWays >= 2) this.addChopControl(row, amount, chopWays);
         };
 
-        pots.forEach(pot => addRow(pot.label, pot.amount, pot.eligible.join(", ")));
+        pots.forEach(pot => addRow(pot.label, pot.amount, pot.eligible.join(", "), "", pot.eligible.length));
         returns.forEach(ret => addRow("Uncalled", ret.amount, `back to ${ret.id}`, "unevenPotReturn"));
 
         const total = players.reduce((sum, p) => sum + p.contribution, 0);

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

@@ -524,13 +524,41 @@ const Render = {
         this.updatePotBadge();
         this.renderSeatTotal(form, player);
         this.refreshPuck(index);
+        // The editor deliberately refreshes narrowly rather than redrawing everything —
+        // a full render on every keystroke would take the name field out from under the
+        // dealer mid-word. But the action bar answers "is there a table here at all",
+        // and seating somebody is exactly what changes that answer. Without this it
+        // stayed hidden until something else happened to redraw: two players seated, a
+        // dealable hand, and a blank bar until the page was reloaded.
+        //
+        // Safe to do on every keystroke: the bar is small, it's rebuilt on every action
+        // anyway, and nothing inside it can hold focus while the sidebar has it.
+        if (typeof ActionBar !== "undefined" && ActionBar.state) ActionBar.render();
     },
 
     wireSeatFields(form, player, index) {
         const nameInput = form.querySelector(".seatNameInput");
         nameInput.value = player.name;
         nameInput.addEventListener("input", () => {
+            // Putting a name on an empty chair is somebody sitting down, so they get
+            // dealt in. It used to be two separate acts, and the second one was easy to
+            // miss: a dealer setting up typed six names, got six seats that still
+            // weren't in the hand, and the action bar hid itself because by its reckoning
+            // nobody was playing. Six people at the table and a blank screen.
+            //
+            // Only for a chair that was empty — no name and not dealt in. Renaming
+            // somebody who is sitting out is a correction, not an arrival, and dealing
+            // them back in over a typo would be the tool overruling the dealer.
+            const wasEmpty = !player.name.trim() && !player.inHand;
             player.name = nameInput.value;
+            if (wasEmpty && player.name.trim()) {
+                player.inHand = true;
+                player.folded = false;
+                const inHandBox = form.querySelector(".inHandCheckbox");
+                if (inHandBox) inHandBox.checked = true;
+                const foldBox = form.querySelector(".foldCheckbox");
+                if (foldBox) { foldBox.checked = false; foldBox.disabled = false; }
+            }
             document.getElementById("seatEditorTitle").textContent = this.puckLabel(player, index);
             this.commitSeatChange(form, player, index);
         });
@@ -790,9 +818,15 @@ const Render = {
             netEl.classList.toggle("netUp", row.net > 0);
             netEl.classList.toggle("netDown", row.net < 0);
 
-            // What they'd actually be handed if the night ended now: chips in front of
-            // them less the cash they gave the banker. This was computed and written to
-            // the CSV all along, but never shown to the person doing the paying out.
+            // The cash to count out, which is a plain amount and never signed — this
+            // is the one the banker's hands follow. It sat only in the CSV: on screen
+            // the column headed "Cash out" held the difference against their buy-in
+            // instead, so a player up $140 on a $340 stack read as "$140" at the exact
+            // moment somebody was counting money onto the table.
+            node.querySelector(".standingsChips").textContent = Money.format(row.chipsInFront);
+
+            // And whether that leaves them up or down, which is the question the rest
+            // of the table asks and the one the old column was actually answering.
             const cashEl = node.querySelector(".standingsCashOut");
             cashEl.textContent = Money.formatSigned(row.cashPosition);
             cashEl.classList.toggle("netUp", row.cashPosition > 0);

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

@@ -86,6 +86,12 @@ const HoldemState = {
             // seating as it stands, because by then the people it needs to know about
             // are exactly the ones who have got up and gone.
             postedBlinds: null,
+            // Who last bet or raised, on this street and anywhere in the hand. Kept
+            // apart because the showdown rule needs both: normally the aggressor of the
+            // final betting round shows first, but a round nobody could bet in — chips
+            // already all-in — falls back to the last one who could.
+            streetAggressorIndex: null,
+            handAggressorIndex: null,
             // Player ids that were dealt in the last hand actually dealt. What makes a
             // seat recognisable as having *just* joined — new to the table, or back
             // from sitting out — which is the whole question behind owing a blind.
@@ -173,7 +179,8 @@ const HoldemState = {
             // them in rather than making the dealer reset a table mid-session.
             const defaults = this.createDefault();
             ["smallBlind", "bigBlind", "defaultStack", "street", "currentBet", "lastRaiseSize",
-                "actingSeatIndex", "blindOverride", "postedBlinds"]
+                "actingSeatIndex", "blindOverride", "postedBlinds",
+                "streetAggressorIndex", "handAggressorIndex"]
                 .forEach(key => {
                     if (parsed[key] === undefined) parsed[key] = defaults[key];
                 });
@@ -676,6 +683,14 @@ const HoldemState = {
                     net: Money.round(t.won - t.in),
                     boughtIn,
                     chipsNow,
+                    // Everything still theirs: the stack in front of them plus whatever
+                    // is out in the middle for the hand in progress. This is the number
+                    // a banker counts out when somebody leaves, and it was the one
+                    // figure the standings never showed — the column called "Cash out"
+                    // held the difference against their buy-in, so a player up $140 on
+                    // a $340 stack read as "$140" at the exact moment cash changed
+                    // hands.
+                    chipsInFront: Money.round(chipsNow + inFrontOfThem),
                     cashPosition: Money.round(chipsNow + inFrontOfThem - boughtIn),
                     notes,
                 };

tests/holdem/bankAudit.test.js

@@ -167,3 +167,58 @@ describe("does the cash box cover the chips on the table", () => {
         assert.equal(HoldemState.bankReconciliation(state).balanced, true);
     });
 });
+
+describe("the number the banker counts out", () => {
+    // The standings had two signed columns and neither was an amount to pay. A player
+    // up $140 on a $340 stack read "$140" under a heading saying "Cash out", at the
+    // exact moment somebody was counting money onto the table.
+    test("chips in front is what they are holding, not what they are up", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 340 });
+        state.seats[0].name = "Ann";
+        state.seats[0].buyIns = 200;
+        state.seats[1].buyIns = 200;
+        state.seats[1].stack = 60;
+
+        const rows = HoldemState.sessionStandings(state);
+        const ann = rows.find(r => r.name === "Ann");
+        assert.equal(ann.chipsInFront, 340, "the cash to count out");
+        assert.equal(ann.cashPosition, 140, "and separately, that they are up $140");
+    });
+
+    test("a player who is down still has chips to be handed", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 60 });
+        state.seats[0].name = "Cal";
+        state.seats.forEach(p => { p.buyIns = 200; });
+
+        const cal = HoldemState.sessionStandings(state).find(r => r.name === "Cal");
+        assert.equal(cal.chipsInFront, 60, "they leave with $60 of chips");
+        assert.equal(cal.cashPosition, -140, "having lost $140 of the $200 they brought");
+    });
+
+    test("chips still out in the middle are counted as theirs", () => {
+        // Cashing out mid-hand isn't a thing, but the panel is read mid-hand constantly
+        // and a stack that drops by the size of a bet looks like money going missing.
+        const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 200 });
+        state.seats[0].name = "Dee";
+        state.seats.forEach(p => { p.buyIns = 200; });
+        Betting.beginHand(state);
+        Betting.raiseTo(state, 0, 50);
+
+        const dee = HoldemState.sessionStandings(state).find(r => r.name === "Dee");
+        assert.equal(dee.chipsInFront, 200, "stack plus what's in the middle for them");
+        assert.equal(dee.cashPosition, 0, "so they are still level");
+    });
+
+    test("chips and up/down always differ by exactly the buy-in", () => {
+        const state = makeTable({ seatCount: 9, seated: [0, 1, 2, 3], stack: 100 });
+        [340, 150, 60, 250].forEach((chips, i) => {
+            state.seats[i].stack = chips;
+            state.seats[i].buyIns = 200 + i * 50;
+        });
+
+        HoldemState.sessionStandings(state).forEach(row => {
+            assert.equal(Money.round(row.chipsInFront - row.boughtIn), row.cashPosition,
+                `${row.name}'s two columns should tell one story`);
+        });
+    });
+});

tests/holdem/load.js

@@ -29,6 +29,10 @@ globalThis.Render = Render;
 const HoldemState = require(path.join(SRC, "state.js"));
 globalThis.HoldemState = HoldemState;
 
+// actionBar.js after state, since its own module-level code reaches for neither but
+// its methods reach for both. Loaded last so nothing it touches is still undefined.
+const ActionBar = load("actionBar");
+
 // ---- Table builders ----------------------------------------------------------
 
 // A table with `seatCount` chairs where `seated` (a list of seat indexes) are dealt
@@ -81,6 +85,7 @@ module.exports = {
     SettleUp,
     Betting,
     HoldemState,
+    ActionBar,
     makeTable,
     chipsOnTable,
     contributions,

tests/holdem/potRaise.test.js

@@ -0,0 +1,180 @@
+// What a pot-sized raise actually is.
+//
+// The raise pad worked it out as "the current bet plus the pot as it stands", which
+// leaves out the fact that the raiser calls first and their call is in the pot before
+// the raise is measured off it. Every quick amount came out short — pre-flop at 1/2 it
+// offered "Pot $5" where a pot raise is $7. Players say "pot" out loud meaning a
+// definite number, and a dealer tapping the button that claims to be it should record
+// what was actually said.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { Betting, Money, makeTable } = require("./load");
+
+describe("pre-flop at 1/2", () => {
+    const dealt = () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack: 200, dealerSeatIndex: 0 });
+        Betting.beginHand(state);
+        return state;
+    };
+
+    test("a pot raise from the first player to act is $7", () => {
+        // Call the $2, which makes the pot $5, then raise $5.
+        const state = dealt();
+        assert.equal(Betting.potSoFar(state), 3, "the blinds");
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex), 7);
+    });
+
+    test("half pot is $5 — $4.50 rounded up to something the chips can make", () => {
+        // The old arithmetic gave $3.50, which clamped up to the minimum and put the
+        // same $4 on two buttons side by side. The honest half-pot is $4.50, and the
+        // smallest chip in the default legend is a dollar, so the button would have
+        // offered an amount the dealer had to round themselves every single time.
+        const state = dealt();
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex, 0.5), 5);
+        assert.notEqual(Betting.potRaiseTo(state, state.actingSeatIndex, 0.5),
+            Betting.minRaiseTo(state), "the two quick buttons say different things");
+    });
+
+    test("the small blind owes less, so their pot raise is smaller", () => {
+        // They have $1 in already: call $1, pot becomes $4, raise $4, total $6.
+        const state = dealt();
+        const { sbIndex } = require("./load").HoldemState.getBlindSeats(state);
+        assert.equal(Betting.toCall(state, state.seats[sbIndex]), 1);
+        assert.equal(Betting.potRaiseTo(state, sbIndex), 6);
+    });
+
+    test("the big blind owes nothing, so it is just the pot", () => {
+        const state = dealt();
+        const { bbIndex } = require("./load").HoldemState.getBlindSeats(state);
+        assert.equal(Betting.toCall(state, state.seats[bbIndex]), 0);
+        assert.equal(Betting.potRaiseTo(state, bbIndex), 5, "the $2 bet plus the $3 pot");
+    });
+});
+
+describe("after the flop", () => {
+    const flopWithBet = () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 500, dealerSeatIndex: 0 });
+        Betting.beginHand(state);
+        while (state.actingSeatIndex !== null) Betting.call(state, state.actingSeatIndex);
+        Betting.closeStreet(state);
+        return state;
+    };
+
+    test("a pot raise facing a bet is three times the bet plus the dead money", () => {
+        const state = flopWithBet();
+        const potBefore = Betting.potSoFar(state);         // $6 carried over
+        const bettor = state.actingSeatIndex;
+        Betting.raiseTo(state, bettor, 10);
+
+        const raiser = state.actingSeatIndex;
+        // Call $10, pot becomes $26, raise $26 → $36. Which is 3×10 + 6.
+        assert.equal(Betting.potRaiseTo(state, raiser), 36);
+        assert.equal(Betting.potRaiseTo(state, raiser), 3 * 10 + potBefore);
+    });
+
+    test("half pot facing that bet is $23", () => {
+        const state = flopWithBet();
+        Betting.raiseTo(state, state.actingSeatIndex, 10);
+        // Call $10, pot becomes $26, raise $13 → $23.
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex, 0.5), 23);
+    });
+
+    test("facing no bet at all it is a plain pot-sized bet", () => {
+        const state = flopWithBet();
+        assert.equal(state.currentBet, 0, "nobody has bet the flop");
+        assert.equal(Betting.toCall(state, state.seats[state.actingSeatIndex]), 0);
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex), Betting.potSoFar(state));
+    });
+});
+
+describe("it stays sane at the edges", () => {
+    test("a seat that doesn't exist gets zero rather than throwing", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+        assert.equal(Betting.potRaiseTo(state, 99), 0);
+    });
+
+    test("the amount is always at least a call", () => {
+        // A raise-to below the current bet would be nonsense to offer. Every fraction
+        // from a tenth up lands at or above what the player owes.
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack: 200 });
+        Betting.beginHand(state);
+        const index = state.actingSeatIndex;
+        [0.1, 0.25, 0.5, 0.75, 1].forEach(fraction => {
+            assert.ok(Betting.potRaiseTo(state, index, fraction) >= state.currentBet,
+                `${fraction} of the pot should still cover the bet`);
+        });
+    });
+
+    test("cent-sized blinds don't drift", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 20, smallBlind: 0.05, bigBlind: 0.1 });
+        Betting.beginHand(state);
+        // Pot $0.15, owes $0.10: call to $0.25, raise $0.25 → $0.35.
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex), 0.35);
+    });
+});
+
+describe("the amounts are ones the table can actually build", () => {
+    const CENTS = [{ value: 0.25 }, { value: 0.05 }, { value: 0.01 }];
+    const DOLLARS = [{ value: 1 }, { value: 5 }, { value: 25 }, { value: 100 }];
+
+    const table = (legend, smallBlind, bigBlind, stack = 200) => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack, smallBlind, bigBlind });
+        state.chipLegend = legend;
+        Betting.beginHand(state);
+        return state;
+    };
+
+    test("a half-pot that lands on a half chip is rounded up, not offered as it is", () => {
+        const state = table(DOLLARS, 1, 2);
+        // Honestly $4.50. No dollar chip makes fifty cents.
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex, 0.5), 5);
+        assert.equal(Money.chipBreakdown(5, DOLLARS).remainder, 0);
+    });
+
+    test("up rather than down — a shaved pot bet is not a pot bet", () => {
+        const state = table(DOLLARS, 1, 2);
+        assert.ok(Betting.potRaiseTo(state, state.actingSeatIndex, 0.5) > 4.5);
+    });
+
+    test("an amount the chips already make is left exactly alone", () => {
+        const state = table(DOLLARS, 1, 2);
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex), 7, "the pot raise was already whole");
+    });
+
+    test("a cent table keeps its cents", () => {
+        const state = table(CENTS, 0.05, 0.1);
+        // Pot $0.15, owes $0.10: call to $0.25, raise $0.25 → $0.35, which cent chips make.
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex), 0.35);
+        assert.equal(Money.chipBreakdown(0.35, CENTS).remainder, 0);
+    });
+
+    test("a legend that plainly isn't for these stakes is not applied", () => {
+        // Dollar chips on a 5c/10c game means somebody never filled the legend in.
+        // Rounding those blinds up to whole dollars would be the tool doing real
+        // damage on the strength of a stale field, so the amounts stay exact and the
+        // wrong legend stays visible.
+        const state = table(DOLLARS, 0.05, 0.1);
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex), 0.35);
+    });
+
+    test("a table with no legend at all gets exact amounts", () => {
+        const state = table([], 1, 2);
+        assert.equal(Betting.potRaiseTo(state, state.actingSeatIndex, 0.5), 4.5);
+    });
+
+    test("every fraction comes out buildable, and never shaved", () => {
+        const state = table(DOLLARS, 1, 2);
+        const index = state.actingSeatIndex;
+        const potAfterCall = Betting.potSoFar(state) + Betting.toCall(state, state.seats[index]);
+
+        [0.1, 0.25, 0.5, 0.75, 1].forEach(fraction => {
+            const value = Betting.potRaiseTo(state, index, fraction);
+            const exact = state.currentBet + potAfterCall * fraction;
+            assert.ok(value >= exact, `${fraction} of the pot should never be rounded down`);
+            assert.ok(value - exact < 1, `${fraction} of the pot should round by less than a chip`);
+            assert.equal(Money.chipBreakdown(value, DOLLARS).remainder, 0,
+                `${fraction} of the pot should be buildable from the table's chips`);
+        });
+    });
+});

tests/holdem/seatingTheTable.test.js

@@ -0,0 +1,181 @@
+// Sitting people down, which is the first thing anybody does with the tool.
+//
+// Naming a chair and dealing that chair in were two separate acts and the second was
+// easy to miss. A dealer setting up typed six names, got six seats that still weren't
+// in the hand, and the action bar hid itself because by its reckoning nobody was
+// playing: six people at the table and a blank screen with no way forward.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { HoldemState, Betting, ActionBar, makeTable } = require("./load");
+
+const emptyTable = (seatCount = 10) => {
+    const state = HoldemState.createDefault();
+    HoldemState.resizeSeats(state, seatCount);
+    return state;
+};
+
+const bar = state => Object.assign(Object.create(ActionBar), { state });
+
+describe("the bar knows the difference between an empty table and a named one", () => {
+    test("a table nobody has touched gets no bar", () => {
+        assert.equal(bar(emptyTable()).isRunning(), false, "an empty felt stays uncluttered");
+    });
+
+    test("a table with names on it gets one, dealt in or not", () => {
+        const state = emptyTable();
+        state.seats[0].name = "Ann";
+        state.seats[1].name = "Ben";
+
+        assert.equal(Betting.liveSeats(state).length, 0, "nobody is in the hand");
+        assert.equal(bar(state).isRunning(), true, "but there are people at the table to say something to");
+    });
+
+    test("whitespace isn't a player", () => {
+        const state = emptyTable();
+        state.seats[0].name = "   ";
+        assert.equal(bar(state).isRunning(), false);
+    });
+
+    test("a table that is playing still gets one", () => {
+        assert.equal(bar(makeTable({ seatCount: 6, seated: [0, 1] })).isRunning(), true);
+    });
+});
+
+describe("naming an empty chair sits somebody down", () => {
+    // What the seat editor's name field does, as the rule it applies rather than
+    // through the DOM: a chair with no name and nobody in it is empty, and putting a
+    // name on it is somebody arriving.
+    const nameSeat = (player, name) => {
+        const wasEmpty = !player.name.trim() && !player.inHand;
+        player.name = name;
+        if (wasEmpty && player.name.trim()) { player.inHand = true; player.folded = false; }
+    };
+
+    test("an empty chair gets dealt in", () => {
+        const state = emptyTable();
+        nameSeat(state.seats[0], "Ann");
+        assert.equal(state.seats[0].inHand, true);
+        assert.equal(state.seats[0].folded, false);
+    });
+
+    test("six names is six players, not six benched seats", () => {
+        const state = emptyTable();
+        state.defaultStack = 200;    // a table that has told the tool what a buy-in is
+        ["Ann", "Ben", "Cal", "Dee", "Eve", "Fay"].forEach((name, i) => nameSeat(state.seats[i], name));
+
+        assert.equal(state.seats.filter(p => p.inHand).length, 6);
+        assert.equal(bar(state).isRunning(), true);
+        assert.ok(Betting.blindPreview(state), "and there's a hand to deal");
+    });
+
+    test("renaming somebody who is sitting out doesn't deal them back in", () => {
+        // A correction, not an arrival. Dealing them in over a typo would be the tool
+        // overruling a dealer who sat them out on purpose.
+        const state = emptyTable();
+        state.seats[0].name = "Ann";
+        state.seats[0].inHand = false;
+
+        nameSeat(state.seats[0], "Anne");
+        assert.equal(state.seats[0].inHand, false, "still sitting out, now spelled right");
+    });
+
+    test("clearing a name doesn't sit anybody down", () => {
+        const state = emptyTable();
+        nameSeat(state.seats[0], "Ann");
+        nameSeat(state.seats[0], "");
+        assert.equal(state.seats[0].name, "");
+    });
+
+    test("a chair already in the hand is left alone", () => {
+        const state = makeTable({ seatCount: 6, seated: [0] });
+        state.seats[0].folded = true;
+        nameSeat(state.seats[0], "Ann");
+        assert.equal(state.seats[0].folded, true, "mid-hand a fold is not undone by typing");
+    });
+});
+
+describe("the way back from a table where everybody is sat out", () => {
+    test("there are named seats to offer", () => {
+        // Can't be reached by naming any more, but a table where everyone was sat out
+        // — or a save from before naming seated people — still lands here.
+        const state = emptyTable();
+        ["Ann", "Ben", "Cal"].forEach((name, i) => { state.seats[i].name = name; });
+
+        const benched = state.seats
+            .map((player, index) => ({ player, index }))
+            .filter(({ player }) => (player.name || "").trim() && !player.inHand)
+            .map(({ index }) => index);
+
+        assert.deepEqual(benched, [0, 1, 2]);
+        assert.equal(Betting.blindPreview(state), null, "no hand to deal until they're in");
+    });
+
+    test("dealing them all in makes a hand possible", () => {
+        const state = emptyTable();
+        ["Ann", "Ben", "Cal"].forEach((name, i) => { state.seats[i].name = name; state.seats[i].stack = 100; });
+
+        state.seats.forEach(player => {
+            if ((player.name || "").trim()) { player.inHand = true; player.folded = false; }
+        });
+
+        assert.equal(Betting.liveSeats(state).length, 3);
+        assert.ok(Betting.blindPreview(state), "the table can be dealt");
+    });
+
+    test("an unnamed chair is never swept in by it", () => {
+        const state = emptyTable();
+        state.seats[0].name = "Ann";
+        state.seats.forEach(player => {
+            if ((player.name || "").trim()) { player.inHand = true; }
+        });
+        assert.equal(state.seats.filter(p => p.inHand).length, 1, "empty chairs stay empty");
+    });
+});
+
+describe("a table where nobody has bought in", () => {
+    // Different from a table that has busted out, and the difference is the whole
+    // point: one needs a starting stack named, the other needs a rebuy. Telling a
+    // dealer their brand-new players have "no chips left" sends them hunting for the
+    // wrong thing.
+    const neverBoughtIn = state => state.seats.every(p =>
+        !(Number(p.buyIns) > 0) && !(Number(p.stack) > 0));
+
+    test("six freshly named players have never bought in", () => {
+        const state = emptyTable();
+        ["Ann", "Ben", "Cal", "Dee", "Eve", "Fay"].forEach((name, i) => {
+            state.seats[i].name = name;
+            state.seats[i].inHand = true;
+        });
+
+        assert.equal(neverBoughtIn(state), true);
+        assert.equal(Betting.blindPreview(state), null, "and there is no hand to deal");
+    });
+
+    test("a table that has busted out is not the same thing", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 200 });
+        state.seats.forEach(p => { p.buyIns = 200; p.stack = 0; });
+
+        assert.equal(neverBoughtIn(state), false, "they had chips — they lost them");
+    });
+
+    test("one player still holding chips is not a never-bought-in table either", () => {
+        const state = emptyTable();
+        ["Ann", "Ben"].forEach((name, i) => { state.seats[i].name = name; state.seats[i].inHand = true; });
+        state.seats[0].stack = 50;
+
+        assert.equal(neverBoughtIn(state), false);
+    });
+
+    test("naming a starting stack is enough to deal", () => {
+        // The one field the message now points at. A seat with no stack of its own
+        // falls back to the table default, so setting it seats everybody's chips at
+        // once — which is why it's the right thing to send the dealer to.
+        const state = emptyTable();
+        ["Ann", "Ben", "Cal"].forEach((name, i) => { state.seats[i].name = name; state.seats[i].inHand = true; });
+        assert.equal(Betting.blindPreview(state), null);
+
+        state.defaultStack = 200;
+        assert.ok(Betting.blindPreview(state), "one number and the table can play");
+    });
+});

tests/holdem/showdownOrder.test.js

@@ -0,0 +1,202 @@
+// Who turns their hand over first.
+//
+// A call the dealer makes at every showdown that isn't a fold, and one nobody at the
+// table volunteers for — everyone would rather see a hand than show one. The tool knew
+// who last raised and who sits left of the button and said neither.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { HoldemState, Betting, makeTable } = require("./load");
+
+const NAMES = ["Ann", "Ben", "Cal", "Dee"];
+const table = (dealerSeatIndex = 0, stack = 200) => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack, dealerSeatIndex });
+    NAMES.forEach((name, i) => { state.seats[i].name = name; });
+    Betting.beginHand(state);
+    return state;
+};
+
+const call = state => {
+    const answer = Betting.showdownOrder(state);
+    return answer && { who: state.seats[answer.index].name, reason: answer.reason };
+};
+
+// Everybody left just calls whatever is in front of them, then the street closes.
+const checkRound = state => {
+    let guard = 0;
+    while (state.actingSeatIndex !== null && guard++ < 12) {
+        const index = state.actingSeatIndex;
+        if (Betting.toCall(state, state.seats[index]) > 0) Betting.call(state, index);
+        else Betting.check(state, index);
+    }
+    Betting.closeStreet(state);
+};
+
+describe("a bet on the river", () => {
+    test("the last player to raise shows first", () => {
+        const state = table(0);                 // blinds Ben and Cal
+        checkRound(state);                      // pre-flop
+        checkRound(state);                      // flop
+        checkRound(state);                      // turn
+
+        Betting.raiseTo(state, state.actingSeatIndex, 20);
+        const raiser = state.seats.findIndex(p => Betting.committed(p) === 20);
+        while (state.actingSeatIndex !== null) Betting.call(state, state.actingSeatIndex);
+
+        assert.deepEqual(call(state), { who: state.seats[raiser].name, reason: "aggressor" });
+    });
+
+    test("a re-raise moves it to the last one, not the first", () => {
+        const state = table(0);
+        checkRound(state); checkRound(state); checkRound(state);
+
+        const first = state.actingSeatIndex;
+        Betting.raiseTo(state, first, 20);
+        const second = state.actingSeatIndex;
+        Betting.raiseTo(state, second, 60);
+        while (state.actingSeatIndex !== null) {
+            const i = state.actingSeatIndex;
+            if (Betting.toCall(state, state.seats[i]) > 0) Betting.call(state, i); else Betting.check(state, i);
+        }
+
+        assert.equal(call(state).who, state.seats[second].name);
+    });
+
+    test("a short all-in still shows first, even though it doesn't reopen the betting", () => {
+        // The rule about reopening is about who may raise. It says nothing about who
+        // shows, and the player who shoved is still the last one who put money in.
+        const state = table(0);
+        checkRound(state); checkRound(state); checkRound(state);
+
+        const bettor = state.actingSeatIndex;
+        Betting.raiseTo(state, bettor, 40);
+        const shortStack = state.actingSeatIndex;
+        // Over the $40 but only by $15, where a full raise would need $40 more. Going
+        // *under* the bet would be a short call, not a short raise, and wouldn't make
+        // them the aggressor at all.
+        state.seats[shortStack].stack = 55;
+        Betting.allIn(state, shortStack);
+        assert.equal(Betting.committed(state.seats[shortStack]), 55, "raised, if not by enough");
+        while (state.actingSeatIndex !== null) {
+            const i = state.actingSeatIndex;
+            if (Betting.toCall(state, state.seats[i]) > 0) Betting.call(state, i); else Betting.check(state, i);
+        }
+
+        assert.equal(call(state).who, state.seats[shortStack].name);
+    });
+});
+
+describe("a river checked through", () => {
+    test("the first live player left of the button shows first", () => {
+        const state = table(0);                 // button Ann
+        checkRound(state); checkRound(state); checkRound(state); checkRound(state);
+
+        assert.deepEqual(call(state), { who: "Ben", reason: "leftOfButton" });
+    });
+
+    test("an earlier street's raiser doesn't carry over to the river", () => {
+        // The rule is about the *final* round. Leading the flop and then checking the
+        // river doesn't oblige anyone.
+        const state = table(0);
+        checkRound(state);                      // pre-flop
+        Betting.raiseTo(state, state.actingSeatIndex, 20);   // leads the flop
+        while (state.actingSeatIndex !== null) Betting.call(state, state.actingSeatIndex);
+        Betting.closeStreet(state);
+        checkRound(state);                      // turn
+        checkRound(state);                      // river
+
+        assert.equal(call(state).reason, "leftOfButton");
+    });
+
+    test("it skips a folded seat rather than naming somebody who isn't in the hand", () => {
+        const state = table(0);                 // button Ann, so Ben would be first
+        checkRound(state); checkRound(state); checkRound(state);
+        Betting.fold(state, 1);                 // Ben gets out on the river
+        while (state.actingSeatIndex !== null) {
+            const i = state.actingSeatIndex;
+            if (Betting.toCall(state, state.seats[i]) > 0) Betting.call(state, i); else Betting.check(state, i);
+        }
+        Betting.closeStreet(state);
+
+        assert.equal(call(state).who, "Cal", "the next one round who is still in");
+    });
+});
+
+describe("everyone all-in before the river", () => {
+    test("the last player who could put money in shows first", () => {
+        // There was no final round to lead, so "checked round" isn't a choice anybody
+        // made and the seat left of the button hasn't earned the obligation.
+        const state = table(0, 30);
+        checkRound(state);                      // pre-flop
+
+        const shover = state.actingSeatIndex;
+        Betting.allIn(state, shover);
+        while (state.actingSeatIndex !== null) Betting.call(state, state.actingSeatIndex);
+        Betting.closeStreet(state);
+
+        assert.equal(Betting.canStillBet(state), false, "nobody has chips left to bet");
+        assert.deepEqual(call(state), { who: state.seats[shover].name, reason: "allInAggressor" });
+    });
+
+    test("a hand where everyone got in for the blind and nobody raised falls to the button", () => {
+        // Two-dollar stacks against a two-dollar blind: everyone is all-in by calling,
+        // and calling is not aggression. Nobody chose to lead, so nobody is on the hook
+        // and it goes back to the seat left of the button.
+        const state = table(0, 2);
+        checkRound(state);
+
+        assert.equal(Betting.canStillBet(state), false, "nobody has a chip behind");
+        assert.equal(state.handAggressorIndex, null, "and nobody ever raised");
+        const answer = call(state);
+        assert.ok(answer, "there is still a showdown to order");
+        assert.equal(answer.reason, "leftOfButton");
+    });
+});
+
+describe("when there is nothing to call", () => {
+    test("one player left isn't a showdown", () => {
+        const state = table(0);
+        [1, 2, 3].forEach(i => Betting.fold(state, i));
+        assert.equal(Betting.showdownOrder(state), null);
+    });
+
+    test("an aggressor who has since folded doesn't get named", () => {
+        // Can't happen in play — you don't fold after raising unopposed — but the
+        // index is a number on the state and a reset table could hold a stale one.
+        const state = table(0);
+        checkRound(state); checkRound(state); checkRound(state); checkRound(state);
+        state.streetAggressorIndex = 1;
+        state.seats[1].folded = true;
+
+        const answer = call(state);
+        assert.notEqual(answer.who, "Ben");
+        assert.equal(answer.reason, "leftOfButton");
+    });
+
+    test("an index pointing at no seat at all is ignored", () => {
+        const state = table(0);
+        checkRound(state); checkRound(state); checkRound(state); checkRound(state);
+        state.streetAggressorIndex = 99;
+        assert.equal(call(state).reason, "leftOfButton");
+    });
+});
+
+describe("the tracking resets when it should", () => {
+    test("a new hand starts with nobody on the hook", () => {
+        const state = table(0);
+        checkRound(state); checkRound(state); checkRound(state);
+        Betting.raiseTo(state, state.actingSeatIndex, 20);
+        assert.notEqual(state.handAggressorIndex, null);
+
+        HoldemState.startNextHand(state);
+        Betting.beginHand(state);
+        assert.equal(state.streetAggressorIndex, null);
+        assert.equal(state.handAggressorIndex, null, "last night's raise isn't this hand's business");
+    });
+
+    test("posting a blind is not aggression", () => {
+        const state = table(0);
+        assert.equal(state.streetAggressorIndex, null);
+        assert.equal(state.handAggressorIndex, null);
+    });
+});