Keep the list of who's next, instead of leaving it on a napkin

A full home game always has two or three people standing behind the chairs, and
the list of who's next lives on a napkin or in the dealer's head. That is where
the argument an hour later comes from. The tool had just learned to open a chair
— somebody cashes out and the seat is free — and had nothing to say about who
should sit in it.

The Session panel keeps the list in order of arrival, which is the only ordering
anybody has ever agreed to. Whoever is at the front is offered the first open
chair by number, and everybody else waits their turn: a list that isn't kept in
order is a pile of names, and jumping the queue is the thing a dealer gets
shouted at for. With the table full it says so rather than offering a seat that
doesn't exist. The same offer appears on the empty chair's own menu — "Seat
Priya" — because tapping the chair somebody is about to sit in is what a dealer's
hand does anyway.

Sitting somebody down puts their name on the chair and nothing else. No stack, no
buy-in, not dealt in: they haven't paid yet, and inventing chips for them would
put money on the table nobody has handed over, which is the one thing the bank
check exists to catch. Add chips is the next thing the dealer does, and it is one
tap away in the same menu.

Two people called Mike are two people — the list is keyed by id, not by name.
Names are trimmed, blanks are refused, and a saved list from a table that never
had one comes back empty rather than undefined.

15 new tests, with the occupied-chair guard removed and a stack handed to the new
player on purpose to confirm they fail. Walked through the browser: two names
added to a full table, a player cashed out to open seat 2, the front of the queue
seated there with nothing in front of them, the bank still balanced, and the
second name taken off the list. 156 audits with the list populated, including a
name long enough to test the row.

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

JoshHeaps.Net/Pages/Casino/TexasHoldem.cshtml

@@ -14,6 +14,7 @@
         </div>
         <div id="holdemHeaderActions">
             <a href="/casino/texasholdem/quicksplit" class="holdemBtn" title="Chop a pot without setting up a table">Quick Split</a>
+            <button id="misdealBtn" class="holdemBtn" title="Take this hand back — every chip returns to the player who put it in, and the same button deals again" hidden>Misdeal</button>
             <button id="nextHandBtn" class="holdemBtn" title="Move the button, small blind and big blind to the next occupied seat">Next Hand ⟳</button>
             <button id="resolvePotBtn" class="holdemBtn holdemBtnAccent">Resolve Pot</button>
             <button id="resetTableBtn" class="holdemBtn holdemBtnDanger">Reset Table</button>
@@ -145,6 +146,14 @@
                     </div>
                     <p id="standingsEmptyHint" class="fieldHint">Everyone who has bought in shows up here, with what they'd be owed if the night ended now.</p>
 
+                    <h3 class="panelSubhead">Waiting list</h3>
+                    <form id="waitingListForm" class="waitingAdd">
+                        <input type="text" id="waitingNameInput" maxlength="24" placeholder="Who's waiting?" autocomplete="off" />
+                        <button type="submit" id="waitingAddBtn" class="holdemBtn holdemBtnSmall">Add</button>
+                    </form>
+                    <ol id="waitingList" class="waitingList"></ol>
+                    <p id="waitingEmptyHint" class="fieldHint">Nobody waiting. Add the people standing behind the chairs, and the tool will offer them the next seat that opens.</p>
+
                     <div id="bankReconcile" class="bankReconcile" hidden>
                         <div class="bankReconcileRow">
                             <span>Cash taken</span>

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

@@ -2312,6 +2312,86 @@ body.hasActionBar #holdemSidebar {
     font-style: italic;
 }
 
+/* The people standing behind the chairs. A short list in a panel that already has a
+   lot in it, so it is built from rows rather than a table: a name, the seat it can go
+   in, and a way off the list. */
+.waitingAdd {
+    display: flex;
+    gap: 0.4rem;
+    margin-bottom: 0.5rem;
+}
+
+.waitingAdd input {
+    flex: 1;
+    min-width: 0;
+    min-height: 44px;
+    background: #141414;
+    border: 1px solid #3a3a3a;
+    border-radius: 8px;
+    color: #eee;
+    font-family: inherit;
+    /* 16px, or iOS zooms the whole page in when it takes focus. */
+    font-size: 16px;
+    padding: 0.35rem 0.6rem;
+}
+
+.waitingAdd .holdemBtn {
+    flex: none;
+    min-height: 44px;
+}
+
+.waitingList {
+    list-style: none;
+    counter-reset: waiting;
+    margin: 0 0 0.5rem;
+    padding: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.35rem;
+}
+
+.waitingRow {
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    counter-increment: waiting;
+}
+
+/* The position in the queue, which is the whole point of the list. */
+.waitingRow::before {
+    content: counter(waiting) ".";
+    flex: none;
+    min-width: 1.2rem;
+    color: #9a9a9a;
+    font-size: 0.78rem;
+    font-variant-numeric: tabular-nums;
+}
+
+.waitingName {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: #e8e8e8;
+    font-size: 0.85rem;
+}
+
+.waitingNote {
+    flex: none;
+    color: #9a9a9a;
+    font-size: 0.75rem;
+}
+
+.waitingRow .holdemBtn {
+    flex: none;
+    min-height: 44px;
+}
+
+.waitingDropBtn {
+    min-width: 44px;
+}
+
 /* ---------- Side-pot breakdown ---------- */
 
 .potBreakdown {

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

@@ -459,6 +459,55 @@ const Betting = {
         return (state.street || "preflop") === "preflop" && state.seats.every(p => !p.hasActed);
     },
 
+    // A misdeal: the hand never happened, so every chip goes back where it came from.
+    //
+    // The rulings sheet in this tool has told dealers to redeal since the day it was
+    // written — first card to the wrong seat, a seat entitled to a hand dealt out, one
+    // of the first two cards exposed — and the tool had no way to do it. The only
+    // control that ended a live hand was Next Hand, which says out loud that it takes
+    // the money off the table without paying anybody. That is right for an abandoned
+    // pot and wrong for a misdeal, where the blinds and any calls belong to the people
+    // who put them in.
+    //
+    // Undo covers the first second of it — "↶ dealing the hand" is one tap — but only
+    // while the action history is still there. It lives in memory, so a dealer who
+    // refreshes the page mid-hand, or who is three calls in, has nothing.
+    //
+    // What is deliberately kept: the button, the blinds, the straddle and anyone
+    // posting in. A misdeal is the *same* hand dealt again, not the next one.
+    takeHandBack(state) {
+        const returned = [];
+        state.seats.forEach((player, index) => {
+            const back = this.round(this.committed(player) + (Number(player.amountOverride) || 0));
+            if (back > 0) {
+                player.stack = this.round(this.stackOf(state, player) + back);
+                returned.push({ index, name: HoldemState.displayName(player, index), amount: back });
+            }
+            player.committed = 0;
+            player.amountOverride = null;
+            player.hasActed = false;
+            player.folded = false;
+            player.cards = ["", ""];
+        });
+
+        state.bettingOpen = false;
+        state.street = "preflop";
+        state.currentBet = 0;
+        state.lastRaiseSize = 0;
+        state.actingSeatIndex = null;
+        state.streetAggressorIndex = null;
+        state.handAggressorIndex = null;
+        // Nothing was posted, as far as the next rotation is concerned: the hand this
+        // would have counted as is being dealt again from the same button.
+        state.postedBlinds = null;
+        state.postedStraddles = [];
+
+        return {
+            returned,
+            total: this.round(returned.reduce((sum, row) => sum + row.amount, 0)),
+        };
+    },
+
     // Pulls the blinds back off the table and posts them again from wherever the
     // button and the blind assignment now say they belong. Refunding first is what
     // keeps the chip count straight when the button gets passed round three or four

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

@@ -56,6 +56,35 @@ document.addEventListener("DOMContentLoaded", () => {
         },
 
         onSeatLongPress: index => SeatMenu.open(state, seatMenuHooks, index),
+
+        // The waiting list, from the Session panel and from an empty chair's menu.
+        // The state change goes inside runUndoable, not before it: the snapshot is
+        // taken as the first thing that happens, so anything done ahead of it is
+        // already baked into what Undo would restore.
+        seatWaiting: (id, index) => {
+            const entry = (state.waitingList || []).find(row => row.id === id);
+            const seat = state.seats[index];
+            if (!entry || !seat) {
+                Toast.show("They aren't on the list any more.", { duration: 3000 });
+                hooks.rerender();
+                return;
+            }
+            const occupied = (seat.name || "").trim() || Number(seat.buyIns) > 0 || Number(seat.stack) > 0;
+            if (occupied) {
+                Toast.show(`${HoldemState.displayName(seat, index)} is already in that seat.`, { duration: 3500 });
+                hooks.rerender();
+                return;
+            }
+            runUndoable(`${entry.name} takes seat ${index + 1}. Add their chips when they buy in.`,
+                () => HoldemState.seatFromWaitingList(state, id, index));
+        },
+
+        dropWaiting: id => {
+            const entry = (state.waitingList || []).find(row => row.id === id);
+            if (!entry) return;
+            runUndoable(`${entry.name} taken off the waiting list.`,
+                () => HoldemState.removeFromWaitingList(state, id));
+        },
         onGiveButton: index => seatMenuHooks.makeDealer(index),
     };
 
@@ -401,6 +430,41 @@ document.addEventListener("DOMContentLoaded", () => {
         Render.renderAll();
     });
 
+    // A misdeal. Everything in the middle goes back to whoever put it there, and the
+    // same button deals the same hand again.
+    document.getElementById("waitingListForm").addEventListener("submit", e => {
+        e.preventDefault();
+        const field = document.getElementById("waitingNameInput");
+        const name = field.value.trim();
+        if (!name) return;
+        field.value = "";
+        runUndoable(`${name} added to the waiting list.`, () => HoldemState.addToWaitingList(state, name));
+        field.focus();
+    });
+
+    document.getElementById("misdealBtn").addEventListener("click", async () => {
+        const inPlay = HoldemState.unresolvedContributions(state);
+        const acted = state.seats.filter(p => p.hasActed).length;
+
+        const ok = await Dialog.confirm({
+            title: "Misdeal — take the hand back?",
+            message: inPlay > Betting.EPSILON_CHIPS
+                ? `${Money.format(inPlay)} goes back to the players who put it in, cards are cleared, and the same ` +
+                  `button deals again.${acted > 1 ? " Note that most rooms let a deal stand once two players have acted." : ""}`
+                : "Cards are cleared and the same button deals again. Nothing has been put in yet, so no chips move.",
+            confirmLabel: "Take it back",
+        });
+        if (!ok) return;
+
+        // The label is both the toast a dealer reads now and the words on the undo
+        // control afterwards, so it says what happened to the money rather than naming
+        // the ruling: "the misdeal" told a table nothing about where their chips went.
+        const label = inPlay > Betting.EPSILON_CHIPS
+            ? `Misdeal — ${Money.format(inPlay)} returned, same button deals again.`
+            : "Misdeal — nothing was in yet, same button deals again.";
+        runUndoable(label, () => Betting.takeHandBack(state));
+    });
+
     document.getElementById("nextHandBtn").addEventListener("click", async () => {
         // Moving on wipes every seat's contribution, so an unresolved pot is simply
         // destroyed — measured at a four-handed table, pressing this with $8 in the

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

@@ -33,6 +33,7 @@ const Render = {
         this.renderNotes();
         this.updatePotBadge();
         this.renderSetupFields();
+        this.renderHeaderActions();
         this.renderTableHint();
         this.renderStandings();
         this.renderHandHistory();
@@ -62,6 +63,16 @@ const Render = {
         if (taken > 0) hint.textContent = `Taken so far tonight: ${Money.format(taken)}.`;
     },
 
+    // Misdeal is only a thing you can call on a hand that is out. Before the deal there
+    // is nothing to take back, and afterwards the header would be offering to unwind a
+    // hand that has already been paid — so the button comes and goes with the hand
+    // rather than sitting there all night waiting to be pressed by accident.
+    renderHeaderActions() {
+        const misdeal = document.getElementById("misdealBtn");
+        if (!misdeal) return;
+        misdeal.hidden = !this.state.bettingOpen;
+    },
+
     // Whether this device can actually drag a seat. HTML5 drag events are never
     // generated from a touch screen, so on a phone the last clause of the hint below
     // described something impossible — on the device the rest of the sentence was
@@ -1047,9 +1058,63 @@ const Render = {
 
         this.renderBankReconciliation();
         this.renderSettleUp(standings);
+        this.renderWaitingList();
         this.renderStorageWarning();
     },
 
+    // Who is standing behind the chairs, in the order they turned up. Each one carries
+    // the two things a dealer does with them: sit them down, or take them off the list
+    // because they've gone to the bar.
+    renderWaitingList() {
+        const list = document.getElementById("waitingList");
+        const hint = document.getElementById("waitingEmptyHint");
+        if (!list) return;
+
+        const waiting = this.state.waitingList || [];
+        const open = HoldemState.openSeats(this.state);
+        list.innerHTML = "";
+        hint.hidden = waiting.length > 0;
+
+        waiting.forEach((entry, position) => {
+            const row = document.createElement("li");
+            row.className = "waitingRow";
+
+            const name = document.createElement("span");
+            name.className = "waitingName";
+            name.textContent = entry.name;
+            row.appendChild(name);
+
+            // Only the person at the front is offered a seat, because a list nobody
+            // keeps in order is just a pile of names — and jumping the queue is the
+            // thing the dealer gets shouted at for.
+            if (position === 0 && open.length > 0) {
+                const seat = document.createElement("button");
+                seat.type = "button";
+                seat.className = "holdemBtn holdemBtnSmall waitingSeatBtn";
+                seat.textContent = `Seat ${open[0] + 1}`;
+                seat.title = `Sit ${entry.name} in seat ${open[0] + 1}`;
+                seat.addEventListener("click", () => this.hooks.seatWaiting(entry.id, open[0]));
+                row.appendChild(seat);
+            } else if (position === 0) {
+                const full = document.createElement("span");
+                full.className = "waitingNote";
+                full.textContent = "table full";
+                row.appendChild(full);
+            }
+
+            const drop = document.createElement("button");
+            drop.type = "button";
+            drop.className = "holdemBtn holdemBtnSmall holdemBtnGhost waitingDropBtn";
+            drop.textContent = "✕";
+            drop.setAttribute("aria-label", `Take ${entry.name} off the waiting list`);
+            drop.title = `Take ${entry.name} off the list`;
+            drop.addEventListener("click", () => this.hooks.dropWaiting(entry.id));
+            row.appendChild(drop);
+
+            list.appendChild(row);
+        });
+    },
+
     // A toast is a moment; this table not being saved is a fact about the rest of the
     // night. It sits at the top of the panel a dealer opens to check the money, and it
     // stays there, because the raise pad dismisses toasts and the one time this warning

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

@@ -47,6 +47,21 @@ const SeatMenu = {
             run: () => this.hooks.toggleDealtIn(index),
         });
 
+        // An empty chair with people waiting: the dealer taps the chair somebody is
+        // about to sit in, which is what their hand is doing anyway. Only the front of
+        // the queue is offered, for the same reason the panel only offers them — a list
+        // that isn't kept in order is just a pile of names.
+        const waiting = (this.state.waitingList || [])[0];
+        const emptyChair = !(player.name || "").trim() &&
+            !(Number(player.buyIns) > 0) && !(Number(player.stack) > 0);
+        if (waiting && emptyChair) {
+            actions.push({
+                label: `Seat ${waiting.name}`,
+                className: "menuAccent",
+                run: () => this.hooks.seatWaiting(waiting.id, index),
+            });
+        }
+
         // Leaving for the night, which is a different thing from sitting out a hand:
         // the chips go back over the rail and the chair opens. Offered only for a seat
         // that has somebody in it, since an empty chair has nobody to pay.

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

@@ -115,6 +115,10 @@ const HoldemState = {
             // out, and both halves have to stay on the record or the bank check reads
             // as a shortfall for the rest of the evening.
             cashedOut: [],
+            // People standing behind the chairs. A dealer at a full table keeps this
+            // list on a napkin; keeping it here means the tool can offer the next seat
+            // that opens to whoever has been waiting longest.
+            waitingList: [],
             // Which seats actually put a straddle out when the hand was dealt, so the
             // felt can badge them. Read off the deal rather than worked out again
             // later, the same way the posted blinds are.
@@ -233,6 +237,16 @@ const HoldemState = {
                 noFlopNoDrop: rake.noFlopNoDrop !== false,
             };
             parsed.rakeTaken = Math.max(0, Money.round(Number(parsed.rakeTaken) || 0));
+            parsed.waitingList = Array.isArray(parsed.waitingList)
+                ? parsed.waitingList
+                    .map(row => (typeof row === "string" ? { id: null, name: row } : row))
+                    .filter(row => row && String(row.name || "").trim())
+                    .map(row => ({
+                        id: row.id || this.makeId("waiting"),
+                        name: String(row.name).trim().slice(0, 24),
+                        addedAt: Number(row.addedAt) || 0,
+                    }))
+                : [];
             parsed.cashedOut = Array.isArray(parsed.cashedOut)
                 ? parsed.cashedOut
                     .filter(row => row && row.id)
@@ -875,6 +889,59 @@ const HoldemState = {
     //
     // Chips in play counts everything a player could hand back: what's in front of
     // them and what's in the middle waiting to be won.
+    // ---- The people standing behind the chairs ----
+    //
+    // A full home game always has a couple of them, and the list lives on a napkin or
+    // in the dealer's head — which is where the argument comes from an hour later about
+    // who said they were next. Kept in order of arrival, because that is the only
+    // ordering anybody has ever agreed to.
+
+    addToWaitingList(state, name) {
+        const trimmed = String(name || "").trim().slice(0, 24);
+        if (!trimmed) return null;
+        if (!Array.isArray(state.waitingList)) state.waitingList = [];
+        const entry = { id: this.makeId("waiting"), name: trimmed, addedAt: Date.now() };
+        state.waitingList.push(entry);
+        return entry;
+    },
+
+    removeFromWaitingList(state, id) {
+        if (!Array.isArray(state.waitingList)) return null;
+        const index = state.waitingList.findIndex(row => row.id === id);
+        if (index < 0) return null;
+        return state.waitingList.splice(index, 1)[0];
+    },
+
+    // Chairs with nobody in them, in seat order. What "a seat has opened" means, and
+    // the same question the deal prompt answers when it counts the players.
+    openSeats(state) {
+        return state.seats
+            .map((player, index) => ({ player, index }))
+            .filter(({ player }) => !(player.name || "").trim() &&
+                !(Number(player.buyIns) > 0) && !(Number(player.stack) > 0))
+            .map(({ index }) => index);
+    },
+
+    // Sit the next person down. Their name goes on the chair and nothing else does:
+    // they haven't bought in yet, and guessing a stack for them would put chips on the
+    // table that nobody has paid for — which is the one thing the bank check exists to
+    // catch.
+    seatFromWaitingList(state, id, index) {
+        const seat = state.seats[index];
+        if (!seat) return { ok: false, reason: "There's no such seat." };
+        if ((seat.name || "").trim() || Number(seat.buyIns) > 0 || Number(seat.stack) > 0) {
+            return { ok: false, reason: `${this.displayName(seat, index)} is already in that seat.` };
+        }
+        const entry = this.removeFromWaitingList(state, id);
+        if (!entry) return { ok: false, reason: "They aren't on the list any more." };
+
+        seat.name = entry.name;
+        // Not dealt in and holding nothing: the next thing that happens is the dealer
+        // taking their money, and Add chips is what says so.
+        seat.inHand = false;
+        return { ok: true, name: entry.name, index };
+    },
+
     // ---- Somebody leaving with their chips ----
     //
     // The most ordinary thing that happens at a home game after midnight, and the tool

tests/holdem/misdeal.test.js

@@ -0,0 +1,155 @@
+// Taking a hand back.
+//
+// The rulings sheet in this tool has told dealers to redeal since the day it was
+// written — first card to the wrong seat, a seat entitled to a hand dealt out, one of
+// the first two cards exposed — and the tool had no way to do it. The only control that
+// ended a live hand was Next Hand, which says out loud that it takes the money off the
+// table without paying anybody. That is right for an abandoned pot and wrong for a
+// misdeal, where the blinds and the calls belong to the people who put them in.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { Money, Betting, HoldemState, makeTable, chipsOnTable } = require("./load");
+
+const dealt = (extra = {}) => {
+    const state = makeTable({ seatCount: 6, stack: 200, smallBlind: 5, bigBlind: 10, dealerSeatIndex: 0, ...extra });
+    Betting.beginHand(state);
+    return state;
+};
+
+describe("the money", () => {
+    test("goes back to the people who put it in", () => {
+        const state = dealt();
+        const before = state.seats.map(p => Betting.stackOf(state, p) + Betting.committed(p));
+        Betting.takeHandBack(state);
+        assert.deepEqual(state.seats.map(p => Betting.stackOf(state, p)), before);
+    });
+
+    test("including calls and raises, not just the blinds", () => {
+        const state = dealt();
+        Betting.raiseTo(state, state.actingSeatIndex, 40);
+        Betting.call(state, state.actingSeatIndex);
+        assert.ok(Betting.potSoFar(state) > 50, "there is real money in the middle");
+
+        const taken = Betting.takeHandBack(state);
+        assert.equal(taken.total, 95, "blinds and both wagers");
+        assert.deepEqual(state.seats.map(p => Betting.stackOf(state, p)), [200, 200, 200, 200, 200, 200]);
+    });
+
+    test("and across streets, once chips have been swept into hand totals", () => {
+        const state = dealt();
+        [3, 4, 5, 0, 1, 2].forEach(seat => {
+            if (state.actingSeatIndex !== null) Betting.call(state, state.actingSeatIndex);
+        });
+        Betting.closeStreet(state);
+        assert.ok(state.seats.some(p => (Number(p.amountOverride) || 0) > 0), "the flop's money is banked");
+
+        Betting.takeHandBack(state);
+        assert.deepEqual(state.seats.map(p => Betting.stackOf(state, p)), [200, 200, 200, 200, 200, 200]);
+        assert.deepEqual(state.seats.map(p => p.amountOverride), [null, null, null, null, null, null]);
+    });
+
+    test("the table has exactly the chips it started with", () => {
+        const fresh = makeTable({ seatCount: 6, stack: 200, smallBlind: 5, bigBlind: 10 });
+        const total = chipsOnTable(fresh);
+        const state = dealt();
+        Betting.raiseTo(state, state.actingSeatIndex, 40);
+        Betting.takeHandBack(state);
+        assert.equal(chipsOnTable(state), total);
+    });
+
+    test("nothing is thrown away — the discard pile doesn't move", () => {
+        const state = dealt();
+        state.discarded = 8;
+        Betting.takeHandBack(state);
+        assert.equal(state.discarded, 8, "a misdeal is not an abandoned pot");
+    });
+
+    test("it says what went back and to whom", () => {
+        const state = dealt();
+        const taken = Betting.takeHandBack(state);
+        assert.equal(taken.returned.length, 2, "the two blinds");
+        assert.deepEqual(taken.returned.map(r => r.amount).sort((a, b) => a - b), [5, 10]);
+        assert.ok(taken.returned.every(r => r.name), "named, because the dealer says it out loud");
+    });
+});
+
+describe("the table afterwards", () => {
+    test("is waiting to deal the same hand again", () => {
+        const state = dealt();
+        Betting.takeHandBack(state);
+        assert.equal(state.bettingOpen, false, "the dealer says when");
+        assert.equal(state.street, "preflop");
+        assert.equal(state.actingSeatIndex, null);
+        assert.equal(state.currentBet, 0);
+    });
+
+    test("keeps the button where it was — a misdeal is not the next hand", () => {
+        const state = dealt({ dealerSeatIndex: 3 });
+        const handNumber = state.handNumber;
+        Betting.takeHandBack(state);
+        assert.equal(state.dealerSeatIndex, 3);
+        assert.equal(state.handNumber, handNumber, "no hand has been played");
+        assert.equal((state.handHistory || []).length, 0, "and none is logged");
+    });
+
+    test("keeps the straddle, which was announced and still stands", () => {
+        const state = makeTable({ seatCount: 6, stack: 200, smallBlind: 5, bigBlind: 10 });
+        state.straddleCount = 1;
+        Betting.beginHand(state);
+        assert.deepEqual(state.postedStraddles, [3]);
+
+        Betting.takeHandBack(state);
+        assert.equal(state.straddleCount, 1, "still on for the redeal");
+        assert.deepEqual(state.postedStraddles, [], "but nothing is out there yet");
+
+        Betting.beginHand(state);
+        assert.deepEqual(state.postedStraddles, [3], "and it goes out again");
+    });
+
+    test("clears the cards and the folds, because none of it happened", () => {
+        const state = dealt();
+        state.seats[3].cards = ["As", "Kd"];
+        Betting.fold(state, 3);
+        Betting.takeHandBack(state);
+        assert.deepEqual(state.seats[3].cards, ["", ""]);
+        assert.equal(state.seats[3].folded, false);
+        assert.ok(state.seats.every(p => !p.hasActed));
+    });
+
+    test("deals again cleanly, with the same blinds on the same players", () => {
+        const state = dealt();
+        const first = state.seats.map(p => Betting.committed(p));
+        Betting.takeHandBack(state);
+        Betting.beginHand(state);
+        assert.deepEqual(state.seats.map(p => Betting.committed(p)), first);
+    });
+});
+
+describe("the bank still balances", () => {
+    test("through a misdeal and the redeal after it", () => {
+        const state = dealt();
+        state.seats.forEach(p => { p.buyIns = 200; });
+        assert.equal(HoldemState.bankReconciliation(state).balanced, true);
+
+        Betting.raiseTo(state, state.actingSeatIndex, 60);
+        Betting.takeHandBack(state);
+        assert.equal(HoldemState.bankReconciliation(state).balanced, true);
+
+        Betting.beginHand(state);
+        const bank = HoldemState.bankReconciliation(state);
+        assert.equal(bank.balanced, true);
+        assert.equal(bank.cashIn, 1200);
+    });
+});
+
+describe("taking back a hand nobody had money in", () => {
+    test("is harmless: no blinds, nothing moves", () => {
+        const state = makeTable({ seatCount: 6, stack: 200, smallBlind: 0, bigBlind: 0 });
+        Betting.beginHand(state);
+        const taken = Betting.takeHandBack(state);
+        assert.equal(taken.total, 0);
+        assert.deepEqual(taken.returned, []);
+        assert.equal(state.bettingOpen, false);
+    });
+});

tests/holdem/waitingList.test.js

@@ -0,0 +1,167 @@
+// The people standing behind the chairs.
+//
+// A full home game always has a couple of them, and the list lives on a napkin or in
+// the dealer's head — which is where the argument comes from an hour later about who
+// said they were next. Order of arrival, because it is the only ordering anybody has
+// ever agreed to.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { HoldemState } = require("./load");
+
+const table = (seated = 2, seats = 4) => {
+    const state = HoldemState.createDefault();
+    HoldemState.resizeSeats(state, seats);
+    ["Ann", "Ben", "Cal", "Dee"].slice(0, seated).forEach((name, i) => {
+        state.seats[i].name = name;
+        state.seats[i].stack = 200;
+        state.seats[i].buyIns = 200;
+    });
+    return state;
+};
+
+describe("keeping the list", () => {
+    test("names go on in the order they arrive", () => {
+        const state = table();
+        HoldemState.addToWaitingList(state, "Priya");
+        HoldemState.addToWaitingList(state, "Sam");
+        assert.deepEqual(state.waitingList.map(row => row.name), ["Priya", "Sam"]);
+    });
+
+    test("whitespace is trimmed and nothing empty gets on", () => {
+        const state = table();
+        assert.ok(HoldemState.addToWaitingList(state, "  Priya  "));
+        assert.equal(HoldemState.addToWaitingList(state, "   "), null);
+        assert.equal(HoldemState.addToWaitingList(state, ""), null);
+        assert.deepEqual(state.waitingList.map(row => row.name), ["Priya"]);
+    });
+
+    test("two people with the same name are two people", () => {
+        // Home games have two Mikes. The list is keyed by id, not by name.
+        const state = table();
+        HoldemState.addToWaitingList(state, "Mike");
+        HoldemState.addToWaitingList(state, "Mike");
+        assert.equal(state.waitingList.length, 2);
+        assert.notEqual(state.waitingList[0].id, state.waitingList[1].id);
+
+        HoldemState.removeFromWaitingList(state, state.waitingList[0].id);
+        assert.equal(state.waitingList.length, 1, "only one of them leaves");
+    });
+
+    test("taking somebody off gives them back, so the toast can name them", () => {
+        const state = table();
+        HoldemState.addToWaitingList(state, "Priya");
+        const gone = HoldemState.removeFromWaitingList(state, state.waitingList[0].id);
+        assert.equal(gone.name, "Priya");
+        assert.deepEqual(state.waitingList, []);
+        assert.equal(HoldemState.removeFromWaitingList(state, "not-a-real-id"), null);
+    });
+});
+
+describe("which chairs are open", () => {
+    test("the ones with nobody in them, in seat order", () => {
+        assert.deepEqual(HoldemState.openSeats(table(2, 4)), [2, 3]);
+        assert.deepEqual(HoldemState.openSeats(table(4, 4)), []);
+    });
+
+    test("a chair with chips or a buy-in on it is not open", () => {
+        // Somebody who has stepped away from the table still owns their seat.
+        const state = table(2, 4);
+        state.seats[2].stack = 120;
+        state.seats[3].buyIns = 100;
+        assert.deepEqual(HoldemState.openSeats(state), []);
+    });
+});
+
+describe("sitting somebody down", () => {
+    test("their name goes on the chair and they come off the list", () => {
+        const state = table();
+        HoldemState.addToWaitingList(state, "Priya");
+        HoldemState.addToWaitingList(state, "Sam");
+        const result = HoldemState.seatFromWaitingList(state, state.waitingList[0].id, 2);
+
+        assert.equal(result.ok, true);
+        assert.equal(state.seats[2].name, "Priya");
+        assert.deepEqual(state.waitingList.map(row => row.name), ["Sam"]);
+    });
+
+    test("with nothing in front of them, because they haven't bought in yet", () => {
+        // Guessing a stack would put chips on the table nobody has paid for, which is
+        // the one thing the bank check exists to catch.
+        const state = table();
+        HoldemState.addToWaitingList(state, "Priya");
+        HoldemState.seatFromWaitingList(state, state.waitingList[0].id, 2);
+
+        assert.equal(state.seats[2].stack, null);
+        assert.equal(state.seats[2].buyIns, 0);
+        assert.equal(state.seats[2].inHand, false, "they're in the next hand, not this one");
+        assert.equal(HoldemState.bankReconciliation(state).balanced, true);
+    });
+
+    test("never into a chair somebody is already in", () => {
+        const state = table();
+        HoldemState.addToWaitingList(state, "Priya");
+        const result = HoldemState.seatFromWaitingList(state, state.waitingList[0].id, 0);
+        assert.equal(result.ok, false);
+        assert.match(result.reason, /Ann is already/);
+        assert.equal(state.waitingList.length, 1, "and they keep their place in the queue");
+    });
+
+    test("nor from a name that has already been seated", () => {
+        const state = table();
+        HoldemState.addToWaitingList(state, "Priya");
+        const id = state.waitingList[0].id;
+        HoldemState.seatFromWaitingList(state, id, 2);
+        const again = HoldemState.seatFromWaitingList(state, id, 3);
+        assert.equal(again.ok, false);
+        assert.equal(state.seats[3].name, "", "the second chair is untouched");
+    });
+
+    test("a seat that doesn't exist is refused rather than invented", () => {
+        const state = table();
+        HoldemState.addToWaitingList(state, "Priya");
+        assert.equal(HoldemState.seatFromWaitingList(state, state.waitingList[0].id, 99).ok, false);
+        assert.equal(state.waitingList.length, 1);
+    });
+});
+
+describe("a seat opening up", () => {
+    test("cashing somebody out is what makes room for the next one", () => {
+        const state = table(4, 4);
+        HoldemState.addToWaitingList(state, "Priya");
+        assert.deepEqual(HoldemState.openSeats(state), [], "the table is full");
+
+        HoldemState.cashOut(state, 1);
+        assert.deepEqual(HoldemState.openSeats(state), [1]);
+
+        const seated = HoldemState.seatFromWaitingList(state, state.waitingList[0].id, 1);
+        assert.equal(seated.ok, true);
+        assert.equal(state.seats[1].name, "Priya");
+        // Ben's night is still on the record, and the money still adds up.
+        assert.equal(state.cashedOut.length, 1);
+        assert.equal(HoldemState.bankReconciliation(state).balanced, true);
+    });
+});
+
+describe("what a saved table remembers", () => {
+    test("the list survives a reload", () => {
+        const state = table();
+        HoldemState.addToWaitingList(state, "Priya");
+        const migrated = HoldemState.migrate(JSON.parse(JSON.stringify(state)));
+        assert.deepEqual(migrated.waitingList.map(row => row.name), ["Priya"]);
+    });
+
+    test("a table saved before the list existed has nobody waiting", () => {
+        const parsed = JSON.parse(JSON.stringify(table()));
+        delete parsed.waitingList;
+        assert.deepEqual(HoldemState.migrate(parsed).waitingList, []);
+    });
+
+    test("junk in a saved list is cleaned up rather than trusted", () => {
+        const parsed = JSON.parse(JSON.stringify(table()));
+        parsed.waitingList = [{ name: "  Priya  " }, { name: "" }, null, "Sam"];
+        const migrated = HoldemState.migrate(parsed);
+        assert.deepEqual(migrated.waitingList.map(row => row.name), ["Priya", "Sam"]);
+        assert.ok(migrated.waitingList.every(row => row.id), "and everybody gets an id");
+    });
+});