Let Quick Split handle the pot it used to send people away for

Quick Split answered the easy half of the question and printed a footnote for
the hard half: if somebody was all-in for less, go set up the full table. That's
the moment a dealer least wants to be setting up a table.

A second mode takes what each player put in and lists the main pot and each side
pot with who can win it, plus anything uncalled that goes back. Rows can be
marked folded, so dead money lands in the right pot without its owner being able
to win it. The running total is shown so the breakdown can be checked against
the chips actually on the table.

It reuses the same pot maths as the full table rather than growing a second
implementation, which means the two screens can't drift apart and Quick Split
inherits the uncalled-bet and everyone-folded handling that was fixed there.

Also fixes hiding: these sections carry a `display` declaration, which outranks
the browser's own [hidden] rule, so toggling `hidden` on them did nothing and
both modes' controls showed at once.

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

JoshHeaps.Net/Pages/Casino/TexasHoldem.cshtml

@@ -31,6 +31,7 @@
                         <span id="potBadgeAmount">$0</span>
                     </div>
                 </div>
+                <div id="betsLayer" aria-hidden="true"></div>
                 <div id="seatsLayer"></div>
             </div>
             <p id="tableHint" class="tableHint"></p>
@@ -81,34 +82,25 @@
                         <span>Starting stack ($)</span>
                         <input type="number" id="defaultStackInput" min="0" step="1" placeholder="e.g. 200" />
                     </label>
-                    <p class="fieldHint">Blinds post themselves each hand, and every seat without its own stack starts here. Set a seat's own stack in its editor.</p>
+                    <p class="fieldHint">Blinds post themselves each hand. Seats without their own stack start here.</p>
-                    <label class="fieldRow">
+
-                        <span>Base pot amount ($)</span>
+                    <details class="subPanel">
-                        <input type="number" id="basePotInput" min="0" step="1" placeholder="e.g. 500" />
+                        <summary>Without live betting</summary>
-                    </label>
+                        <div class="subPanelBody">
-                    <p class="fieldHint">Every player who didn't go all-in short is assumed to have put in this amount. Enter a smaller amount on a seat only if that player is all-in for less.</p>
+                            <label class="fieldRow">
+                                <span>Base pot amount ($)</span>
+                                <input type="number" id="basePotInput" min="0" step="1" placeholder="e.g. 500" />
+                            </label>
+                            <p class="fieldHint">For tracking a hand by hand instead of tapping the action: everyone is assumed to have put in this much, unless their seat says otherwise.</p>
+                        </div>
+                    </details>
                 </div>
             </details>
 
             <details class="sidebarPanel">
-                <summary>Chip Legend</summary>
+                <summary>Session</summary>
-                <div class="panelBody">
-                    <div id="chipLegendList"></div>
-                    <button id="addChipColorBtn" class="holdemBtn holdemBtnSmall">+ Add chip color</button>
-                    <p class="fieldHint">Give each chip color a dollar value, then count chips per seat instead of typing a total.</p>
-                </div>
-            </details>
-
-            <details class="sidebarPanel">
-                <summary>Table Notes</summary>
-                <div class="panelBody">
-                    <textarea id="tableNotes" rows="4" placeholder="Anything else worth tracking — side bets, IOUs, running totals..."></textarea>
-                </div>
-            </details>
-
-            <details class="sidebarPanel">
-                <summary>Session Standings</summary>
                 <div class="panelBody">
+                    <h3 class="panelSubhead">Standings</h3>
                     <div id="standingsTable">
                         <div class="standingsRow standingsHeader">
                             <span>Player</span>
@@ -119,20 +111,33 @@
                         <div id="standingsList"></div>
                     </div>
                     <p id="standingsEmptyHint" class="fieldHint">Once you resolve a pot, everyone's running total for the night shows up here.</p>
-                </div>
-            </details>
 
-            <details class="sidebarPanel">
+                    <h3 class="panelSubhead">Hands</h3>
-                <summary>Hand History</summary>
-                <div class="panelBody">
                     <div id="handHistoryList"></div>
-                    <p id="handHistoryEmptyHint" class="fieldHint">Resolved pots show up here as you play, in case a chip count is disputed later.</p>
+                    <p id="handHistoryEmptyHint" class="fieldHint">Resolved pots are logged here, in case a chip count is disputed later.</p>
+
                     <div class="handHistoryActions">
                         <button id="exportHistoryBtn" class="holdemBtn holdemBtnSmall">Export CSV</button>
                         <button id="clearHistoryBtn" class="holdemBtn holdemBtnSmall holdemBtnDanger">Clear history</button>
                     </div>
                 </div>
             </details>
+
+            <details class="sidebarPanel">
+                <summary>Chip Legend</summary>
+                <div class="panelBody">
+                    <div id="chipLegendList"></div>
+                    <button id="addChipColorBtn" class="holdemBtn holdemBtnSmall">+ Add chip color</button>
+                    <p class="fieldHint">Give each chip color a value, then count chips on a seat instead of typing a total.</p>
+                </div>
+            </details>
+
+            <details class="sidebarPanel">
+                <summary>Table Notes</summary>
+                <div class="panelBody">
+                    <textarea id="tableNotes" rows="4" placeholder="Anything else worth tracking — side bets, IOUs, running totals..."></textarea>
+                </div>
+            </details>
         </aside>
     </div>
 </div>
@@ -294,6 +299,7 @@
     <script src="~/js/casino/holdem/seatMenu.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/betting.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/actionBar.js?v=@ViewData["cssVersion"]"></script>
+    <script src="~/js/casino/holdem/shortcuts.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/potWizard.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/handHistoryExport.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/main.js?v=@ViewData["cssVersion"]"></script>

JoshHeaps.Net/Pages/Casino/TexasHoldem/QuickSplit.cshtml

@@ -11,6 +11,11 @@
         <p class="splitSubtitle">Chop a pot without setting up a table.</p>
     </header>
 
+    <div id="modeToggle" class="chipRow" role="group" aria-label="How the money went in">
+        <button type="button" id="modeEvenBtn" class="choiceChip selected">Everyone matched</button>
+        <button type="button" id="modeUnevenBtn" class="choiceChip">Someone's all-in</button>
+    </div>
+
     <div id="splitResult" aria-live="polite">
         <div id="splitResultLabel">Each player gets</div>
         <div id="splitResultAmount">$0.00</div>
@@ -18,7 +23,18 @@
         <div id="splitDustNote" hidden></div>
     </div>
 
-    <section class="splitField">
+    <div id="unevenResult" hidden aria-live="polite">
+        <div id="unevenPots"></div>
+        <p id="unevenEmpty" class="unevenEmpty">Enter what each player put in.</p>
+    </div>
+
+    <section class="splitField unevenOnly" hidden>
+        <span class="splitLabel">What each player put in</span>
+        <div id="unevenRows"></div>
+        <button type="button" id="addPlayerBtn" class="splitBtn splitBtnGhost">+ Add player</button>
+    </section>
+
+    <section class="splitField evenOnly">
         <label for="potInput" class="splitLabel">Pot</label>
         <div class="potInputWrap">
             <span class="potCurrency">$</span>
@@ -28,12 +44,12 @@
         </div>
     </section>
 
-    <section class="splitField">
+    <section class="splitField evenOnly">
         <span class="splitLabel" id="waysLabel">Split between</span>
         <div id="waysChoices" class="chipRow" role="group" aria-labelledby="waysLabel"></div>
     </section>
 
-    <section class="splitField">
+    <section class="splitField evenOnly">
         <span class="splitLabel" id="chipLabel">Smallest chip in play</span>
         <div id="chipChoices" class="chipRow" role="group" aria-labelledby="chipLabel"></div>
     </section>
@@ -43,12 +59,30 @@
         <a href="/casino/texasholdem" class="splitBtn splitBtnGhost">Full dealer table →</a>
     </div>
 
-    <p class="splitFootnote">
+    <p class="splitFootnote evenOnly">
-        Uneven pots — someone all-in for less — need the side-pot walkthrough on the
+        If somebody was all-in for less than the others, switch to
-        <a href="/casino/texasholdem">full table</a>.
+        <strong>Someone's all-in</strong> above.
+    </p>
+
+    <p class="splitFootnote unevenOnly" hidden>
+        Pots are listed with who can win each. Award them by hand strength, best hand
+        first. Nothing here is saved — the <a href="/casino/texasholdem">full table</a>
+        keeps a log.
     </p>
 </div>
 
+<template id="unevenRowTemplate">
+    <div class="unevenRow">
+        <span class="unevenRowLabel"></span>
+        <div class="unevenAmountWrap">
+            <span class="unevenCurrency">$</span>
+            <input type="text" class="unevenAmount" inputmode="decimal" autocomplete="off" placeholder="0" />
+        </div>
+        <button type="button" class="unevenFoldBtn" aria-pressed="false">Folded</button>
+        <button type="button" class="unevenRemoveBtn" aria-label="Remove player">✕</button>
+    </div>
+</template>
+
 @section Styles {
     <link href="/css/casino/quicksplit.css?v=@ViewData["cssVersion"]" rel="stylesheet" type="text/css" />
 }
@@ -56,5 +90,6 @@
 @section Scripts {
     <script src="~/js/casino/holdem/money.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/splitCalculator.js?v=@ViewData["cssVersion"]"></script>
+    <script src="~/js/casino/holdem/potCalculator.js?v=@ViewData["cssVersion"]"></script>
     <script src="~/js/casino/holdem/quickSplit.js?v=@ViewData["cssVersion"]"></script>
 }

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

@@ -223,6 +223,68 @@ body {
     inset: 0;
 }
 
+/* ---------- Bets on the felt ---------- */
+
+/* Shares the seat ring's box exactly, so a bet always lands on the spoke between its
+   player and the pot. When the seat ring gets inset on a phone, this moves with it —
+   measured the alternative, and a bets ring on its own geometry ends up either behind
+   the pucks or on top of the pot badge. */
+#betsLayer {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+}
+
+.betChip {
+    position: absolute;
+    transform: translate(-50%, -50%);
+    display: flex;
+    align-items: center;
+    gap: 0.28rem;
+    padding: 0.1rem 0.42rem 0.1rem 0.2rem;
+    background: rgba(0, 0, 0, 0.55);
+    border: 1px solid rgba(255, 255, 255, 0.14);
+    border-radius: 999px;
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.5);
+    white-space: nowrap;
+}
+
+/* Reads as a chip seen from above: a lighter top-left, a rim, and the notches a
+   casino chip has around its edge. */
+.betChipDisc {
+    width: 13px;
+    height: 13px;
+    border-radius: 50%;
+    border: 1px solid rgba(255, 255, 255, 0.45);
+    box-shadow:
+        inset 0 1px 1px rgba(255, 255, 255, 0.45),
+        inset 0 -1px 2px rgba(0, 0, 0, 0.45);
+}
+
+.betChipAmount {
+    font-size: 0.62rem;
+    font-weight: 700;
+    color: #f0f0f0;
+    font-variant-numeric: tabular-nums;
+}
+
+/* Clinging to a puck rather than sitting on its own ring — the phone layout. */
+.betChipAnchored {
+    left: 50%;
+    z-index: 3;
+}
+
+.betChipAbove {
+    top: -11px;
+    transform: translate(-50%, -50%);
+}
+
+.betChipBelow {
+    top: auto;
+    bottom: -11px;
+    transform: translate(-50%, 50%);
+}
+
 /* ---------- Seats (compact pucks on the table) ---------- */
 
 .seat {
@@ -872,6 +934,46 @@ body {
     gap: 0.7rem;
 }
 
+/* A heading inside a panel, so one panel can hold two related things — the
+   standings and the hand log are two views of the same session — without needing
+   two identical-looking accordions to say so. */
+.panelSubhead {
+    margin: 0.2rem 0 0;
+    color: #d8b46a;
+    font-size: 0.68rem;
+    font-weight: 600;
+    letter-spacing: 0.09em;
+    text-transform: uppercase;
+}
+
+.panelSubhead + * {
+    margin-top: -0.2rem;
+}
+
+/* Nested disclosure for the things a dealer sets once and then forgets, kept out
+   of the way of the settings they actually touch. */
+.subPanel {
+    border-top: 1px solid #2c2c2c;
+    padding-top: 0.5rem;
+}
+
+.subPanel summary {
+    cursor: pointer;
+    color: #8f8f8f;
+    font-size: 0.78rem;
+}
+
+.subPanel summary:hover {
+    color: #c5c5c5;
+}
+
+.subPanelBody {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    padding-top: 0.6rem;
+}
+
 .fieldRow {
     display: flex;
     align-items: center;
@@ -1219,6 +1321,7 @@ body.hasActionBar #holdemSidebar {
 }
 
 .actionBtn {
+    position: relative;
     flex: 1;
     display: flex;
     flex-direction: column;
@@ -1256,6 +1359,29 @@ body.hasActionBar #holdemSidebar {
     font-variant-numeric: tabular-nums;
 }
 
+.actionKey {
+    position: absolute;
+    top: 5px;
+    right: 7px;
+    padding: 0 0.25rem;
+    border-radius: 4px;
+    border: 1px solid currentColor;
+    opacity: 0.4;
+    font-family: inherit;
+    font-size: 0.6rem;
+    line-height: 1.4;
+    text-transform: uppercase;
+    pointer-events: none;
+}
+
+/* No keyboard, no key badges — on a phone they'd just be clutter on the buttons
+   the dealer is already tapping. */
+@media (hover: none) {
+    .actionKey {
+        display: none;
+    }
+}
+
 .actionFold {
     background: linear-gradient(180deg, #3d1f1f, #2c1515);
     border-color: #5b2626;
@@ -1366,11 +1492,18 @@ body.hasActionBar #holdemSidebar {
 .blindsRow .fieldRow {
     flex: 1 1 120px;
     min-width: 0;
+    gap: 0.4rem;
+}
+
+/* "Small blind" broke onto two lines beside its input, which made the pair look
+   like a mistake rather than a pair. */
+.blindsRow .fieldRow > span {
+    white-space: nowrap;
 }
 
 .blindsRow input {
     min-width: 0;
-    width: 5rem;
+    width: 3.4rem;
 }
 
 /* ---------- Toasts ---------- */
@@ -1663,7 +1796,8 @@ body.hasActionBar #toastHost {
 
     /* Keeps every puck inside the viewport: the ring is drawn within this box,
        so half a puck of padding is exactly enough to stop the overhang. */
-    #seatsLayer {
+    #seatsLayer,
+    #betsLayer {
         inset: 26px 44px;
     }
 

JoshHeaps.Net/wwwroot/css/casino/quicksplit.css

@@ -45,6 +45,171 @@ body {
     font-size: 0.85rem;
 }
 
+/* ---------- Mode toggle ---------- */
+
+#modeToggle {
+    margin-bottom: 1.1rem;
+}
+
+/* ---------- Uneven amounts ---------- */
+
+#unevenRows {
+    display: flex;
+    flex-direction: column;
+    gap: 0.45rem;
+    margin-bottom: 0.6rem;
+}
+
+.unevenRow {
+    display: flex;
+    align-items: center;
+    gap: 0.45rem;
+}
+
+.unevenRowLabel {
+    flex: none;
+    width: 2rem;
+    color: #8f8f8f;
+    font-size: 0.8rem;
+    font-weight: 600;
+}
+
+.unevenAmountWrap {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    align-items: center;
+    gap: 0.3rem;
+    background: #141414;
+    border: 1px solid #3a3a3a;
+    border-radius: 10px;
+    padding: 0 0.6rem;
+}
+
+.unevenAmountWrap:focus-within {
+    border-color: #d8b46a;
+}
+
+.unevenCurrency {
+    color: #777;
+}
+
+.unevenAmount {
+    flex: 1;
+    min-width: 0;
+    background: none;
+    border: none;
+    outline: none;
+    color: #f2f2f2;
+    font-family: inherit;
+    font-size: 16px;
+    font-variant-numeric: tabular-nums;
+    padding: 0.6rem 0;
+}
+
+.unevenFoldBtn {
+    flex: none;
+    min-height: 44px;
+    padding: 0 0.6rem;
+    border-radius: 9px;
+    border: 1px solid #3a3a3a;
+    background: #232323;
+    color: #8f8f8f;
+    font-family: inherit;
+    font-size: 0.72rem;
+    cursor: pointer;
+}
+
+.unevenFoldBtn.selected {
+    background: linear-gradient(180deg, #3d1f1f, #2c1515);
+    border-color: #5b2626;
+    color: #ffd6d6;
+}
+
+.unevenRemoveBtn {
+    flex: none;
+    width: 30px;
+    height: 44px;
+    border: none;
+    background: none;
+    color: #6a6a6a;
+    font-size: 0.85rem;
+    cursor: pointer;
+}
+
+.unevenRemoveBtn:disabled {
+    opacity: 0.3;
+    cursor: not-allowed;
+}
+
+#unevenResult {
+    background: linear-gradient(160deg, #1f2a21, #161c17);
+    border: 1px solid #2c3a2f;
+    border-radius: 14px;
+    padding: 0.9rem 1rem;
+    margin-bottom: 1.5rem;
+}
+
+#unevenResult[hidden] {
+    display: none;
+}
+
+.unevenPot {
+    display: flex;
+    align-items: baseline;
+    gap: 0.6rem;
+    padding: 0.3rem 0;
+    font-size: 0.85rem;
+}
+
+.unevenPot + .unevenPot {
+    border-top: 1px solid rgba(255, 255, 255, 0.06);
+}
+
+.unevenPotLabel {
+    flex: none;
+    color: #d8b46a;
+    font-weight: 600;
+}
+
+.unevenPotAmount {
+    flex: none;
+    color: #f2f2f2;
+    font-weight: 600;
+    font-variant-numeric: tabular-nums;
+}
+
+.unevenPotWho {
+    flex: 1;
+    min-width: 0;
+    text-align: right;
+    color: #9a9a9a;
+    font-size: 0.78rem;
+}
+
+.unevenPotReturn .unevenPotLabel,
+.unevenPotReturn .unevenPotAmount {
+    color: #9a9a9a;
+    font-weight: 500;
+}
+
+.unevenPotTotal {
+    margin-top: 0.15rem;
+    border-top: 1px solid rgba(255, 255, 255, 0.14) !important;
+}
+
+.unevenPotTotal .unevenPotLabel {
+    color: #8f9d92;
+    font-weight: 500;
+}
+
+.unevenEmpty {
+    margin: 0;
+    color: #8f9d92;
+    font-size: 0.82rem;
+    line-height: 1.45;
+}
+
 /* ---------- The answer ---------- */
 
 #splitResult {
@@ -104,6 +269,12 @@ body {
     margin-bottom: 1.35rem;
 }
 
+/* A `display` declaration outranks the browser's own [hidden] rule, so anything
+   given one has to opt back out explicitly or toggling `hidden` does nothing. */
+[hidden] {
+    display: none !important;
+}
+
 .splitLabel {
     display: block;
     margin-bottom: 0.5rem;

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

@@ -194,6 +194,19 @@ const ActionBar = {
         );
     },
 
+    // Which key presses each button. Shown on the button itself and hidden on touch
+    // devices — a shortcut nobody can discover may as well not exist, and a key badge
+    // on a phone is just clutter.
+    KEY_HINTS: {
+        actionFold: "F",
+        actionCheck: "C",
+        actionCall: "C",
+        actionRaise: "R",
+        actionAdvance: "↵",
+        raiseConfirm: "↵",
+        raiseCancel: "esc",
+    },
+
     button(label, className, onClick, sublabel) {
         const btn = document.createElement("button");
         btn.type = "button";
@@ -204,6 +217,14 @@ const ActionBar = {
         main.textContent = label;
         btn.appendChild(main);
 
+        const hint = this.KEY_HINTS[className];
+        if (hint) {
+            const kbd = document.createElement("kbd");
+            kbd.className = "actionKey";
+            kbd.textContent = hint;
+            btn.appendChild(kbd);
+        }
+
         if (sublabel) {
             const sub = document.createElement("span");
             sub.className = "actionBtnSub";

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

@@ -116,6 +116,38 @@ document.addEventListener("DOMContentLoaded", () => {
     // snapshots refer to a hand that no longer exists.
     const clearActionHistory = () => { actionHistory.length = 0; };
 
+    // Keyboard shortcuts press the very same buttons a dealer would tap, rather than
+    // calling the betting engine themselves — there's no second code path to drift out
+    // of step with what the bar is actually offering right now.
+    const pressInBar = selector => {
+        const btn = document.querySelector(`#actionBar ${selector}`);
+        if (!btn || btn.disabled) return false;
+        btn.click();
+        return true;
+    };
+
+    const quickRaiseButton = label =>
+        [...document.querySelectorAll("#actionBar .raiseQuickBtn")]
+            .find(b => b.querySelector(".actionBtnLabel").textContent === label);
+
+    Shortcuts.mount({
+        fold: () => pressInBar(".actionFold"),
+        checkOrCall: () => pressInBar(".actionCheck") || pressInBar(".actionCall"),
+        raise: () => pressInBar(".actionRaise"),
+        allIn: () => {
+            // Open the raise pad first if it isn't already, then take its All-in amount.
+            if (!document.querySelector("#actionBar .raisePad") && !pressInBar(".actionRaise")) return false;
+            const quick = quickRaiseButton("All-in");
+            if (!quick) return false;
+            quick.click();
+            return true;
+        },
+        // Enter confirms a raise if one is being entered, otherwise moves the hand on.
+        advance: () => pressInBar(".raiseConfirm") || pressInBar(".actionAdvance"),
+        undo: () => pressInBar(".actionUndo"),
+        cancel: () => pressInBar(".raiseCancel"),
+    });
+
     // Moving to the next hand used to ask "are you sure?" every single time —
     // the most-pressed button in a session, gated behind a system dialog. It now
     // just happens, and the toast offers the way back for the few seconds anyone

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

@@ -15,12 +15,28 @@ const QuickSplit = {
     ways: 2,
     chip: 1,
 
+    // "even" is the common case — one pot, everyone matched. "uneven" is the one this
+    // screen used to send people back to the full table for: somebody all-in for less,
+    // so the money splits into a main pot and side pots.
+    mode: "even",
+    entries: [],
+
     mount() {
         this.potInput = document.getElementById("potInput");
         this.clearPotBtn = document.getElementById("clearPotBtn");
+        this.entries = [{ amount: "", folded: false }, { amount: "", folded: false }, { amount: "", folded: false }];
 
         this.renderWayChoices();
         this.renderChipChoices();
+        this.renderUnevenRows();
+
+        document.getElementById("modeEvenBtn").addEventListener("click", () => this.setMode("even"));
+        document.getElementById("modeUnevenBtn").addEventListener("click", () => this.setMode("uneven"));
+        document.getElementById("addPlayerBtn").addEventListener("click", () => {
+            this.entries.push({ amount: "", folded: false });
+            this.renderUnevenRows();
+            this.update();
+        });
 
         this.potInput.addEventListener("input", () => {
             this.sanitizePotInput();
@@ -127,7 +143,112 @@ const QuickSplit = {
         });
     },
 
+    setMode(mode) {
+        this.mode = mode;
+        document.getElementById("modeEvenBtn").classList.toggle("selected", mode === "even");
+        document.getElementById("modeUnevenBtn").classList.toggle("selected", mode === "uneven");
+
+        document.querySelectorAll(".evenOnly").forEach(el => { el.hidden = mode !== "even"; });
+        document.querySelectorAll(".unevenOnly").forEach(el => { el.hidden = mode !== "uneven"; });
+        document.getElementById("splitResult").hidden = mode !== "even";
+        document.getElementById("unevenResult").hidden = mode !== "uneven";
+
+        this.update();
+    },
+
+    renderUnevenRows() {
+        const host = document.getElementById("unevenRows");
+        const template = document.getElementById("unevenRowTemplate");
+        host.innerHTML = "";
+
+        this.entries.forEach((entry, index) => {
+            const row = template.content.firstElementChild.cloneNode(true);
+            row.querySelector(".unevenRowLabel").textContent = `P${index + 1}`;
+
+            const amount = row.querySelector(".unevenAmount");
+            amount.value = entry.amount;
+            amount.setAttribute("aria-label", `Player ${index + 1} amount`);
+            amount.addEventListener("input", () => {
+                entry.amount = amount.value.replace(/[^0-9.]/g, "").replace(/(\..*)\./g, "$1");
+                if (entry.amount !== amount.value) amount.value = entry.amount;
+                this.update();
+            });
+
+            // Folded money stays in the pot as dead money, but its owner can't win any
+            // of it — which is exactly the distinction that makes side pots tricky.
+            const fold = row.querySelector(".unevenFoldBtn");
+            fold.classList.toggle("selected", entry.folded);
+            fold.setAttribute("aria-pressed", String(entry.folded));
+            fold.addEventListener("click", () => {
+                entry.folded = !entry.folded;
+                this.renderUnevenRows();
+                this.update();
+            });
+
+            const remove = row.querySelector(".unevenRemoveBtn");
+            remove.disabled = this.entries.length <= 2;
+            remove.addEventListener("click", () => {
+                this.entries.splice(index, 1);
+                this.renderUnevenRows();
+                this.update();
+            });
+
+            host.appendChild(row);
+        });
+    },
+
+    updateUneven() {
+        const players = this.entries
+            .map((entry, index) => ({ id: `P${index + 1}`, contribution: Number(entry.amount) || 0, folded: entry.folded }))
+            .filter(p => p.contribution > 0);
+
+        const pots = PotCalculator.layers(players);
+        const returns = PotCalculator.uncalledReturns(players);
+
+        const host = document.getElementById("unevenPots");
+        const empty = document.getElementById("unevenEmpty");
+        host.innerHTML = "";
+
+        if (pots.length === 0 && returns.length === 0) {
+            empty.hidden = false;
+            empty.textContent = players.length === 0
+                ? "Enter what each player put in."
+                : "Nobody left who can win — un-fold whoever should take it.";
+            return;
+        }
+        empty.hidden = true;
+
+        const addRow = (label, amount, who, className) => {
+            const row = document.createElement("div");
+            row.className = `unevenPot ${className || ""}`;
+            const name = document.createElement("span");
+            name.className = "unevenPotLabel";
+            name.textContent = label;
+            const value = document.createElement("span");
+            value.className = "unevenPotAmount";
+            value.textContent = Money.format(amount);
+            const eligible = document.createElement("span");
+            eligible.className = "unevenPotWho";
+            eligible.textContent = who;
+            row.appendChild(name);
+            row.appendChild(value);
+            row.appendChild(eligible);
+            host.appendChild(row);
+        };
+
+        pots.forEach(pot => addRow(pot.label, pot.amount, pot.eligible.join(", ")));
+        returns.forEach(ret => addRow("Uncalled", ret.amount, `back to ${ret.id}`, "unevenPotReturn"));
+
+        const total = players.reduce((sum, p) => sum + p.contribution, 0);
+        addRow("On the table", Math.round(total * 100) / 100, "", "unevenPotTotal");
+    },
+
     update() {
+        if (this.mode === "uneven") {
+            this.updateUneven();
+            return;
+        }
+
         const potValue = Number(this.potInput.value);
         const pot = Number.isNaN(potValue) ? 0 : potValue;
         this.clearPotBtn.hidden = this.potInput.value === "";

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

@@ -69,13 +69,85 @@ const Render = {
     // ---- Seats around the table (compact pucks) ----
 
     seatPosition(index, count) {
+        return this.positionOnRing(index, count, 44, 42);
+    },
+
+    // Bets sit on the felt between their player and the pot, the way chips actually
+    // do — closer in than the seats, on the same spoke. The bets layer is inset to
+    // match the seat ring (see the CSS), so this one radius holds at every size.
+    betPosition(index, count) {
+        return this.positionOnRing(index, count, 27, 25);
+    },
+
+    positionOnRing(index, count, rx, ry) {
         const angle = -90 + (360 / count) * index;
         const radians = (angle * Math.PI) / 180;
-        const rx = 44;
+        return {
-        const ry = 42;
+            left: 50 + rx * Math.cos(radians),
-        const left = 50 + rx * Math.cos(radians);
+            top: 50 + ry * Math.sin(radians),
-        const top = 50 + ry * Math.sin(radians);
+        };
-        return { left, top };
+    },
+
+    // Colour a bet by the biggest chip that fits it, so a table with a chip legend
+    // gets bets that look like the chips actually being pushed out.
+    chipColorFor(amount) {
+        const legend = [...(this.state.chipLegend || [])]
+            .filter(chip => Number(chip.value) > 0)
+            .sort((a, b) => Number(b.value) - Number(a.value));
+        const match = legend.find(chip => amount >= Number(chip.value));
+        return (match || legend[legend.length - 1] || {}).color || "#8a8a8a";
+    },
+
+    // ---- Bets on the felt ----
+
+    makeBetChip(bet) {
+        const chip = document.createElement("div");
+        chip.className = "betChip";
+
+        const disc = document.createElement("span");
+        disc.className = "betChipDisc";
+        disc.style.background = this.chipColorFor(bet);
+
+        const amount = document.createElement("span");
+        amount.className = "betChipAmount";
+        amount.textContent = Money.format(bet);
+
+        chip.appendChild(disc);
+        chip.appendChild(amount);
+        return chip;
+    },
+
+    // A phone's felt has no room for a third ring: measured every radius between the
+    // seats and the pot badge and each one collides with one or the other. So on a
+    // narrow screen the bet clings to its own puck instead — same chip, no ring —
+    // sitting on whichever side faces the middle of the table.
+    renderBets() {
+        const layer = document.getElementById("betsLayer");
+        if (!layer) return;
+        layer.innerHTML = "";
+
+        const anchorToSeat = window.matchMedia("(max-width: 700px)").matches;
+
+        this.state.seats.forEach((player, index) => {
+            const bet = Betting.committed(player);
+            if (bet <= 0) return;
+
+            const chip = this.makeBetChip(bet);
+            const pos = this.betPosition(index, this.state.seatCount);
+
+            if (anchorToSeat) {
+                const seat = document.querySelector(`.seat[data-seat-index="${index}"]`);
+                if (!seat) return;
+                const seatPos = this.seatPosition(index, this.state.seatCount);
+                chip.classList.add("betChipAnchored", seatPos.top > 50 ? "betChipAbove" : "betChipBelow");
+                seat.appendChild(chip);
+                return;
+            }
+
+            chip.style.left = `${pos.left}%`;
+            chip.style.top = `${pos.top}%`;
+            layer.appendChild(chip);
+        });
     },
 
     puckLabel(player, seatIndex) {
@@ -118,6 +190,8 @@ const Render = {
 
             layer.appendChild(node);
         });
+
+        this.renderBets();
     },
 
     isRedSuit(card) {
@@ -168,11 +242,13 @@ const Render = {
             span.textContent = this.formatCard(card);
             cardsEl.appendChild(span);
         });
-        // What's in front of them this street reads as the live number during betting;
+        // Always this player's total for the hand. What they've just pushed out on this
-        // between hands it falls back to their total for the hand.
+        // street is shown as a chip on the felt instead — the puck used to flip between
-        const streetBet = Betting.committed(player);
+        // the two meanings depending on the moment, which is a bad thing for a number
-        const total = streetBet > 0
+        // sitting next to a stack size to do.
-            ? streetBet
+        const handTotal = Betting.handTotal(player);
+        const total = handTotal > 0
+            ? handTotal
             : HoldemState.computeContribution(player, this.state.chipLegend, this.state.basePotAmount);
         node.querySelector(".seatPuckTotal").textContent = total > 0 ? Money.format(total) : "";
 

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

@@ -0,0 +1,64 @@
+// Keyboard control for a dealer running this on a laptop.
+//
+// The phone has gestures; the desktop had a mouse and nothing else. These are the
+// same actions the bar already offers, reachable without moving a hand to the
+// trackpad between every decision — which is the whole point when the bar is being
+// tapped thirty times a hand.
+const Shortcuts = {
+    // Deliberately single letters with no modifier: a dealer's spare hand rests on
+    // the keyboard, and a chord is slower than reaching for the button would be.
+    KEYS: {
+        f: "fold",
+        c: "checkOrCall",
+        r: "raise",
+        a: "allIn",
+        " ": "advance",
+        enter: "advance",
+        u: "undo",
+        escape: "cancel",
+    },
+
+    mount(handlers) {
+        this.handlers = handlers;
+        document.addEventListener("keydown", e => this.onKey(e));
+    },
+
+    // Nothing fires while the dealer is typing a name, an amount, or a note — the
+    // "c" in "Cass" must not fold the table.
+    isTyping() {
+        const el = document.activeElement;
+        if (!el) return false;
+        const tag = el.tagName;
+        return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || el.isContentEditable;
+    },
+
+    // An overlay owns the keyboard while it's up: the confirm dialog already binds
+    // Enter and Escape, and the card picker and seat menu are modal.
+    overlayOpen() {
+        return ["confirmOverlay", "potWizardOverlay", "cardPickerOverlay", "seatMenuOverlay"]
+            .some(id => {
+                const el = document.getElementById(id);
+                return el && !el.hidden;
+            });
+    },
+
+    onKey(e) {
+        if (e.metaKey || e.ctrlKey || e.altKey) return;
+
+        const key = e.key.length === 1 ? e.key.toLowerCase() : e.key.toLowerCase();
+        const action = this.KEYS[key];
+        if (!action) return;
+
+        // Escape is the exception: it should still close the raise pad even if focus
+        // happens to be sitting in its amount field.
+        if (this.isTyping() && !(action === "cancel")) return;
+        if (this.overlayOpen()) return;
+
+        const handled = this.handlers[action] && this.handlers[action]();
+        if (handled) e.preventDefault();
+    },
+};
+
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = Shortcuts;
+}