Call who shows first at the showdown, instead of leaving the dealer to remember

Every showdown that isn't a fold needs somebody to turn over first, and it is the one call at the table nobody volunteers for — everyone would rather see a hand than show one. The tool held both facts the rule needs, who last raised and who sits left of the button, and said neither. The dealer worked it out from memory while five people waited, every hand. The action bar now names the seat and the reason above the resolve button: Dee shows first — last to bet or raise. Ben shows first — checked round, first left of the button. Dee shows first — last to put money in; nobody could bet the river. The reason is there so the call can be repeated to whoever argues with it, which is half of what makes it stick. Three cases, in the order the rule asks them. Somebody bet or raised on the final round: they show. Nobody did: first live player left of the button. Nobody *could*, because the chips were already in: it falls to whoever last put money in, on whichever street that was — "no bet on the final round" isn't a choice anybody made when there was no round to bet in, so the seat left of the button hasn't earned it. Aggression is tracked per street and per hand, because those two answers differ exactly when it matters. A short all-in counts: not reopening the betting is a rule about who may raise, and says nothing about who shows. Posting a blind doesn't — a hand limped and checked all the way down has no aggressor at all, which is the case that goes to the button. A matching ruling goes in Common rulings, since the dealer will be asked. Co-Authored-By: Claude Opus 5 <[email protected]> Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb
Let the dealer find one hand in the log instead of scrolling the night
2026-09-01 22:53:14 -06:00 · 2026-09-01 22:39:55 -06:00 · 2026-09-01 22:27:22 -06:00 · 2026-09-01 22:04:57 -06:00 · 2026-09-01 20:27:46 -06:00 · 2026-09-01 20:06:42 -06:00
19 changed files with 2256 additions and 80 deletions
@@ -25,7 +25,6 @@
        <section id="tableSection">
            <div id="pokerTableWrap">
                <div id="pokerTable">
-                    <div id="tableWatermark" aria-hidden="true">Texas Hold'em</div>
                    <div id="potBadge">
                        <span id="potBadgeLabel">Pot</span>
                        <span id="potBadgeAmount">$0</span>
@@ -128,6 +127,10 @@
                            <span>Chips in play</span>
                            <span id="bankChipsInPlay"></span>
                        </div>
+                        <div class="bankReconcileRow" id="bankDiscardedRow" hidden>
+                            <span>Taken off the table</span>
+                            <span id="bankDiscarded"></span>
+                        </div>
                        <p id="bankReconcileVerdict" class="bankReconcileVerdict"></p>
                    </div>

@@ -138,7 +141,13 @@
                    </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">
@@ -154,6 +163,12 @@
                    <div id="chipLegendList"></div>
                    <button id="addChipColorBtn" class="holdemBtn holdemBtnSmall">+ Add chip color</button>
                    <p class="fieldHint">Give each chip color a value, then count chips on a seat instead of typing a total.</p>
+
+                    <div id="colourUp" hidden>
+                        <h3 class="panelSubhead">Stacks in chips</h3>
+                        <dl id="colourUpList" class="colourUpList"></dl>
+                        <p class="fieldHint">The fewest chips that make each stack — for colouring up, or counting one out.</p>
+                    </div>
                </div>
            </details>

@@ -384,6 +399,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>
@@ -357,21 +357,18 @@ button,
    justify-content: center;
 }

-#tableWatermark {
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    color: rgba(255, 255, 255, 0.06);
-    font-size: 2.4rem;
-    font-weight: 700;
-    letter-spacing: 0.15em;
-    text-transform: uppercase;
-    text-align: center;
-    pointer-events: none;
-    user-select: none;
-}
+/* The felt used to carry a "TEXAS HOLD'EM" wordmark across its middle. It came out
+   from behind the pot badge in two pieces — measured at every seat count from two to
+   ten, the middle 20% of it was covered, so the felt read "TEXAS  LD'EM" — and no
+   placement fixed that everywhere. Thirty per cent down cleared the badge on a desktop
+   and landed on the seats of a phone's square felt (43-70% covered); a smaller mark at
+   20% or 78% was clean on desktop and tablet and no better on a phone; the bottom one
+   fell off the oval entirely at 360px. A square felt with six to nine seats has no
+   clear band wide enough for a word.
+   
+   So it's gone. A watermark that looks broken is worse than no watermark, and the felt
+   has a gradient, a rim, an inner gold line and a shadow to be a table with — plus a
+   header saying "Texas Hold'em Dealer" a few inches above it. */

 #potBadge {
    position: relative;
@@ -513,13 +510,53 @@ button,

 /* Sitting out, not gone: still a person the dealer may need to deal back in, so
   the name has to stay readable rather than fading almost to the felt. */
+/* Out of the hand, still readable.
+
+   Both of these used to fade the whole seat — opacity 0.5 folded, 0.58 sitting out —
+   and opacity on a box fades the text you still have to read along with the box you
+   wanted to push back. Measured off the rendered pixels at 11.5px text, where AA asks
+   for 4.5:1:
+
+     live     name 13.28   stack 4.75
+     folded   name  4.75   stack 2.22
+     sat out  name  7.00   stack 3.22
+
+   A folded player's stack is not decoration. It's what they'll have next hand and the
+   answer to "how much has Ben got?", and at 2.22:1 it was barely there.
+
+   So the box recedes and the text doesn't: a flatter, darker background and a muted
+   border say "not in this hand", while the name and the stack keep colours that
+   measure. The folded seat keeps its red border and the line through the name, which
+   is the part that actually names the state. */
+.seat.seatInactive,
+.seat.seatFolded {
+    background: linear-gradient(160deg, #232323, #171717);
+    border-color: rgba(255, 255, 255, 0.06);
+}
+
+/* A folded seat already says so twice — a red border and a line through the name — but
+   a seat that's sitting out said it only by being faint, and taking the faintness away
+   took the whole signal with it. A dashed edge is the same thing an empty chair wears,
+   which is right: neither is in this hand. The name and the stack tell them apart. */
 .seat.seatInactive {
-    opacity: 0.58;
+    border-style: dashed;
+    border-color: rgba(255, 255, 255, 0.22);
+}
+
+.seat.seatInactive .seatPuckName,
+.seat.seatFolded .seatPuckName {
+    color: #b0b0b0;
+}
+
+.seat.seatInactive .seatPuckStack,
+.seat.seatFolded .seatPuckStack,
+.seat.seatInactive .seatPuckTotal,
+.seat.seatFolded .seatPuckTotal {
+    color: #8f8f8f;
 }

 .seat.seatFolded {
    border-color: rgba(224, 123, 123, 0.4);
-    opacity: 0.5;
 }

 .seat.seatFolded .seatPuckName {
@@ -693,6 +730,18 @@ button,
    display: none;
 }

+/* The dead button. It's on an empty chair on purpose, and that reads as a mistake —
+   a gold puck on nobody looks exactly like a button that has drifted and wants
+   dragging back. So it keeps the button's gold, to stay findable as the button, but
+   goes hollow and dashed: the same shape, visibly holding a place rather than
+   marking a player. The deal prompt says why in words; this is so the felt agrees
+   with it at a glance instead of contradicting it. */
+.dealerChip.active.dealerChipDead {
+    background: rgba(245, 213, 71, 0.14);
+    border-style: dashed;
+    color: #f0d98c;
+}
+
 .blindBadge {
    display: none;
    position: absolute;
@@ -1108,6 +1157,30 @@ button,
    line-height: 1.4;
 }

+/* Each stack and the chips that make it, laid out like the shortcut legend below —
+   the thing being named on one line, the answer under it, so a dealer with a rack in
+   one hand reads down rather than across. */
+.colourUpList {
+    margin: 0.2rem 0 0;
+}
+
+.colourUpWho {
+    color: #ddd;
+    font-size: 0.78rem;
+    font-variant-numeric: tabular-nums;
+}
+
+.colourUpChips {
+    margin: 0 0 0.45rem;
+    color: #9fb8a6;
+    font-size: 0.74rem;
+    font-variant-numeric: tabular-nums;
+}
+
+.colourUpChips:last-child {
+    margin-bottom: 0;
+}
+
 /* The shortcut legend. A touch device has no keys to press, so it doesn't get a panel
   telling it about them — the same pointer question the touch-target rules ask. */
@media (pointer: coarse) {
@@ -1884,11 +1957,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;
 }

@@ -2172,11 +2296,12 @@ body.hasActionBar #holdemSidebar {

 /* The undo pill's key, inline rather than pinned to a corner — see actionBar.js. */
 .actionUndoKey {
+    /* See .actionKey below for why these are not fainter. */
    margin-left: 0.4rem;
    padding: 0 0.25rem;
    border-radius: 4px;
    border: 1px solid currentColor;
-    opacity: 0.55;
+    opacity: 0.75;
    font-family: inherit;
    font-size: 0.6rem;
    line-height: 1.4;
@@ -2184,6 +2309,10 @@ body.hasActionBar #holdemSidebar {
    pointer-events: none;
 }

+/* A key hint is small — 9.6px — so AA asks 4.5:1 of it, and at the opacity these used
+   to carry they measured 2.97 to 3.33 against their buttons. That's the same fault as
+   the folded seats above: a fade chosen for looks pushing text a dealer is meant to
+   read under the threshold. They're still quieter than the label they sit beside. */
 .actionKey {
    position: absolute;
    top: 5px;
@@ -2191,7 +2320,7 @@ body.hasActionBar #holdemSidebar {
    padding: 0 0.25rem;
    border-radius: 4px;
    border: 1px solid currentColor;
-    opacity: 0.4;
+    opacity: 0.75;
    font-family: inherit;
    font-size: 0.6rem;
    line-height: 1.4;
@@ -2845,10 +2974,6 @@ body.hasActionBar #toastHost {
        padding: 0.25rem 0.3rem;
    }

-    #tableWatermark {
-        font-size: 1.4rem;
-    }
-
    #potBadge {
        padding: 0.5rem 1.1rem;
    }
@@ -3332,6 +3457,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
@@ -11,6 +11,11 @@ const ActionBar = {
    mount(state, hooks) {
        this.state = state;
        this.hooks = hooks;
+        // Whoever was already on the clock when this page loaded — see tankUnknownFor.
+        this.tankUnknownFor = state.bettingOpen &&
+            state.actingSeatIndex !== null && state.actingSeatIndex !== undefined
+            ? state.actingSeatIndex
+            : null;
        this.watchHeight();
        this.render();
    },
@@ -207,6 +212,14 @@ const ActionBar = {
    tankStartedAt: null,
    tankInterval: null,

+    // The seat that was already being asked to act when this page loaded, if there was
+    // one. Its clock is unknowable: the action moved to them before this session
+    // started — maybe two minutes ago, maybe last night — and starting from zero would
+    // have the bar say they had just begun thinking. Which it did, every time a dealer
+    // refreshed mid-hand. Cleared the moment the action moves, because from then on the
+    // clock is measuring something it actually saw.
+    tankUnknownFor: null,
+
    // Restarts only when the action actually moves — a re-render for any other reason
    // (a chip edit, a name change) must not put a thinking player back to zero.
    syncTankTimer() {
@@ -220,6 +233,8 @@ const ActionBar = {
        }

        if (this.tankSeatIndex !== index) {
+            // Once the action has moved under our own eyes, nothing is unknown any more.
+            if (this.tankSeatIndex !== null) this.tankUnknownFor = null;
            this.tankSeatIndex = index;
            this.tankStartedAt = Date.now();
        }
@@ -243,13 +258,33 @@ const ActionBar = {
        const el = document.getElementById("actionTank");
        if (!el || this.tankStartedAt === null) return;

+        if (this.tankUnknownFor !== null && this.tankSeatIndex === this.tankUnknownFor) {
+            el.textContent = "—";
+            el.title = "The action was already on this seat when the page loaded, so there's nothing to time from yet. The clock starts when the action next moves.";
+            el.classList.remove("tankNudge", "tankSlow");
+            return;
+        }
+
        const seconds = Math.floor((Date.now() - this.tankStartedAt) / 1000);
-        const mins = Math.floor(seconds / 60);
-        el.textContent = `${mins}:${String(seconds % 60).padStart(2, "0")}`;
+        el.title = "How long this player has been thinking";
+        el.textContent = this.formatTank(seconds);
        el.classList.toggle("tankNudge", seconds >= this.NUDGE_AFTER_S && seconds < this.SLOW_AFTER_S);
        el.classList.toggle("tankSlow", seconds >= this.SLOW_AFTER_S);
    },

+    // "0:07", "4:01", and past the hour "1:05:03" rather than "65:03" — a table left
+    // open on a hand does reach that, and sixty-five minutes written as though it were
+    // a minutes-and-seconds reading is a number the eye gets wrong.
+    formatTank(seconds) {
+        const pad = value => String(value).padStart(2, "0");
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const rest = seconds % 60;
+        return hours > 0
+            ? `${hours}:${pad(minutes)}:${pad(rest)}`
+            : `${minutes}:${pad(rest)}`;
+    },
+
    // Shown only once someone is all-in and the money has actually split — a single
    // undivided pot needs no announcement, and a line that's always there stops being
    // read.
@@ -566,12 +601,27 @@ const ActionBar = {
            return wrap;
        }

-        line.textContent =
-            `${name(preview.sbIndex)} posts ${Money.format(preview.smallBlind)}, ` +
-            `${name(preview.bbIndex)} posts ${Money.format(preview.bigBlind)}` +
-            `${preview.headsUp ? " · heads-up" : ""}${preview.manual ? " · blinds set by hand" : ""}`;
+        // A dead small blind is a hand with only one blind in it. Saying "nobody posts
+        // the small blind" out loud is the whole point — a dealer who reads a preview
+        // with a blind missing and isn't told why will assume the tool has lost track.
+        line.textContent = preview.deadSmallBlind
+            ? `No small blind this hand, ${name(preview.bbIndex)} posts ${Money.format(preview.bigBlind)}`
+            : `${name(preview.sbIndex)} posts ${Money.format(preview.smallBlind)}, ` +
+              `${name(preview.bbIndex)} posts ${Money.format(preview.bigBlind)}` +
+              `${preview.headsUp ? " · heads-up" : ""}${preview.manual ? " · blinds set by hand" : ""}`;
        wrap.appendChild(line);

+        // Why a position is missing. Both of these are the dead button rule doing its
+        // job, and both look like a bug until somebody says otherwise.
+        if (preview.deadButton || preview.deadSmallBlind) {
+            const dead = document.createElement("p");
+            dead.className = "dealPromptLine dealPromptAside";
+            dead.textContent = preview.deadButton
+                ? `Dead button — seat ${preview.buttonIndex + 1} is empty. Its player left out of the blinds, so the button waits a hand rather than moving the big blind on twice.`
+                : `Dead small blind — the player due to post it left the table. The big blind still moves on one player, so nobody pays two in an orbit.`;
+            wrap.appendChild(dead);
+        }
+
        // Dealing relocates a button sitting on an empty chair. That has to be said
        // before it happens rather than discovered afterwards — a fresh table starts
        // the button on seat 1 whether or not anyone is sitting there.
@@ -593,6 +643,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", () => {
@@ -603,13 +691,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();
@@ -617,22 +733,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;
    },
 };

@@ -78,10 +78,16 @@ const Betting = {
            : { ...dealt, dealerSeatIndex: buttonIndex };

        const satOut = this.brokeSeats(state);
-        const { sbIndex, bbIndex, headsUp, manual } = HoldemState.getBlindSeats(asDealt);
-        if (sbIndex === null || bbIndex === null) return null;
+        const { sbIndex, bbIndex, headsUp, manual, deadSmallBlind } = HoldemState.getBlindSeats(asDealt);
+        if (bbIndex === null) return null;
        return {
-            sbIndex, bbIndex, headsUp, manual: !!manual,
+            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,
@@ -270,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);
@@ -331,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";
@@ -418,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.
        //
@@ -448,16 +468,46 @@ const Betting = {
        const bb = Number(state.bigBlind) || 0;
        const { sbIndex, bbIndex, headsUp } = HoldemState.getBlindSeats(state);

-        if (sbIndex === null || bbIndex === null) {
+        // A null big blind means there aren't enough players to post at all. A null
+        // small blind with a big blind behind it is the dead small blind, which is a
+        // hand that gets dealt like any other — it just has one blind in it.
+        if (bbIndex === null) {
            state.currentBet = 0;
            state.actingSeatIndex = null;
+            state.postedBlinds = null;
            return;
        }

-        if (sb > 0) this.putIn(state, sbIndex, sb);
+        if (sb > 0 && sbIndex !== null) this.putIn(state, sbIndex, sb);
        if (bb > 0) this.putIn(state, bbIndex, bb);

-        state.currentBet = this.round(Math.max(this.committed(state.seats[sbIndex]), this.committed(state.seats[bbIndex])));
+        // 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])));
        state.lastRaiseSize = bb || 0;

        // Heads-up the button is the small blind and acts first before the flop; with
@@ -468,6 +518,45 @@ const Betting = {
            : this.nextToAct(state, bbIndex);
    },

+    // 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 => {
@@ -19,7 +19,7 @@ const HandHistoryExport = {
    // text, so the one thing anybody opens this file to do — total a column and see
    // who owes what — doesn't work without cleaning every cell first. The commas were
    // quoted correctly, so the file parsed; it just wouldn't add up.
-    toCsv(handHistory, standings = []) {
+    toCsv(handHistory, standings = [], { notes = "" } = {}) {
        const rows = [["Hand #", "Time", "Pot", "Payouts"]];
        // handHistory is stored newest-first; the export reads better oldest-first.
        [...handHistory].reverse().forEach(entry => {
@@ -41,7 +41,12 @@ const HandHistoryExport = {
            rows.push(["Session Standings"]);
            // Bought in and chips now are what a cash-out is settled from; paid in and
            // won describe the hands. Both belong in the file the dealer hands over.
-            rows.push(["Player", "Paid In", "Won", "Net", "Bought In", "Chips Now", "Up/Down"]);
+            //
+            // Notes go last so the money columns keep the shape a spreadsheet expects.
+            // "IOU: $20 to Ann" is exactly the kind of thing that has to be in the file
+            // somebody settles up from, and it was only ever visible inside that seat's
+            // own editor.
+            rows.push(["Player", "Paid In", "Won", "Net", "Bought In", "Chips Now", "Up/Down", "Notes"]);
            standings.forEach(row => {
                rows.push([
                    row.name,
@@ -51,6 +56,7 @@ const HandHistoryExport = {
                    Money.forSheet(row.boughtIn || 0),
                    Money.forSheet(row.chipsNow || 0),
                    Money.forSheet(row.cashPosition || 0),
+                    row.notes || "",
                ]);
            });

@@ -76,6 +82,17 @@ const HandHistoryExport = {
            }
        }

+        // The table's own notes — side bets, IOUs, the promo running until midnight.
+        // The dealer typed them because they matter to the night, and the export is the
+        // thing that outlives the browser tab; leaving them behind meant the one place
+        // the context was written down was the one place it couldn't be handed over.
+        // csvField quotes the line breaks, so a multi-line note survives as one cell.
+        if (notes && notes.trim()) {
+            rows.push([]);
+            rows.push(["Table Notes"]);
+            rows.push([notes.trim()]);
+        }
+
        return rows.map(row => row.map(f => this.csvField(f)).join(",")).join("\r\n");
    },

@@ -86,8 +103,8 @@ const HandHistoryExport = {
        return `holdem-hand-history-${stamp}.csv`;
    },

-    download(handHistory, standings = []) {
-        const csv = this.toCsv(handHistory, standings);
+    download(handHistory, standings = [], options = {}) {
+        const csv = this.toCsv(handHistory, standings, options);
        const blob = new Blob([csv], { type: "text/csv;charset=utf-8;" });
        const url = URL.createObjectURL(blob);
        const link = document.createElement("a");
@@ -121,6 +121,11 @@ document.addEventListener("DOMContentLoaded", () => {
                ? `Button on ${nameOf(index)} — blinds taken back and re-posted.`
                : `Button on ${nameOf(index)}.`, () => {
                state.dealerSeatIndex = index;
+                // Putting the button somewhere by hand is the dealer overruling the
+                // rotation, dead positions included. Leaving them set would hold a
+                // small blind dead at a table whose button has moved out from under it.
+                state.deadButton = false;
+                state.deadSmallBlind = false;
                if (willRepost) Betting.repostBlinds(state);
            });
        },
@@ -376,17 +381,30 @@ document.addEventListener("DOMContentLoaded", () => {
            if (!ok) return;
        }

-        // startNextHand moves the button on by one; say where it landed so the
-        // dealer can confirm the rotation without hunting for the badge.
-        const nextDealer = HoldemState.nextSeatIndex(state, state.dealerSeatIndex, 1);
-        const where = state.dedicatedDealer
-            ? `small blind on seat ${HoldemState.nextSeatIndex(state, nextDealer, 1) + 1}`
-            : `button on seat ${nextDealer + 1}`;
+        // Say where the button landed so the dealer can confirm the rotation without
+        // hunting for the badge. Asked of the rotation itself rather than guessed at as
+        // "the next chair along" — which was only ever right at a table with nobody
+        // missing, and is the exact thing the dead button makes untrue.
+        const rotation = HoldemState.nextButtonRotation(state);
+        const nextDealer = rotation.buttonIndex !== null
+            ? rotation.buttonIndex
+            : HoldemState.buttonSeatForDeal({ ...state, dealerSeatIndex: HoldemState.nextSeatIndex(state, state.dealerSeatIndex, 1) });
+        const where = rotation.deadButton
+            ? `dead button on seat ${nextDealer + 1}`
+            : state.dedicatedDealer
+                ? `small blind on seat ${HoldemState.nextSeatIndex(state, nextDealer, 1) + 1}`
+                : `button on seat ${nextDealer + 1}`;
        const discarded = unresolved > Betting.EPSILON_CHIPS
            ? ` ${Money.format(unresolved)} taken off the table.`
            : "";

        runUndoable(`Next hand — ${where}. Seat the table, then deal.${discarded}`, () => {
+            // Written down as well as announced. The toast is a moment; the bank check
+            // is asked at cash-out, and until now it saw only that the chips were gone
+            // and reported them as missing.
+            if (unresolved > Betting.EPSILON_CHIPS) {
+                state.discarded = Money.round((Number(state.discarded) || 0) + unresolved);
+            }
            HoldemState.startNextHand(state);
        });
    });
@@ -461,6 +479,17 @@ document.addEventListener("DOMContentLoaded", () => {
    // The one time the browser refuses to save, say so out loud as well as leaving the
    // standing warning in the Session panel. Set before the first render so a failure
    // during start-up is caught too.
+    // Another tab writing to the same table. Said once, with the way out attached —
+    // reloading here adopts whatever that tab has done, which is the only resolution
+    // that doesn't throw somebody's work away.
+    HoldemState.onOtherTab = () => {
+        Toast.show(
+            "This table is open in another tab. Whichever acts last wins.",
+            { actionLabel: "Reload", onAction: () => window.location.reload(), duration: 20000 });
+        Render.renderStorageWarning();
+    };
+    HoldemState.watchOtherTabs();
+
    HoldemState.onSaveFailed = () => {
        Toast.show(
            "This table isn't being saved — refreshing would lose it. Keep this tab open.",
@@ -562,13 +591,42 @@ 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 });
    });

+    // 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;
-        HandHistoryExport.download(state.handHistory, HoldemState.sessionStandings(state));
+        // 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
+    // show it in, so this is checked here rather than wired as a callback. The standing
+    // warning in the Session panel doesn't need it — that reads the flag every render —
+    // but an empty table is a thing a dealer needs told, not left to notice.
+    if (HoldemState.loadFailed) {
+        Toast.show(
+            "The saved table couldn't be read, so this one started empty.",
+            { duration: 12000 });
+    }
 });
@@ -173,6 +173,12 @@ const Render = {
        layer.innerHTML = "";
        const template = document.getElementById("seatTemplate");
        const { dealerIndex, sbIndex, bbIndex, manual: manualBlinds } = HoldemState.getBlindSeats(this.state);
+        // A button on an empty chair normally means the table has drifted and wants
+        // fixing. Once it's the dead button it means the opposite — it's exactly where
+        // it belongs — so it gets marked rather than looking like the thing to correct.
+        const deadButtonHere = this.state.deadButton &&
+            HoldemState.deadPositionsApply(this.state) &&
+            !this.state.seats[dealerIndex].inHand;

        this.state.seats.forEach((player, index) => {
            const node = template.content.firstElementChild.cloneNode(true);
@@ -201,8 +207,11 @@ const Render = {
            // of nine identical buttons and couldn't tell which seat held the real one.
            // The label now says whose it is, or what pressing it would do.
            const who = (player.name || "").trim() || `seat ${index + 1}`;
+            dealerChip.classList.toggle("dealerChipDead", hasButton && deadButtonHere);
            const chipLabel = hasButton
-                ? `${who} has the dealer button`
+                ? (deadButtonHere
+                    ? `Dead button on empty seat ${index + 1} — its player left out of the blinds`
+                    : `${who} has the dealer button`)
                : `Give the dealer button to ${who}`;
            dealerChip.setAttribute("aria-label", chipLabel);
            dealerChip.title = chipLabel;
@@ -667,6 +676,49 @@ const Render = {

            list.appendChild(row);
        });
+
+        this.renderColourUp();
+    },
+
+    // Each stack as the chips that make it.
+    //
+    // The legend has only ever read chips *into* an amount — counting what's in front
+    // of somebody. Colouring up at the end of a level is the same question backwards,
+    // and it's the one the dealer has to answer with a rack in one hand: $205 is four
+    // fifties and a five. So is counting a stack out for a player who's leaving.
+    //
+    // Only when there's a legend to work from and a stack to break down; a table that
+    // never set its chip colours up gets nothing, which is what it had before.
+    renderColourUp() {
+        const host = document.getElementById("colourUp");
+        const list = document.getElementById("colourUpList");
+        if (!host || !list) return;
+
+        const legend = this.state.chipLegend || [];
+        const rows = this.state.seats
+            .map((player, index) => ({ player, index }))
+            .filter(({ player }) => Betting.round(Number(player.stack) || 0) > 0)
+            .map(({ player, index }) => ({
+                name: HoldemState.displayName(player, index),
+                stack: Betting.round(Number(player.stack) || 0),
+                chips: Money.formatChipBreakdown(Number(player.stack) || 0, legend),
+            }))
+            .filter(row => row.chips);
+
+        host.hidden = rows.length === 0;
+        if (host.hidden) return;
+
+        list.innerHTML = "";
+        rows.forEach(row => {
+            const term = document.createElement("dt");
+            term.className = "colourUpWho";
+            term.textContent = `${row.name} — ${Money.format(row.stack)}`;
+            const detail = document.createElement("dd");
+            detail.className = "colourUpChips";
+            detail.textContent = row.chips;
+            list.appendChild(term);
+            list.appendChild(detail);
+        });
    },

    // ---- Pot breakdown ----
@@ -761,11 +813,31 @@ const Render = {
    renderStorageWarning() {
        const host = document.getElementById("storageWarning");
        if (!host) return;
-        host.hidden = !HoldemState.saveFailed;
+        host.hidden = !HoldemState.saveFailed && !HoldemState.loadFailed && !HoldemState.otherTabActive;
        if (host.hidden) return;
-        host.textContent =
-            "This table isn't being saved — the browser refused. It'll keep working, " +
-            "but closing or refreshing this tab loses the session. Export CSV below keeps a copy.";
+
+        // Any of these can be true at once — a browser having trouble with storage
+        // tends to have it in both directions — and the one that explains an empty
+        // table goes first, because that's the question the dealer is standing there
+        // asking.
+        const lines = [];
+        if (HoldemState.otherTabActive) {
+            lines.push(
+                "This table is open in another tab, and both are writing to it — " +
+                "whichever acts last wins, so work done in the other one can vanish. " +
+                "Close one, then reload this tab to pick up the table as it stands.");
+        }
+        if (HoldemState.loadFailed) {
+            lines.push(
+                "The saved table couldn't be read, so this one started empty. " +
+                "The unreadable copy has been kept rather than written over.");
+        }
+        if (HoldemState.saveFailed) {
+            lines.push(
+                "This table isn't being saved — the browser refused. It'll keep working, " +
+                "but closing or refreshing this tab loses the session. Export CSV below keeps a copy.");
+        }
+        host.textContent = lines.join(" ");
    },

    // The last step the standings stopped short of. Six signed numbers at 2am is not
@@ -813,8 +885,13 @@ const Render = {
            note.textContent =
                `${Money.format(plan.shortBy)} of winnings has nothing to pay it — there are more chips on the table than cash was taken for. Fix that above before anyone cashes out.`;
        } else {
-            note.textContent =
-                `${Money.format(plan.overBy)} is owed with nobody to pay it to — more cash was taken than there are chips in play. Fix that above before anyone cashes out.`;
+            // If a pot was thrown away on purpose, that's where the gap went, and the
+            // dealer already answered a dialog about it. Telling them to go and fix it
+            // would be sending them after their own decision.
+            const discarded = Math.max(0, Number(this.state.discarded) || 0);
+            note.textContent = discarded > 0
+                ? `${Money.format(plan.overBy)} is owed with nobody to pay it to. ${Money.format(discarded)} was taken off the table when a hand was abandoned, which accounts for ${discarded >= plan.overBy ? "it" : "some of it"}.`
+                : `${Money.format(plan.overBy)} is owed with nobody to pay it to — more cash was taken than there are chips in play. Fix that above before anyone cashes out.`;
        }
        note.classList.toggle("settleUpOff", !plan.balanced);
    },
@@ -833,9 +910,22 @@ const Render = {
        document.getElementById("bankCashIn").textContent = Money.format(bank.cashIn);
        document.getElementById("bankChipsInPlay").textContent = Money.format(bank.chipsInPlay);

+        // An abandoned pot the dealer confirmed throwing away is money that left the
+        // table on purpose. It gets its own line so the two columns still add up in
+        // front of them, rather than looking like a shortfall they have to explain.
+        const discardedRow = document.getElementById("bankDiscardedRow");
+        if (discardedRow) {
+            discardedRow.hidden = !(bank.discarded > 0);
+            if (bank.discarded > 0) {
+                document.getElementById("bankDiscarded").textContent = Money.format(bank.discarded);
+            }
+        }
+
        const verdict = document.getElementById("bankReconcileVerdict");
        if (bank.balanced) {
-            verdict.textContent = "Balanced — the cash covers every chip on the table.";
+            verdict.textContent = bank.discarded > 0
+                ? `Balanced — the cash covers every chip on the table, once the ${Money.format(bank.discarded)} taken off it is counted.`
+                : "Balanced — the cash covers every chip on the table.";
        } else if (bank.difference > 0) {
            verdict.textContent =
                `${Money.format(bank.difference)} more in chips than cash taken. Someone's rebuy probably wasn't recorded — the box will be short at cash-out.`;
@@ -877,9 +967,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
@@ -898,10 +1029,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);
@@ -51,6 +51,9 @@ const HoldemState = {
            notes: "",
            handNumber: 1,
            handHistory: [],
+            // Chips taken off the table on purpose, so the bank check can tell them
+            // apart from chips that have gone missing.
+            discarded: 0,
            smallBlind: 1,
            bigBlind: 2,
            defaultStack: null,
@@ -78,27 +81,122 @@ const HoldemState = {
            // button order is the wrong answer often enough that it has to be
            // overridable. Cleared at the start of every hand.
            blindOverride: null,
+            // Who actually posted, the last time cards went out — { sbIndex, bbIndex }.
+            // The next hand's rotation is worked out from this rather than from the
+            // 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.
+            deadButton: false,
+            deadSmallBlind: false,
        };
    },

+    // Where an unreadable save is kept instead of being written over.
+    RECOVERY_KEY: "casino.holdem.state.v1.unreadable",
+
+    // True once another tab has written to this table. Two tabs each hold their own
+    // copy in memory and each save writes the whole thing, so the second one to act
+    // silently throws the first one's work away — measured: tab A deals and takes a
+    // call, tab B renames a seat, and the deal, the blinds and the call are gone with
+    // nothing said in either tab.
+    //
+    // Watched rather than merged. Replacing the table under a dealer's hands mid-hand
+    // would be its own hazard; knowing there are two of them is what they need.
+    otherTabActive: false,
+    onOtherTab: null,
+
+    // The browser fires this in every *other* tab, never the one that wrote, so our
+    // own saves can't trip it.
+    watchOtherTabs() {
+        if (typeof window === "undefined" || this.tabWatcher) return;
+        this.tabWatcher = event => {
+            if (event.key !== this.STORAGE_KEY) return;
+            if (this.otherTabActive) return;
+            this.otherTabActive = true;
+            if (typeof this.onOtherTab === "function") this.onOtherTab();
+        };
+        window.addEventListener("storage", this.tabWatcher);
+    },
+
+    // True when there was a saved table and it couldn't be read. Same pair as
+    // saveFailed above, for the same reason: the UI has to be able to say so.
+    loadFailed: false,
+    onLoadFailed: null,
+
+    // A saved table that won't parse becomes an empty table, which is the only thing
+    // it can become — but it used to become one silently, and then the first edit
+    // saved over the top of it. A dealer mid-session saw an empty felt with no idea
+    // whether they'd mis-tapped Reset or the browser had lost the night, and whatever
+    // a person might have picked out of the raw JSON was gone a tap later.
+    //
+    // So the unreadable value is moved aside first. It is not offered as a restore —
+    // half a JSON document isn't a table, and pretending otherwise would be worse than
+    // an empty one — but it stops being destroyed, and somebody who wants the
+    // standings out of it still can.
+    failedLoad(raw) {
+        if (!this.loadFailed) {
+            this.loadFailed = true;
+            try {
+                if (raw) localStorage.setItem(this.RECOVERY_KEY, raw);
+            } catch {
+                // No room to keep it. Nothing more to try, and the warning below is
+                // the part that actually matters.
+            }
+            if (typeof this.onLoadFailed === "function") this.onLoadFailed();
+        }
+        return this.createDefault();
+    },
+
    load() {
+        let raw = null;
        try {
-            const raw = localStorage.getItem(this.STORAGE_KEY);
+            raw = localStorage.getItem(this.STORAGE_KEY);
            if (!raw) return this.createDefault();
            const parsed = JSON.parse(raw);
-            if (!parsed || !Array.isArray(parsed.seats)) return this.createDefault();
+            if (!parsed || !Array.isArray(parsed.seats)) return this.failedLoad(raw);
            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;

            // Tables saved before live betting existed are missing its fields; fill
            // them in rather than making the dealer reset a table mid-session.
            const defaults = this.createDefault();
            ["smallBlind", "bigBlind", "defaultStack", "street", "currentBet", "lastRaiseSize",
-                "actingSeatIndex", "blindOverride"]
+                "actingSeatIndex", "blindOverride", "postedBlinds",
+                "streetAggressorIndex", "handAggressorIndex"]
                .forEach(key => {
                    if (parsed[key] === undefined) parsed[key] = defaults[key];
                });

+            // A table saved before the dead button existed has neither flag. False is
+            // the right guess for both: it means the rotation carries on the ordinary
+            // 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
            // progress. Anything already committed, or anyone already on the clock,
@@ -118,7 +216,8 @@ const HoldemState = {

            return parsed;
        } catch {
-            return this.createDefault();
+            // Malformed JSON — a truncated write, another tab, a browser hiccup.
+            return this.failedLoad(raw);
        }
    },

@@ -265,6 +364,10 @@ const HoldemState = {
    // sits on nobody most hands — and that isn't only untidy: position and blinds are
    // supposed to come round to each player at the same rate, and they don't if the
    // button is rotating past chairs nobody is sitting in.
+    //
+    // The fallback, now. nextButtonRotation is what a hand that was actually dealt
+    // rotates by; this is for the cases it has nothing to work from — a fresh table,
+    // a hand never dealt, a dealer pressing Next Hand twice to pass the button on.
    advanceButton(state) {
        for (let step = 1; step <= state.seatCount; step++) {
            const index = this.nextSeatIndex(state, state.dealerSeatIndex, step);
@@ -303,6 +406,10 @@ const HoldemState = {
    buttonSeatForDeal(state) {
        const seated = state.seats[state.dealerSeatIndex];
        if (seated && seated.inHand) return state.dealerSeatIndex;
+        // A button left on an empty chair on purpose is the dead button, and moving it
+        // to a player is precisely what it's there to stop. Only a button that has been
+        // stranded by accident gets rescued.
+        if (state.deadButton && this.deadPositionsApply(state)) return state.dealerSeatIndex;
        for (let step = 0; step < state.seatCount; step++) {
            const index = this.nextSeatIndex(state, state.dealerSeatIndex, step);
            if (state.seats[index].inHand) return index;
@@ -325,6 +432,13 @@ const HoldemState = {
        return o;
    },

+    // A dead button and a dead small blind are three-handed-and-up ideas. Down to two
+    // players the button *is* the small blind and the blinds simply alternate, so
+    // whatever the last rotation left behind stops applying.
+    deadPositionsApply(state) {
+        return state.seats.filter(p => p.inHand).length >= 3;
+    },
+
    // Who posts what. Heads-up is its own rule: with two players the button posts the
    // small blind, which is the opposite of the usual order.
    getBlindSeats(state) {
@@ -356,11 +470,88 @@ const HoldemState = {
            return { dealerIndex, sbIndex, bbIndex, headsUp: true };
        }

+        // The small blind is dead: whoever would have moved into it has left the table,
+        // and the seat stays empty for a hand rather than dragging the big blind
+        // forward an extra place. One player gets a free hand out of position for it;
+        // that's the price of nobody being charged two big blinds in an orbit.
+        if (state.deadSmallBlind && this.deadPositionsApply(state)) {
+            return { dealerIndex, sbIndex: null, bbIndex: live[0], headsUp: false, deadSmallBlind: true };
+        }
+
        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
+    // what it has always done. The case that needs care is somebody getting up out of
+    // the blinds. Passing the button to the next *player* then pulls the whole blind
+    // order forward a place: the player after the empty chair is never asked for a big
+    // blind at all, and the one after them is asked an orbit early. Holding the
+    // rotation to the seats instead is the dead button, and getting it wrong costs a
+    // real player a real big blind.
+    //
+    // Worked out from who actually posted last hand, not from the seating as it stands,
+    // because by now the people it needs to know about are the ones who have gone.
+    nextButtonRotation(state) {
+        const posted = state.postedBlinds;
+        const inRange = i => Number.isInteger(i) && i >= 0 && i < state.seatCount && state.seats[i];
+        const here = i => inRange(i) && state.seats[i].inHand;
+
+        // Nothing to hold to: a fresh table, a hand that was never dealt, or one where
+        // the blinds were named by hand. And heads-up has its own rule — with two
+        // players the button is the small blind, so there is no position to leave dead.
+        if (!posted || !inRange(posted.sbIndex) || !inRange(posted.bbIndex) || !this.deadPositionsApply(state)) {
+            return { buttonIndex: null, deadButton: false, deadSmallBlind: false };
+        }
+
+        // Both still sitting there is the ordinary case, and this comes out as the next
+        // player along — the same answer as passing the button, arrived at from the
+        // blinds so that the unusual case doesn't need a separate path.
+        return {
+            buttonIndex: posted.sbIndex,
+            deadButton: !here(posted.sbIndex),
+            deadSmallBlind: !here(posted.bbIndex),
+        };
+    },
+
    startNextHand(state) {
-        this.advanceButton(state);
+        const rotation = this.nextButtonRotation(state);
+        if (rotation.buttonIndex === null) {
+            this.advanceButton(state);
+            state.deadButton = false;
+            state.deadSmallBlind = false;
+        } else {
+            state.dealerSeatIndex = rotation.buttonIndex;
+            state.deadButton = rotation.deadButton;
+            state.deadSmallBlind = rotation.deadSmallBlind;
+        }
+        // Spent. Pressing Next Hand again without dealing is a dealer passing the
+        // button along, not a second rotation off the same hand.
+        state.postedBlinds = null;
        // Cards aren't out and nothing is posted until the dealer says so.
        state.bettingOpen = false;
        state.actingSeatIndex = null;
@@ -371,6 +562,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 = ["", ""];
@@ -474,6 +668,14 @@ const HoldemState = {
                // window is almost always.
                const inFrontOfThem = seat ? (Number(seat.amountOverride) || 0) + (Number(seat.committed) || 0) : 0;

+                // Whatever the dealer wrote against this seat — "IOU: $20 to Ann",
+                // "Venmo: @ann". It's carried here so the export can hand it over with
+                // the money it belongs to; the standings panel itself doesn't show it.
+                const notes = (seat && Array.isArray(seat.customFields) ? seat.customFields : [])
+                    .filter(field => (field.label || "").trim() || (field.value || "").trim())
+                    .map(field => `${(field.label || "").trim()}: ${(field.value || "").trim()}`.replace(/^: | :$/, ""))
+                    .join("; ");
+
                return {
                    ...t,
                    in: Money.round(t.in),
@@ -482,6 +684,7 @@ const HoldemState = {
                    boughtIn,
                    chipsNow,
                    cashPosition: Money.round(chipsNow + inFrontOfThem - boughtIn),
+                    notes,
                };
            })
            .sort((a, b) => b.net - a.net);
@@ -523,10 +726,19 @@ const HoldemState = {
            0
        );

-        const difference = Money.round(chipsInPlay - cashIn);
+        // Chips the dealer deliberately took off the table — an abandoned pot they
+        // were asked about and confirmed. They are gone, so they can't be counted as
+        // in play, but they aren't missing either: the box knows exactly where they
+        // went. Without this the check blamed the tool's own confirmed action on
+        // "someone has paid for chips they haven't been given", which sends a dealer
+        // hunting for a miscount that never happened.
+        const discarded = Math.max(0, Money.round(Number(state.discarded) || 0));
+
+        const difference = Money.round(chipsInPlay + discarded - cashIn);
        return {
            cashIn: Money.round(cashIn),
            chipsInPlay: Money.round(chipsInPlay),
+            discarded,
            difference,
            // Half a cent of float dust isn't a discrepancy worth alarming anyone over.
            balanced: Math.abs(difference) <= Money.EPSILON,
@@ -0,0 +1,268 @@
+// The button when somebody gets up out of the blinds.
+//
+// Passing the button to the next *player* is right until a chair between the button
+// and the blinds empties. Then it pulls the whole blind order forward a place: the
+// player after the empty chair is never asked for a big blind, and the one after them
+// is asked an orbit early. The dead button rule holds the rotation to the seats for
+// one hand so the big blind still advances exactly one player.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { HoldemState, Betting, makeTable } = require("./load");
+
+// Four players in six chairs: Ann 0, Ben 1, Cal 2, Dee 3.
+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;
+};
+
+const nameOf = (state, index) =>
+    index === null || index === undefined ? null : (state.seats[index].name || `empty seat ${index + 1}`);
+
+const blinds = state => {
+    const { sbIndex, bbIndex } = HoldemState.getBlindSeats(state);
+    return { sb: nameOf(state, sbIndex), bb: nameOf(state, bbIndex) };
+};
+
+const leave = (state, index) => {
+    state.seats[index].name = "";
+    state.seats[index].inHand = false;
+    state.seats[index].stack = 0;
+    state.seats[index].buyIns = 0;
+};
+
+describe("somebody gets up out of the blinds", () => {
+    test("the small blind leaves: dead button, and the big blind still moves one player", () => {
+        const state = table(1);                 // button Ben, small Cal, big Dee
+        Betting.beginHand(state);
+        assert.deepEqual(blinds(state), { sb: "Cal", bb: "Dee" });
+
+        leave(state, 2);                        // Cal takes their chips and goes
+        HoldemState.startNextHand(state);
+        Betting.beginHand(state);
+
+        assert.equal(state.dealerSeatIndex, 2, "the button holds Cal's empty chair");
+        assert.equal(state.seats[2].inHand, false, "which is the point — it's on nobody");
+        assert.deepEqual(blinds(state), { sb: "Dee", bb: "Ann" },
+            "Dee moves from big to small and Ann posts the big blind, one player along");
+    });
+
+    test("and Ann is not skipped, which is the money in it", () => {
+        // The old rotation passed the button to the next player, which made the blinds
+        // Ann/Ben — Ann never posting a big blind at all, and Ben posting one an orbit
+        // early. That is a real big blind out of a real player's stack.
+        const state = table(1);
+        Betting.beginHand(state);
+        leave(state, 2);
+        HoldemState.startNextHand(state);
+
+        assert.equal(blinds(state).bb, "Ann", "Ann owes the big blind and still owes it");
+    });
+
+    test("the big blind leaves: no small blind is posted this hand", () => {
+        const state = table(1);                 // button Ben, small Cal, big Dee
+        Betting.beginHand(state);
+
+        leave(state, 3);                        // Dee goes
+        HoldemState.startNextHand(state);
+        Betting.beginHand(state);
+
+        const { sbIndex, bbIndex, deadSmallBlind } = HoldemState.getBlindSeats(state);
+        assert.equal(state.dealerSeatIndex, 2, "the button reaches Cal as it was always going to");
+        assert.equal(sbIndex, null, "the small blind is dead");
+        assert.equal(deadSmallBlind, true, "and says so, rather than looking like a table with no blinds");
+        assert.equal(nameOf(state, bbIndex), "Ann", "the big blind still moves on one player");
+    });
+
+    test("a dead small blind still deals a hand, with one blind in the middle", () => {
+        const state = table(1);
+        Betting.beginHand(state);
+        leave(state, 3);
+        HoldemState.startNextHand(state);
+        Betting.beginHand(state);
+
+        assert.equal(state.bettingOpen, true, "the hand goes ahead");
+        const posted = state.seats.reduce((sum, p) => sum + Betting.committed(p), 0);
+        assert.equal(posted, state.bigBlind, "just the big blind, and nothing conjured to stand in for the small");
+        assert.equal(state.currentBet, state.bigBlind);
+        assert.ok(state.actingSeatIndex !== null, "and somebody is on the clock");
+    });
+
+    test("somebody leaving from anywhere else changes nothing", () => {
+        const state = table(1);                 // button Ben, small Cal, big Dee
+        Betting.beginHand(state);
+
+        leave(state, 0);                        // Ann, who was under the gun
+        HoldemState.startNextHand(state);
+
+        assert.equal(state.dealerSeatIndex, 2, "the button passes to Cal exactly as before");
+        assert.equal(state.deadButton, false);
+        assert.equal(state.deadSmallBlind, false);
+        assert.deepEqual(blinds(state), { sb: "Dee", bb: "Ben" });
+    });
+});
+
+describe("the ordinary rotation is untouched", () => {
+    test("a full table passes the button one player at a time", () => {
+        const state = table(0);
+        const seen = [];
+        for (let hand = 0; hand < 8; hand++) {
+            Betting.beginHand(state);
+            seen.push(blinds(state).bb);
+            HoldemState.startNextHand(state);
+        }
+        assert.deepEqual(seen, ["Cal", "Dee", "Ann", "Ben", "Cal", "Dee", "Ann", "Ben"],
+            "two clean orbits, everybody paying one big blind per orbit");
+        assert.equal(state.deadButton, false);
+        assert.equal(state.deadSmallBlind, false);
+    });
+
+    test("players spread thinly around a big table don't create dead positions", () => {
+        // Three players in nine chairs. The chairs between them were never in the
+        // rotation, so holding to seats there would post blinds to nobody hand after
+        // hand — which is why the button follows players, not chairs, by default.
+        const state = makeTable({ seatCount: 9, seated: [0, 4, 7], stack: 200, dealerSeatIndex: 0 });
+        ["Ann", "", "", "", "Ben", "", "", "Cal"].forEach((n, i) => { state.seats[i].name = n; });
+
+        const seen = [];
+        for (let hand = 0; hand < 6; hand++) {
+            Betting.beginHand(state);
+            const { sbIndex, bbIndex } = HoldemState.getBlindSeats(state);
+            assert.ok(state.seats[sbIndex].inHand, "a real player posts the small blind");
+            assert.ok(state.seats[bbIndex].inHand, "and a real player the big");
+            seen.push(nameOf(state, bbIndex));
+            HoldemState.startNextHand(state);
+        }
+        assert.deepEqual(seen, ["Cal", "Ann", "Ben", "Cal", "Ann", "Ben"], "one big blind each per orbit");
+    });
+
+    test("pressing next hand twice without dealing just passes the button along", () => {
+        const state = table(0);
+        Betting.beginHand(state);
+
+        HoldemState.startNextHand(state);
+        assert.equal(state.dealerSeatIndex, 1);
+        HoldemState.startNextHand(state);
+        assert.equal(state.dealerSeatIndex, 2, "and doesn't rotate off the same hand twice");
+    });
+});
+
+describe("the rule knows where it stops", () => {
+    test("down to two players, heads-up takes over and nothing is left dead", () => {
+        const state = table(1);
+        Betting.beginHand(state);
+        leave(state, 2);
+        leave(state, 3);                        // both blinds walk at once
+
+        HoldemState.startNextHand(state);
+        Betting.beginHand(state);
+
+        const { sbIndex, headsUp } = HoldemState.getBlindSeats(state);
+        assert.equal(headsUp, true);
+        assert.equal(sbIndex, state.dealerSeatIndex, "heads-up the button posts the small blind");
+        assert.ok(state.seats[state.dealerSeatIndex].inHand, "and the button is on a player again");
+    });
+
+    test("a button stranded by accident is still rescued", () => {
+        // Not the dead button: nobody left out of the blinds, the chair the button is
+        // on just emptied. That one does want putting back on a player.
+        const state = table(3);
+        state.seats[3].inHand = false;
+        HoldemState.ensureButtonOnPlayer(state);
+        assert.ok(state.seats[state.dealerSeatIndex].inHand);
+    });
+
+    test("moving the button by hand clears the dead positions", () => {
+        const state = table(1);
+        Betting.beginHand(state);
+        leave(state, 2);
+        HoldemState.startNextHand(state);
+        assert.equal(state.deadButton, true);
+
+        // What the seat menu's "Give the button" does.
+        state.dealerSeatIndex = 0;
+        state.deadButton = false;
+        state.deadSmallBlind = false;
+        Betting.beginHand(state);
+
+        const { sbIndex } = HoldemState.getBlindSeats(state);
+        assert.ok(state.seats[sbIndex].inHand, "a real small blind again, where the dealer put it");
+    });
+
+    test("naming a blind by hand overrules a dead one", () => {
+        const state = table(1);
+        Betting.beginHand(state);
+        leave(state, 3);
+        HoldemState.startNextHand(state);
+        assert.equal(state.deadSmallBlind, true);
+
+        state.blindOverride = { sbIndex: 1, bbIndex: 0 };
+        const { sbIndex, bbIndex, manual } = HoldemState.getBlindSeats(state);
+        assert.equal(manual, true);
+        assert.equal(sbIndex, 1, "the dealer's word beats the rule");
+        assert.equal(bbIndex, 0);
+    });
+
+    test("a table saved before any of this reads as nothing dead", () => {
+        const state = table(0);
+        const parsed = JSON.parse(JSON.stringify(state));
+        delete parsed.deadButton;
+        delete parsed.deadSmallBlind;
+        delete parsed.postedBlinds;
+
+        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.equal(loaded.deadButton, false);
+        assert.equal(loaded.deadSmallBlind, false);
+        assert.equal(loaded.postedBlinds, null);
+
+        HoldemState.startNextHand(loaded);
+        assert.ok(loaded.seats[loaded.dealerSeatIndex].inHand, "and rotates the ordinary way");
+        delete globalThis.localStorage;
+    });
+});
+
+describe("chips are not invented or lost by any of it", () => {
+    test("posting one blind instead of two moves chips and doesn't make them", () => {
+        // Measured across the deal, which is the step that touches stacks. A hand with
+        // a dead small blind has one blind in the middle instead of two — the danger is
+        // a null small blind being treated as a zero-cost posting somewhere, or the big
+        // blind quietly covering for it.
+        const state = table(1);
+        const chips = s => s.seats.reduce(
+            (sum, p) => sum + Betting.stackOf(s, p) + Betting.handTotal(p), 0);
+
+        Betting.beginHand(state);
+        leave(state, 3);                        // the big blind goes, small blind dies
+
+        for (let hand = 0; hand < 4; hand++) {
+            HoldemState.startNextHand(state);
+            const before = chips(state);
+            Betting.beginHand(state);
+            assert.equal(chips(state), before, `the deal drifted the count on hand ${hand + 1}`);
+        }
+    });
+
+    test("a dead small blind takes exactly one blind out of one stack", () => {
+        const state = table(1);
+        Betting.beginHand(state);
+        leave(state, 3);
+        HoldemState.startNextHand(state);
+
+        const stacks = () => state.seats.map(p => Betting.stackOf(state, p));
+        const before = stacks();
+        Betting.beginHand(state);
+        const after = stacks();
+
+        const paid = before.map((v, i) => v - after[i]).filter(d => d !== 0);
+        assert.deepEqual(paid, [state.bigBlind], "one player, one big blind, nobody else touched");
+    });
+});
@@ -0,0 +1,94 @@
+// Chips the dealer took off the table on purpose.
+//
+// Starting the next hand with money still in the middle destroys it — the tool asks
+// first and says so afterwards. What it didn't do was remember, so the bank check saw
+// only that chips were gone and reported them as missing.
+const test = require("node:test");
+const assert = require("node:assert");
+const { HoldemState, Money, makeTable } = require("./load");
+
+const table = () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack: 200 });
+    state.seats.slice(0, 4).forEach(player => { player.buyIns = 200; });
+    return state;
+};
+
+test("a table with nothing thrown away balances as before", () => {
+    const bank = HoldemState.bankReconciliation(table());
+
+    assert.equal(bank.balanced, true);
+    assert.equal(bank.discarded, 0);
+});
+
+test("chips that went missing are still reported", () => {
+    // The check exists for this: cash in the box with no chips to match it.
+    const state = table();
+    state.seats[0].stack = 150;
+
+    const bank = HoldemState.bankReconciliation(state);
+    assert.equal(bank.balanced, false);
+    assert.equal(bank.difference, -50);
+});
+
+test("an abandoned pot is accounted for rather than counted as missing", () => {
+    const state = table();
+    state.seats[1].stack = 199;
+    state.seats[2].stack = 198;
+    state.seats[3].stack = 198;
+    state.discarded = 5;
+
+    const bank = HoldemState.bankReconciliation(state);
+    assert.equal(bank.chipsInPlay, 795);
+    assert.equal(bank.discarded, 5);
+    assert.equal(bank.balanced, true, "the box knows exactly where that $5 went");
+});
+
+test("throwing a pot away doesn't hide a real shortfall underneath it", () => {
+    const state = table();
+    state.seats[1].stack = 199;
+    state.seats[2].stack = 198;
+    state.seats[3].stack = 148;   // $50 genuinely unaccounted for as well
+    state.discarded = 5;
+
+    const bank = HoldemState.bankReconciliation(state);
+    assert.equal(bank.balanced, false);
+    assert.equal(bank.difference, -50);
+});
+
+test("a nonsense discarded value can't move the answer", () => {
+    const state = table();
+    state.discarded = -100;
+    assert.equal(HoldemState.bankReconciliation(state).discarded, 0);
+
+    state.discarded = "not a number";
+    assert.equal(HoldemState.bankReconciliation(state).discarded, 0);
+});
+
+test("a table saved before this existed reads as nothing thrown away", () => {
+    const saved = JSON.stringify(table());
+    const parsed = JSON.parse(saved);
+    delete parsed.discarded;
+
+    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.equal(loaded.discarded, 0);
+    assert.equal(HoldemState.bankReconciliation(loaded).balanced, true);
+    delete globalThis.localStorage;
+});
+
+test("the amounts still add up the way the panel shows them", () => {
+    const state = table();
+    state.seats[1].stack = 199;
+    state.seats[2].stack = 198;
+    state.seats[3].stack = 198;
+    state.discarded = 5;
+
+    const bank = HoldemState.bankReconciliation(state);
+    assert.equal(Money.round(bank.chipsInPlay + bank.discarded), bank.cashIn);
+});
@@ -0,0 +1,97 @@
+// The things the dealer wrote down, in the file they hand over.
+//
+// The export already carried the hands, the standings and the settle-up. It didn't
+// carry either of the two places a dealer types context — the per-seat fields and the
+// table's own notes — so the one place an IOU was written down was the one place it
+// couldn't leave.
+const test = require("node:test");
+const assert = require("node:assert");
+const { HandHistoryExport, HoldemState, makeTable } = require("./load");
+
+const tableWithNotes = () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 200 });
+    ["Ann", "Ben", "Cal"].forEach((name, i) => {
+        state.seats[i].name = name;
+        state.seats[i].buyIns = 200;
+    });
+    state.seats[0].customFields = [
+        { label: "Seat rent", value: "paid to 2am" },
+        { label: "Venmo", value: "@ann" },
+    ];
+    state.seats[1].customFields = [{ label: "IOU", value: "$20 to Ann" }];
+    return state;
+};
+
+test("a seat's own fields ride along with its standings row", () => {
+    const state = tableWithNotes();
+    const csv = HandHistoryExport.toCsv([], HoldemState.sessionStandings(state));
+
+    assert.match(csv, /Seat rent: paid to 2am; Venmo: @ann/);
+    assert.match(csv, /IOU: \$20 to Ann/);
+});
+
+test("the money columns keep their order, with notes on the end", () => {
+    const state = tableWithNotes();
+    const csv = HandHistoryExport.toCsv([], HoldemState.sessionStandings(state));
+
+    assert.match(csv, /Player,Paid In,Won,Net,Bought In,Chips Now,Up\/Down,Notes/);
+});
+
+test("a seat with nothing written against it gets an empty cell, not the word undefined", () => {
+    const state = tableWithNotes();
+    const csv = HandHistoryExport.toCsv([], HoldemState.sessionStandings(state));
+    const calRow = csv.split("\r\n").find(line => line.startsWith("Cal,"));
+
+    assert.ok(calRow, "Cal should have a row");
+    assert.ok(calRow.endsWith(","), `expected an empty last cell, got ${calRow}`);
+    assert.ok(!/undefined|null/.test(calRow));
+});
+
+test("a blank label or value doesn't produce a stray colon", () => {
+    const state = tableWithNotes();
+    state.seats[2].customFields = [{ label: "Note", value: "" }, { label: "", value: "" }];
+    const csv = HandHistoryExport.toCsv([], HoldemState.sessionStandings(state));
+    const calRow = csv.split("\r\n").find(line => line.startsWith("Cal,"));
+
+    assert.match(calRow, /Note/);
+    assert.ok(!/;\s*;/.test(calRow), "an entirely blank field shouldn't take a slot");
+});
+
+test("the table's notes are in the file", () => {
+    const state = tableWithNotes();
+    state.notes = "High-hand promo until midnight.";
+    const csv = HandHistoryExport.toCsv([], HoldemState.sessionStandings(state), { notes: state.notes });
+
+    assert.match(csv, /Table Notes/);
+    assert.match(csv, /High-hand promo until midnight\./);
+});
+
+test("a multi-line note survives as one cell", () => {
+    // csvField quotes anything with a line break in it, so the note doesn't turn into
+    // rows a spreadsheet reads as more players.
+    const state = tableWithNotes();
+    const notes = "Line one\nLine two, with a comma\nLine \"three\"";
+    const csv = HandHistoryExport.toCsv([], HoldemState.sessionStandings(state), { notes });
+
+    assert.match(csv, /"Line one\nLine two, with a comma\nLine ""three"""/);
+});
+
+test("no notes means no section, not an empty heading", () => {
+    const state = tableWithNotes();
+    const csv = HandHistoryExport.toCsv([], HoldemState.sessionStandings(state), { notes: "   " });
+
+    assert.ok(!/Table Notes/.test(csv));
+});
+
+test("the export still works with no standings at all", () => {
+    assert.doesNotThrow(() => HandHistoryExport.toCsv([], [], { notes: "just a note" }));
+    const csv = HandHistoryExport.toCsv([], [], { notes: "just a note" });
+    assert.match(csv, /Table Notes/);
+});
+
+test("asking for the standings doesn't change the seats", () => {
+    const state = tableWithNotes();
+    const before = JSON.stringify(state.seats);
+    HoldemState.sessionStandings(state);
+    assert.equal(JSON.stringify(state.seats), before);
+});
@@ -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");
+    });
+});
@@ -0,0 +1,114 @@
+// What happens when the saved table can't be read.
+//
+// An unreadable save can only become an empty table. What it must not do is become
+// one silently and then get written over by the first edit.
+const test = require("node:test");
+const assert = require("node:assert");
+const { HoldemState } = require("./load");
+
+function withStored(value, { readOnly = false } = {}) {
+    const store = new Map();
+    if (value !== undefined) store.set(HoldemState.STORAGE_KEY, value);
+    globalThis.localStorage = {
+        getItem: key => (store.has(key) ? store.get(key) : null),
+        setItem(key, val) {
+            if (readOnly) throw new Error("QuotaExceededError");
+            store.set(key, val);
+        },
+        removeItem: key => store.delete(key),
+    };
+    return store;
+}
+
+test.beforeEach(() => {
+    HoldemState.loadFailed = false;
+    HoldemState.onLoadFailed = null;
+});
+
+test.after(() => {
+    delete globalThis.localStorage;
+    HoldemState.loadFailed = false;
+    HoldemState.onLoadFailed = null;
+});
+
+test("nothing stored is a new table, not a failure", () => {
+    withStored(undefined);
+    const state = HoldemState.load();
+
+    assert.equal(HoldemState.loadFailed, false);
+    assert.ok(Array.isArray(state.seats));
+});
+
+test("a good save loads and reports nothing", () => {
+    const store = withStored(undefined);
+    const original = HoldemState.createDefault();
+    original.handNumber = 34;
+    HoldemState.save(original);
+
+    const state = HoldemState.load();
+    assert.equal(HoldemState.loadFailed, false);
+    assert.equal(state.handNumber, 34);
+    assert.equal(store.has(HoldemState.RECOVERY_KEY), false);
+});
+
+test("a truncated save is reported rather than silently becoming an empty table", () => {
+    const good = JSON.stringify(HoldemState.createDefault());
+    withStored(good.slice(0, Math.floor(good.length * 0.7)));
+
+    const state = HoldemState.load();
+    assert.equal(HoldemState.loadFailed, true);
+    assert.ok(Array.isArray(state.seats), "it still hands back a usable table");
+});
+
+test("valid JSON of the wrong shape counts as unreadable too", () => {
+    withStored(JSON.stringify({ hello: "world" }));
+
+    HoldemState.load();
+    assert.equal(HoldemState.loadFailed, true);
+});
+
+test("the unreadable copy is kept instead of being written over", () => {
+    // This is the half that matters: whatever a person could have picked out of the
+    // raw JSON used to be gone the moment the dealer touched a seat.
+    const broken = '{"seats":[{"name":"Ann","stack":250},{"name":"Ben"';
+    const store = withStored(broken);
+
+    HoldemState.load();
+
+    assert.equal(store.get(HoldemState.RECOVERY_KEY), broken);
+});
+
+test("a later save doesn't touch the copy that was set aside", () => {
+    const broken = '{"seats":[{"name":"Ann"';
+    const store = withStored(broken);
+
+    const state = HoldemState.load();
+    state.handNumber = 2;
+    HoldemState.save(state);
+
+    assert.equal(store.get(HoldemState.RECOVERY_KEY), broken);
+    assert.notEqual(store.get(HoldemState.STORAGE_KEY), broken);
+});
+
+test("the listener fires once, not on every read", () => {
+    withStored("{not json");
+    let told = 0;
+    HoldemState.onLoadFailed = () => { told++; };
+
+    HoldemState.load();
+    HoldemState.load();
+    HoldemState.load();
+
+    assert.equal(told, 1);
+});
+
+test("no room to keep the copy is not a crash", () => {
+    // Storage that refuses writes is exactly the storage most likely to hand back a
+    // half-written value in the first place.
+    withStored("{not json", { readOnly: true });
+
+    let state;
+    assert.doesNotThrow(() => { state = HoldemState.load(); });
+    assert.ok(Array.isArray(state.seats));
+    assert.equal(HoldemState.loadFailed, true);
+});
@@ -96,11 +96,26 @@ describe("the exported CSV", () => {
            assert.ok(cell !== "" && !Number.isNaN(Number(cell)), `pot cell "${cell}" isn't a number`);
        });

-        // Standings rows: every column after the name has to be numeric.
+        // Standings rows: the money columns have to be numeric. Named rather than
+        // "everything after the first", which is what this used to say — the row now
+        // ends with a Notes column carrying whatever the dealer typed against the seat,
+        // and that is text by definition. The point of this test is that a column
+        // somebody totals adds up, so it checks the columns somebody totals.
        const standingsStart = lines.findIndex(l => l.startsWith("Player,"));
+        const header = splitRow(lines[standingsStart]);
+        const moneyColumns = ["Paid In", "Won", "Net", "Bought In", "Chips Now", "Up/Down"]
+            .map(name => {
+                const index = header.indexOf(name);
+                assert.ok(index > 0, `the standings header should still have a ${name} column`);
+                return index;
+            });
+
        lines.slice(standingsStart + 1).filter(Boolean).forEach(line => {
-            splitRow(line).slice(1).forEach(cell => {
-                assert.ok(cell !== "" && !Number.isNaN(Number(cell)), `standings cell "${cell}" isn't a number`);
+            const cells = splitRow(line);
+            moneyColumns.forEach(index => {
+                const cell = cells[index];
+                assert.ok(cell !== "" && !Number.isNaN(Number(cell)),
+                    `standings cell "${cell}" in column ${header[index]} isn't a number`);
            });
        });
    });
@@ -0,0 +1,100 @@
+// Noticing that the same table is open twice.
+//
+// Two tabs each hold their own copy in memory and each save writes the whole thing,
+// so the second one to act throws the first one's work away. This doesn't merge them
+// — replacing a table under a dealer's hands mid-hand would be its own hazard — it
+// notices, which is what lets them decide.
+const test = require("node:test");
+const assert = require("node:assert");
+const { HoldemState } = require("./load");
+
+function withWindow() {
+    const listeners = [];
+    globalThis.window = {
+        addEventListener(type, fn) { if (type === "storage") listeners.push(fn); },
+        removeEventListener(type, fn) {
+            const i = listeners.indexOf(fn);
+            if (i >= 0) listeners.splice(i, 1);
+        },
+    };
+    return {
+        listeners,
+        fire(key) { listeners.forEach(fn => fn({ key })); },
+    };
+}
+
+test.beforeEach(() => {
+    HoldemState.otherTabActive = false;
+    HoldemState.onOtherTab = null;
+    HoldemState.tabWatcher = null;
+});
+
+test.after(() => {
+    delete globalThis.window;
+    HoldemState.otherTabActive = false;
+    HoldemState.onOtherTab = null;
+    HoldemState.tabWatcher = null;
+});
+
+test("a write to this table from elsewhere is noticed", () => {
+    const win = withWindow();
+    let told = 0;
+    HoldemState.onOtherTab = () => { told++; };
+    HoldemState.watchOtherTabs();
+
+    win.fire(HoldemState.STORAGE_KEY);
+
+    assert.equal(HoldemState.otherTabActive, true);
+    assert.equal(told, 1);
+});
+
+test("somebody else's storage key is not our business", () => {
+    const win = withWindow();
+    let told = 0;
+    HoldemState.onOtherTab = () => { told++; };
+    HoldemState.watchOtherTabs();
+
+    win.fire("some.other.app.state");
+    win.fire(HoldemState.RECOVERY_KEY);
+
+    assert.equal(HoldemState.otherTabActive, false);
+    assert.equal(told, 0);
+});
+
+test("told once, however many times the other tab acts", () => {
+    const win = withWindow();
+    let told = 0;
+    HoldemState.onOtherTab = () => { told++; };
+    HoldemState.watchOtherTabs();
+
+    for (let i = 0; i < 10; i++) win.fire(HoldemState.STORAGE_KEY);
+
+    assert.equal(told, 1);
+});
+
+test("watching twice doesn't listen twice", () => {
+    const win = withWindow();
+    HoldemState.watchOtherTabs();
+    HoldemState.watchOtherTabs();
+    HoldemState.watchOtherTabs();
+
+    assert.equal(win.listeners.length, 1);
+});
+
+test("no listener set is not an error", () => {
+    const win = withWindow();
+    HoldemState.onOtherTab = null;
+    HoldemState.watchOtherTabs();
+
+    assert.doesNotThrow(() => win.fire(HoldemState.STORAGE_KEY));
+    assert.equal(HoldemState.otherTabActive, true);
+});
+
+test("no window at all is not an error", () => {
+    // The same modules are loaded in Node by the test harness.
+    delete globalThis.window;
+    HoldemState.tabWatcher = null;
+
+    assert.doesNotThrow(() => HoldemState.watchOtherTabs());
+    assert.equal(HoldemState.otherTabActive, false);
+});
@@ -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;
+    });
+});
@@ -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);
+    });
+});
@@ -0,0 +1,37 @@
+// How the think-clock reads.
+const test = require("node:test");
+const assert = require("node:assert");
+const path = require("path");
+
+const ActionBar = require(path.join(
+    __dirname, "..", "..", "JoshHeaps.Net", "wwwroot", "js", "casino", "holdem", "actionBar.js"));
+
+test("seconds under a minute", () => {
+    assert.equal(ActionBar.formatTank(0), "0:00");
+    assert.equal(ActionBar.formatTank(7), "0:07");
+    assert.equal(ActionBar.formatTank(59), "0:59");
+});
+
+test("minutes and seconds", () => {
+    assert.equal(ActionBar.formatTank(60), "1:00");
+    assert.equal(ActionBar.formatTank(241), "4:01");
+    assert.equal(ActionBar.formatTank(3599), "59:59");
+});
+
+test("past the hour it says the hour", () => {
+    // A table left open on a hand reaches this, and "65:03" is a number the eye reads
+    // as minutes and seconds when it isn't.
+    assert.equal(ActionBar.formatTank(3600), "1:00:00");
+    assert.equal(ActionBar.formatTank(3903), "1:05:03");
+    assert.equal(ActionBar.formatTank(45296), "12:34:56");
+});
+
+test("the minutes are padded once there are hours, and not before", () => {
+    // "1:5:03" would be wrong; "05:03" on its own would be odd.
+    assert.equal(ActionBar.formatTank(3903), "1:05:03");
+    assert.equal(ActionBar.formatTank(303), "5:03");
+});
+
+test("a day is still a readable number rather than a wrapped one", () => {
+    assert.equal(ActionBar.formatTank(90000), "25:00:00");
+});
@@ -180,6 +180,12 @@ const LayoutAudit = {
    collapsedColumns() {
        const offenders = [];
        [...document.querySelectorAll("[class*='Row'], [class*='row']")].forEach(row => {
+            // Nothing inside something the page has hidden. A hidden element's children
+            // all measure zero wide, so the standings header — which is hidden along
+            // with its table until somebody has bought in — was reported as three
+            // collapsed columns on every empty table. A column nobody can see hasn't
+            // collapsed; it isn't there.
+            if (row.closest("[hidden]")) return;
            if (getComputedStyle(row).display !== "grid") return;
            [...row.children].forEach(cell => {
                if (getComputedStyle(cell).display === "none") return;
@@ -343,6 +349,16 @@ const LayoutAudit = {
        });
    },

+    // Every element between this one and the document, so an opacity set on a
+    // container can be seen from the text inside it.
+    *ancestors(el) {
+        let node = el.parentElement;
+        while (node) {
+            yield node;
+            node = node.parentElement;
+        }
+    },
+
    contrast({ minimum = 4.5, largeMinimum = 3, selector = null } = {}) {
        const offenders = [];
        const unmeasured = [];
@@ -352,19 +368,50 @@ const LayoutAudit = {
            : [...document.querySelectorAll("*")];

        nodes.forEach(el => {
-            if (el.children.length > 0) return;               // leaf text only
-            const text = (el.textContent || "").trim();
+            // An element's *own* text, not its descendants' — they get measured on
+            // their own turn, against their own colour.
+            //
+            // This used to be "leaf elements only", which quietly stopped measuring
+            // anything the moment a child was added to it. The undo control went that
+            // way the day a <kbd> was appended to it: its label became invisible to
+            // this check, with no sign that anything had changed.
+            const text = [...el.childNodes]
+                .filter(node => node.nodeType === 3)
+                .map(node => node.textContent)
+                .join(" ")
+                .trim();
            if (!text) return;
            const rect = el.getBoundingClientRect();
            if (rect.width === 0 || rect.height === 0) return;
            const style = getComputedStyle(el);
            if (style.visibility === "hidden" || style.display === "none") return;
-            if (parseFloat(style.opacity) < 0.99) return;     // faded on purpose
-            // Decoration is exempt by definition: the watermark on the felt is meant
-            // to be barely there, and holding it to a reading threshold would mean
-            // making it not a watermark. Marked aria-hidden so screen readers skip it
-            // too, which is the same claim expressed where it also does some good.
-            if (el.closest("[aria-hidden='true']")) return;
+            // Faded text used to be skipped outright as "faded on purpose", and that
+            // exemption hid a real fault: the folded and sat-out seats dimmed their
+            // whole box with opacity, so a folded player's stack measured 2.22:1 at
+            // 11.5px and this check never looked at it. Something invisible is still
+            // exempt — there's nothing to read at zero — but anything in between is
+            // reported as unmeasured rather than passed over in silence, because a
+            // number nobody checked is not the same as a number that's fine.
+            const opacity = parseFloat(style.opacity);
+            if (opacity <= 0.02) return;
+            const faded = opacity < 0.99 ||
+                [...this.ancestors(el)].some(a => parseFloat(getComputedStyle(a).opacity) < 0.99);
+            if (faded) {
+                unmeasured.push(`${this.describe(el)} :: faded (opacity ${opacity}), contrast not checked`);
+                return;
+            }
+            // aria-hidden used to exempt text here, on the grounds that decoration
+            // marked for screen readers was decoration for everyone. Those are two
+            // different questions and the answer differs: the bet chips on the felt are
+            // aria-hidden because their amounts are already announced by the seat and
+            // the action bar, and repeating them would be noise — but they are exactly
+            // what a sighted dealer reads the felt for, and this check had stopped
+            // looking at them. Hiding something from one audience is not a claim about
+            // whether the other audience can read it.
+            //
+            // Nothing is exempt now. If something genuinely decorative turns up, it
+            // should say so in its own words rather than borrowing an attribute that
+            // means something else.

            const fgRaw = this.parseColour(style.color);
            if (!fgRaw) return;