A short all-in doesn't reopen the betting

Went looking at dealer procedure again and ended up checking the rule home games
argue about longest. The tool had it wrong.

Blinds 1/2. Seat 4 raises to 10 — a full raise of 8. Seat 1 calls. Seat 2 is
all-in for 13: three more, where a full raise would need eight. Under TDA rule 44
that does not reopen the betting to anyone who has already acted; they owe the
extra three or they fold. Seat 1 and seat 4 were both being handed another go.

Two things were wrong in raiseTo. Any increase at all reset hasActed for every
live player, so a short shove gave the whole table another chance to raise. And
lastRaiseSize was overwritten with the short amount, so the next legal raise was
computed off 3 instead of 8 and came out too small — a second, quieter error that
only shows up when somebody then tries to raise.

Both now key off whether the increase was actually a full raise. A player who had
not yet acted keeps full rights, which falls out naturally because their hasActed
is already false — that distinction is the part of the rule people get wrong in
the other direction.

Everyone still owes the difference: isStreetComplete already asks anyone with
chips left to call, so the short all-in is answered without being re-raiseable.

The rulings sheet now covers what the tool does for you

It had three entries. A dealer challenged on a payout couldn't look up why the
tool did what it did, even for the rules it enforces automatically. Added the
short all-in rule above, uncalled chips coming back rather than being announced
as a side pot, and the odd chip in a chopped pot going to the first player left
of the button — all three are things this tool already decides silently, and all
three are worth being able to point at when somebody objects.

10 tests (137 total): already-acted players aren't reopened but still owe the
difference, a player yet to act keeps full rights, the minimum raise isn't
shrunk, calling it ends the street, no chips are created, and — the other half of
the rule — a full-sized all-in, an ordinary raise, a raise exactly matching the
last one, and a full-sized opening bet all still reopen everyone.

Validated through the real action bar: after the short shove, lastRaiseSize stays
8 and the player who had already called stays settled, while the two who hadn't
acted keep their turn. The longer rulings sheet still fits a phone, scrolls, traps
focus and closes on Escape.

Sources: TDA rules via thelodgepokerclub.com/tda-rules/,
pokernews.com/strategy/deal-with-it-tips-for-mistake-free-dealing-in-home-games-30231.htm

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

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

@@ -153,14 +153,33 @@ const Betting = {
         const delta = this.round(target - this.committed(player));
         const moved = this.putIn(state, index, delta);
         const newBet = this.committed(player);
+        const previousBet = state.currentBet || 0;
+
+        if (newBet > previousBet) {
+            const increase = this.round(newBet - previousBet);
+            // What a full raise would have had to be: at least as much again as the
+            // last one, or the big blind if there hasn't been a raise yet.
+            const fullRaise = this.round(state.lastRaiseSize || state.bigBlind || 0);
+            const isFullRaise = increase >= fullRaise - this.EPSILON_CHIPS;
 
-        if (newBet > (state.currentBet || 0)) {
-            state.lastRaiseSize = this.round(newBet - (state.currentBet || 0));
             state.currentBet = newBet;
-            // A raise reopens the action: everyone else owes a response again.
-            state.seats.forEach((p, i) => {
-                if (i !== index && p.inHand && !p.folded) p.hasActed = false;
-            });
+
+            if (isFullRaise) {
+                state.lastRaiseSize = increase;
+                // A real raise reopens the action: everyone else owes a response again.
+                state.seats.forEach((p, i) => {
+                    if (i !== index && p.inHand && !p.folded) p.hasActed = false;
+                });
+            }
+            // Otherwise this is a short all-in — somebody with less than a full raise
+            // left shoving it in. The most misread rule in poker: it does *not* reopen
+            // the betting to anyone who has already acted. They owe the difference or
+            // they fold; they don't get to raise again because a short stack happened
+            // to be between them. Players yet to act keep their full rights, which
+            // they do here because their hasActed is already false.
+            //
+            // lastRaiseSize deliberately isn't lowered either, or the next legal raise
+            // would be computed off the short amount and come out too small.
         }
 
         player.hasActed = true;