Say the payout in chips, not just in money

"Ann - $135" is the answer to the arithmetic. The dealer's actual job at that moment
is working out that $135 is a black, a green and two reds, while four people watch
them do it.

The chip legend has known the denominations all along. It was only being used to read
chips *into* an amount -- counting a seat's stack -- and never to turn an amount back
into chips.

  Final Payouts
    Ann - $135
    1x$100, 1x$25, 2x$5

Largest first, which is greedy and so not optimal for an arbitrary set of values. Poker
chips are not arbitrary: every real set is canonical -- each denomination divides the
next, 1/5/25/100/500 -- and greedy is exactly optimal on those. A dealer who invents a
3-and-7 chip set still gets a valid answer, possibly one chip longer than it needed to
be, which is a fair trade for not solving a knapsack in a modal.

Two cases where saying nothing is the right answer, and one where it is not.

A table with no chip legend gets the amount on its own -- it has not told us its
denominations, so there is no advice to give. But a legend that exists and cannot reach
the amount does say so: "$3 no chip covers" when the smallest chip is $5. Half a dollar
in a dollar-chip game is the dealer's problem to solve and they can only solve it if
they are told, so it is never rounded away.

12 tests (244 total): the breakdown adds up to the amount across eight amounts, cent
chips make cent amounts exactly, a jumbled legend still pays largest first, the colour
comes along for a future caller, and the two no-advice cases are told apart from the
cannot-reach one.

Driven through a real all-in hand at four sizes: $135 reads "1x$100, 1x$25, 2x$5" and
a tournament-sized $1,350 reads "2x$500, 3x$100, 2x$25", fitting without spill down to
360px. With the legend emptied the line disappears and the payout stands alone.
Contrast clean, no console errors.

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

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

@@ -212,6 +212,20 @@ button,
 }
 
 .holdemBtn {
+    /* Stated, because this class is worn by both <button> and <a> and the browser
+       does not give them the same box. Chromium's own stylesheet makes a button
+       border-box and leaves a link content-box, so `min-height: 46px` on the header
+       row came out as 46px on the buttons and 64px on the two links — and the row
+       stretches to its tallest item, so every button became 64px too. A 46px touch
+       target was quietly costing 64px of a phone screen, twice over, because the
+       header wraps to two rows. */
+    box-sizing: border-box;
+    /* And the touch floor is stated here rather than only under a width breakpoint.
+       It used to arrive by accident — the content-box links were 64px tall and the
+       row stretched everything to match — so once the boxes agree, a landscape phone
+       (wider than the phone breakpoint, still a thumb) would have been left with 42px
+       buttons. 44px is the floor everywhere; the narrow layout still asks for 46. */
+    min-height: 44px;
     background: linear-gradient(180deg, #2e2e2e, #232323);
     color: #eee;
     border: 1px solid #3a3a3a;
@@ -695,6 +709,23 @@ button,
     display: inline-block;
 }
 
+/* Seats on the bottom of the ring wear their badge underneath, because that's the
+   edge the pot isn't on. Bets sit between a seat and the pot, so on the bottom arc
+   the chip comes down onto the seat's top edge — which is exactly where this badge
+   was, and the chip is a layer above it. See render.js for the measurement. */
+.seat.seatBelowCentre .blindBadge {
+    top: auto;
+    bottom: -9px;
+}
+
+/* And the badge outranks the chips regardless, so a layout this doesn't anticipate
+   can't hide it again. Which blind a seat is posting is the one thing on that puck
+   nothing else on the felt repeats — a bet chip's amount is on the seat's own total
+   line as well. Measured across 12 table sizes: no chip loses its amount to this. */
+.blindBadge {
+    z-index: 4;
+}
+
 /* Both badges failed WCAG AA against their own gradients — measured at the worst
    stop, the small blind was 3.52:1 and the big blind 2.15:1, in 9px bold text a
    dealer is meant to read at a glance across a table.
@@ -982,9 +1013,24 @@ button,
     text-align: center;
 }
 
+/* A bare checkbox ships at 13x13, which misses the 24px minimum with a mouse as well
+   as with a thumb. The row around it is the real target on touch, but the box itself
+   should be findable on any device. */
+#dedicatedDealerToggle {
+    width: 24px;
+    height: 24px;
+}
+
 .linkBtn {
     background: none;
     border: none;
+    /* An underlined word was a 91x14 target, which misses the 24px minimum with a
+       mouse as well as with a thumb. The coarse-pointer block takes it to 44; this is
+       the floor everywhere else, and it changes nothing about how it looks. */
+    display: inline-flex;
+    align-items: center;
+    box-sizing: border-box;
+    min-height: 24px;
     padding: 0;
     color: #d8b46a;
     font-family: inherit;
@@ -1439,7 +1485,16 @@ button,
 
 .sidebarPanel summary {
     cursor: pointer;
-    padding: 0.7rem 0;
+    /* These headers are the sidebar's whole navigation and were 38px tall on every
+       device, phones included — the touch pass further down never reached them.
+       Padding rather than a flex box with min-height, because a <summary> only draws
+       its disclosure triangle while it is display: list-item. */
+    padding: 0.85rem 0;
+    /* A <summary> is content-box, so min-height would have been *added* to the padding
+       — measured at 71px before this line went in. Same trap the header buttons were
+       in, one file over. */
+    box-sizing: border-box;
+    min-height: 44px;
     font-size: 0.9rem;
     color: #eee;
     letter-spacing: 0.03em;
@@ -2548,6 +2603,16 @@ body.hasActionBar #toastHost {
     color: #d6ffe0;
 }
 
+/* The chips to push, under the amount they add up to. Quieter than the payout it
+   belongs to — the dealer reads the name and the money first, then counts. */
+.payoutChips {
+    display: block;
+    margin-top: 0.15rem;
+    font-size: 0.76rem;
+    color: #9fb8a6;
+    font-variant-numeric: tabular-nums;
+}
+
 .potWizardActions {
     display: flex;
     gap: 0.6rem;
@@ -3154,3 +3219,66 @@ textarea:focus-visible {
     font-size: 0.72rem;
     color: #9a9a9a;
 }
+
+/* ---------- Touch targets on a wide touch screen ----------
+
+   Every touch-target rule in this file sits behind `max-width: 700px`, and width was
+   never the question. A phone held sideways is 844px wide, so none of that work
+   applied to it. Measured on an emulated touch device at 844x390, with the sidebar
+   panels open: twelve controls under 44px, including the rulings link at 91x14 and
+   the dedicated-dealer checkbox at 13x13.
+
+   Restated here against the pointer instead of the viewport. The width-scoped block
+   keeps its layout changes — one column, stacked dialogs — because those really are
+   about how much room there is. This is only about what a thumb can hit, so it asks
+   about the thumb. */
+@media (pointer: coarse) {
+    .panelBody input:not([type="checkbox"]):not([type="color"]),
+    .subPanelBody input:not([type="checkbox"]):not([type="color"]),
+    .panelBody select {
+        font-size: 16px;
+        min-height: 44px;
+        padding: 0.4rem 0.6rem;
+    }
+
+    .panelBody .holdemBtnSmall,
+    .handHistoryActions .holdemBtn,
+    .toastAction {
+        min-height: 44px;
+    }
+
+    /* Destructive and tiny is the worst combination: these delete a chip colour or a
+       custom field, and are 28px wide. */
+    .removeChipColorBtn,
+    .removeFieldBtn {
+        min-width: 44px;
+        min-height: 44px;
+    }
+
+    /* flex-shrink would take a stated width straight back off again. */
+    .chipColorInput {
+        flex: none;
+        width: 44px;
+        height: 44px;
+    }
+
+    /* A bare checkbox can't grow into a target, but the row it sits in can — the
+       label is what a tap actually lands on. */
+    .panelBody .fieldRow {
+        min-height: 44px;
+    }
+
+    #dedicatedDealerToggle {
+        width: 24px;
+        height: 24px;
+    }
+
+    /* An underlined word is a 14px-tall target; give it room without making it look
+       like a button. */
+    .linkBtn {
+        display: inline-flex;
+        align-items: center;
+        min-height: 44px;
+        padding: 0 0.4rem;
+    }
+}

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

@@ -90,6 +90,28 @@ const Betting = {
         };
     },
 
+    // Does handing this seat chips also put them back in the game?
+    //
+    // At a real table those are one event, and here they were two: a busted player got
+    // their chips and stayed sat out, silently skipped hand after hand until somebody
+    // noticed and found "Deal in" in the seat menu. Nothing said so — the toast just
+    // read "Ben added $100".
+    //
+    // Not for a seat that was sat out while *holding* chips. That's a dealer who sat
+    // somebody out on purpose and is topping them up, and dealing them back in would be
+    // the tool guessing at something it wasn't told. Only a seat with no stack of its
+    // own: busted at zero, or a chair being bought into for the first time.
+    //
+    // Deliberately reads player.stack rather than stackOf(), which substitutes the
+    // table's starting stack for a seat that has none — the question here is what this
+    // seat was actually recorded as holding.
+    buyInDealsThemIn(player) {
+        if (!player || player.inHand) return false;
+        const own = player.stack;
+        const recorded = own !== null && own !== undefined && String(own).trim() !== "";
+        return !recorded || Number(own) <= this.EPSILON_CHIPS;
+    },
+
     // "bet" or "raise" — what putting more in is actually called right now.
     //
     // A wager into a pot nobody has wagered into is a bet; everything after that is a

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

@@ -96,6 +96,19 @@ document.addEventListener("DOMContentLoaded", () => {
             });
         },
 
+        // Two players change chairs. Undoable like every other seat action, because a
+        // swap is easy to aim wrong and the seats look alike at a glance.
+        swapSeats: (from, to) => {
+            const movedName = nameOf(from);
+            const intoName = nameOf(to);
+            const wasEmpty = Render.isEmptySeat(state.seats[to]);
+            runUndoable(
+                wasEmpty
+                    ? `${movedName} moved to seat ${to + 1}.`
+                    : `${movedName} and ${intoName} changed seats.`,
+                () => HoldemState.swapSeats(state, from, to));
+        },
+
         makeDealer: index => {
             // Before the deal there's nothing posted, so this is just moving a marker.
             // After it, the blinds have to follow the button or the badges and the
@@ -140,11 +153,27 @@ document.addEventListener("DOMContentLoaded", () => {
         editSeat: index => Render.toggleSeatEditor(index),
 
         addChips: index => AddChips.open(state, index, (seatIndex, amount) => {
-            seatAction(seatIndex, `${nameOf(seatIndex)} added ${Money.format(amount)}.`, player => {
+            // Buying chips puts you back in the game — see Betting.buyInDealsThemIn.
+            const dealBackIn = Betting.buyInDealsThemIn(state.seats[seatIndex]);
+            const handRunning = !Betting.onlyBlindsIn(state) || Betting.potSoFar(state) > 0;
+
+            const message = `${nameOf(seatIndex)} added ${Money.format(amount)}` +
+                (dealBackIn
+                    ? handRunning ? " — in from the next hand." : " — dealt in."
+                    : ".");
+
+            seatAction(seatIndex, message, p => {
                 // Chips in front and cash in are different questions — the stack moves
                 // every hand, what they've handed over only moves when they buy.
-                player.stack = Money.round(Betting.stackOf(state, player) + amount);
-                player.buyIns = Money.round((Number(player.buyIns) || 0) + amount);
+                p.stack = Money.round(Betting.stackOf(state, p) + amount);
+                p.buyIns = Money.round((Number(p.buyIns) || 0) + amount);
+
+                if (dealBackIn) {
+                    p.inHand = true;
+                    // Same rule "Deal in" follows: you can't buy into a pot you haven't
+                    // been paying for, and `folded` is exactly that state for one hand.
+                    p.folded = handRunning;
+                }
             });
         }),
     };
@@ -378,6 +407,29 @@ document.addEventListener("DOMContentLoaded", () => {
         Toast.show("Table reset.", { duration: 2500 });
     });
 
+    // A pre-filled amount is a suggestion, so reaching for the box replaces it.
+    //
+    // Delegated from the document rather than wired per field: the raise pad, the
+    // add-chips sheet and the seat editor all build their inputs fresh every render,
+    // and a box added later should not have to remember to ask for this.
+    document.addEventListener("focusin", event => {
+        const field = event.target;
+        if (!Money.selectsOnFocus(field)) return;
+        if (!field.value) return;
+        // After the browser has finished placing its own caret, or it wins the race
+        // and the selection collapses again the moment the tap completes.
+        setTimeout(() => {
+            if (document.activeElement !== field) return;
+            try {
+                field.select();
+            } catch {
+                // A number input refuses setSelectionRange in some browsers; select()
+                // is the one that works on both, and if neither does the field is
+                // simply left as it was.
+            }
+        }, 0);
+    });
+
     document.getElementById("resolvePotBtn").addEventListener("click", openPotWizard);
 
     [

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

@@ -48,6 +48,76 @@ const Money = {
         return (this.toCents(amount) / 100).toFixed(2);
     },
 
+    // The chips to actually push, for an amount.
+    //
+    // A payout figure is the answer to the arithmetic, not to the dealer's job: they
+    // still have to work out that $132 is two blacks, a green, a red and two whites
+    // while six people watch. The chip legend already knows the denominations.
+    //
+    // Largest first, which is greedy and therefore not optimal for an arbitrary set of
+    // values — but poker chips are not arbitrary. Every real set is canonical (each
+    // denomination divides the next: 1, 5, 25, 100, 500), and greedy is exactly optimal
+    // on those. A dealer who invents a 3-and-7 chip set gets a valid answer that might
+    // use one chip more than it had to.
+    //
+    // Anything the smallest chip can't make comes back as `remainder` rather than being
+    // rounded away: a 50c share in a game whose smallest chip is a dollar is a real
+    // problem for the dealer to solve, not a rounding error to hide.
+    chipBreakdown(amount, legend) {
+        let cents = this.toCents(amount);
+        if (cents <= 0) return { chips: [], remainder: 0 };
+
+        const values = (legend || [])
+            .map(chip => ({ chip, cents: this.toCents(chip.value) }))
+            .filter(entry => entry.cents > 0)
+            .sort((a, b) => b.cents - a.cents);
+
+        const chips = [];
+        values.forEach(entry => {
+            const count = Math.floor(cents / entry.cents);
+            if (count <= 0) return;
+            cents -= count * entry.cents;
+            chips.push({ value: this.fromCents(entry.cents), count, color: entry.chip.color });
+        });
+
+        return { chips, remainder: this.fromCents(cents) };
+    },
+
+    // "2×$50, 1×$25, 2×$1" — the breakdown as a dealer would say it out loud.
+    //
+    // A table with no chip legend gets nothing rather than "$132 no chip covers": it
+    // hasn't told us its denominations, so there is no advice to give and the amount
+    // stands on its own. A legend that exists but can't reach the amount is different,
+    // and does say so.
+    formatChipBreakdown(amount, legend) {
+        const hasDenominations = (legend || []).some(chip => this.toCents(chip.value) > 0);
+        if (!hasDenominations) return "";
+
+        const { chips, remainder } = this.chipBreakdown(amount, legend);
+        if (chips.length === 0 && remainder === 0) return "";
+        const parts = chips.map(chip => `${chip.count}×${this.format(chip.value)}`);
+        if (remainder > 0) parts.push(`${this.format(remainder)} no chip covers`);
+        return parts.join(", ");
+    },
+
+    // Should focusing this field select what's already in it?
+    //
+    // Every amount box in this tool opens pre-filled with a suggestion: the raise pad
+    // offers the minimum, Add chips offers a buy-in, the seat editor offers the stack
+    // it already has. A dealer taps the box because they want a *different* number,
+    // and a tap puts the caret after the suggestion instead of over it. Measured on a
+    // phone: the raise pad showing 4, tap, type "60" — the field reads 460. Add chips
+    // showing 200, tap, type "50" — 20050.
+    //
+    // Only number boxes. A name or a note is a thing you edit, and selecting all of
+    // it on focus would be the same mistake pointing the other way.
+    selectsOnFocus(field) {
+        if (!field || field.tagName !== "INPUT") return false;
+        const type = String(field.type || "").toLowerCase();
+        if (type === "number") return true;
+        return type === "text" && String(field.inputMode || "").toLowerCase() === "decimal";
+    },
+
     // "+$40.00" / "-$40.00" rather than "$-40.00" — a standings column is read at a
     // glance, and the sign belongs out front where the eye lands first.
     formatSigned(amount) {

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

@@ -246,10 +246,23 @@ const PotWizard = {
             empty.textContent = "Nobody has money in this pot yet — mark seats \"In hand\" and set contributions first.";
             wrap.appendChild(empty);
         } else {
+            const legend = (this.state && this.state.chipLegend) || [];
             const list = document.createElement("ul");
             for (const [id, amount] of this.totals.entries()) {
                 const li = document.createElement("li");
                 li.textContent = `${this.playerLabelById.get(id)} — ${Money.format(amount)}`;
+
+                // The amount is the answer to the arithmetic; the chips are the answer
+                // to the dealer's job. Only when the legend has been filled in — a
+                // table that never set up chip colours gets the number on its own,
+                // which is what it had before.
+                const chips = Money.formatChipBreakdown(amount, legend);
+                if (chips) {
+                    const note = document.createElement("span");
+                    note.className = "payoutChips";
+                    note.textContent = chips;
+                    li.appendChild(note);
+                }
                 list.appendChild(li);
             }
             wrap.appendChild(list);

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

@@ -49,11 +49,21 @@ const Render = {
         document.getElementById("defaultStackInput").value = this.state.defaultStack ?? "";
     },
 
+    // 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
+    // written for. Touch gets told about the menu route instead, which works.
+    canDragSeats() {
+        return typeof matchMedia !== "function" || matchMedia("(hover: hover)").matches;
+    },
+
     renderTableHint() {
         const hint = document.getElementById("tableHint");
         // Gestures are invisible until someone tells you about them, and this is the
         // only place on the table with room to say so.
-        hint.textContent = "Tap a seat to edit · double-tap to fold · press and hold for quick actions · drag to swap seats.";
+        hint.textContent = this.canDragSeats()
+            ? "Tap a seat to edit · double-tap to fold · press and hold for quick actions · drag to swap seats."
+            : "Tap a seat to edit · double-tap to fold · press and hold for quick actions, including moving a seat.";
     },
 
     renderNotes() {
@@ -171,6 +181,16 @@ const Render = {
             node.style.top = `${pos.top}%`;
             node.dataset.seatIndex = String(index);
 
+            // Which side of the seat the pot is on, which is the side its bet chip
+            // arrives from — the chip sits on the same spoke, closer in. For a seat on
+            // the top of the ring that's from below; on the bottom, from above.
+            //
+            // The blind badge has to be on the other side or the chip lands on top of
+            // it. Measured on a 390px phone: the big blind's own $2 chip covered 196 of
+            // the badge's 288 square pixels, and it sits a layer higher, so the marker
+            // telling the dealer who the big blind is was simply gone.
+            node.classList.toggle("seatBelowCentre", pos.top > 50);
+
             node.querySelector(".seatChairNumber").textContent = index + 1;
 
             const dealerChip = node.querySelector(".dealerChip");

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

@@ -6,10 +6,16 @@ const SeatMenu = {
     hooks: null,
     seatIndex: null,
 
+    mode: null,
+
     open(state, hooks, seatIndex) {
         this.state = state;
         this.hooks = hooks;
         this.seatIndex = seatIndex;
+        // Always the action list, never whatever the sheet was showing when it last
+        // closed — a seat menu that opens on a list of chairs is a menu that lost the
+        // dealer's place.
+        this.mode = null;
         this.render();
         document.getElementById("seatMenuOverlay").hidden = false;
     },
@@ -63,29 +69,81 @@ const SeatMenu = {
             }
         }
 
+        // Changing chairs was drag-and-drop only, and HTML5 drag events are never
+        // generated from a touch screen — so on the device this tool is mostly used on,
+        // the "drag to swap seats" the hint advertised did nothing at all. This is the
+        // same move, by the route a thumb can actually take.
+        if (this.state.seats.length > 1) {
+            actions.push({ label: "Move to…", run: () => this.openMovePicker() });
+        }
+
         actions.push({ label: "Edit seat…", run: () => this.hooks.editSeat(index) });
         return actions;
     },
 
+    // The chairs this player could move to. Every other chair: swapping into an empty
+    // one is how a player moves, and swapping with an occupied one is two players
+    // changing places, which is the other half of the same job.
+    destinationsFor(index) {
+        return this.state.seats
+            .map((player, seat) => ({ player, seat }))
+            .filter(entry => entry.seat !== index);
+    },
+
+    openMovePicker() {
+        this.mode = "move";
+        this.render();
+    },
+
     render() {
         const player = this.state.seats[this.seatIndex];
-        document.getElementById("seatMenuTitle").textContent = HoldemState.displayName(player, this.seatIndex);
+        const title = document.getElementById("seatMenuTitle");
+        const subtitle = document.getElementById("seatMenuSubtitle");
+        const list = document.getElementById("seatMenuActions");
+        list.innerHTML = "";
+
+        if (this.mode === "move") {
+            title.textContent = `Move ${HoldemState.displayName(player, this.seatIndex)} to…`;
+            subtitle.textContent = "Their chips, cards and bet go with them. The button and the blinds stay on the chair.";
+            this.destinationsFor(this.seatIndex).forEach(({ player: other, seat }) => {
+                const btn = document.createElement("button");
+                btn.type = "button";
+                btn.className = "seatMenuBtn";
+                // displayName falls back to "Seat 5" for a chair with nobody in it,
+                // which reads as "Seat 5 — Seat 5". An empty chair says it's empty.
+                const named = (other.name || "").trim();
+                btn.textContent = named ? `Seat ${seat + 1} — ${named}` : `Seat ${seat + 1} — empty`;
+                btn.addEventListener("click", () => {
+                    const from = this.seatIndex;
+                    this.close();
+                    this.hooks.swapSeats(from, seat);
+                });
+                list.appendChild(btn);
+            });
+            return;
+        }
+
+        title.textContent = HoldemState.displayName(player, this.seatIndex);
 
         const stack = Betting.stackOf(this.state, player);
         const owed = Betting.toCall(this.state, player);
         const bits = [];
         if (stack > 0) bits.push(`${Money.format(stack)} behind`);
         if (owed > 0) bits.push(`${Money.format(owed)} to call`);
-        document.getElementById("seatMenuSubtitle").textContent = bits.join(" · ");
+        subtitle.textContent = bits.join(" · ");
 
-        const list = document.getElementById("seatMenuActions");
-        list.innerHTML = "";
         this.actionsFor(player, this.seatIndex).forEach(action => {
             const btn = document.createElement("button");
             btn.type = "button";
             btn.className = `seatMenuBtn ${action.className || ""}`;
             btn.textContent = action.label;
             btn.addEventListener("click", () => {
+                // "Move to…" stays on the sheet and swaps it for the seat list; every
+                // other action is the end of the interaction.
+                if (action.label === "Move to…") {
+                    action.run();
+                    return;
+                }
                 this.close();
                 action.run();
             });

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

@@ -467,6 +467,21 @@ const HoldemState = {
             .sort((a, b) => b.net - a.net);
     },
 
+    // Two players change chairs.
+    //
+    // The whole seat moves — name, stack, cards, what they have in the pot — because
+    // that is what changing chairs is. What stays behind is everything that belongs to
+    // the *position*: the button, the blinds and the acting index all name a chair, and
+    // a player who moves into the big blind's chair is the big blind. That is the same
+    // answer a card room gives.
+    swapSeats(state, a, b) {
+        const seats = state.seats || [];
+        if (a === b) return false;
+        if (!seats[a] || !seats[b]) return false;
+        [seats[a], seats[b]] = [seats[b], seats[a]];
+        return true;
+    },
+
     // The one check a banker actually needs, and the one nothing here did.
     //
     // Every chip on the table is a promise to pay cash for it later. If the chips in

tests/holdem/buyIn.test.js

@@ -0,0 +1,76 @@
+// Whether handing a seat chips also puts them back in the game.
+const test = require("node:test");
+const assert = require("node:assert");
+const { Betting, makeTable } = require("./load");
+
+test("a busted player who has been sat out comes back in", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 100 });
+    state.seats[1].stack = 0;
+    Betting.beginHand(state);           // the deal sits them out
+
+    assert.equal(state.seats[1].inHand, false);
+    assert.equal(Betting.buyInDealsThemIn(state.seats[1]), true);
+});
+
+test("a chair being bought into for the first time comes in", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    state.seats[4].name = "Eve";
+    state.seats[4].stack = null;
+
+    assert.equal(Betting.buyInDealsThemIn(state.seats[4]), true);
+});
+
+test("a seat sat out while holding chips stays out", () => {
+    // A dealer sat them out on purpose and is topping them up. Dealing them back in
+    // would be the tool guessing at something it wasn't told.
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 100 });
+    state.seats[2].inHand = false;
+
+    assert.equal(Betting.buyInDealsThemIn(state.seats[2]), false);
+});
+
+test("somebody already in the hand is left exactly where they are", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 100 });
+    assert.equal(Betting.buyInDealsThemIn(state.seats[0]), false);
+
+    // Including a player who is in but out of chips — they're all-in, not sat out.
+    state.seats[2].stack = 0;
+    assert.equal(state.seats[2].inHand, true);
+    assert.equal(Betting.buyInDealsThemIn(state.seats[2]), false);
+});
+
+test("a blank stack field reads as nothing recorded, not as a number", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    state.seats[3].name = "Dee";
+    state.seats[3].stack = "";
+
+    assert.equal(Betting.buyInDealsThemIn(state.seats[3]), true);
+});
+
+test("it doesn't ask the table what a missing stack would have been", () => {
+    // stackOf substitutes the table's starting stack for a seat that has none, which
+    // would make a seat with nothing recorded look like it was holding chips.
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    state.defaultStack = 500;
+    state.seats[4].name = "Eve";
+    state.seats[4].stack = null;
+
+    assert.equal(Betting.stackOf(state, state.seats[4]), 500);
+    assert.equal(Betting.buyInDealsThemIn(state.seats[4]), true);
+});
+
+test("asking doesn't change anything", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 100 });
+    state.seats[2].stack = 0;
+    state.seats[2].inHand = false;
+    const before = JSON.stringify(state);
+
+    Betting.buyInDealsThemIn(state.seats[2]);
+
+    assert.equal(JSON.stringify(state), before);
+});
+
+test("nothing to decide about a seat that isn't there", () => {
+    assert.equal(Betting.buyInDealsThemIn(null), false);
+    assert.equal(Betting.buyInDealsThemIn(undefined), false);
+});

tests/holdem/chipBreakdown.test.js

@@ -0,0 +1,82 @@
+// The chips to actually push, for an amount.
+const test = require("node:test");
+const assert = require("node:assert");
+const { Money } = require("./load");
+
+// A standard house set.
+const LEGEND = [
+    { value: 1, color: "#fff" },
+    { value: 5, color: "#c0392b" },
+    { value: 25, color: "#27ae60" },
+    { value: 100, color: "#2c3e50" },
+    { value: 500, color: "#8e44ad" },
+];
+
+const say = (amount, legend = LEGEND) => Money.formatChipBreakdown(amount, legend);
+
+test("a payout comes back as chips, largest first", () => {
+    assert.equal(say(132), "1×$100, 1×$25, 1×$5, 2×$1");
+});
+
+test("it uses the fewest chips on a normal set", () => {
+    const { chips } = Money.chipBreakdown(500, LEGEND);
+    assert.deepEqual(chips.map(c => `${c.count}×${c.value}`), ["1×500"]);
+});
+
+test("a denomination that doesn't fit is skipped rather than listed as none", () => {
+    assert.equal(say(7), "1×$5, 2×$1");
+});
+
+test("nothing to pay is nothing to say", () => {
+    assert.equal(say(0), "");
+    assert.equal(say(-5), "");
+});
+
+test("no legend means no advice, not a wrong answer", () => {
+    // A table that never set chip colours up gets the amount on its own.
+    assert.equal(say(132, []), "");
+    assert.equal(say(132, null), "");
+});
+
+test("a legend with no values in it yet is the same as none", () => {
+    assert.equal(say(132, [{ value: "", color: "#fff" }, { value: 0, color: "#000" }]), "");
+});
+
+test("what the smallest chip can't make is reported, not rounded away", () => {
+    // 50c in a game whose smallest chip is a dollar is the dealer's problem to solve,
+    // and they can only solve it if they're told.
+    const { chips, remainder } = Money.chipBreakdown(10.5, LEGEND);
+    assert.deepEqual(chips.map(c => `${c.count}×${c.value}`), ["2×5"]);
+    assert.equal(remainder, 0.5);
+    assert.equal(say(10.5), "2×$5, $0.50 no chip covers");
+});
+
+test("cent chips make cent amounts exactly", () => {
+    const cents = [{ value: 0.25 }, { value: 0.05 }, { value: 0.01 }];
+    assert.equal(say(0.41, cents), "1×$0.25, 3×$0.05, 1×$0.01");
+    assert.equal(Money.chipBreakdown(0.41, cents).remainder, 0);
+});
+
+test("the chips add up to the amount", () => {
+    for (const amount of [1, 7, 33, 132, 499, 500, 1234, 9999]) {
+        const { chips, remainder } = Money.chipBreakdown(amount, LEGEND);
+        const total = chips.reduce((sum, c) => sum + c.count * c.value, 0) + remainder;
+        assert.equal(Money.round(total), amount, `${amount} should be accounted for`);
+    }
+});
+
+test("a legend in any order still pays largest first", () => {
+    const jumbled = [{ value: 25 }, { value: 1 }, { value: 500 }, { value: 5 }, { value: 100 }];
+    assert.equal(say(631, jumbled), "1×$500, 1×$100, 1×$25, 1×$5, 1×$1");
+});
+
+test("the colour comes along, so the felt can say it in chips", () => {
+    const { chips } = Money.chipBreakdown(25, LEGEND);
+    assert.equal(chips[0].color, "#27ae60");
+});
+
+test("a legend that exists but can't reach the amount does say so", () => {
+    // Different from having no legend at all: this table has told us its chips, and
+    // the answer is that they don't go that low.
+    assert.equal(say(3, [{ value: 5 }, { value: 25 }]), "$3 no chip covers");
+});

tests/holdem/selectsOnFocus.test.js

@@ -0,0 +1,53 @@
+// Which fields replace their contents when a dealer reaches for them.
+const test = require("node:test");
+const assert = require("node:assert");
+const { Money } = require("./load");
+
+// Enough of an input to answer the question, without a DOM.
+const field = (props = {}) => ({ tagName: "INPUT", type: "text", inputMode: "", ...props });
+
+test("a number box selects", () => {
+    assert.equal(Money.selectsOnFocus(field({ type: "number" })), true);
+});
+
+test("a decimal keypad box selects", () => {
+    // The raise pad's amount is type=text with inputmode=decimal, so the phone shows
+    // a number pad without the browser's spinner arrows.
+    assert.equal(Money.selectsOnFocus(field({ type: "text", inputMode: "decimal" })), true);
+});
+
+test("a name does not", () => {
+    // Selecting all of a name on focus is the same mistake pointing the other way:
+    // a name is a thing you edit, not a suggestion you replace.
+    assert.equal(Money.selectsOnFocus(field({ type: "text" })), false);
+});
+
+test("a colour swatch does not", () => {
+    assert.equal(Money.selectsOnFocus(field({ type: "color" })), false);
+});
+
+test("a checkbox does not", () => {
+    assert.equal(Money.selectsOnFocus(field({ type: "checkbox" })), false);
+});
+
+test("a textarea does not, whatever it is asked", () => {
+    assert.equal(Money.selectsOnFocus({ tagName: "TEXTAREA", type: "text", inputMode: "decimal" }), false);
+});
+
+test("a select does not", () => {
+    assert.equal(Money.selectsOnFocus({ tagName: "SELECT", type: "select-one" }), false);
+});
+
+test("case doesn't matter", () => {
+    assert.equal(Money.selectsOnFocus(field({ type: "NUMBER" })), true);
+    assert.equal(Money.selectsOnFocus(field({ type: "TEXT", inputMode: "DECIMAL" })), true);
+});
+
+test("nothing at all is not a field", () => {
+    assert.equal(Money.selectsOnFocus(null), false);
+    assert.equal(Money.selectsOnFocus(undefined), false);
+});
+
+test("a field with no type stated is a text box, so it does not", () => {
+    assert.equal(Money.selectsOnFocus({ tagName: "INPUT" }), false);
+});

tests/holdem/swapSeats.test.js

@@ -0,0 +1,95 @@
+// Two players changing chairs.
+const test = require("node:test");
+const assert = require("node:assert");
+const { Betting, HoldemState, makeTable, chipsOnTable } = require("./load");
+
+test("the whole seat moves", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 100 });
+    state.seats[0].name = "Ann";
+    state.seats[0].cards = ["AS", "KD"];
+    state.seats[0].stack = 175;
+    state.seats[4].name = "";
+
+    HoldemState.swapSeats(state, 0, 4);
+
+    assert.equal(state.seats[4].name, "Ann");
+    assert.deepEqual(state.seats[4].cards, ["AS", "KD"]);
+    assert.equal(state.seats[4].stack, 175);
+    assert.equal(state.seats[0].name, "");
+});
+
+test("what they have in the pot goes with them", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 100 });
+    Betting.beginHand(state);
+    const posted = state.seats.map(p => p.committed);
+    const before = chipsOnTable(state);
+
+    HoldemState.swapSeats(state, 1, 4);
+
+    assert.equal(state.seats[4].committed, posted[1]);
+    assert.equal(state.seats[1].committed, posted[4]);
+    assert.equal(chipsOnTable(state), before, "a swap never creates or destroys a chip");
+});
+
+test("the button stays on the chair, not on the player", () => {
+    // A card room moves the button around the table, not around the people. Somebody
+    // who sits down in the big blind's chair is the big blind.
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 100, dealerSeatIndex: 0 });
+    state.seats[0].name = "Ann";
+
+    HoldemState.swapSeats(state, 0, 2);
+
+    assert.equal(state.dealerSeatIndex, 0);
+    assert.notEqual(state.seats[0].name, "Ann");
+});
+
+test("the blinds follow the chairs too", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack: 100, dealerSeatIndex: 0 });
+    Betting.beginHand(state);
+    const before = HoldemState.getBlindSeats(state);
+
+    HoldemState.swapSeats(state, before.sbIndex, before.bbIndex);
+    const after = HoldemState.getBlindSeats(state);
+
+    assert.equal(after.sbIndex, before.sbIndex);
+    assert.equal(after.bbIndex, before.bbIndex);
+});
+
+test("swapping a seat with itself does nothing and says so", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    const before = JSON.stringify(state);
+
+    assert.equal(HoldemState.swapSeats(state, 1, 1), false);
+    assert.equal(JSON.stringify(state), before);
+});
+
+test("a chair that isn't there is refused rather than swallowed", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    const before = JSON.stringify(state);
+
+    assert.equal(HoldemState.swapSeats(state, 0, 99), false);
+    assert.equal(HoldemState.swapSeats(state, -1, 0), false);
+    assert.equal(JSON.stringify(state), before);
+});
+
+test("swapping twice puts everything back", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack: 100 });
+    Betting.beginHand(state);
+    const before = JSON.stringify(state);
+
+    HoldemState.swapSeats(state, 1, 3);
+    HoldemState.swapSeats(state, 1, 3);
+
+    assert.equal(JSON.stringify(state), before);
+});
+
+test("moving into an empty chair leaves an empty chair behind", () => {
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    state.seats[1].name = "Ben";
+
+    HoldemState.swapSeats(state, 1, 5);
+
+    assert.equal(state.seats[5].name, "Ben");
+    assert.equal(state.seats[5].inHand, true);
+    assert.equal(state.seats[1].inHand, false);
+});

tests/holdem/uiAudit.js

@@ -522,8 +522,15 @@ const LayoutAudit = {
         const chips = [...document.querySelectorAll(".dealerChip")];
         const shown = chips.filter(chip => {
             const style = getComputedStyle(chip);
-            return style.display !== "none" && style.visibility !== "hidden" &&
-                parseFloat(style.opacity) > 0.05;
+            if (style.display === "none" || style.visibility === "hidden") return false;
+            if (parseFloat(style.opacity) <= 0.05) return false;
+            // A hovered seat deliberately fades its empty slot in — that's the "put the
+            // button here" preview, and it is on screen because a pointer is sitting on
+            // that seat. Counting it reports two buttons whenever the mouse happens to
+            // rest on the table, which is most of the time a mouse exists.
+            const seat = chip.closest(".seat");
+            if (seat && seat.matches(":hover") && !chip.classList.contains("active")) return false;
+            return true;
         });
         const offenders = [];