Make big numbers readable, and make the export add up

Seeded a table that looks like a real game — "Mike from work", "Jean-Philippe",
stacks from $12 to $3,200,000 — and measured what the layout does with it.

".00" was costing a third of a seat puck

Every amount rendered with two forced decimal places. Measured, the trailing
".00" is ~22px, against the 64px a seat puck has to show a stack in. So
"$1,250,000.00" needed 102px of a 64px box — and because a number has no spaces
to break on, it neither wrapped nor ellipsised. It drew straight out over the
seat next to it.

Money now shows cents only when there are cents. A chip game deals in whole
numbers nearly all the time, and "$12" says exactly what "$12.00" said in half
the width. A quarter-blind game is untouched: $0.25, $12.50 and $0.75 pots all
still read as before, checked against a 25c/50c table.

That alone took "$1,250,000.00" down to "$1,250,000" — 102px to 80px, still
wider than the 64px puck. The remaining overflow is handled by stepping the font
down on long amounts, which keeps every digit. Abbreviating to "$1.25M" would
have fit more comfortably and was the obvious move, but a dealer reading a
rounded stack off the felt is a worse failure than a small one, and the exact
figure is the entire point of the tool. Measured after: every stack now paints
inside its own puck, nothing spills onto a neighbour.

Because Money.format is the single formatter all 47 call sites go through, this
lands on the seat pucks, action bar, pot breakdown, seat menu, standings and
history at once — the payoff from consolidating it earlier.

The CSV export couldn't be added up

The file exists so a house manager or a disputed chip count has something that
outlives the tab, and every money column in it was written as text:
"$1,250,000.00". The commas were quoted correctly so the file always parsed —
it just imported as strings, so the one thing anyone opens it to do, total a
column, needed every cell cleaned first.

Money columns now go in as bare numbers (1250000.00) with no symbol and no
separators. The columns meant for humans stay human: names are still names,
payouts still read "Alexandra: $1,250,000", and a name with a comma in it is
still quoted.

12 new tests (88 total, all passing), including the case that would be ruined by
dropping cents unconditionally, and a proper quote-aware CSV parser to check
every money cell parses as a number.

Re-ran the occlusion sweep from the previous round at 9 seats, 10 seats and
tournament stacks: still clean, no regression from the font changes.

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

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

@@ -306,8 +306,10 @@ button,
     position: relative;
     width: 100%;
     padding-bottom: 72%;
+    margin: 0 auto;
 }
 
+
 #pokerTable {
     position: absolute;
     inset: 6%;
@@ -627,6 +629,13 @@ button,
     color: #fff7e6;
 }
 
+/* A blind the dealer named by hand rather than one the button handed out. Without
+   the ring the table just looks like it's put the blinds in the wrong place. */
+.blindBadge.blindManual {
+    outline: 1.5px solid #f2f2f2;
+    outline-offset: 1px;
+}
+
 /* ---------- Seat editor panel (sidebar form for the selected seat) ---------- */
 
 .seatEditorPanel {
@@ -1914,6 +1923,24 @@ body.hasActionBar #holdemSidebar {
     margin-top: 0.1rem;
 }
 
+/* Tournament-sized amounts. A number has no spaces to break on, so an amount too
+   wide for the 64px puck neither wraps nor ellipsises — it draws straight out over
+   the seat next to it. These step the size down so every digit stays on its own
+   puck. Shrinking rather than abbreviating is deliberate: "$1.25M" would fit more
+   comfortably, but a dealer reading a rounded stack off the felt is a worse failure
+   than a small one, and the exact figure is what the tool is for. */
+.seatPuckStack.puckAmountLong,
+.seatPuckTotal.puckAmountLong {
+    font-size: 0.5rem;
+    letter-spacing: -0.01em;
+}
+
+.seatPuckStack.puckAmountHuge,
+.seatPuckTotal.puckAmountHuge {
+    font-size: 0.44rem;
+    letter-spacing: -0.02em;
+}
+
 .blindsRow {
     display: flex;
     flex-wrap: wrap;
@@ -1955,8 +1982,13 @@ body.hasActionBar #holdemSidebar {
 
 /* Sit above the action bar rather than on top of it, so an Undo never covers the
    Fold button the dealer is reaching for. */
+/* Sit the toast directly on top of the action bar, whatever height it happens to be.
+   This was a hardcoded 9rem, which is roughly right for the bar at rest and wrong the
+   moment the raise pad opens — and on a short phone it put the toast, Undo button and
+   all, straight over the bottom seats of the table, so a tap meant for a player hit
+   "Undo" instead. */
 body.hasActionBar #toastHost {
-    bottom: calc(9rem + env(safe-area-inset-bottom, 0px));
+    bottom: calc(var(--actionBarHeight, 9rem) + 0.75rem + env(safe-area-inset-bottom, 0px));
 }
 
 .toast {
@@ -2287,8 +2319,13 @@ body.hasActionBar #toastHost {
    seat looks like it did nothing. Inset the ring by half a puck, and float the
    editor up as a bottom sheet over the table. */
 @media (max-width: 700px) {
+    /* The bottom padding has to clear the fixed action bar, plus room for a toast to
+       sit above it. Without it the table just carries on underneath the bar and the
+       lower seats of the oval are behind the Fold button — measured at 360x640, where
+       62px of felt was covered. `--actionBarHeight` is published by actionBar.js and
+       is 0 when no hand is running, so the page doesn't hold a gap it doesn't need. */
     #holdemApp {
-        padding: 1rem 0.75rem 2rem;
+        padding: 1rem 0.75rem calc(var(--actionBarHeight, 0px) + 5rem + env(safe-area-inset-bottom, 0px));
     }
 
     #holdemHeader {
@@ -2560,3 +2597,96 @@ body.hasActionBar #toastHost {
         justify-content: center;
     }
 }
+
+/* ---------- A phone on its side ----------
+   Deliberately last in the file. The felt is an aspect-ratio box whose height comes
+   from `padding-bottom`, and the `max-width: 900px` block above re-sets that to 100%
+   — so a landscape rule placed any earlier is overridden at equal specificity and
+   does nothing, which is exactly what happened on the first attempt.
+
+   Landscape is where this layout falls apart worst: sized from width, the table came
+   out 765px tall in a 390px-tall window, putting six of the nine seats below the fold
+   and the rest behind the action bar. Sizing it from the height that's actually left
+   makes every seat reachable without scrolling. The table ends up small, but a seat
+   you have to go hunting for is worse than a seat that's small. */
+@media (orientation: landscape) and (max-height: 560px) {
+    /* Set outright rather than via padding-bottom: a percentage padding resolves
+       against the containing block's width, not the element's own, so narrowing the
+       wrap on its own left it full height regardless. */
+    #pokerTableWrap {
+        --feltRoom: calc(100vh - var(--actionBarHeight, 0px) - 8.5rem);
+        width: min(100%, calc(var(--feltRoom) / 0.72));
+        height: var(--feltRoom);
+        padding-bottom: 0;
+    }
+
+    /* The header ate 148px of a 390px-tall window, which was most of the reason the
+       table started below the fold. Here it only needs to be a title bar. */
+    #holdemHeader {
+        margin-bottom: 0.4rem;
+        gap: 0.35rem;
+    }
+
+    #holdemHeader h1 {
+        font-size: 1.05rem;
+        padding-bottom: 0.15rem;
+    }
+
+    .holdemSubtitle {
+        display: none;
+    }
+
+    /* There's no vertical room left, but plenty either side of a table this narrow,
+       so the toast moves out of the middle and sits beside the felt instead of on
+       top of it. Centred, it was covering up to six seats at once — and it carries
+       an Undo button, so a tap meant for a player was landing on "Undo". */
+    body.hasActionBar #toastHost,
+    #toastHost {
+        left: auto;
+        right: 0.5rem;
+        max-width: 17rem;
+        bottom: calc(var(--actionBarHeight, 0px) + 0.5rem + env(safe-area-inset-bottom, 0px));
+    }
+
+    /* Nine seats around a table this small overlap each other, so they shrink to suit. */
+    .seat {
+        width: 62px;
+        min-height: 40px;
+    }
+}
+
+/* ---------- Short phones, upright ----------
+   A 640px-tall screen spends ~150px on the header before the felt even starts, which
+   left the bottom of the table sitting behind the action bar until you scrolled. The
+   header carries no information a dealer needs mid-hand, so it gives the space up. */
+@media (max-height: 700px) {
+    /* Nowhere on a screen this short is the toast clear of both the table and the
+       action bar, so it overlaps the one that costs least: it sits over the bar's
+       status line, which is information a dealer can re-read a second later, rather
+       than over the seats and buttons, which are things they need to hit. Overlapping
+       a readout beats covering a control. */
+    body.hasActionBar #toastHost {
+        bottom: calc(var(--actionBarHeight, 0px) - 3.1rem);
+    }
+
+    .toast {
+        padding: 0.5rem 0.7rem;
+        font-size: 0.78rem;
+    }
+}
+
+@media (max-width: 700px) and (max-height: 700px) {
+    #holdemHeader {
+        margin-bottom: 0.5rem;
+        gap: 0.4rem;
+    }
+
+    #holdemHeader h1 {
+        font-size: 1.15rem;
+        padding-bottom: 0.2rem;
+    }
+
+    .holdemSubtitle {
+        display: none;
+    }
+}

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

@@ -11,9 +11,35 @@ const ActionBar = {
     mount(state, hooks) {
         this.state = state;
         this.hooks = hooks;
+        this.watchHeight();
         this.render();
     },
 
+    // The bar is fixed to the bottom of the screen, so everything else has to know how
+    // tall it is or the table simply runs underneath it — on a 640px-tall phone the
+    // bottom seats of the oval were sitting behind the Fold button. Its height isn't a
+    // constant either: opening the raise pad grows it. Publishing the measured height
+    // as a custom property lets the layout and the toast both stay clear of it without
+    // anyone guessing a number.
+    watchHeight() {
+        const host = document.getElementById("actionBar");
+        if (!host || this.heightWatcher) return;
+
+        const publish = () => {
+            const visible = !host.hidden;
+            const height = visible ? host.getBoundingClientRect().height : 0;
+            document.documentElement.style.setProperty("--actionBarHeight", `${Math.round(height)}px`);
+        };
+
+        if (typeof ResizeObserver === "function") {
+            this.heightWatcher = new ResizeObserver(publish);
+            this.heightWatcher.observe(host);
+        }
+        window.addEventListener("resize", publish);
+        window.addEventListener("orientationchange", publish);
+        publish();
+    },
+
     // Anything to act on? A hand with nobody dealt in doesn't get a bar.
     isRunning() {
         return Betting.liveSeats(this.state).length > 0;
@@ -27,6 +53,7 @@ const ActionBar = {
         if (!this.isRunning()) {
             host.hidden = true;
             document.body.classList.remove("hasActionBar");
+            document.documentElement.style.setProperty("--actionBarHeight", "0px");
             this.stopTankTimer();
             this.tankSeatIndex = null;
             return;

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

@@ -243,6 +243,28 @@ const Betting = {
         return this.liveSeats(state).length > 1 && !this.canStillBet(state);
     },
 
+    // True while nothing has happened in this hand except the blinds going in. Up to
+    // that point the dealer can still move the button or rename the blinds and have
+    // it cost nothing — which is the state a home game spends a lot of time in,
+    // arguing about whose turn it is before the cards come out.
+    onlyBlindsIn(state) {
+        return (state.street || "preflop") === "preflop" && state.seats.every(p => !p.hasActed);
+    },
+
+    // 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
+    // times before anybody is happy with it.
+    repostBlinds(state) {
+        state.seats.forEach(player => {
+            const back = this.committed(player);
+            if (back > 0) player.stack = this.round(this.stackOf(state, player) + back);
+            player.committed = 0;
+            player.hasActed = false;
+        });
+        this.beginHand(state);
+    },
+
     // Deals a fresh betting round: blinds posted, action to the seat after the big
     // blind, which is where a dealer expects to be looking when the cards go out.
     beginHand(state) {
@@ -250,6 +272,11 @@ const Betting = {
         state.currentBet = 0;
         state.lastRaiseSize = 0;
 
+        // Position is read off the button all through the hand, so it has to be on
+        // somebody before the blinds are worked out — not on the empty seat 1 a
+        // brand-new table starts on.
+        HoldemState.ensureButtonOnPlayer(state);
+
         state.seats.forEach(player => {
             player.committed = 0;
             player.hasActed = false;

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

@@ -15,6 +15,10 @@ const HandHistoryExport = {
         }
     },
 
+    // Money columns go in as bare numbers. Written as "$1,250,000.00" they import as
+    // 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 = []) {
         const rows = [["Hand #", "Time", "Pot", "Payouts"]];
         // handHistory is stored newest-first; the export reads better oldest-first.
@@ -25,7 +29,7 @@ const HandHistoryExport = {
             rows.push([
                 entry.handNumber,
                 this.formatTimestamp(entry.timestamp),
-                Money.format(entry.pot),
+                Money.forSheet(entry.pot),
                 payouts,
             ]);
         });
@@ -41,12 +45,12 @@ const HandHistoryExport = {
             standings.forEach(row => {
                 rows.push([
                     row.name,
-                    Money.format(row.in),
-                    Money.format(row.won),
-                    Money.formatSigned(row.net),
-                    Money.format(row.boughtIn || 0),
-                    Money.format(row.chipsNow || 0),
-                    Money.formatSigned(row.cashPosition || 0),
+                    Money.forSheet(row.in),
+                    Money.forSheet(row.won),
+                    Money.forSheet(row.net),
+                    Money.forSheet(row.boughtIn || 0),
+                    Money.forSheet(row.chipsNow || 0),
+                    Money.forSheet(row.cashPosition || 0),
                 ]);
             });
         }

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

@@ -52,6 +52,7 @@ document.addEventListener("DOMContentLoaded", () => {
         },
 
         onSeatLongPress: index => SeatMenu.open(state, seatMenuHooks, index),
+        onGiveButton: index => seatMenuHooks.makeDealer(index),
     };
 
     const seatMenuHooks = {
@@ -59,13 +60,71 @@ document.addEventListener("DOMContentLoaded", () => {
         unfold: index => seatAction(index, `${nameOf(index)} is back in the hand.`, p => { p.folded = false; }),
         allIn: index => seatAction(index, `${nameOf(index)} is all-in.`, () => Betting.allIn(state, index)),
         toggleDealtIn: index => {
-            const dealtIn = state.seats[index].inHand;
-            seatAction(index, dealtIn ? `${nameOf(index)} sits out.` : `${nameOf(index)} is dealt in.`, p => {
+            const player = state.seats[index];
+            const dealtIn = player.inHand;
+            const handRunning = !Betting.onlyBlindsIn(state) || Betting.potSoFar(state) > 0;
+            const alreadyIn = Betting.handTotal(player);
+
+            // Somebody walking away mid-hand doesn't get their chips back — they're
+            // dead money the winner collects. Say so, because the pot total pointedly
+            // does not go down and a dealer needs to know that's deliberate.
+            const message = dealtIn
+                ? (alreadyIn > 0
+                    ? `${nameOf(index)} is out — their ${Money.format(alreadyIn)} stays in the pot.`
+                    : `${nameOf(index)} sits out.`)
+                : (handRunning
+                    ? `${nameOf(index)} is in from the next hand.`
+                    : `${nameOf(index)} is dealt in.`);
+
+            seatAction(index, message, p => {
                 p.inHand = !dealtIn;
-                if (!p.inHand) p.folded = false;
+                if (!p.inHand) {
+                    // Their chips stay put; only the fold flag is cleared, since being
+                    // out of the hand already covers not winning it.
+                    p.folded = false;
+                    if (state.actingSeatIndex === index) Betting.passAction(state, index);
+                } else if (handRunning) {
+                    // Joining a hand already in progress means sitting this one out —
+                    // you can't buy into a pot you haven't been paying for. `folded`
+                    // is exactly that state, and the next hand clears it.
+                    p.folded = true;
+                }
             });
         },
-        makeDealer: index => seatAction(index, `Button on ${nameOf(index)}.`, () => { state.dealerSeatIndex = index; }),
+
+        makeDealer: index => seatAction(index, `Button on ${nameOf(index)}.`, () => {
+            state.dealerSeatIndex = index;
+            // Before anyone has acted the blinds are still just sitting there, so
+            // moving the button moves them too — a home game passes it round several
+            // times before the cards come out, and the posted chips have to follow.
+            if (Betting.onlyBlindsIn(state)) Betting.repostBlinds(state);
+        }),
+
+        assignBlind: (index, which) => {
+            const blinds = HoldemState.getBlindSeats(state);
+            const other = which === "sb" ? blinds.bbIndex : blinds.sbIndex;
+            // Naming one blind pins the other where it already is, so the dealer only
+            // has to state the part they're changing. If that would land both on one
+            // player, the other blind moves to the next seat along.
+            let partner = other !== null && other !== undefined && other !== index
+                ? other
+                : Betting.nextLiveIndex(state, index);
+            if (partner === index || partner === null) partner = Betting.nextLiveIndex(state, index);
+
+            const label = which === "sb" ? "small blind" : "big blind";
+            seatAction(index, `${nameOf(index)} posts the ${label}.`, () => {
+                state.blindOverride = which === "sb"
+                    ? { sbIndex: index, bbIndex: partner }
+                    : { sbIndex: partner, bbIndex: index };
+                if (Betting.onlyBlindsIn(state)) Betting.repostBlinds(state);
+            });
+        },
+
+        clearBlindOverride: () => seatAction(state.dealerSeatIndex, "Blinds follow the button again.", () => {
+            state.blindOverride = null;
+            if (Betting.onlyBlindsIn(state)) Betting.repostBlinds(state);
+        }),
+
         editSeat: index => Render.toggleSeatEditor(index),
 
         addChips: index => AddChips.open(state, index, (seatIndex, amount) => {

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

@@ -25,9 +25,27 @@ const Money = {
         return this.toCents(amount) / 100;
     },
 
+    // Cents only when there are cents.
+    //
+    // A chip game deals in whole numbers nearly all the time, and a trailing ".00"
+    // is two characters that say nothing — measured at ~22px, against the 64px a
+    // seat puck has to show a stack in. "$1,250,000.00" doesn't fit and wraps;
+    // "$1,250,000" does. Amounts that genuinely carry cents still show them, so a
+    // 25c-blind game reads exactly as it did.
     format(amount) {
         const value = Number(amount) || 0;
-        return `$${value.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+        const hasCents = this.toCents(value) % 100 !== 0;
+        return `$${value.toLocaleString(undefined, {
+            minimumFractionDigits: hasCents ? 2 : 0,
+            maximumFractionDigits: 2,
+        })}`;
+    },
+
+    // The same amount for a spreadsheet rather than for a person: no currency symbol
+    // and no thousands separators, because those are what make a column of money
+    // import as text and refuse to add up.
+    forSheet(amount) {
+        return (this.toCents(amount) / 100).toFixed(2);
     },
 
     // "+$40.00" / "-$40.00" rather than "$-40.00" — a standings column is read at a

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

@@ -30,7 +30,10 @@ const PotWizard = {
         const contributions = players.map(p => ({
             id: p.id,
             contribution: HoldemState.computeContribution(p, state.chipLegend, state.basePotAmount),
-            folded: p.folded,
+            // A seat switched off mid-hand still has its chips in the pot, but it
+            // can no more win them than a folded one can — same dead money, and the
+            // wizard must not offer it as a winner.
+            folded: p.folded || HoldemState.isDeadMoney(p),
         }));
         this.entries = PotCalculator.buildEntries(contributions);
         // Kept so the wizard can show the whole breakdown up front, not just the layer

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

@@ -158,7 +158,7 @@ const Render = {
         const layer = document.getElementById("seatsLayer");
         layer.innerHTML = "";
         const template = document.getElementById("seatTemplate");
-        const { dealerIndex, sbIndex, bbIndex } = HoldemState.getBlindSeats(this.state);
+        const { dealerIndex, sbIndex, bbIndex, manual: manualBlinds } = HoldemState.getBlindSeats(this.state);
 
         this.state.seats.forEach((player, index) => {
             const node = template.content.firstElementChild.cloneNode(true);
@@ -172,15 +172,26 @@ const Render = {
             const dealerChip = node.querySelector(".dealerChip");
             dealerChip.classList.toggle("active", index === dealerIndex);
             dealerChip.classList.toggle("hidden", !!this.state.dedicatedDealer);
+            // Tapping the puck is the same act as "Give the button" in the seat menu,
+            // so it goes through the same hook — otherwise this one path would move
+            // the button without moving the blinds that follow it.
             dealerChip.addEventListener("click", e => {
                 e.stopPropagation();
-                this.state.dealerSeatIndex = index;
-                this.hooks.save(this.state);
-                this.renderSeats();
+                this.hooks.onGiveButton(index);
             });
 
-            node.querySelector(".sbBadge").classList.toggle("visible", index === sbIndex);
-            node.querySelector(".bbBadge").classList.toggle("visible", index === bbIndex);
+            const sbBadge = node.querySelector(".sbBadge");
+            const bbBadge = node.querySelector(".bbBadge");
+            sbBadge.classList.toggle("visible", index === sbIndex);
+            bbBadge.classList.toggle("visible", index === bbIndex);
+            // A blind the dealer named by hand isn't where the button would have put
+            // it, so it's marked — otherwise the table looks like it's just wrong.
+            // The `!!` matters: getBlindSeats leaves `manual` undefined when the
+            // blinds are positional, and classList.toggle with an undefined second
+            // argument *flips* the class instead of clearing it, so the marker
+            // appeared and disappeared on alternate renders.
+            sbBadge.classList.toggle("blindManual", !!manualBlinds && index === sbIndex);
+            bbBadge.classList.toggle("blindManual", !!manualBlinds && index === bbIndex);
 
             this.updatePuckContent(node, player, index);
             node.classList.toggle("seatSelected", index === this.selectedSeatIndex);
@@ -250,11 +261,14 @@ const Render = {
         const total = handTotal > 0
             ? handTotal
             : HoldemState.computeContribution(player, this.state.chipLegend, this.state.basePotAmount);
-        node.querySelector(".seatPuckTotal").textContent = total > 0 ? Money.format(total) : "";
+        const totalEl = node.querySelector(".seatPuckTotal");
+        totalEl.textContent = total > 0 ? Money.format(total) : "";
+        this.fitAmount(totalEl);
 
         const stackEl = node.querySelector(".seatPuckStack");
         const stack = Betting.stackOf(this.state, player);
         stackEl.textContent = !empty && stack > 0 ? Money.format(stack) : "";
+        this.fitAmount(stackEl);
 
         node.classList.toggle("seatActing", index === this.state.actingSeatIndex);
         node.classList.toggle("seatEmpty", empty);
@@ -263,6 +277,17 @@ const Render = {
         node.classList.toggle("seatLive", player.inHand && !player.folded);
     },
 
+    // A seat puck is 64px of usable width. A tournament stack doesn't fit in that and,
+    // because the number has no spaces to break on, it doesn't wrap or ellipsise
+    // either — it just draws straight out over the neighbouring seat. Stepping the
+    // font down keeps every digit, which matters: a dealer misreading a stack is a
+    // worse outcome than a small one, so this shrinks rather than abbreviating.
+    fitAmount(el) {
+        const length = (el.textContent || "").length;
+        el.classList.toggle("puckAmountLong", length >= 8 && length < 10);
+        el.classList.toggle("puckAmountHuge", length >= 10);
+    },
+
     // Cheaper than a full renderSeats() — used after edits so the seat editor's inputs
     // (which live in a separate panel) never lose focus.
     refreshPuck(index) {

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

@@ -45,6 +45,24 @@ const SeatMenu = {
             actions.push({ label: "Give the button", run: () => this.hooks.makeDealer(index) });
         }
 
+        // Naming a blind by hand. Only offered while nothing but the blinds are in —
+        // once somebody has called, moving a blind would mean unpicking a bet that
+        // has already been answered, and that's a decision for the dealer's mouth,
+        // not a menu item. Which blind a seat already has is shown rather than
+        // offered again.
+        if (dealtIn && Betting.onlyBlindsIn(this.state)) {
+            const blinds = HoldemState.getBlindSeats(this.state);
+            if (blinds.sbIndex !== index) {
+                actions.push({ label: "Make small blind", run: () => this.hooks.assignBlind(index, "sb") });
+            }
+            if (blinds.bbIndex !== index) {
+                actions.push({ label: "Make big blind", run: () => this.hooks.assignBlind(index, "bb") });
+            }
+            if (this.state.blindOverride) {
+                actions.push({ label: "Blinds follow the button again", run: () => this.hooks.clearBlindOverride() });
+            }
+        }
+
         actions.push({ label: "Edit seat…", run: () => this.hooks.editSeat(index) });
         return actions;
     },

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

@@ -58,6 +58,12 @@ const HoldemState = {
             currentBet: 0,
             lastRaiseSize: 0,
             actingSeatIndex: null,
+            // Set when the dealer names the blinds by hand instead of letting them
+            // follow the button — { sbIndex, bbIndex }. Home games do this constantly
+            // ("you had it last time", someone arriving late owing a blind), and the
+            // button order is the wrong answer often enough that it has to be
+            // overridable. Cleared at the start of every hand.
+            blindOverride: null,
         };
     },
 
@@ -73,7 +79,8 @@ const HoldemState = {
             // 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"]
+            ["smallBlind", "bigBlind", "defaultStack", "street", "currentBet", "lastRaiseSize",
+                "actingSeatIndex", "blindOverride"]
                 .forEach(key => {
                     if (parsed[key] === undefined) parsed[key] = defaults[key];
                 });
@@ -124,9 +131,14 @@ const HoldemState = {
     },
 
     // Contribution the table calculator will treat this player as having put in.
+    //
+    // Chips already pushed into the middle count whether or not the player is still
+    // in the hand. Someone who storms off, gets taken out by the dealer, or is
+    // dealt out mid-hand leaves their money on the felt — it's dead money owed to
+    // whoever wins, and it is not theirs to take back. Reading `inHand` first is
+    // how those chips used to disappear out of the pot the instant a seat was
+    // switched off, quietly shrinking the payout by whatever they had posted.
     computeContribution(player, chipLegend, basePotAmount) {
-        if (!player.inHand) return 0;
-
         const override = player.amountOverride;
         if (override !== null && override !== undefined && String(override).trim() !== "") {
             const parsed = Number(override);
@@ -139,10 +151,22 @@ const HoldemState = {
         }, 0);
         if (chipTotal > 0) return chipTotal;
 
+        // The table-wide default is the one thing that stays tied to being dealt in:
+        // it's a stand-in for "everyone put the same amount in", so applying it to
+        // empty chairs would invent a contribution from every seat nobody is using.
+        if (!player.inHand) return 0;
+
         const base = Number(basePotAmount);
         return Number.isNaN(base) ? 0 : Math.max(0, base);
     },
 
+    // Anyone whose chips are in the pot, whether or not they're still in the hand.
+    // A seat that's been switched off mid-hand is dead money: it counts towards the
+    // pot but can never be picked as a winner, exactly like a fold.
+    isDeadMoney(player) {
+        return !player.inHand;
+    },
+
     totalPot(state) {
         return state.seats.reduce(
             (sum, p) => sum + this.computeContribution(p, state.chipLegend, state.basePotAmount),
@@ -188,12 +212,52 @@ const HoldemState = {
         return order;
     },
 
+    // A button sitting on an empty chair is only cosmetic until you try to read
+    // position off it. On the very first hand of a fresh table it starts on seat 1
+    // whether or not anybody is sitting there, and a table that empties out around it
+    // leaves it stranded. Move it to a real player before a hand is dealt.
+    ensureButtonOnPlayer(state) {
+        if (state.seats[state.dealerSeatIndex] && state.seats[state.dealerSeatIndex].inHand) return;
+        for (let step = 0; step < state.seatCount; step++) {
+            const index = this.nextSeatIndex(state, state.dealerSeatIndex, step);
+            if (state.seats[index].inHand) {
+                state.dealerSeatIndex = index;
+                return;
+            }
+        }
+    },
+
+    // A hand-picked blind is only usable if that seat is actually in the hand — a
+    // dealer who names a blind and then deals that player out shouldn't have the
+    // table quietly post to nobody.
+    validBlindOverride(state) {
+        const o = state.blindOverride;
+        if (!o) return null;
+        const ok = i => Number.isInteger(i) && i >= 0 && i < state.seatCount && state.seats[i] && state.seats[i].inHand;
+        if (!ok(o.sbIndex) || !ok(o.bbIndex) || o.sbIndex === o.bbIndex) return null;
+        return o;
+    },
+
     // 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) {
         const live = this.liveOrderFromButton(state);
         const dealerIndex = state.dealerSeatIndex;
 
+        // A blind the dealer named by hand wins over anything positional. Heads-up is
+        // still reported honestly so the betting order stays right — who posts what
+        // is the dealer's call, but two-handed play acting in reverse is a rule.
+        const override = this.validBlindOverride(state);
+        if (override) {
+            return {
+                dealerIndex,
+                sbIndex: override.sbIndex,
+                bbIndex: override.bbIndex,
+                headsUp: live.length === 2,
+                manual: true,
+            };
+        }
+
         if (live.length < 2) {
             return { dealerIndex, sbIndex: null, bbIndex: null, headsUp: false };
         }
@@ -210,6 +274,10 @@ const HoldemState = {
 
     startNextHand(state) {
         this.advanceButton(state);
+        // A hand-picked blind applies to the hand it was picked for. Carrying it into
+        // 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;
         state.seats.forEach(p => {
             p.folded = false;
             p.cards = ["", ""];
@@ -218,6 +286,8 @@ const HoldemState = {
             p.committed = 0;
             p.hasActed = false;
         });
+        // Anyone who joined mid-hand is a full player again from here.
+        this.ensureButtonOnPlayer(state);
     },
 
     // Appends a resolved-pot record to the running session log a dealer can point to

tests/holdem/load.js

@@ -18,6 +18,7 @@ const Money = load("money");
 const PotCalculator = load("potCalculator");
 const SplitCalculator = load("splitCalculator");
 const Betting = load("betting");
+const HandHistoryExport = load("handHistoryExport");
 
 // state.js exports `HoldemState`, which doesn't match its filename.
 const HoldemState = require(path.join(SRC, "state.js"));
@@ -68,6 +69,7 @@ function contributions(state) {
 
 module.exports = {
     Money,
+    HandHistoryExport,
     PotCalculator,
     SplitCalculator,
     Betting,

tests/holdem/messyTables.test.js

@@ -0,0 +1,260 @@
+// Home games are messy. People walk up mid-hand, storm off mid-hand, argue about
+// whose blind it is, and pass the button round three times before anyone deals.
+// These are the cases the positional rules quietly get wrong.
+const { test, describe } = require("node:test");
+const assert = require("node:assert/strict");
+const { Betting, HoldemState, PotCalculator, Money, makeTable, chipsOnTable, contributions } = require("./load");
+
+const potOf = state => HoldemState.totalPot(state);
+
+describe("a player leaves in the middle of a hand", () => {
+    test("their chips stay in the pot", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], dealerSeatIndex: 0 });
+        Betting.beginHand(state);
+        Betting.call(state, 3); Betting.call(state, 0); Betting.call(state, 1); Betting.check(state, 2);
+        Betting.sweepToHandTotals(state);
+
+        const before = potOf(state);
+        assert.equal(before, 8);
+
+        state.seats[1].inHand = false; // dealer takes them out
+
+        assert.equal(potOf(state), before, "the pot must not shrink when a player is taken out");
+    });
+
+    test("they cannot be paid out of a pot they walked away from", () => {
+        const state = makeTable({ seatCount: 4, seated: [0, 1, 2], dealerSeatIndex: 0 });
+        Betting.beginHand(state);
+        Betting.call(state, 0); Betting.call(state, 1); Betting.check(state, 2);
+        Betting.sweepToHandTotals(state);
+
+        state.seats[1].inHand = false;
+
+        const players = state.seats
+            .filter(p => HoldemState.computeContribution(p, state.chipLegend, state.basePotAmount) > 0)
+            .map(p => ({
+                id: p.id,
+                contribution: HoldemState.computeContribution(p, state.chipLegend, state.basePotAmount),
+                folded: p.folded || HoldemState.isDeadMoney(p),
+            }));
+
+        const layers = PotCalculator.layers(players);
+        assert.ok(!layers[0].eligible.includes(state.seats[1].id), "a departed player can't win");
+        assert.equal(layers.reduce((s, l) => s + l.amount, 0), 6, "but their money is still being played for");
+    });
+
+    test("taking out the player who is to act moves the action on", () => {
+        const state = makeTable({ seatCount: 4, seated: [0, 1, 2, 3], dealerSeatIndex: 0 });
+        Betting.beginHand(state);
+        const acting = state.actingSeatIndex;
+
+        state.seats[acting].inHand = false;
+        Betting.passAction(state, acting);
+
+        assert.notEqual(state.actingSeatIndex, acting, "the table can't wait on somebody who left");
+        assert.ok(state.actingSeatIndex === null || state.seats[state.actingSeatIndex].inHand);
+    });
+
+    test("an empty chair still contributes nothing, base pot or not", () => {
+        // The table-wide default must not be read as an ante from seats nobody is in.
+        const state = makeTable({ seatCount: 6, seated: [0, 1], dealerSeatIndex: 0 });
+        state.basePotAmount = 25;
+        assert.equal(HoldemState.computeContribution(state.seats[4], state.chipLegend, 25), 0);
+    });
+});
+
+describe("a player joins in the middle of a hand", () => {
+    test("they sit the hand out rather than joining a pot they never paid into", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2], dealerSeatIndex: 0 });
+        Betting.beginHand(state);
+        Betting.call(state, 0); Betting.call(state, 1); Betting.check(state, 2);
+        Betting.sweepToHandTotals(state);
+
+        // Walks up and is dealt in — the app marks them folded for this hand.
+        state.seats[4].inHand = true;
+        state.seats[4].stack = 100;
+        state.seats[4].folded = true;
+
+        assert.ok(!Betting.liveSeats(state).some(s => s.index === 4), "not live this hand");
+        assert.equal(HoldemState.computeContribution(state.seats[4], state.chipLegend, state.basePotAmount), 0);
+    });
+
+    test("they are a full player again on the next hand", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2], dealerSeatIndex: 0 });
+        Betting.beginHand(state);
+        state.seats[4].inHand = true;
+        state.seats[4].stack = 100;
+        state.seats[4].folded = true;
+
+        HoldemState.startNextHand(state);
+        Betting.beginHand(state);
+
+        assert.equal(state.seats[4].folded, false);
+        assert.ok(Betting.liveSeats(state).some(s => s.index === 4), "dealt in like anyone else");
+    });
+});
+
+describe("passing the button around before the cards come out", () => {
+    test("moving the button re-posts the blinds and keeps the chip count straight", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], dealerSeatIndex: 0 });
+        const startingChips = chipsOnTable(state);
+        Betting.beginHand(state);
+
+        assert.equal(state.seats[1].committed, 1);
+        assert.equal(state.seats[2].committed, 2);
+
+        state.dealerSeatIndex = 2;
+        Betting.repostBlinds(state);
+
+        assert.equal(state.seats[1].committed, 0, "the old small blind got their chip back");
+        assert.equal(state.seats[3].committed, 1, "and the new one has posted");
+        assert.equal(state.seats[0].committed, 2);
+        assert.equal(chipsOnTable(state), startingChips, "no chips created or lost in the shuffle");
+    });
+
+    test("passing it round many times still balances", () => {
+        const state = makeTable({ seatCount: 8, seated: [0, 2, 3, 5, 7], dealerSeatIndex: 0 });
+        const startingChips = chipsOnTable(state);
+        Betting.beginHand(state);
+
+        [2, 5, 7, 3, 0, 5].forEach(seat => {
+            state.dealerSeatIndex = seat;
+            Betting.repostBlinds(state);
+            assert.equal(chipsOnTable(state), startingChips, `chips drifted after passing to seat ${seat}`);
+        });
+
+        const { sbIndex, bbIndex } = HoldemState.getBlindSeats(state);
+        assert.equal(Betting.committed(state.seats[sbIndex]), 1);
+        assert.equal(Betting.committed(state.seats[bbIndex]), 2);
+    });
+
+    test("once somebody has acted, the blinds are settled", () => {
+        const state = makeTable({ seatCount: 4, seated: [0, 1, 2, 3], dealerSeatIndex: 0 });
+        Betting.beginHand(state);
+        assert.equal(Betting.onlyBlindsIn(state), true, "nothing but blinds so far");
+
+        Betting.call(state, 3);
+        assert.equal(Betting.onlyBlindsIn(state), false, "a call means the blinds are set where they are");
+    });
+});
+
+describe("naming the blinds by hand", () => {
+    test("a named blind wins over the button order", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], dealerSeatIndex: 0 });
+        state.blindOverride = { sbIndex: 3, bbIndex: 0 };
+
+        const { sbIndex, bbIndex, manual } = HoldemState.getBlindSeats(state);
+        assert.equal(sbIndex, 3);
+        assert.equal(bbIndex, 0);
+        assert.equal(manual, true);
+
+        Betting.beginHand(state);
+        assert.equal(state.seats[3].committed, 1);
+        assert.equal(state.seats[0].committed, 2);
+        assert.equal(state.seats[1].committed, 0, "the positional small blind posts nothing");
+    });
+
+    test("a named blind on a player who isn't dealt in is ignored", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2], dealerSeatIndex: 0 });
+        state.blindOverride = { sbIndex: 4, bbIndex: 0 }; // seat 4 is an empty chair
+
+        const { sbIndex, manual } = HoldemState.getBlindSeats(state);
+        assert.ok(!manual, "falls back to the button order rather than posting to nobody");
+        assert.ok(state.seats[sbIndex].inHand);
+    });
+
+    test("both blinds on one player is refused", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2], dealerSeatIndex: 0 });
+        state.blindOverride = { sbIndex: 1, bbIndex: 1 };
+        const { sbIndex, bbIndex } = HoldemState.getBlindSeats(state);
+        assert.notEqual(sbIndex, bbIndex);
+    });
+
+    test("naming blinds heads-up still acts in the right order", () => {
+        const state = makeTable({ seatCount: 6, seated: [2, 5], dealerSeatIndex: 2 });
+        state.blindOverride = { sbIndex: 5, bbIndex: 2 }; // deliberately the reverse
+
+        Betting.beginHand(state);
+        assert.equal(state.seats[5].committed, 1);
+        assert.equal(state.seats[2].committed, 2);
+        assert.equal(state.actingSeatIndex, 5, "the small blind acts first pre-flop heads-up");
+
+        Betting.call(state, 5);
+        Betting.check(state, 2);
+        Betting.closeStreet(state);
+        assert.equal(state.actingSeatIndex, 2, "and the big blind leads after the flop");
+    });
+
+    test("the naming only lasts the hand it was made for", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], dealerSeatIndex: 0 });
+        state.blindOverride = { sbIndex: 3, bbIndex: 0 };
+        Betting.beginHand(state);
+
+        HoldemState.startNextHand(state);
+        assert.equal(state.blindOverride, null, "blinds go back to following the button");
+    });
+});
+
+describe("the first hand on a fresh table", () => {
+    test("the button never starts on an empty chair", () => {
+        const state = HoldemState.createDefault();
+        HoldemState.resizeSeats(state, 9);
+        [4, 6, 7].forEach(i => { state.seats[i].inHand = true; state.seats[i].stack = 100; });
+        assert.equal(state.dealerSeatIndex, 0, "a fresh table starts the button on seat 1");
+        assert.equal(state.seats[0].inHand, false, "which nobody is sitting in");
+
+        Betting.beginHand(state);
+
+        assert.ok(state.seats[state.dealerSeatIndex].inHand, "the button moved to a real player");
+        const { sbIndex, bbIndex } = HoldemState.getBlindSeats(state);
+        assert.ok(state.seats[sbIndex].inHand);
+        assert.ok(state.seats[bbIndex].inHand);
+        assert.notEqual(sbIndex, bbIndex);
+    });
+
+    test("a table that empties out around the button recovers", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], dealerSeatIndex: 3 });
+        state.seats[3].inHand = false; // the player holding the button leaves
+        HoldemState.ensureButtonOnPlayer(state);
+        assert.ok(state.seats[state.dealerSeatIndex].inHand);
+    });
+
+    test("two players left after everyone else walks is heads-up, blinds reversed", () => {
+        const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], dealerSeatIndex: 0 });
+        [2, 3].forEach(i => { state.seats[i].inHand = false; });
+
+        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");
+    });
+});
+
+describe("chips survive a messy table", () => {
+    test("joining, leaving and passing the button never changes the chip count", () => {
+        const state = makeTable({ seatCount: 8, seated: [0, 1, 2, 3], stack: 100, dealerSeatIndex: 0 });
+        state.seats[6].stack = 100; // sitting down but not dealt in yet
+        const startingChips = chipsOnTable(state);
+
+        Betting.beginHand(state);
+        state.dealerSeatIndex = 2;
+        Betting.repostBlinds(state);
+
+        state.seats[6].inHand = true;   // walks up mid-hand
+        state.seats[6].folded = true;
+        assert.equal(chipsOnTable(state), startingChips);
+
+        Betting.call(state, state.actingSeatIndex);
+        state.seats[1].inHand = false;  // and someone storms off
+        Betting.sweepToHandTotals(state);
+
+        assert.equal(chipsOnTable(state), startingChips, "every chip is still accounted for");
+        assert.equal(
+            Money.toCents(potOf(state) + state.seats.reduce((s, p) => s + (Number(p.stack) || 0), 0)),
+            Money.toCents(startingChips),
+            "and the pot plus the stacks is the whole table"
+        );
+    });
+});

tests/holdem/money.test.js

@@ -0,0 +1,126 @@
+const { test, describe } = require("node:test");
+const assert = require("node:assert/strict");
+const { Money, HandHistoryExport } = require("./load");
+
+describe("Money.format", () => {
+    test("whole amounts drop the pointless cents", () => {
+        assert.equal(Money.format(12), "$12");
+        assert.equal(Money.format(450), "$450");
+        assert.equal(Money.format(1250000), "$1,250,000");
+        assert.equal(Money.format(0), "$0");
+    });
+
+    test("amounts that carry cents still show them", () => {
+        assert.equal(Money.format(12.5), "$12.50");
+        assert.equal(Money.format(0.25), "$0.25");
+        assert.equal(Money.format(3.01), "$3.01");
+    });
+
+    test("a quarter-blind game reads exactly as it did", () => {
+        // The case that would be ruined by dropping cents unconditionally.
+        [0.25, 0.5, 1.75, 12.05].forEach(v => {
+            assert.match(Money.format(v), /\.\d\d$/, `${v} lost its cents`);
+        });
+    });
+
+    test("floating-point dust doesn't invent cents", () => {
+        assert.equal(Money.format(0.1 + 0.2), "$0.30");
+        assert.equal(Money.format(1.0000000001), "$1");
+    });
+
+    test("signed amounts put the sign out front, both scales", () => {
+        assert.equal(Money.formatSigned(87500), "+$87,500");
+        assert.equal(Money.formatSigned(-87500), "-$87,500");
+        assert.equal(Money.formatSigned(-12.5), "-$12.50");
+        assert.equal(Money.formatSigned(0), "$0");
+    });
+
+    test("rubbish in doesn't produce rubbish out", () => {
+        assert.equal(Money.format(null), "$0");
+        assert.equal(Money.format(undefined), "$0");
+        assert.equal(Money.format("nonsense"), "$0");
+    });
+});
+
+describe("Money.forSheet", () => {
+    test("a bare number a spreadsheet will add up", () => {
+        assert.equal(Money.forSheet(1250000), "1250000.00");
+        assert.equal(Money.forSheet(12.5), "12.50");
+        assert.equal(Money.forSheet(-87500), "-87500.00");
+    });
+
+    test("no currency symbol and no thousands separators", () => {
+        const written = Money.forSheet(1234567.89);
+        assert.ok(!written.includes("$"), "a $ makes the cell text");
+        assert.ok(!written.includes(","), "a comma makes the cell text");
+        assert.equal(Number(written), 1234567.89, "and it parses straight back to a number");
+    });
+});
+
+describe("the exported CSV", () => {
+    const history = [
+        { handNumber: 2, timestamp: 0, pot: 1250000, payouts: [{ id: "a", label: "Alexandra", amount: 1250000 }] },
+        { handNumber: 1, timestamp: 0, pot: 24.5, payouts: [{ id: "b", label: "Bob", amount: 24.5 }] },
+    ];
+    const standings = [
+        { id: "a", name: "Alexandra", in: 1250000, won: 1250000, net: 0, boughtIn: 3200000, chipsNow: 3200000, cashPosition: 0 },
+        { id: "b", name: "Bob", in: 24.5, won: 0, net: -24.5, boughtIn: 100, chipsNow: 75.5, cashPosition: -24.5 },
+    ];
+
+    // Splitting on commas isn't good enough: the timestamp column legitimately holds
+    // one ("1/1/1970, 5:00:00 PM") and is quoted for exactly that reason.
+    const splitRow = line => {
+        const fields = [];
+        let field = "";
+        let quoted = false;
+        for (let i = 0; i < line.length; i++) {
+            const c = line[i];
+            if (quoted) {
+                if (c === '"' && line[i + 1] === '"') { field += '"'; i++; }
+                else if (c === '"') quoted = false;
+                else field += c;
+            } else if (c === '"') quoted = true;
+            else if (c === ",") { fields.push(field); field = ""; }
+            else field += c;
+        }
+        fields.push(field);
+        return fields;
+    };
+
+    test("every money cell parses as a number", () => {
+        const csv = HandHistoryExport.toCsv(history, standings);
+        const lines = csv.split("\r\n");
+
+        lines.slice(1, 3).forEach(line => {
+            const cell = splitRow(line)[2]; // Pot
+            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.
+        const standingsStart = lines.findIndex(l => l.startsWith("Player,"));
+        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`);
+            });
+        });
+    });
+
+    test("a million-dollar pot doesn't need quoting any more", () => {
+        const csv = HandHistoryExport.toCsv(history, []);
+        assert.ok(csv.includes("1250000.00"), "written plainly");
+        assert.ok(!csv.includes('"$1,250,000'), "not as a quoted, unsummable string");
+    });
+
+    test("names and payout descriptions stay human", () => {
+        const csv = HandHistoryExport.toCsv(history, standings);
+        assert.ok(csv.includes("Alexandra"), "the name column is still a name");
+        assert.ok(csv.includes("Alexandra: $1,250,000"), "the payout column still reads like a sentence");
+    });
+
+    test("a name with a comma is still quoted properly", () => {
+        const csv = HandHistoryExport.toCsv([], [
+            { id: "x", name: "Smith, John", in: 0, won: 0, net: 0, boughtIn: 0, chipsNow: 0, cashPosition: 0 },
+        ]);
+        assert.ok(csv.includes('"Smith, John"'), "the CSV escaping still applies where it's needed");
+    });
+});