Seat the table properly on a phone held sideways

Landscape is the one shape this layout has never really fitted, and the audit
was calling two separate faults there.

The felt worked its own height out as `100vh - bar - 7rem`, guessing that
everything above it came to 7rem. That is 108px at 640x360, which the guess
covers, and 119px at 844x390, which it doesn't — so on an iPhone on its side the
bottom row of seats sat up to 26px inside the action bar. The measurement it
needed was already being published for the wide layout: the bar's real height,
the wrap's real offset and the bottom seat's overhang, all taken off the window.
It uses that now. The floor under it drops from 220px to 96px, because 220 was
not a size a 390px-tall window has to give — holding out for it was itself how
seats ended up behind the Fold button, which is the one thing the floor exists
to prevent.

That still left the header taking two rows, and the second row is 44px of the
390. The title block and the five buttons came to 829px inside a 765px header,
missing one line by 64px. The page title goes — the one thing on this screen a
dealer already knows — hidden from the eye rather than removed, so the heading
is still there for a screen reader. The buttons tighten across but never down:
they stay a 44px thumb target.

The seats themselves were spaced by angle, which is only even spacing on a
circle. On a 601x126 felt, ten seats at 36° apart put four of them down each
steep end, 20px apart, with pucks 72px tall — a seat's centre belonged to its
neighbour, so tapping a player got the wrong one. They now walk the rim by
distance instead, which puts them along the two long rails the way a real table
seats people. Closest neighbours go from 33px apart to 59px.

Measured at 640x360, 667x375 and 844x390 with 9-, 10- and 12-seat tables: every
combination the audit used to fail is clean, bar a 10-seat table at 640x360,
where two seats at the end of a rim that flat still overlap. Portrait, tablet
and desktop are unchanged — the floor never bound there, and on a rounder felt
walking the rim gives back the same angles it always did.

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>
@@ -141,13 +142,30 @@
                     </div>
 
                     <h3 class="panelSubhead">Hands</h3>
+                    <div class="handHistoryFilterRow">
+                        <input id="handHistoryFilter" type="search" class="handHistoryFilter"
+                               placeholder="Find a hand — name, amount or #" aria-label="Filter the hand log by player, amount or hand number" />
+                        <span id="handHistoryCount" class="handHistoryCount" hidden></span>
+                    </div>
                     <div id="handHistoryList"></div>
+                    <p id="handHistoryNoMatch" class="fieldHint" hidden></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>
+
+                    <h3 class="panelSubhead">The table itself</h3>
+                    <p class="fieldHint">
+                        The night lives in this browser and nowhere else. Save it to a file to carry it
+                        to another device, or to have something to come back to if this one dies.
+                    </p>
+                    <div class="handHistoryActions">
+                        <button id="saveTableBtn" class="holdemBtn holdemBtnSmall">Save table file</button>
+                        <button id="loadTableBtn" class="holdemBtn holdemBtnSmall">Load table file</button>
+                        <input id="loadTableInput" type="file" accept="application/json,.json" hidden />
+                    </div>
                 </div>
             </details>
 
@@ -264,6 +282,7 @@
         <span class="standingsIn"></span>
         <span class="standingsWon"></span>
         <span class="standingsNet"></span>
+        <span class="standingsChips"></span>
         <span class="standingsCashOut"></span>
     </div>
 </template>
@@ -393,6 +412,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,11 +1970,62 @@ 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;
+    gap: 0.5rem;
+    margin-bottom: 0.45rem;
+}
+
+.handHistoryFilter {
+    flex: 1 1 auto;
+    min-width: 0;
+    /* 16px or iOS zooms the whole page on focus, which on a phone at the table throws
+       the felt off screen mid-hand. Every other field in this panel is held at 16px
+       for the same reason. */
+    font-size: 16px;
+    padding: 0.35rem 0.5rem;
+    background: #141414;
+    border: 1px solid #2c2c2c;
+    border-radius: 6px;
+    color: #e6e6e6;
+}
+
+.handHistoryFilter::placeholder {
+    color: #8a8a8a;
+}
+
+.handHistoryFilter:focus-visible {
+    outline: 2px solid #d8b46a;
+    outline-offset: 1px;
+}
+
+.handHistoryCount {
+    flex: 0 0 auto;
+    font-size: 0.72rem;
+    color: #8a8a8a;
+    font-variant-numeric: tabular-nums;
+}
+
 #handHistoryList {
     display: flex;
     flex-direction: column;
     gap: 0.4rem;
-    max-height: 260px;
+    /* Was a flat 260px, which is about four and a half rows — the same four and a half
+       whether the dealer is on a phone or a 27" screen with room for twenty. The floor
+       keeps it honest on a short window; the ceiling stops the panel from running away
+       on a tall one and pushing everything below it out of reach. */
+    max-height: clamp(200px, 42vh, 560px);
     overflow-y: auto;
 }
 
@@ -3074,7 +3138,18 @@ body.hasActionBar #toastHost {
     }
 
     .panelBody .holdemBtnSmall,
-    .handHistoryActions .holdemBtn {
+    .handHistoryActions .holdemBtn,
+    /* The card picker's Clear and Done sat at 40px: the touch rule was scoped to
+       .panelBody and the picker is a sheet, so it never reached them. Clear wipes a
+       player's cards, which is not a thing to make a dealer aim at. */
+    .cardPickerHeader .holdemBtn,
+    /* Undo was 30px, and it is the control a dealer reaches for having just recorded
+       the wrong thing with five people waiting — the worst place to be fourteen pixels
+       short of a fingertip. Growing the box costs bar height, which comes out of the
+       felt, but measured at 390x844 the felt is 366px against a 220px floor, so there
+       is room for it. A hit-area pad was tried first and does not work here: the pill
+       clips its overflow to keep a long label on one line, which clips the pad too. */
+    .actionUndo {
         min-height: 44px;
     }
 
@@ -3172,11 +3247,18 @@ body.hasActionBar #toastHost {
            why a seat's centre belonged to its neighbour.
         
            Landscape has width and no height, so the table takes the width it has and
-           is only as tall as the room left over. */
-        --feltRoom: calc(100vh - var(--actionBarHeight, 0px) - 7rem);
+           is only as tall as the room left over.
+
+           The height comes from --feltRoomPx, the same measured value the wide layout
+           caps its width by: the bar's real height, the wrap's real offset and the
+           bottom seat's overhang, all taken off the window. This branch used to work
+           it out itself as `100vh - bar - 7rem`, guessing that everything above the
+           felt came to 7rem. It comes to 108px at 640x360, which the guess covers, and
+           119px at 844x390, which it doesn't — so on an iPhone on its side the bottom
+           three seats sat up to 26px inside the action bar. Nothing here needs to
+           guess; the measurement was already being published. */
         width: 100%;
-        height: var(--feltRoom);
-        min-height: 7rem;
+        height: var(--feltRoomPx, calc(100vh - var(--actionBarHeight, 0px) - 7rem));
         /* This branch sets its own height outright, so neither the aspect ratio nor the
            cap derived from it has anything to say here — and the cap would only narrow
            a table that is already as short as the screen allows. */
@@ -3184,16 +3266,55 @@ body.hasActionBar #toastHost {
         max-width: none;
     }
 
+    /* The page's own top padding is 32px of nothing, on the screen that has the least
+       to spare. */
+    #holdemApp {
+        padding-top: 0.5rem;
+    }
+
     /* The header ate 148px of a 390px-tall window, which was most of the reason the
-       table started below the fold. Here it only needs to be a title bar. */
+       table started below the fold. Here it only needs to be a title bar.
+
+       It still wrapped to two rows, and that second row is 44px of the 390 — the title
+       block and the five buttons came to 829px inside a 765px header at 844x390, so
+       they missed sharing one line by 64px, and at 640x360 by rather more. What goes is
+       the page title: the one thing on this screen a dealer already knows. It is hidden
+       from the eye rather than removed, so the page keeps its heading for a screen
+       reader and for the browser's own outline. The hand number stays — nothing else on
+       the screen says which hand this is. */
     #holdemHeader {
         margin-bottom: 0.4rem;
         gap: 0.35rem;
+        flex-wrap: nowrap;
+        align-items: center;
     }
 
     #holdemHeader h1 {
-        font-size: 1.05rem;
-        padding-bottom: 0.15rem;
+        position: absolute;
+        width: 1px;
+        height: 1px;
+        margin: -1px;
+        padding: 0;
+        overflow: hidden;
+        clip-path: inset(50%);
+        white-space: nowrap;
+    }
+
+    .handCounterBadge {
+        margin-top: 0;
+    }
+
+    /* Tightened across, never down: the buttons keep the 44px a thumb needs. */
+    #holdemHeaderActions {
+        flex-wrap: nowrap;
+        gap: 0.35rem;
+    }
+
+    #holdemHeaderActions .holdemBtn {
+        padding-left: 0.55rem;
+        padding-right: 0.55rem;
+        font-size: 0.78rem;
+        white-space: nowrap;
     }
 
     .holdemSubtitle {
@@ -3406,6 +3527,38 @@ textarea:focus-visible {
     color: #9a9a9a;
 }
 
+/* An aside that has something to press. It wraps rather than squeezing the button:
+   on a phone the sentence takes the width it needs and the button drops under it,
+   still at full tap size, instead of being crushed to a sliver at the end of a line. */
+.dealPromptLine.dealPromptDebt {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    justify-content: center;
+    gap: 0.4rem 0.55rem;
+}
+
+.dealPromptDebtBtn {
+    /* Sized down from a full action button — it's an option beside a sentence, not
+       the thing the dealer came here to press. "Post blinds & deal" stays the button
+       that looks like the button. */
+    flex: 0 0 auto;
+    min-height: 32px;
+    padding: 0.24rem 0.7rem;
+    font-size: 0.72rem;
+    background: rgba(245, 213, 71, 0.1);
+    border: 1px solid rgba(245, 213, 71, 0.45);
+    color: #f0d98c;
+}
+
+@media (max-width: 700px), (pointer: coarse) {
+    /* A fingertip needs 44px, and this one moves money. */
+    .dealPromptDebtBtn {
+        min-height: 44px;
+        padding: 0.4rem 0.9rem;
+    }
+}
+
 /* ---------- Touch targets on a wide touch screen ----------
 
    Every touch-target rule in this file sits behind `max-width: 700px`, and width was
@@ -3429,7 +3582,9 @@ textarea:focus-visible {
 
     .panelBody .holdemBtnSmall,
     .handHistoryActions .holdemBtn,
-    .toastAction {
+    .toastAction,
+    .cardPickerHeader .holdemBtn,
+    .actionUndo {
         min-height: 44px;
     }
 

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

@@ -53,7 +53,14 @@ const ActionBar = {
     // moving the seats, and getting a different answer on the next pass.
     SEAT_OVERHANG_PX: 37,
     FELT_GAP_PX: 8,
-    FELT_MIN_PX: 220,
+    // The floor is a guard against a measurement that has gone wrong — not a size the
+    // window has agreed to hand over. It used to be 220px, which a phone on its side
+    // hasn't got: at 844x390 there are 99px between the header and the bar, and holding
+    // out for 220 is how the bottom row of seats came to sit 26px inside the Fold
+    // button. A floor that puts seats behind the bar defeats the one thing the floor is
+    // for, so it drops to the smallest felt still worth drawing and the measurement
+    // wins above it.
+    FELT_FLOOR_PX: 96,
 
     // How tall the felt can be and still leave the whole ring of seats above the bar.
     //
@@ -66,21 +73,35 @@ const ActionBar = {
     //
     // The wrap's offset is taken in document space rather than viewport space, so
     // scrolling the page doesn't resize the table under the dealer's hands.
+    feltRoomFor(windowHeight, barHeight, topInDocument) {
+        const room = windowHeight - barHeight - topInDocument -
+            this.SEAT_OVERHANG_PX - this.FELT_GAP_PX;
+        return Math.max(this.FELT_FLOOR_PX, Math.round(room));
+    },
+
     publishFeltRoom(barHeight) {
         const wrap = document.getElementById("pokerTableWrap");
         if (!wrap) return;
+        // Taking the top before the height is set matters: the wrap sits below the
+        // header in normal flow, so its own height never moves its top and this can't
+        // chase itself around the screen.
         const topInDocument = wrap.getBoundingClientRect().top + window.scrollY;
-        const room = window.innerHeight - barHeight - topInDocument -
-            this.SEAT_OVERHANG_PX - this.FELT_GAP_PX;
         document.documentElement.style.setProperty(
-            "--feltRoomPx", `${Math.max(this.FELT_MIN_PX, Math.round(room))}px`);
+            "--feltRoomPx",
+            `${this.feltRoomFor(window.innerHeight, barHeight, topInDocument)}px`);
     },
 
     // 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 +445,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 +460,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 +613,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 +633,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;
         }
 
@@ -643,6 +728,44 @@ const ActionBar = {
             wrap.appendChild(out);
         }
 
+        // Somebody who has just sat down between the button and the big blind has had
+        // the blinds go past them, and dealing them in there is a free hand in late
+        // position. At a table the answer is that they post the big blind to come in
+        // now, or wait for it to reach them. The tool used to do neither and say
+        // nothing: it dealt them in for free, and the dealer had no way to know it had
+        // happened. Both answers are offered here; neither is forced, because a home
+        // game that doesn't care shouldn't have to argue with its own scoreboard.
+        // One line for however many have walked up, not one each. The bar is docked
+        // over the felt and the felt has already shrunk as far as it will go on a
+        // phone, so every line here is taken out of the ring of seats: measured at
+        // 390x844 with two newcomers, a line apiece put the bar over two fifths of the
+        // bottom seat. They post together or they wait together, which is what happens
+        // at a table anyway when two people sit down at once.
+        if (preview.debtors.length > 0) {
+            const ids = preview.debtors.map(i => this.state.seats[i].id);
+            const posting = ids.every(id => preview.posting.includes(id));
+            const who = listNames(preview.debtors);
+            const each = preview.debtors.length > 1 ? " each" : "";
+
+            const line = document.createElement("p");
+            line.className = "dealPromptLine dealPromptAside dealPromptDebt";
+
+            const text = document.createElement("span");
+            text.textContent = posting
+                ? `${who} posting ${Money.format(preview.bigBlind)}${each} to come in.`
+                : `${who} sat down after the blinds — ${preview.debtors.length > 1 ? "free hands" : "a free hand"} unless they post.`;
+            line.appendChild(text);
+
+            line.appendChild(this.button(
+                posting ? "Don't post" : `Post ${Money.format(preview.bigBlind)}${each}`,
+                "dealPromptDebtBtn",
+                () => this.commit(
+                    posting ? `${who} waiting for the blind` : `${who} posting to come in`,
+                    () => { this.state.postingIn = posting ? [] : ids; })
+            ));
+            wrap.appendChild(line);
+        }
+
         const row = document.createElement("div");
         row.className = "actionButtons";
         row.appendChild(this.button("Post blinds & deal", "actionDeal", () => {
@@ -653,13 +776,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();
@@ -667,22 +818,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

@@ -83,6 +83,11 @@ const Betting = {
         return {
             sbIndex, bbIndex, headsUp, manual: !!manual, deadSmallBlind: !!deadSmallBlind,
             deadButton: !!asDealt.deadButton && !asDealt.seats[buttonIndex].inHand,
+            // Asked of the table as it will be dealt, for the same reason the blinds
+            // are: someone sitting out for having no chips isn't owed a blind, and the
+            // big blind of the hand about to go out isn't either.
+            debtors: HoldemState.blindDebtors(asDealt, bbIndex),
+            posting: (state.postingIn || []).slice(),
             buttonIndex,
             buttonMoves: buttonIndex !== state.dealerSeatIndex,
             satOut,
@@ -271,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);
@@ -332,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";
@@ -419,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.
         //
@@ -462,11 +481,30 @@ const Betting = {
         if (sb > 0 && sbIndex !== null) this.putIn(state, sbIndex, sb);
         if (bb > 0) this.putIn(state, bbIndex, bb);
 
+        // Anyone the dealer said would post to come in past the blinds. It's a big
+        // blind like any other — it buys them a hand they'd otherwise have to wait for
+        // — so it goes in the middle the same way, before the count below reads it.
+        const posting = Array.isArray(state.postingIn) ? state.postingIn : [];
+        if (bb > 0) {
+            state.seats.forEach((player, index) => {
+                if (index === sbIndex || index === bbIndex) return;
+                if (player.inHand && posting.includes(player.id)) this.putIn(state, index, bb);
+            });
+        }
+        // Deliberately not cleared here. repostBlinds takes every posted chip back and
+        // deals again through this same function, so a post that cleared itself on the
+        // way in would be refunded and never retaken — the dealer moves the button and
+        // somebody's post quietly vanishes. startNextHand is what ends it.
+
         // What the next hand's rotation is worked out from. Recorded here, where the
         // blinds are actually posted, because by the time it's needed the seats have
         // moved on and the answer can no longer be read off the table.
         state.postedBlinds = { sbIndex, bbIndex };
 
+        // Who got cards. Read next hand to tell a player who has been here all along
+        // from one who has just walked up and had the blinds go past them.
+        state.dealtLastHand = state.seats.filter(p => p.inHand).map(p => p.id);
+
         state.currentBet = this.round(Math.max(
             sbIndex === null ? 0 : this.committed(state.seats[sbIndex]),
             this.committed(state.seats[bbIndex])));
@@ -480,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/main.js

@@ -591,15 +591,99 @@ document.addEventListener("DOMContentLoaded", () => {
         if (!ok) return;
 
         HoldemState.clearHistory(state);
+        Render.historyFilter = "";
+        document.getElementById("handHistoryFilter").value = "";
         hooks.save(state);
         Render.renderAll();
         Toast.show("Hand history cleared.", { duration: 2500 });
     });
 
+    document.getElementById("saveTableBtn").addEventListener("click", () => {
+        const blob = new Blob([HoldemState.toBackup(state)], { type: "application/json" });
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement("a");
+        link.href = url;
+        link.download = HoldemState.backupFileName();
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        URL.revokeObjectURL(url);
+        Toast.show(`Table saved as ${link.download}.`, { duration: 3500 });
+    });
+
+    document.getElementById("loadTableBtn").addEventListener("click", () => {
+        document.getElementById("loadTableInput").click();
+    });
+
+    document.getElementById("loadTableInput").addEventListener("change", async e => {
+        const file = e.target.files && e.target.files[0];
+        // Cleared straight away so picking the same file twice still fires a change.
+        e.target.value = "";
+        if (!file) return;
+
+        let text;
+        try {
+            text = await file.text();
+        } catch {
+            Toast.show("That file couldn't be read.", { duration: 4000 });
+            return;
+        }
+
+        const result = HoldemState.fromBackup(text);
+        if (result.error) {
+            Toast.show(result.error, { duration: 5000 });
+            return;
+        }
+
+        // Loading replaces everything: stacks, buy-ins, the button, the log. Naming
+        // what is about to be lost is the difference between a dealer choosing that
+        // and discovering it — and the current table might be the live one.
+        const here = HoldemState.sessionStandings(state).length;
+        const incoming = HoldemState.sessionStandings(result.table).length;
+        const when = result.savedAt ? new Date(result.savedAt) : null;
+        const saidWhen = when && !Number.isNaN(when.getTime())
+            ? ` It was saved ${when.toLocaleString()}.`
+            : "";
+        const ok = await Dialog.confirm({
+            title: "Replace this table?",
+            message:
+                `The file has a table with ${incoming} ${incoming === 1 ? "player" : "players"} in it.${saidWhen} ` +
+                `Loading it replaces the table on screen — ${here} ${here === 1 ? "player" : "players"}, ` +
+                `${(state.handHistory || []).length} logged ${(state.handHistory || []).length === 1 ? "hand" : "hands"}. ` +
+                `Undo will bring it back for a few seconds; after that it is gone.`,
+            confirmLabel: "Load it",
+            danger: true,
+        });
+        if (!ok) return;
+
+        runUndoable("loading a saved table", () => {
+            // Replace the contents rather than the reference: everything on the page
+            // holds a pointer to this object.
+            Object.keys(state).forEach(key => { delete state[key]; });
+            Object.assign(state, result.table);
+        });
+    });
+
+    // The filter is how the dealer looks at the log, not something about the table, so
+    // it lives on the view: it isn't saved, isn't undoable, and doesn't reach the other
+    // tab. Clearing the history clears it too, since there is nothing left to filter.
+    document.getElementById("handHistoryFilter").addEventListener("input", e => {
+        Render.historyFilter = e.target.value;
+        Render.renderHandHistory();
+    });
+
     document.getElementById("exportHistoryBtn").addEventListener("click", () => {
         if ((state.handHistory || []).length === 0) return;
+        // Always the whole night. A filter is for reading the panel; an export that
+        // quietly dropped the hands scrolled past would be a record with holes in it,
+        // and nothing on the CSV would say so.
         HandHistoryExport.download(state.handHistory, HoldemState.sessionStandings(state),
             { notes: state.notes });
+        if (Render.historyFilter) {
+            Toast.show(`Exported all ${state.handHistory.length} hands, not just the ${
+                state.handHistory.filter(h => Render.handMatchesFilter(h, Render.historyFilter)).length} shown.`,
+                { duration: 3500 });
+        }
     });
 
     // The load happens on the first line of this file, long before there's a Toast to

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

@@ -82,26 +82,100 @@ const Render = {
 
     // ---- Seats around the table (compact pucks) ----
 
-    seatPosition(index, count) {
-        return this.positionOnRing(index, count, 44, 42);
+    seatPosition(index, count, aspect = this.feltAspect()) {
+        return this.positionOnRing(index, count, 44, 42, aspect);
+    },
+
+    // How many times wider than tall the felt actually is, which is the one thing the
+    // ring needs from the layout and can't work out from percentages. Falls back to a
+    // circle when there's nothing to measure — the same answer the ring gave before it
+    // asked.
+    feltAspect() {
+        if (typeof document === "undefined") return 1;
+        const wrap = document.getElementById("pokerTableWrap");
+        if (!wrap) return 1;
+        const box = wrap.getBoundingClientRect();
+        if (!box.width || !box.height) return 1;
+        return box.width / box.height;
     },
 
     // 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);
+    //
+    // The angle is the seat's own rather than one walked again round a tighter ellipse.
+    // The two answers are within half a degree of each other, so this is not a fix for
+    // anything visible — it is just the honest way to say "on that player's spoke",
+    // and it saves the second walk.
+    betPosition(index, count, aspect = this.feltAspect()) {
+        const angle = this.ringAngles(count, 44, 42, aspect)[index];
+        return { left: 50 + 27 * Math.cos(angle), top: 50 + 25 * Math.sin(angle) };
     },
 
-    positionOnRing(index, count, rx, ry) {
-        const angle = -90 + (360 / count) * index;
-        const radians = (angle * Math.PI) / 180;
+    // Seats spaced evenly around the rim — by the distance between them, not by the
+    // angle they sit at.
+    //
+    // Equal angles are only equal spacing on a circle. The felt is an ellipse, and a
+    // phone on its side makes it a very flat one: 601x126 at 640x360. Ten seats at 36°
+    // apart then put four of them down each steep side, where 36° of turn is barely any
+    // distance — seats 3 and 4 came out at the same x and 20px apart vertically, each
+    // puck 72px tall. Their centres landed on each other, so tapping a player got their
+    // neighbour, and the layout audit had been calling it at 640x360 and 667x375.
+    //
+    // Walking the perimeter instead puts the seats where a real table has them: along
+    // the two long rails, one at each end. The arc length is summed numerically because
+    // an ellipse's has no closed form — 720 steps is far more than enough for a rim a
+    // few hundred pixels long, and it runs once per render.
+    positionOnRing(index, count, rx, ry, aspect = 1) {
+        const target = this.ringAngles(count, rx, ry, aspect)[index];
         return {
-            left: 50 + rx * Math.cos(radians),
-            top: 50 + ry * Math.sin(radians),
+            left: 50 + rx * Math.cos(target),
+            top: 50 + ry * Math.sin(target),
         };
     },
 
+    RING_STEPS: 720,
+    ringCache: {},
+
+    // The angles that cut the rim into `count` equal lengths, starting at the top.
+    // Every seat on a ring wants the same answer, so it is worked out once per shape
+    // and kept — the ring only changes when the table is resized or the window is.
+    ringAngles(count, rx, ry, aspect) {
+        if (count <= 0) return [];
+        const key = `${count}:${rx}:${ry}:${aspect.toFixed(3)}`;
+        if (this.ringCache[key]) return this.ringCache[key];
+
+        const start = -Math.PI / 2;
+        // Percentages of the width and of the height are not the same distance, so the
+        // horizontal radius is scaled into the vertical one's units before measuring.
+        const a = rx * aspect;
+        const b = ry;
+        const step = (2 * Math.PI) / this.RING_STEPS;
+        const cumulative = [0];
+        for (let i = 1; i <= this.RING_STEPS; i++) {
+            const from = start + (i - 1) * step;
+            const to = start + i * step;
+            const dx = a * (Math.cos(to) - Math.cos(from));
+            const dy = b * (Math.sin(to) - Math.sin(from));
+            cumulative.push(cumulative[i - 1] + Math.hypot(dx, dy));
+        }
+
+        const perimeter = cumulative[this.RING_STEPS];
+        const angles = [];
+        let walked = 0;
+        for (let seat = 0; seat < count; seat++) {
+            const wanted = (perimeter * seat) / count;
+            while (walked < this.RING_STEPS && cumulative[walked + 1] < wanted) walked++;
+            // Interpolate inside the step the seat falls in, so the answer doesn't
+            // jump in 0.5° increments.
+            const spanned = cumulative[walked + 1] - cumulative[walked];
+            const into = spanned > 0 ? (wanted - cumulative[walked]) / spanned : 0;
+            angles.push(start + (walked + into) * step);
+        }
+        this.ringCache[key] = angles;
+        return angles;
+    },
+
     // 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) {
@@ -524,13 +598,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 +892,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);
@@ -967,9 +1075,50 @@ const Render = {
             newest ? newest.handNumber : "",
             newest ? newest.timestamp : "",
             newest ? newest.pot : "",
+            // Typing in the filter changes the list without changing the history, and
+            // the redraw is skipped when the signature matches — leave this out and the
+            // box takes input and does nothing.
+            this.historyFilter || "",
         ].join("|");
     },
 
+    // What the dealer opens the log for is one hand: the one somebody is arguing
+    // about. A night runs to sixty or more, five at a time in the panel, so finding it
+    // meant scrolling and reading every row. A name, an amount, or a hand number
+    // narrows it instead.
+    //
+    // Matching is deliberately loose. "fay" finds Fay whatever case it's typed in;
+    // "190" finds a $190 pot, a $190 payout, or hand 190, because a dealer half
+    // remembering an amount shouldn't have to know which of those they mean; "#12"
+    // pins it to the hand number, for when they do.
+    handMatchesFilter(entry, query) {
+        if (!query) return true;
+        const term = query.trim().toLowerCase();
+        if (!term) return true;
+
+        const handNumber = String(entry.handNumber || "");
+        if (term.startsWith("#")) return handNumber.startsWith(term.slice(1));
+
+        // Only what the row itself shows. Matching the hand's full ledger as well was
+        // the first attempt, on the reasoning that a dealer might hunt for the hand
+        // that broke somebody by the loser's name — but the ledger holds everyone who
+        // put a chip in, so at a table where nobody folds it matched every hand.
+        // Measured on a seven-handed night: "Fay" returned 60 of 60. Searching text the
+        // panel doesn't display is a filter that looks broken even when it's right.
+        const labels = (entry.payouts || []).map(p => String(p.label || "").toLowerCase()).join(" ");
+        if (labels.includes(term)) return true;
+
+        // Amounts, matched on the digits so "$190", "190" and "1,90" all behave.
+        const digits = term.replace(/[^0-9.]/g, "");
+        if (digits) {
+            const amounts = [entry.pot, ...(entry.payouts || []).map(p => p.amount)]
+                .map(a => String(Money.round(Number(a) || 0)));
+            if (amounts.some(a => a.startsWith(digits))) return true;
+            if (handNumber === digits) return true;
+        }
+        return false;
+    },
+
     // Rebuilding this panel measured 25.7ms of the 30ms a full re-render costs — and a
     // full re-render runs after every fold, call and raise. The log only changes when a
     // hand is settled or the history is cleared, perhaps once every thirty taps, so it
@@ -988,10 +1137,29 @@ const Render = {
         emptyHint.hidden = history.length > 0;
         document.getElementById("exportHistoryBtn").disabled = history.length === 0;
 
+        const query = this.historyFilter || "";
+        const shown = query ? history.filter(entry => this.handMatchesFilter(entry, query)) : history;
+
+        // How much of the night is being hidden. Without it a filter that matches one
+        // hand looks exactly like a table that only played one, which is the sort of
+        // thing a dealer reads wrong at 2am with somebody leaning over the rail.
+        const count = document.getElementById("handHistoryCount");
+        if (count) {
+            count.hidden = !query || history.length === 0;
+            count.textContent = `${shown.length} of ${history.length}`;
+        }
+        const noMatch = document.getElementById("handHistoryNoMatch");
+        if (noMatch) {
+            noMatch.hidden = !(query && history.length > 0 && shown.length === 0);
+            noMatch.textContent = `No hand matches “${query.trim()}”. The log still has all ${history.length}.`;
+        }
+        const filterBox = document.getElementById("handHistoryFilter");
+        if (filterBox) filterBox.hidden = history.length === 0;
+
         // Built off-document so the panel is laid out once instead of once per row.
         const fragment = document.createDocumentFragment();
         const template = document.getElementById("handHistoryRowTemplate");
-        history.forEach(entry => {
+        shown.forEach(entry => {
             const row = template.content.firstElementChild.cloneNode(true);
             row.querySelector(".handHistoryHandNumber").textContent = `Hand #${entry.handNumber}`;
             row.querySelector(".handHistoryPot").textContent = Money.format(entry.pot);

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

@@ -86,6 +86,20 @@ 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.
+            dealtLastHand: [],
+            // Ids the dealer has said will buy in past the blinds this hand, by posting
+            // the big blind rather than waiting for it. Cleared every hand: it's a
+            // decision about one deal, not a standing arrangement.
+            postingIn: [],
             // Set when somebody leaves out of the blinds and the rotation has to hold
             // to the seats to keep the big blind moving one player at a time. The
             // button then sits on the chair they vacated, and no small blind is posted.
@@ -150,13 +164,18 @@ const HoldemState = {
         return this.createDefault();
     },
 
-    load() {
-        let raw = null;
-        try {
-            raw = localStorage.getItem(this.STORAGE_KEY);
-            if (!raw) return this.createDefault();
-            const parsed = JSON.parse(raw);
-            if (!parsed || !Array.isArray(parsed.seats)) return this.failedLoad(raw);
+    // Everything a table has to be put through before it can be trusted, whichever
+    // direction it arrived from.
+    //
+    // Pulled out of load() so a table read from a file goes through exactly the same
+    // checks as one read from storage. A second, looser path for imports is how a
+    // format grows two meanings of the same field.
+    //
+    // Returns null for anything that isn't a table at all; every other repair is
+    // silent and forward, the way a save from an older version is treated.
+    migrate(parsed) {
+        if (!parsed || !Array.isArray(parsed.seats)) return null;
+        {
             if (typeof parsed.handNumber !== "number" || parsed.handNumber < 1) parsed.handNumber = 1;
             if (!Array.isArray(parsed.handHistory)) parsed.handHistory = [];
             if (typeof parsed.discarded !== "number" || !(parsed.discarded >= 0)) parsed.discarded = 0;
@@ -165,7 +184,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];
                 });
@@ -175,6 +195,12 @@ const HoldemState = {
             // way, which is what that table was already doing.
             parsed.deadButton = parsed.deadButton === true;
             parsed.deadSmallBlind = parsed.deadSmallBlind === true;
+            // An old save has no record of who was dealt last hand. Empty is the
+            // honest answer — it reads as "this table hasn't played yet", so the first
+            // hand after reopening treats nobody as having just walked up, rather than
+            // asking the whole table to post.
+            if (!Array.isArray(parsed.dealtLastHand)) parsed.dealtLastHand = [];
+            if (!Array.isArray(parsed.postingIn)) parsed.postingIn = [];
 
             // A table saved before dealing and betting were separate has no flag, and
             // guessing false would show "deal the hand" over a hand already in
@@ -194,12 +220,85 @@ const HoldemState = {
             });
 
             return parsed;
+        }
+    },
+
+    load() {
+        let raw = null;
+        try {
+            raw = localStorage.getItem(this.STORAGE_KEY);
+            if (!raw) return this.createDefault();
+            const migrated = this.migrate(JSON.parse(raw));
+            if (!migrated) return this.failedLoad(raw);
+            return migrated;
         } catch {
             // Malformed JSON — a truncated write, another tab, a browser hiccup.
             return this.failedLoad(raw);
         }
     },
 
+    // ---- Taking the table off this device ------------------------------------
+    //
+    // A night lives in one browser's localStorage and nowhere else. A dealer whose
+    // phone dies, or who wants to carry on from the tablet after the break, loses the
+    // stacks, the buy-ins, where the button is and the whole hand log — and the CSV
+    // export can't bring any of that back, because it records what happened rather
+    // than where the table stands.
+    //
+    // So the table can be written out as a file and read back in. Same shape that goes
+    // into storage, wrapped in enough to recognise it later.
+    BACKUP_KIND: "casino.holdem.table",
+    BACKUP_VERSION: 1,
+
+    toBackup(state) {
+        return JSON.stringify({
+            kind: this.BACKUP_KIND,
+            version: this.BACKUP_VERSION,
+            savedAt: new Date().toISOString(),
+            table: state,
+        }, null, 2);
+    },
+
+    // Reads a file back. Returns { table } on success, or { error } with something a
+    // dealer can act on — never a half-loaded table, because the failure mode there is
+    // a night that looks restored and isn't.
+    fromBackup(text) {
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        } catch {
+            return { error: "That file isn't a saved table — it couldn't be read as JSON." };
+        }
+        if (!parsed || typeof parsed !== "object") {
+            return { error: "That file isn't a saved table." };
+        }
+        // A bare table, from someone who copied the storage value out by hand, is
+        // still a table. The envelope is a convenience, not a password.
+        const table = parsed.kind === this.BACKUP_KIND || parsed.table ? parsed.table : parsed;
+        if (parsed.kind && parsed.kind !== this.BACKUP_KIND) {
+            return { error: "That file is a save from something else, not a Hold'em table." };
+        }
+        const migrated = this.migrate(table);
+        if (!migrated) {
+            return { error: "That file doesn't have a table in it — no seats were found." };
+        }
+        if (parsed.version > this.BACKUP_VERSION) {
+            // Newer than this build understands. Loading it anyway risks reading a
+            // field that has changed meaning, and the dealer would find out from the
+            // money, so say so instead.
+            return { error: "That table was saved by a newer version of this tool. Update, then load it." };
+        }
+        return { table: migrated, savedAt: parsed.savedAt || null };
+    },
+
+    // What the file is called. Dated, because a dealer who saves twice in a night
+    // should not have to guess which is which.
+    backupFileName(now = new Date()) {
+        const pad = n => String(n).padStart(2, "0");
+        return `holdem-table-${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}` +
+            `-${pad(now.getHours())}${pad(now.getMinutes())}.json`;
+    },
+
     // True once a save has failed. The UI reads this to keep saying so, because a
     // toast is a moment and this is a fact about the rest of the night.
     saveFailed: false,
@@ -460,6 +559,29 @@ const HoldemState = {
         return { dealerIndex, sbIndex: live[0], bbIndex: live[1], headsUp: false };
     },
 
+    // Seats about to be dealt a hand they haven't paid for.
+    //
+    // Somebody who walks up and sits down between the button and the big blind has had
+    // the blinds go past them. Dealing them in there is a free hand in late position —
+    // which is exactly what posting is for, and it comes out of everybody else's night
+    // a couple of dollars at a time. At a real table they either post the big blind to
+    // come straight in, or they wait for it to reach them.
+    //
+    // The seat that *is* the big blind this hand isn't owed anything: they're paying.
+    // Neither is anyone at a table that hasn't dealt a hand yet, where everybody is new
+    // and nobody has been skipped.
+    blindDebtors(state, bbIndex) {
+        const played = Array.isArray(state.dealtLastHand) && state.dealtLastHand.length > 0;
+        if (!played) return [];
+        return state.seats
+            .map((player, index) => ({ player, index }))
+            .filter(({ player, index }) =>
+                player.inHand &&
+                index !== bbIndex &&
+                !state.dealtLastHand.includes(player.id))
+            .map(({ index }) => index);
+    },
+
     // Where the button goes for the next hand, and whether anything is left dead.
     //
     // Ordinarily it follows the small blind round — the next player along, which is
@@ -518,6 +640,9 @@ const HoldemState = {
         // the next one would freeze the blinds on two players for the rest of the
         // night, which is the opposite of what naming them once is for.
         state.blindOverride = null;
+        // Posting to come in is a decision about one deal. Carrying it forward would
+        // charge somebody an extra big blind every hand for the rest of the night.
+        state.postingIn = [];
         state.seats.forEach(p => {
             p.folded = false;
             p.cards = ["", ""];
@@ -636,6 +761,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/feltRoom.test.js

@@ -0,0 +1,73 @@
+// How tall the felt is allowed to be.
+//
+// The bar is fixed to the bottom of the screen and grows with the hand, so the table
+// has to be told what is left. Everything below is the arithmetic that decides it —
+// the part that can be wrong without anyone noticing until a seat is behind the Fold
+// button.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { ActionBar } = require("./load");
+
+// window height, bar height, and how far down the page the felt starts.
+const room = (windowHeight, barHeight, top) => ActionBar.feltRoomFor(windowHeight, barHeight, top);
+
+describe("the room left for the felt", () => {
+    test("is what the window has after the bar, the header and the bottom seat", () => {
+        const reserved = ActionBar.SEAT_OVERHANG_PX + ActionBar.FELT_GAP_PX;
+        assert.equal(room(900, 127, 146), 900 - 127 - 146 - reserved);
+    });
+
+    test("shrinks when the bar grows mid-hand", () => {
+        // Side pots make the bar taller exactly when the dealer most needs to see who
+        // is still in.
+        const quiet = room(900, 117, 146);
+        const sidePots = room(900, 172, 146);
+        assert.equal(quiet - sidePots, 55);
+    });
+
+    test("leaves the bottom seat's overhang out of it", () => {
+        // The seat pucks hang below the felt's edge; the felt has to stop short by that
+        // much or the ring ends up in the bar even though the felt doesn't.
+        assert.ok(ActionBar.SEAT_OVERHANG_PX > 30, "half a puck");
+        assert.ok(room(900, 127, 146) < 900 - 127 - 146);
+    });
+});
+
+describe("a window too short to give what was asked", () => {
+    // A phone on its side: 390px tall, 127px of that is the bar and 119px is
+    // everything above the felt. What's left is under 100.
+    const landscape = () => room(390, 127, 119);
+
+    test("gets the measurement, not a comfortable number", () => {
+        // The floor used to be 220px, which this window hasn't got. Holding out for it
+        // put the bottom row of seats 26px inside the action bar — the exact fault the
+        // measurement exists to prevent.
+        assert.ok(landscape() < 150, `${landscape()}px`);
+        assert.ok(landscape() + 119 + 127 <= 390, "the felt still ends above the bar");
+    });
+
+    test("still draws a table rather than a line", () => {
+        assert.equal(ActionBar.feltRoomFor(200, 160, 100), ActionBar.FELT_FLOOR_PX);
+        assert.equal(ActionBar.feltRoomFor(0, 0, 0), ActionBar.FELT_FLOOR_PX);
+    });
+
+    test("never returns something a browser can't lay out", () => {
+        [[390, 300, 200], [100, 90, 90], [-10, 0, 0]].forEach(([h, bar, top]) => {
+            const answer = ActionBar.feltRoomFor(h, bar, top);
+            assert.ok(Number.isFinite(answer) && answer > 0, `${h}/${bar}/${top} gave ${answer}`);
+        });
+    });
+});
+
+describe("a window with room to spare", () => {
+    test("hands over everything that's left, floor or no floor", () => {
+        const reserved = ActionBar.SEAT_OVERHANG_PX + ActionBar.FELT_GAP_PX;
+        assert.equal(room(1000, 127, 146), 1000 - 127 - 146 - reserved);
+        assert.equal(room(1366, 120, 206), 1366 - 120 - 206 - reserved);
+    });
+
+    test("gives a whole number of pixels", () => {
+        assert.equal(room(844.4, 127.6, 223.2) % 1, 0);
+    });
+});

tests/holdem/handHistoryFilter.test.js

@@ -0,0 +1,123 @@
+// Finding one hand in a night of them.
+//
+// What the log is actually opened for is a single hand — the one somebody at the rail
+// is arguing about. A night runs to sixty or more, five at a time in the panel, and
+// there was no way to ask for one: the dealer scrolled and read every row.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { Render } = require("./load");
+
+const hand = (handNumber, pot, payouts, ledger = []) => ({
+    handNumber, pot, timestamp: Date.now(), payouts, ledger,
+});
+
+// A night as the tool records it: labels carry the cards the wizard was shown.
+const NIGHT = [
+    hand(1, 40, [{ label: "Ann (A♠ K♠)", amount: 40 }], [{ name: "Ann", in: 20 }, { name: "Ben", in: 20 }]),
+    hand(2, 190, [{ label: "Fay", amount: 190 }], [{ name: "Fay", in: 95 }, { name: "Gus", in: 95 }]),
+    hand(12, 19, [{ label: "Ben", amount: 19 }], [{ name: "Ben", in: 10 }, { name: "Ann", in: 9 }]),
+    hand(120, 76, [{ label: "Cal", amount: 38 }, { label: "Dee", amount: 38 }], [{ name: "Cal" }, { name: "Dee" }]),
+];
+
+const found = query => NIGHT.filter(h => Render.handMatchesFilter(h, query)).map(h => h.handNumber);
+
+describe("no filter", () => {
+    test("shows the whole night", () => {
+        assert.deepEqual(found(""), [1, 2, 12, 120]);
+        assert.deepEqual(found("   "), [1, 2, 12, 120]);
+        assert.deepEqual(found(null), [1, 2, 12, 120]);
+    });
+});
+
+describe("by name", () => {
+    test("finds the hand somebody won", () => {
+        assert.deepEqual(found("Fay"), [2]);
+    });
+
+    test("case doesn't matter — nobody types a capital at 2am", () => {
+        assert.deepEqual(found("fay"), [2]);
+        assert.deepEqual(found("FAY"), [2]);
+    });
+
+    test("a name inside a label with cards on it still matches", () => {
+        // The wizard writes the label as "Ann (A♠ K♠)", so the name is a substring
+        // rather than the whole cell.
+        assert.deepEqual(found("ann"), [1]);
+    });
+
+    test("matches what the row shows, not everyone who was in the hand", () => {
+        // Gus is in hand 2's ledger — he paid for it — but the row names the winner,
+        // and searching text the panel doesn't display is a filter that looks broken
+        // even when it's right. Measured on a seven-handed night where nobody folded,
+        // matching the ledger returned 60 of 60 for every name at the table.
+        assert.deepEqual(found("gus"), []);
+    });
+
+    test("a split pot is found by either winner", () => {
+        assert.deepEqual(found("cal"), [120]);
+        assert.deepEqual(found("dee"), [120]);
+    });
+
+    test("a name nobody has finds nothing rather than everything", () => {
+        assert.deepEqual(found("zed"), []);
+    });
+});
+
+describe("by amount", () => {
+    test("finds a pot", () => {
+        assert.deepEqual(found("190"), [2]);
+    });
+
+    test("a dollar sign and commas are ignored", () => {
+        assert.deepEqual(found("$190"), [2]);
+        assert.deepEqual(found("$1,90"), [2], "typed badly, still found");
+    });
+
+    test("finds a payout that isn't the whole pot", () => {
+        assert.deepEqual(found("38"), [120], "half of a chopped $76");
+    });
+
+    test("a partial amount narrows rather than missing", () => {
+        // Half remembering "something around forty" should still get there.
+        assert.deepEqual(found("4"), [1], "$40");
+        assert.deepEqual(found("19"), [2, 12], "the $190 pot and the $19 one");
+    });
+
+    test("a bare number is an exact hand number, not a prefix of one", () => {
+        // Amounts match on their leading digits, because half a remembered figure is
+        // still a lead. Hand numbers don't: typing 12 to mean the hand is a dealer who
+        // knows which hand they want, and dragging 120 and 128 along with it is noise.
+        // "#12" is there for when they do want the prefix.
+        assert.ok(!found("12").includes(120));
+    });
+});
+
+describe("by hand number", () => {
+    test("a bare number matches the hand number as well as amounts", () => {
+        assert.ok(found("12").includes(12));
+    });
+
+    test("a hash pins it to the hand number and nothing else", () => {
+        assert.deepEqual(found("#12"), [12, 120], "12 and 120 both start with 12");
+        assert.deepEqual(found("#2"), [2], "and not the $190 pot of hand 2's neighbours");
+    });
+
+    test("a hash with a number nobody played finds nothing", () => {
+        assert.deepEqual(found("#7"), []);
+    });
+});
+
+describe("odd input can't break it", () => {
+    test("punctuation on its own doesn't match everything", () => {
+        assert.deepEqual(found("$"), [], "no digits and no letters left to match on");
+        assert.deepEqual(found("#"), [1, 2, 12, 120], "an empty hand number is a prefix of them all");
+    });
+
+    test("an entry with pieces missing doesn't throw", () => {
+        const broken = { handNumber: 5, pot: 10 };
+        assert.doesNotThrow(() => Render.handMatchesFilter(broken, "ann"));
+        assert.equal(Render.handMatchesFilter(broken, "ann"), false);
+        assert.equal(Render.handMatchesFilter(broken, "10"), true, "the pot is still findable");
+    });
+});

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/postingIn.test.js

@@ -0,0 +1,238 @@
+// Somebody who walks up and sits down after the blinds have gone past them.
+//
+// Dealing them straight in is a free hand in late position — which is what posting
+// exists to stop, and it comes out of everybody else's night a couple of dollars at a
+// time. The tool used to do it silently. It now says so, and takes the post if the
+// dealer says to.
+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) => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack: 200, dealerSeatIndex });
+    NAMES.forEach((name, i) => { state.seats[i].name = name; });
+    return state;
+};
+
+// Eve walks up and takes seat 5 while the table is running.
+const seatEve = state => {
+    state.seats[4].name = "Eve";
+    state.seats[4].inHand = true;
+    state.seats[4].stack = 200;
+    state.seats[4].buyIns = 200;
+    return 4;
+};
+
+const debtors = state => {
+    const { bbIndex } = HoldemState.getBlindSeats(state);
+    return HoldemState.blindDebtors(state, bbIndex).map(i => state.seats[i].name);
+};
+
+describe("who is owed a blind", () => {
+    test("nobody, at a table that hasn't dealt a hand yet", () => {
+        // Everyone is new on the first hand. Asking the whole table to post would be
+        // the tool mistaking the start of the night for five people walking up late.
+        const state = table();
+        assert.deepEqual(debtors(state), []);
+    });
+
+    test("nobody, on an ordinary hand where the same people are still sitting there", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        assert.deepEqual(debtors(state), []);
+    });
+
+    test("the player who has just sat down", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        seatEve(state);
+
+        assert.deepEqual(debtors(state), ["Eve"]);
+    });
+
+    test("not once they've been dealt a hand", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        seatEve(state);
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+
+        assert.deepEqual(debtors(state), [], "she's one of the regulars now");
+    });
+
+    test("not somebody who is the big blind this hand — they're paying already", () => {
+        const state = table(0);              // blinds Ben and Cal
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);    // blinds move to Cal and Dee
+
+        // Dee sits out for a hand and comes straight back into her own big blind.
+        state.seats[3].inHand = false;
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        state.seats[3].inHand = true;
+
+        const { bbIndex } = HoldemState.getBlindSeats(state);
+        assert.ok(!HoldemState.blindDebtors(state, bbIndex).includes(bbIndex),
+            "the big blind is never asked to post on top of their blind");
+    });
+
+    test("somebody back from sitting out is owed one just like a newcomer", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+
+        state.seats[3].inHand = false;       // Dee stands up for a hand
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        state.seats[3].inHand = true;        // and sits back down
+
+        assert.ok(debtors(state).includes("Dee"), "the blinds went past her while she was up");
+    });
+
+    test("a seat sat out for having no chips isn't owed anything", () => {
+        // They aren't being dealt in, so there's no free hand to charge for.
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        const eve = seatEve(state);
+        state.seats[eve].stack = 0;
+
+        const preview = Betting.blindPreview(state);
+        assert.ok(!preview.debtors.includes(eve), "she's sitting out until she buys chips");
+    });
+});
+
+describe("posting to come in", () => {
+    test("the post goes in the middle and buys a hand", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        const eve = seatEve(state);
+
+        state.postingIn = [state.seats[eve].id];
+        const before = Betting.stackOf(state, state.seats[eve]);
+        Betting.beginHand(state);
+
+        assert.equal(Betting.committed(state.seats[eve]), state.bigBlind, "she's posted a big blind");
+        assert.equal(Betting.stackOf(state, state.seats[eve]), before - state.bigBlind,
+            "out of her own stack, not conjured");
+        assert.equal(state.currentBet, state.bigBlind, "and it doesn't raise the hand");
+    });
+
+    test("not posting leaves her stack alone", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        const eve = seatEve(state);
+
+        const before = Betting.stackOf(state, state.seats[eve]);
+        Betting.beginHand(state);
+
+        assert.equal(Betting.committed(state.seats[eve]), 0);
+        assert.equal(Betting.stackOf(state, state.seats[eve]), before);
+    });
+
+    test("the pot is what the blinds and the post add up to", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        const eve = seatEve(state);
+
+        state.postingIn = [state.seats[eve].id];
+        Betting.beginHand(state);
+
+        const middle = state.seats.reduce((sum, p) => sum + Betting.committed(p), 0);
+        assert.equal(middle, state.smallBlind + state.bigBlind + state.bigBlind);
+    });
+
+    test("it's spent after the hand, not a standing charge", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        const eve = seatEve(state);
+
+        state.postingIn = [state.seats[eve].id];
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+
+        assert.deepEqual(state.postingIn, [], "or she'd pay an extra blind every hand all night");
+        Betting.beginHand(state);
+        assert.ok(Betting.committed(state.seats[eve]) === 0 ||
+            state.seats[eve].id === state.seats[HoldemState.getBlindSeats(state).bbIndex]?.id,
+            "she pays nothing extra on the next hand");
+    });
+
+    test("moving the button after a post doesn't lose it", () => {
+        // repostBlinds takes every posted chip back and deals again. A post that
+        // cleared itself on the way in would be refunded and never retaken.
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        const eve = seatEve(state);
+
+        state.postingIn = [state.seats[eve].id];
+        Betting.beginHand(state);
+        const chips = () => state.seats.reduce(
+            (sum, p) => sum + Betting.stackOf(state, p) + Betting.handTotal(p), 0);
+        const before = chips();
+
+        state.dealerSeatIndex = 2;
+        Betting.repostBlinds(state);
+
+        assert.equal(Betting.committed(state.seats[eve]), state.bigBlind, "still posted");
+        assert.equal(chips(), before, "and no chips made or lost in the shuffle");
+    });
+
+    test("a post from somebody who isn't owed one is not taken", () => {
+        // Only seats actually being dealt in can post, and only for their own chips.
+        const state = table();
+        state.postingIn = [state.seats[3].id];
+        state.seats[3].inHand = false;
+        Betting.beginHand(state);
+
+        assert.equal(Betting.committed(state.seats[3]), 0, "she isn't even in the hand");
+    });
+});
+
+describe("what the dealer is shown", () => {
+    test("the prompt has something to say about it, and something to press", () => {
+        const state = table();
+        Betting.beginHand(state);
+        HoldemState.startNextHand(state);
+        const eve = seatEve(state);
+
+        const preview = Betting.blindPreview(state);
+        assert.deepEqual(preview.debtors, [eve]);
+        assert.deepEqual(preview.posting, [], "not posting until the dealer says so");
+
+        state.postingIn = [state.seats[eve].id];
+        assert.deepEqual(Betting.blindPreview(state).posting, [state.seats[eve].id]);
+    });
+
+    test("an old save reads as a table nobody has just walked up to", () => {
+        const state = table();
+        Betting.beginHand(state);
+        const parsed = JSON.parse(JSON.stringify(state));
+        delete parsed.dealtLastHand;
+        delete parsed.postingIn;
+
+        const store = new Map([[HoldemState.STORAGE_KEY, JSON.stringify(parsed)]]);
+        globalThis.localStorage = {
+            getItem: key => (store.has(key) ? store.get(key) : null),
+            setItem: (key, value) => store.set(key, value),
+            removeItem: key => store.delete(key),
+        };
+
+        const loaded = HoldemState.load();
+        assert.deepEqual(loaded.dealtLastHand, []);
+        assert.deepEqual(loaded.postingIn, []);
+        assert.deepEqual(debtors(loaded), [],
+            "reopening the tab doesn't ask the whole table to post");
+        delete globalThis.localStorage;
+    });
+});

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/seatRing.test.js

@@ -0,0 +1,147 @@
+// Where the seats sit on the rim.
+//
+// The ring used to space seats by angle, which is only the same as spacing them evenly
+// when the felt is a circle. On a phone held sideways the felt is 601x126, and equal
+// angles put four seats down each steep end, 20px apart, with pucks 72px tall — so a
+// seat's centre belonged to its neighbour and tapping a player got the wrong one.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { Render } = require("./load");
+
+// The seats as a dealer sees them: pixels on a felt of a given size.
+const ringPixels = (count, width, height, rx = 44, ry = 42) => {
+    const aspect = width / height;
+    return Array.from({ length: count }, (_, i) => {
+        const pos = Render.positionOnRing(i, count, rx, ry, aspect);
+        return { x: (pos.left / 100) * width, y: (pos.top / 100) * height };
+    });
+};
+
+const gaps = (points) => points.map((p, i) => {
+    const next = points[(i + 1) % points.length];
+    return Math.hypot(next.x - p.x, next.y - p.y);
+});
+
+// What the ring did before: one turn cut into equal angles.
+const byAngle = (index, count, rx, ry) => {
+    const radians = ((-90 + (360 / count) * index) * Math.PI) / 180;
+    return { left: 50 + rx * Math.cos(radians), top: 50 + ry * Math.sin(radians) };
+};
+
+describe("a round table", () => {
+    test("still spaces seats by angle, because on a circle that is the same thing", () => {
+        for (let seat = 0; seat < 9; seat++) {
+            const now = Render.positionOnRing(seat, 9, 40, 40, 1);
+            const before = byAngle(seat, 9, 40, 40);
+            assert.ok(Math.abs(now.left - before.left) < 0.2, `seat ${seat} left`);
+            assert.ok(Math.abs(now.top - before.top) < 0.2, `seat ${seat} top`);
+        }
+    });
+
+    test("seat one is at the top, whatever shape the felt is", () => {
+        [[600, 600], [601, 126], [351, 351], [949, 683]].forEach(([w, h]) => {
+            const first = Render.positionOnRing(0, 10, 44, 42, w / h);
+            assert.ok(Math.abs(first.left - 50) < 0.01, `${w}x${h} left`);
+            assert.ok(first.top < 50, `${w}x${h} is above the middle`);
+        });
+    });
+});
+
+describe("a felt wider than it is tall", () => {
+    // 640x360 landscape: the size the audit was failing at.
+    const wide = () => ringPixels(10, 601, 126);
+
+    const byAnglePixels = () => Array.from({ length: 10 }, (_, i) => {
+        const pos = byAngle(i, 10, 44, 42);
+        return { x: (pos.left / 100) * 601, y: (pos.top / 100) * 126 };
+    });
+
+    // The two seats at the right-hand end, which is where they crowd.
+    const endPairApart = (seats) => {
+        const rightmost = [...seats].sort((a, b) => b.x - a.x).slice(0, 2);
+        return Math.abs(rightmost[0].y - rightmost[1].y);
+    };
+
+    test("pulls the pair at each end apart", () => {
+        // They still share the end — ten seats on a rim this flat have nowhere else to
+        // be — but they stop sitting on top of each other.
+        const now = endPairApart(wide());
+        const before = endPairApart(byAnglePixels());
+        assert.ok(now > before * 1.4, `${now.toFixed(1)}px now, ${before.toFixed(1)}px before`);
+    });
+
+    test("nearly doubles the room between the closest two neighbours", () => {
+        // Not equal spacing in a straight line — at the ends the rim turns back on
+        // itself, so the same walk along it covers less ground across. Even there the
+        // gap goes from a third of a puck to most of one.
+        const now = Math.min(...gaps(wide()));
+        const before = Math.min(...gaps(byAnglePixels()));
+        assert.ok(now > before * 1.7, `${now.toFixed(1)}px now, ${before.toFixed(1)}px before`);
+        assert.ok(now > 55, `${now.toFixed(1)}px`);
+    });
+
+    test("never sits two seats on the same spot", () => {
+        const seats = wide();
+        seats.forEach((seat, i) => {
+            seats.slice(i + 1).forEach((other, j) => {
+                const apart = Math.hypot(seat.x - other.x, seat.y - other.y);
+                assert.ok(apart > 50, `seats ${i + 1} and ${i + j + 2} are ${apart.toFixed(1)}px apart`);
+            });
+        });
+    });
+});
+
+describe("the shape of the ring", () => {
+    test("is a mirror image left to right", () => {
+        const seats = ringPixels(10, 601, 126);
+        for (let seat = 1; seat < 5; seat++) {
+            const mirrored = seats[10 - seat];
+            assert.ok(Math.abs((seats[seat].x - 300.5) + (mirrored.x - 300.5)) < 0.5, `seat ${seat} across`);
+            assert.ok(Math.abs(seats[seat].y - mirrored.y) < 0.5, `seat ${seat} down`);
+        }
+    });
+
+    test("holds for the smallest and largest tables the seat count allows", () => {
+        [2, 3, 4, 9, 12, 24].forEach(count => {
+            const seats = ringPixels(count, 601, 126);
+            assert.equal(seats.length, count);
+            seats.forEach((seat, i) => {
+                assert.ok(Number.isFinite(seat.x) && Number.isFinite(seat.y), `${count}-handed seat ${i + 1}`);
+                assert.ok(seat.x >= 0 && seat.x <= 601, `${count}-handed seat ${i + 1} is on the felt`);
+            });
+            assert.ok(Math.min(...gaps(seats)) > 0, `${count}-handed seats are distinct`);
+        });
+    });
+
+    test("shares the rim out equally on a round table at any size", () => {
+        [3, 6, 9, 10, 24].forEach(count => {
+            const spacing = gaps(ringPixels(count, 500, 500, 40, 40));
+            const shortest = Math.min(...spacing);
+            const longest = Math.max(...spacing);
+            assert.ok(longest - shortest < 0.5,
+                `${count}-handed gaps ran ${shortest.toFixed(1)}-${longest.toFixed(1)}px`);
+        });
+    });
+
+    test("asked for no seats, offers no positions", () => {
+        assert.deepEqual(Render.ringAngles(0, 44, 42, 1), []);
+    });
+
+    test("puts each bet between its own player and the pot", () => {
+        // Where a dealer pushes the chips: on that player's line to the middle, short
+        // of the seat.
+        const bearing = (point) => Math.atan2(point.top - 50, point.left - 50);
+        const outFromMiddle = (point) => Math.hypot(point.left - 50, point.top - 50);
+
+        [[601, 126], [810, 583], [351, 351]].forEach(([w, h]) => {
+            for (let seat = 0; seat < 9; seat++) {
+                const player = Render.seatPosition(seat, 9, w / h);
+                const bet = Render.betPosition(seat, 9, w / h);
+                const offBy = Math.abs(bearing(bet) - bearing(player)) * (180 / Math.PI);
+                assert.ok(offBy < 1, `${w}x${h} seat ${seat + 1} is ${offBy.toFixed(1)}° off its spoke`);
+                assert.ok(outFromMiddle(bet) < outFromMiddle(player), `${w}x${h} seat ${seat + 1} is short of the seat`);
+            }
+        });
+    });
+});

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);
+    });
+});

tests/holdem/tableFile.test.js

@@ -0,0 +1,155 @@
+// Taking the table off this device.
+//
+// A night lives in one browser's localStorage and nowhere else. A dealer whose phone
+// dies, or who wants to carry on from the tablet after the break, loses the stacks,
+// the buy-ins, where the button is and the whole hand log — and the CSV export can't
+// bring any of that back, because it records what happened rather than where the
+// table stands.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { HoldemState, Betting, makeTable } = require("./load");
+
+const aNight = () => {
+    const state = makeTable({ seatCount: 9, seated: [0, 1, 2, 3], stack: 200, dealerSeatIndex: 1 });
+    ["Ann", "Ben", "Cal", "Dee"].forEach((name, i) => {
+        state.seats[i].name = name;
+        state.seats[i].buyIns = 200;
+    });
+    state.seats[2].stack = 340;
+    state.notes = "Cal owes the bar $12";
+    Betting.beginHand(state);
+    HoldemState.recordHand(state, [{ id: state.seats[2].id, label: "Cal", amount: 60 }]);
+    return state;
+};
+
+describe("a table written out and read back", () => {
+    test("comes back the same table", () => {
+        const before = aNight();
+        const after = HoldemState.fromBackup(HoldemState.toBackup(before)).table;
+
+        assert.deepEqual(after.seats.map(p => p.name), before.seats.map(p => p.name));
+        assert.deepEqual(after.seats.map(p => p.stack), before.seats.map(p => p.stack));
+        assert.deepEqual(after.seats.map(p => p.buyIns), before.seats.map(p => p.buyIns));
+        assert.equal(after.dealerSeatIndex, before.dealerSeatIndex);
+        assert.equal(after.handNumber, before.handNumber);
+        assert.equal(after.notes, before.notes);
+        assert.equal(after.handHistory.length, before.handHistory.length);
+    });
+
+    test("keeps the things a CSV can't carry", () => {
+        // The whole reason this exists: an export records what happened, not where the
+        // table stands.
+        const before = aNight();
+        const after = HoldemState.fromBackup(HoldemState.toBackup(before)).table;
+
+        assert.equal(after.bettingOpen, before.bettingOpen, "a hand in progress is still in progress");
+        assert.deepEqual(after.postedBlinds, before.postedBlinds, "so the next rotation is right");
+        assert.equal(after.street, before.street);
+        assert.deepEqual(after.seats.map(p => p.committed), before.seats.map(p => p.committed));
+        assert.deepEqual(after.chipLegend, before.chipLegend);
+    });
+
+    test("the standings and the bank check agree across the trip", () => {
+        const before = aNight();
+        const after = HoldemState.fromBackup(HoldemState.toBackup(before)).table;
+
+        assert.deepEqual(HoldemState.sessionStandings(after), HoldemState.sessionStandings(before));
+        assert.deepEqual(HoldemState.bankReconciliation(after), HoldemState.bankReconciliation(before));
+    });
+
+    test("it can be dealt from straight away", () => {
+        const before = aNight();
+        HoldemState.startNextHand(before);
+        const after = HoldemState.fromBackup(HoldemState.toBackup(before)).table;
+
+        Betting.beginHand(after);
+        assert.equal(after.bettingOpen, true);
+        assert.ok(after.actingSeatIndex !== null, "somebody is on the clock");
+    });
+});
+
+describe("what it refuses", () => {
+    const refuses = (text, because) => {
+        const result = HoldemState.fromBackup(text);
+        assert.ok(result.error, because);
+        assert.equal(result.table, undefined, "and never hands back half a table");
+    };
+
+    test("something that isn't JSON", () => {
+        refuses("not a file", "unreadable");
+        refuses("", "empty");
+    });
+
+    test("JSON that isn't a table", () => {
+        refuses('{"hello":"world"}', "no seats in it");
+        refuses("[1,2,3]", "an array of nothing");
+        refuses("null", "null");
+    });
+
+    test("a save from something else that happens to be JSON", () => {
+        refuses('{"kind":"some.other.tool","table":{"seats":[]}}', "wrong kind");
+    });
+
+    test("a file from a newer version, rather than guessing at it", () => {
+        // Loading it risks reading a field whose meaning has changed, and the dealer
+        // would find out from the money.
+        const backup = JSON.parse(HoldemState.toBackup(aNight()));
+        backup.version = HoldemState.BACKUP_VERSION + 1;
+        const result = HoldemState.fromBackup(JSON.stringify(backup));
+        assert.match(result.error, /newer version/i);
+    });
+});
+
+describe("what it accepts anyway", () => {
+    test("a bare table, with no envelope around it", () => {
+        // Somebody who copied the storage value out by hand. The envelope is a
+        // convenience, not a password.
+        const state = aNight();
+        const result = HoldemState.fromBackup(JSON.stringify(state));
+        assert.ok(!result.error);
+        assert.deepEqual(result.table.seats.map(p => p.name), state.seats.map(p => p.name));
+    });
+
+    test("a table from before fields that exist now, migrated on the way in", () => {
+        // Same repairs a save from an older version gets, because it is the same
+        // function — a second, looser path for imports is how a format grows two
+        // meanings of the same field.
+        const state = aNight();
+        const raw = JSON.parse(JSON.stringify(state));
+        delete raw.deadButton;
+        delete raw.postedBlinds;
+        delete raw.dealtLastHand;
+        delete raw.discarded;
+        raw.seats.forEach(p => { delete p.buyIns; });
+
+        const { table, error } = HoldemState.fromBackup(JSON.stringify({
+            kind: HoldemState.BACKUP_KIND, version: 1, table: raw,
+        }));
+        assert.ok(!error);
+        assert.equal(table.deadButton, false);
+        assert.deepEqual(table.dealtLastHand, []);
+        assert.equal(table.discarded, 0);
+        assert.equal(table.seats[0].buyIns, 0);
+    });
+
+    test("the time it was saved comes back with it", () => {
+        const result = HoldemState.fromBackup(HoldemState.toBackup(aNight()));
+        assert.ok(result.savedAt, "so the dealer can tell two files apart");
+        assert.ok(!Number.isNaN(new Date(result.savedAt).getTime()));
+    });
+});
+
+describe("the file itself", () => {
+    test("is named with the date and time, so two saves in a night are told apart", () => {
+        const at = new Date(2026, 8, 2, 21, 5);
+        assert.equal(HoldemState.backupFileName(at), "holdem-table-2026-09-02-2105.json");
+    });
+
+    test("says what it is, for anyone finding it in a downloads folder", () => {
+        const parsed = JSON.parse(HoldemState.toBackup(aNight()));
+        assert.equal(parsed.kind, "casino.holdem.table");
+        assert.equal(parsed.version, 1);
+        assert.ok(parsed.table.seats.length > 0);
+    });
+});

tests/holdem/uiAudit.js

@@ -93,10 +93,44 @@ const LayoutAudit = {
         return false;
     },
 
+    // The modal that is currently on top, if any.
+    //
+    // Every check below asks "is this thing reachable", and while a sheet or dialog is
+    // open the answer for everything behind it is legitimately no — that is what a
+    // modal is for. Without knowing that, the audit reported the pot wizard covering
+    // the seats as ten faults and the rulings sheet as seven, which is the noise that
+    // made it useless in exactly the states nobody had audited. Now it scopes to what
+    // is actually on top and says so.
+    MODAL_SELECTOR: "#potWizardOverlay, #rulingsOverlay, #seatMenuOverlay, #cardPickerOverlay, " +
+        "#confirmOverlay, #addChipsOverlay, #seatEditorOverlay",
+
+    openModal() {
+        const open = [...document.querySelectorAll(this.MODAL_SELECTOR)]
+            .filter(el => !el.hidden && getComputedStyle(el).display !== "none");
+        // Last in the DOM wins, which is how they stack.
+        return open.length > 0 ? open[open.length - 1] : null;
+    },
+
+    // A seat sheet on a phone isn't an overlay element, it's a body class — but it
+    // covers the felt just the same.
+    modalScope() {
+        const overlay = this.openModal();
+        if (overlay) return overlay;
+        if (document.body.classList.contains("seatSheetOpen")) {
+            return document.getElementById("seatEditorPanel") || null;
+        }
+        return null;
+    },
+
     occlusion(selector = "#actionBar button, #holdemHeader button, .seat") {
         const offenders = [];
         const warnings = [];
-        [...document.querySelectorAll(selector)].forEach(el => {
+        // While something is open on top, only what is inside it can be judged. The
+        // rest of the page is meant to be unreachable.
+        const scope = this.modalScope();
+        const candidates = [...document.querySelectorAll(selector)]
+            .filter(el => !scope || scope.contains(el));
+        candidates.forEach(el => {
             const rect = el.getBoundingClientRect();
             if (rect.width === 0 || rect.height === 0) return;
 
@@ -504,10 +538,25 @@ const LayoutAudit = {
         if (!enforceOnPointerDevices && matchMedia("(hover: hover)").matches) {
             return { name: `touch targets at least ${minimum}px`, offenders, skipped: "pointer device" };
         }
+        const unmeasured = [];
         this.visibleControls()
             .filter(el => el.type !== "color")
             .filter(el => !(exempt && el.matches(exempt)))
             .forEach(el => {
+                // A control inside a scrolling sheet can sit below its container's
+                // visible area while still having a viewport rect. elementFromPoint at
+                // its centre then returns the sheet, effectiveTarget gives up, and the
+                // check used to pass it in silence — which is how "Confirm Winner(s)",
+                // the button that pays the pot out, went unmeasured for 36 rounds.
+                // Bring it into view before probing.
+                const scroller = el.closest("[style*='overflow'], .modalBody, #potWizardBody, #rulingsSheet, #seatEditorPanel");
+                if (scroller && scroller.scrollHeight > scroller.clientHeight) {
+                    const box = scroller.getBoundingClientRect();
+                    const own = el.getBoundingClientRect();
+                    if (own.bottom > box.bottom || own.top < box.top) {
+                        el.scrollIntoView({ block: "center" });
+                    }
+                }
                 const rect = el.getBoundingClientRect();
                 // Drawn big enough is big enough — no need to probe, and probing wide
                 // elements is where the cap above used to produce nonsense. Seats sit
@@ -515,15 +564,35 @@ const LayoutAudit = {
                 // measuring their reach would report the crowding as a fault.
                 if (rect.width >= minimum - 1 && rect.height >= minimum - 1) return;
 
+                // A checkbox inside a label is tapped by tapping the label, so the
+                // label is the target. Measured rather than probed, because probing
+                // fails on anything scrolled off the viewport — which is how a 24px
+                // checkbox with a 335x44 label around it came up as unprobeable
+                // instead of as the perfectly good target it is.
+                const label = el.closest("label");
+                if (label) {
+                    const lr = label.getBoundingClientRect();
+                    if (lr.width >= minimum - 1 && lr.height >= minimum - 1) return;
+                }
+
                 const size = this.effectiveTarget(el);
-                if (!size) return;
+                // Still can't measure it. That is not a pass — it is the check failing
+                // to run, and quietly returning here is exactly the kind of exemption
+                // that hides real faults. Say so instead.
+                if (!size) {
+                    unmeasured.push(
+                        `${this.describe(el)} :: could not be probed` +
+                        ` (drawn ${Math.round(rect.width)}x${Math.round(rect.height)})`
+                    );
+                    return;
+                }
                 if (size.width >= minimum - 1 && size.height >= minimum - 1) return;
                 offenders.push(
                     `${this.describe(el)} :: hittable ${size.width}x${size.height}` +
                     ` (drawn ${Math.round(rect.width)}x${Math.round(rect.height)})`
                 );
             });
-        return { name: `touch targets at least ${minimum}px`, offenders };
+        return { name: `touch targets at least ${minimum}px`, offenders, unmeasured };
     },
 
     // Tapping the middle of a seat must give you that seat.
@@ -537,6 +606,13 @@ const LayoutAudit = {
     // Reported separately from occlusion because the cause is different: not an
     // overlay on top of the table, but two pieces of the table fighting over a tap.
     seatOwnership() {
+        // Seats behind an open sheet aren't fighting each other for taps — nothing is
+        // meant to reach them at all. Asking the question there produced six offenders
+        // per modal, every one of them the modal doing its job.
+        if (this.modalScope()) {
+            return { name: "a seat's centre belongs to that seat", offenders: [],
+                skipped: "a sheet is open over the table" };
+        }
         const seats = [...document.querySelectorAll(".seat")];
         const offenders = [];
 
@@ -617,7 +693,9 @@ const LayoutAudit = {
             viewport: `${innerWidth}x${innerHeight}`,
             failed: checks.filter(c => c.offenders.length > 0),
             // Things worth knowing that aren't faults — see occlusion() on toasts.
-            warnings: checks.flatMap(c => c.warnings || []),
+            // Controls a check couldn't probe go here too: not a fault, but not a pass
+            // either, and a silent skip is how faults hide.
+            warnings: checks.flatMap(c => [...(c.warnings || []), ...(c.unmeasured || [])]),
             passed: checks.filter(c => c.offenders.length === 0).map(c => c.name),
             clean: checks.every(c => c.offenders.length === 0),
         };