Take the broken wordmark off the felt

The felt carried "TEXAS HOLD'EM" across its middle, and the pot badge sat on top of
it. Measured at every seat count from two to ten, the middle 20% of the word was
covered, so the table read

  TEXAS  LD'EM

That is not a watermark, it is a rendering fault, and it looked like one.

I tried to move it before removing it. Four placements, measured across six viewports
and two seat counts each, as the share of the word covered by a seat, a bet chip or
the pot badge:

                        desktop   tablet   phone     phone     landscape
                        1280x900  768x1024 390x844   360x640   844x390
  centred (before)        20%      20%      20%       20%        20%
  30% down, full size      0-7%     0-12%   43-60%    48-70%     20-23%
  20% down, smaller        0%       0%      40-67%    53-70%     40%
  78% down, smaller        0%       0%      77-97%    90-100%*   27-37%

  * and off the oval entirely at 360px

Desktop and tablet can be made clean. A phone cannot: below 900px the felt is square,
and a square felt with six to nine seats has no clear horizontal band wide enough for
a word. The best phone result of any placement was 40% covered.

So it is gone rather than special-cased per device for a decoration. The felt still has
its gradient, its rim, the inner gold line and its shadow to be a table with, and the
page header says "Texas Hold'em Dealer" a few inches above it.

The reasoning and the numbers are left in the CSS where the element used to be, so
whoever thinks of adding one back finds out what happened first.

269 tests still passing. Seven viewports: contrast clean, layout audit clean everywhere
but the landscape phone already known from #63, no console errors.

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

JoshHeaps.Net/Pages/Casino/TexasHoldem.cshtml

@@ -25,7 +25,6 @@
         <section id="tableSection">
             <div id="pokerTableWrap">
                 <div id="pokerTable">
-                    <div id="tableWatermark" aria-hidden="true">Texas Hold'em</div>
                     <div id="potBadge">
                         <span id="potBadgeLabel">Pot</span>
                         <span id="potBadgeAmount">$0</span>

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

@@ -357,21 +357,18 @@ button,
     justify-content: center;
 }
 
-#tableWatermark {
+/* The felt used to carry a "TEXAS HOLD'EM" wordmark across its middle. It came out
-    position: absolute;
+   from behind the pot badge in two pieces — measured at every seat count from two to
-    inset: 0;
+   ten, the middle 20% of it was covered, so the felt read "TEXAS  LD'EM" — and no
-    display: flex;
+   placement fixed that everywhere. Thirty per cent down cleared the badge on a desktop
-    align-items: center;
+   and landed on the seats of a phone's square felt (43-70% covered); a smaller mark at
-    justify-content: center;
+   20% or 78% was clean on desktop and tablet and no better on a phone; the bottom one
-    color: rgba(255, 255, 255, 0.06);
+   fell off the oval entirely at 360px. A square felt with six to nine seats has no
-    font-size: 2.4rem;
+   clear band wide enough for a word.
-    font-weight: 700;
+   
-    letter-spacing: 0.15em;
+   So it's gone. A watermark that looks broken is worse than no watermark, and the felt
-    text-transform: uppercase;
+   has a gradient, a rim, an inner gold line and a shadow to be a table with — plus a
-    text-align: center;
+   header saying "Texas Hold'em Dealer" a few inches above it. */
-    pointer-events: none;
-    user-select: none;
-}
 
 #potBadge {
     position: relative;
@@ -2845,10 +2842,6 @@ body.hasActionBar #toastHost {
         padding: 0.25rem 0.3rem;
     }
 
-    #tableWatermark {
-        font-size: 1.4rem;
-    }
-
     #potBadge {
         padding: 0.5rem 1.1rem;
     }

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

@@ -461,6 +461,17 @@ document.addEventListener("DOMContentLoaded", () => {
     // The one time the browser refuses to save, say so out loud as well as leaving the
     // standing warning in the Session panel. Set before the first render so a failure
     // during start-up is caught too.
+    // Another tab writing to the same table. Said once, with the way out attached —
+    // reloading here adopts whatever that tab has done, which is the only resolution
+    // that doesn't throw somebody's work away.
+    HoldemState.onOtherTab = () => {
+        Toast.show(
+            "This table is open in another tab. Whichever acts last wins.",
+            { actionLabel: "Reload", onAction: () => window.location.reload(), duration: 20000 });
+        Render.renderStorageWarning();
+    };
+    HoldemState.watchOtherTabs();
+
     HoldemState.onSaveFailed = () => {
         Toast.show(
             "This table isn't being saved — refreshing would lose it. Keep this tab open.",

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

@@ -761,13 +761,20 @@ const Render = {
     renderStorageWarning() {
         const host = document.getElementById("storageWarning");
         if (!host) return;
-        host.hidden = !HoldemState.saveFailed && !HoldemState.loadFailed;
+        host.hidden = !HoldemState.saveFailed && !HoldemState.loadFailed && !HoldemState.otherTabActive;
         if (host.hidden) return;
 
-        // Both can be true at once — a browser having trouble with storage tends to
+        // Any of these can be true at once — a browser having trouble with storage
-        // have it in both directions — and the one that explains an empty table goes
+        // tends to have it in both directions — and the one that explains an empty
-        // first, because that's the question the dealer is standing there asking.
+        // table goes first, because that's the question the dealer is standing there
+        // asking.
         const lines = [];
+        if (HoldemState.otherTabActive) {
+            lines.push(
+                "This table is open in another tab, and both are writing to it — " +
+                "whichever acts last wins, so work done in the other one can vanish. " +
+                "Close one, then reload this tab to pick up the table as it stands.");
+        }
         if (HoldemState.loadFailed) {
             lines.push(
                 "The saved table couldn't be read, so this one started empty. " +

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

@@ -84,6 +84,30 @@ const HoldemState = {
     // Where an unreadable save is kept instead of being written over.
     RECOVERY_KEY: "casino.holdem.state.v1.unreadable",
 
+    // True once another tab has written to this table. Two tabs each hold their own
+    // copy in memory and each save writes the whole thing, so the second one to act
+    // silently throws the first one's work away — measured: tab A deals and takes a
+    // call, tab B renames a seat, and the deal, the blinds and the call are gone with
+    // nothing said in either tab.
+    //
+    // Watched rather than merged. Replacing the table under a dealer's hands mid-hand
+    // would be its own hazard; knowing there are two of them is what they need.
+    otherTabActive: false,
+    onOtherTab: null,
+
+    // The browser fires this in every *other* tab, never the one that wrote, so our
+    // own saves can't trip it.
+    watchOtherTabs() {
+        if (typeof window === "undefined" || this.tabWatcher) return;
+        this.tabWatcher = event => {
+            if (event.key !== this.STORAGE_KEY) return;
+            if (this.otherTabActive) return;
+            this.otherTabActive = true;
+            if (typeof this.onOtherTab === "function") this.onOtherTab();
+        };
+        window.addEventListener("storage", this.tabWatcher);
+    },
+
     // True when there was a saved table and it couldn't be read. Same pair as
     // saveFailed above, for the same reason: the UI has to be able to say so.
     loadFailed: false,

tests/holdem/otherTab.test.js

@@ -0,0 +1,100 @@
+// Noticing that the same table is open twice.
+//
+// Two tabs each hold their own copy in memory and each save writes the whole thing,
+// so the second one to act throws the first one's work away. This doesn't merge them
+// — replacing a table under a dealer's hands mid-hand would be its own hazard — it
+// notices, which is what lets them decide.
+const test = require("node:test");
+const assert = require("node:assert");
+const { HoldemState } = require("./load");
+
+function withWindow() {
+    const listeners = [];
+    globalThis.window = {
+        addEventListener(type, fn) { if (type === "storage") listeners.push(fn); },
+        removeEventListener(type, fn) {
+            const i = listeners.indexOf(fn);
+            if (i >= 0) listeners.splice(i, 1);
+        },
+    };
+    return {
+        listeners,
+        fire(key) { listeners.forEach(fn => fn({ key })); },
+    };
+}
+
+test.beforeEach(() => {
+    HoldemState.otherTabActive = false;
+    HoldemState.onOtherTab = null;
+    HoldemState.tabWatcher = null;
+});
+
+test.after(() => {
+    delete globalThis.window;
+    HoldemState.otherTabActive = false;
+    HoldemState.onOtherTab = null;
+    HoldemState.tabWatcher = null;
+});
+
+test("a write to this table from elsewhere is noticed", () => {
+    const win = withWindow();
+    let told = 0;
+    HoldemState.onOtherTab = () => { told++; };
+    HoldemState.watchOtherTabs();
+
+    win.fire(HoldemState.STORAGE_KEY);
+
+    assert.equal(HoldemState.otherTabActive, true);
+    assert.equal(told, 1);
+});
+
+test("somebody else's storage key is not our business", () => {
+    const win = withWindow();
+    let told = 0;
+    HoldemState.onOtherTab = () => { told++; };
+    HoldemState.watchOtherTabs();
+
+    win.fire("some.other.app.state");
+    win.fire(HoldemState.RECOVERY_KEY);
+
+    assert.equal(HoldemState.otherTabActive, false);
+    assert.equal(told, 0);
+});
+
+test("told once, however many times the other tab acts", () => {
+    const win = withWindow();
+    let told = 0;
+    HoldemState.onOtherTab = () => { told++; };
+    HoldemState.watchOtherTabs();
+
+    for (let i = 0; i < 10; i++) win.fire(HoldemState.STORAGE_KEY);
+
+    assert.equal(told, 1);
+});
+
+test("watching twice doesn't listen twice", () => {
+    const win = withWindow();
+    HoldemState.watchOtherTabs();
+    HoldemState.watchOtherTabs();
+    HoldemState.watchOtherTabs();
+
+    assert.equal(win.listeners.length, 1);
+});
+
+test("no listener set is not an error", () => {
+    const win = withWindow();
+    HoldemState.onOtherTab = null;
+    HoldemState.watchOtherTabs();
+
+    assert.doesNotThrow(() => win.fire(HoldemState.STORAGE_KEY));
+    assert.equal(HoldemState.otherTabActive, true);
+});
+
+test("no window at all is not an error", () => {
+    // The same modules are loaded in Node by the test harness.
+    delete globalThis.window;
+    HoldemState.tabWatcher = null;
+
+    assert.doesNotThrow(() => HoldemState.watchOtherTabs());
+    assert.equal(HoldemState.otherTabActive, false);
+});