Don't quietly write over a save that couldn't be read

Last change made a failing save say so. This is the other direction, and it turned out to be worse. load() is well defended -- try/catch, a shape check, sensible fallbacks -- and every one of those paths ends in `return this.createDefault()`. So an unreadable save becomes an empty table. Driven with a save truncated to 70% of its length, the way an interrupted write leaves one: 1762 bytes stored, 1233 after truncating loaded: 0 named seats, hand #1 instead of #34 toast: none. warning: none. anything on the page: no. A dealer mid-session sees an empty felt and cannot tell whether they mis-tapped Reset, whether the browser lost the night, or what. And then the first edit destroys the evidence. I typed a name into a seat and storage went from the 1233 unreadable bytes to 2549 bytes of fresh default state. Whatever a person could have picked out of that JSON -- the names, the buy-ins, the standings -- was gone one tap after the tool decided it could not read it. Now the unreadable value is moved aside to its own key before the fallback, and the table says what happened: toast: "The saved table couldn't be read, so this one started empty." panel: "The saved table couldn't be read, so this one started empty. The unreadable copy has been kept rather than written over." It is deliberately not offered as a restore. Half a JSON document is not a table, and pretending otherwise would be worse than an empty one. It just stops being destroyed. The two warnings share the Session panel line and both can show at once -- a browser having trouble with storage tends to have it in both directions -- with the load message first, because "why is my table empty" is the question the dealer is standing there asking. 8 tests (263 total): nothing stored is a new table rather than a failure, a good save loads clean, a truncated one is reported, valid JSON of the wrong shape counts too, the copy is kept, a later save does not touch it, the listener fires once across three reads, and storage with no room to keep the copy is not a crash -- which is exactly the storage most likely to hand back half a value in the first place. Driven through the UI: warning and toast on a corrupted save, the set-aside copy still 1233 bytes intact after editing a seat, and nothing shown at all on a healthy table. One audit correction rides along. The collapsed-column check measured inside hidden elements, so the standings header -- hidden with its table until somebody buys in -- was reported as three collapsed columns on every empty table. It skips hidden subtrees now, and still catches a real one: squeezing a visible column reports the header and all three rows. Co-Authored-By: Claude Opus 5 <[email protected]> Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb
Say so when the browser refuses to save
2026-09-01 18:22:31 -06:00 · 2026-09-01 18:08:05 -06:00 · 2026-09-01 17:52:52 -06:00
11 changed files with 504 additions and 8 deletions
@@ -103,6 +103,7 @@
            <details class="sidebarPanel">
                <summary>Session</summary>
                <div class="panelBody">
+                    <p id="storageWarning" class="storageWarning" hidden></p>
                    <h3 class="panelSubhead">Standings</h3>
                    <div class="standingsTableWrap">
                        <div id="standingsTable">
@@ -156,6 +157,14 @@
                </div>
            </details>

+            <details class="sidebarPanel" id="keyboardPanel">
+                <summary>Keyboard</summary>
+                <div class="panelBody">
+                    <dl id="shortcutLegend" class="shortcutLegend"></dl>
+                    <p class="fieldHint">Nothing fires while you're typing in a field, or while a sheet is open over the table.</p>
+                </div>
+            </details>
+
            <details class="sidebarPanel">
                <summary>Table Notes</summary>
                <div class="panelBody">
@@ -1095,6 +1095,59 @@ button,
    line-height: 1.5;
 }

+/* Amber, like the bank check's disagreement — both are "your record of the night is
+   wrong and you can still do something about it". */
+.storageWarning {
+    margin: 0;
+    padding: 0.5rem 0.6rem;
+    border: 1px solid rgba(240, 180, 106, 0.45);
+    border-radius: 7px;
+    background: rgba(240, 180, 106, 0.08);
+    color: #f0b46a;
+    font-size: 0.76rem;
+    line-height: 1.4;
+}
+
+/* The shortcut legend. A touch device has no keys to press, so it doesn't get a panel
+   telling it about them — the same pointer question the touch-target rules ask. */
+@media (pointer: coarse) {
+    #keyboardPanel {
+        display: none;
+    }
+}
+
+.shortcutLegend {
+    display: grid;
+    grid-template-columns: auto 1fr;
+    gap: 0.45rem 0.6rem;
+    margin: 0;
+    align-items: baseline;
+}
+
+.shortcutLegend dt {
+    display: flex;
+    gap: 0.2rem;
+}
+
+.shortcutLegend dd {
+    margin: 0;
+    color: #b8b8b8;
+    font-size: 0.78rem;
+    line-height: 1.35;
+}
+
+.shortcutKey {
+    background: #232323;
+    border: 1px solid #3f3f3f;
+    border-bottom-width: 2px;
+    border-radius: 4px;
+    padding: 0.05rem 0.32rem;
+    font-family: inherit;
+    font-size: 0.68rem;
+    color: #d8b46a;
+    white-space: nowrap;
+}
+
 /* One chip per ruling, wrapped across the top of the sheet. Names rather than icons:
   a dealer scanning this is looking for the words somebody at the table just said. */
 .rulingsIndex {
@@ -2117,6 +2170,20 @@ body.hasActionBar #holdemSidebar {
    font-variant-numeric: tabular-nums;
 }

+/* The undo pill's key, inline rather than pinned to a corner — see actionBar.js. */
+.actionUndoKey {
+    margin-left: 0.4rem;
+    padding: 0 0.25rem;
+    border-radius: 4px;
+    border: 1px solid currentColor;
+    opacity: 0.55;
+    font-family: inherit;
+    font-size: 0.6rem;
+    line-height: 1.4;
+    text-transform: uppercase;
+    pointer-events: none;
+}
+
 .actionKey {
    position: absolute;
    top: 5px;
@@ -176,6 +176,17 @@ const ActionBar = {
            undo.className = "actionUndo";
            undo.title = `Undo ${undoLabel}`;
            undo.textContent = `↶ ${undoLabel}`;
+            // U undoes, and nothing said so — this control was the only place a dealer
+            // could have learned it, and it was the one action bar control without its
+            // key printed on it.
+            const key = document.createElement("kbd");
+            // Its own class, not .actionKey: that one pins itself to the top-right
+            // corner of a big action button, and this control is a 30px pill with
+            // overflow hidden and no positioning context — the cap escaped it and
+            // floated above the bar. Here the key belongs inline, after the label.
+            key.className = "actionUndoKey";
+            key.textContent = this.KEY_HINTS.actionUndo;
+            undo.appendChild(key);
            undo.addEventListener("click", () => this.hooks.undoLast());
            row.appendChild(undo);
        }
@@ -281,6 +292,8 @@ const ActionBar = {
        actionAdvance: "↵",
        raiseConfirm: "↵",
        raiseCancel: "esc",
+        raiseAllIn: "A",
+        actionUndo: "U",
    },

    button(label, className, onClick, sublabel) {
@@ -293,7 +306,10 @@ const ActionBar = {
        main.textContent = label;
        btn.appendChild(main);

-        const hint = this.KEY_HINTS[className];
+        // Looked up by any of the button's classes, so a button can carry a shared
+        // class for its looks and a specific one for its key — the raise pad's four
+        // quick amounts are all raiseQuickBtn, but only All-in has a key.
+        const hint = className.split(/\s+/).map(name => this.KEY_HINTS[name]).find(Boolean);
        if (hint) {
            const kbd = document.createElement("kbd");
            kbd.className = "actionKey";
@@ -397,7 +413,7 @@ const ActionBar = {
        ];
        options.forEach(option => {
            const value = Math.max(minTo, Math.min(option.value, maxTo));
-            const btn = this.button(option.label, "raiseQuickBtn", () => {
+            const btn = this.button(option.label, `raiseQuickBtn${option.label === "All-in" ? " raiseAllIn" : ""}`, () => {
                this.raiseDraft = value;
                this.render();
            }, Money.format(value));
@@ -458,6 +458,35 @@ document.addEventListener("DOMContentLoaded", () => {
    // Escape is Modal's job now, for this sheet and the five others that never had it.
    const rulingsOverlay = document.getElementById("rulingsOverlay");
    const closeRulings = () => { rulingsOverlay.hidden = true; };
+    // 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.
+    HoldemState.onSaveFailed = () => {
+        Toast.show(
+            "This table isn't being saved — refreshing would lose it. Keep this tab open.",
+            { duration: 12000 });
+        Render.renderStorageWarning();
+    };
+
+    // The shortcut legend, built from the same list the handlers are keyed off, so a
+    // shortcut can't exist without a line here saying what it does.
+    const legend = document.getElementById("shortcutLegend");
+    if (legend) {
+        Shortcuts.LEGEND.forEach(entry => {
+            const term = document.createElement("dt");
+            entry.keys.forEach(key => {
+                const kbd = document.createElement("kbd");
+                kbd.className = "shortcutKey";
+                kbd.textContent = key;
+                term.appendChild(kbd);
+            });
+            const detail = document.createElement("dd");
+            detail.textContent = entry.what;
+            legend.appendChild(term);
+            legend.appendChild(detail);
+        });
+    }
+
    // An index across the top of the rulings sheet, one chip per ruling.
    //
    // This is opened mid-argument with players waiting, and it was nine rulings of
@@ -542,4 +571,14 @@ document.addEventListener("DOMContentLoaded", () => {
        if ((state.handHistory || []).length === 0) return;
        HandHistoryExport.download(state.handHistory, HoldemState.sessionStandings(state));
    });
+
+    // The load happens on the first line of this file, long before there's a Toast to
+    // show it in, so this is checked here rather than wired as a callback. The standing
+    // warning in the Session panel doesn't need it — that reads the flag every render —
+    // but an empty table is a thing a dealer needs told, not left to notice.
+    if (HoldemState.loadFailed) {
+        Toast.show(
+            "The saved table couldn't be read, so this one started empty.",
+            { duration: 12000 });
+    }
 });
@@ -751,6 +751,34 @@ const Render = {

        this.renderBankReconciliation();
        this.renderSettleUp(standings);
+        this.renderStorageWarning();
+    },
+
+    // A toast is a moment; this table not being saved is a fact about the rest of the
+    // night. It sits at the top of the panel a dealer opens to check the money, and it
+    // stays there, because the raise pad dismisses toasts and the one time this warning
+    // matters is the one time it must not have been missed.
+    renderStorageWarning() {
+        const host = document.getElementById("storageWarning");
+        if (!host) return;
+        host.hidden = !HoldemState.saveFailed && !HoldemState.loadFailed;
+        if (host.hidden) return;
+
+        // Both can be true at once — a browser having trouble with storage tends to
+        // have it in both directions — and the one that explains an empty table goes
+        // first, because that's the question the dealer is standing there asking.
+        const lines = [];
+        if (HoldemState.loadFailed) {
+            lines.push(
+                "The saved table couldn't be read, so this one started empty. " +
+                "The unreadable copy has been kept rather than written over.");
+        }
+        if (HoldemState.saveFailed) {
+            lines.push(
+                "This table isn't being saved — the browser refused. It'll keep working, " +
+                "but closing or refreshing this tab loses the session. Export CSV below keeps a copy.");
+        }
+        host.textContent = lines.join(" ");
    },

    // The last step the standings stopped short of. Six signed numbers at 2am is not
@@ -18,6 +18,23 @@ const Shortcuts = {
        escape: "cancel",
    },

+    // What each one does, in a dealer's words, for the legend in the sidebar.
+    //
+    // Lives beside KEYS because the two must not drift: F, C and R are printed on the
+    // buttons they drive, but A and U were on nothing at all — a dealer who learned
+    // the first three from the bar had no way to find out the other two existed. A
+    // shortcut with no line here is a shortcut nobody can find, and there's a test
+    // that says so.
+    LEGEND: [
+        { keys: ["F"], action: "fold", what: "Fold" },
+        { keys: ["C"], action: "checkOrCall", what: "Check, or call the bet" },
+        { keys: ["R"], action: "raise", what: "Open the amount pad to bet or raise" },
+        { keys: ["A"], action: "allIn", what: "Put this player all-in" },
+        { keys: ["U"], action: "undo", what: "Take back the last action" },
+        { keys: ["Space", "Enter"], action: "advance", what: "Deal, or move to the next street" },
+        { keys: ["Esc"], action: "cancel", what: "Close the amount pad without betting" },
+    ],
+
    mount(handlers) {
        this.handlers = handlers;
        document.addEventListener("keydown", e => this.onKey(e));
@@ -81,12 +81,45 @@ const HoldemState = {
        };
    },

+    // Where an unreadable save is kept instead of being written over.
+    RECOVERY_KEY: "casino.holdem.state.v1.unreadable",
+
+    // 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,
+    onLoadFailed: null,
+
+    // A saved table that won't parse becomes an empty table, which is the only thing
+    // it can become — but it used to become one silently, and then the first edit
+    // saved over the top of it. A dealer mid-session saw an empty felt with no idea
+    // whether they'd mis-tapped Reset or the browser had lost the night, and whatever
+    // a person might have picked out of the raw JSON was gone a tap later.
+    //
+    // So the unreadable value is moved aside first. It is not offered as a restore —
+    // half a JSON document isn't a table, and pretending otherwise would be worse than
+    // an empty one — but it stops being destroyed, and somebody who wants the
+    // standings out of it still can.
+    failedLoad(raw) {
+        if (!this.loadFailed) {
+            this.loadFailed = true;
+            try {
+                if (raw) localStorage.setItem(this.RECOVERY_KEY, raw);
+            } catch {
+                // No room to keep it. Nothing more to try, and the warning below is
+                // the part that actually matters.
+            }
+            if (typeof this.onLoadFailed === "function") this.onLoadFailed();
+        }
+        return this.createDefault();
+    },
+
    load() {
+        let raw = null;
        try {
-            const raw = localStorage.getItem(this.STORAGE_KEY);
+            raw = localStorage.getItem(this.STORAGE_KEY);
            if (!raw) return this.createDefault();
            const parsed = JSON.parse(raw);
-            if (!parsed || !Array.isArray(parsed.seats)) return this.createDefault();
+            if (!parsed || !Array.isArray(parsed.seats)) return this.failedLoad(raw);
            if (typeof parsed.handNumber !== "number" || parsed.handNumber < 1) parsed.handNumber = 1;
            if (!Array.isArray(parsed.handHistory)) parsed.handHistory = [];

@@ -118,16 +151,37 @@ const HoldemState = {

            return parsed;
        } catch {
-            return this.createDefault();
+            // Malformed JSON — a truncated write, another tab, a browser hiccup.
+            return this.failedLoad(raw);
        }
    },

+    // True once a save has failed. The UI reads this to keep saying so, because a
+    // toast is a moment and this is a fact about the rest of the night.
+    saveFailed: false,
+
+    // Called the first time a save fails. Set by the UI.
+    onSaveFailed: null,
+
    save(state) {
        try {
            localStorage.setItem(this.STORAGE_KEY, JSON.stringify(state));
-        } catch {
-            // Storage full/unavailable (private browsing, etc.) — the table still works
-            // for the rest of the session, it just won't survive a refresh.
+            return true;
+        } catch (error) {
+            // Storage full, or private browsing. The table still works for the rest of
+            // the session — it just won't survive a refresh, and nothing used to say
+            // so. That is the same shape of fault the bank check exists for: silent
+            // until it is too late to do anything about it. A dealer who finds out by
+            // refreshing has lost the night's standings, and the only warning they got
+            // was the table being empty.
+            //
+            // Announced once. A dealer tapping a bar thirty times a hand does not need
+            // thirty of these.
+            if (!this.saveFailed) {
+                this.saveFailed = true;
+                if (typeof this.onSaveFailed === "function") this.onSaveFailed(error);
+            }
+            return false;
        }
    },

@@ -0,0 +1,114 @@
+// What happens when the saved table can't be read.
+//
+// An unreadable save can only become an empty table. What it must not do is become
+// one silently and then get written over by the first edit.
+const test = require("node:test");
+const assert = require("node:assert");
+const { HoldemState } = require("./load");
+
+function withStored(value, { readOnly = false } = {}) {
+    const store = new Map();
+    if (value !== undefined) store.set(HoldemState.STORAGE_KEY, value);
+    globalThis.localStorage = {
+        getItem: key => (store.has(key) ? store.get(key) : null),
+        setItem(key, val) {
+            if (readOnly) throw new Error("QuotaExceededError");
+            store.set(key, val);
+        },
+        removeItem: key => store.delete(key),
+    };
+    return store;
+}
+
+test.beforeEach(() => {
+    HoldemState.loadFailed = false;
+    HoldemState.onLoadFailed = null;
+});
+
+test.after(() => {
+    delete globalThis.localStorage;
+    HoldemState.loadFailed = false;
+    HoldemState.onLoadFailed = null;
+});
+
+test("nothing stored is a new table, not a failure", () => {
+    withStored(undefined);
+    const state = HoldemState.load();
+
+    assert.equal(HoldemState.loadFailed, false);
+    assert.ok(Array.isArray(state.seats));
+});
+
+test("a good save loads and reports nothing", () => {
+    const store = withStored(undefined);
+    const original = HoldemState.createDefault();
+    original.handNumber = 34;
+    HoldemState.save(original);
+
+    const state = HoldemState.load();
+    assert.equal(HoldemState.loadFailed, false);
+    assert.equal(state.handNumber, 34);
+    assert.equal(store.has(HoldemState.RECOVERY_KEY), false);
+});
+
+test("a truncated save is reported rather than silently becoming an empty table", () => {
+    const good = JSON.stringify(HoldemState.createDefault());
+    withStored(good.slice(0, Math.floor(good.length * 0.7)));
+
+    const state = HoldemState.load();
+    assert.equal(HoldemState.loadFailed, true);
+    assert.ok(Array.isArray(state.seats), "it still hands back a usable table");
+});
+
+test("valid JSON of the wrong shape counts as unreadable too", () => {
+    withStored(JSON.stringify({ hello: "world" }));
+
+    HoldemState.load();
+    assert.equal(HoldemState.loadFailed, true);
+});
+
+test("the unreadable copy is kept instead of being written over", () => {
+    // This is the half that matters: whatever a person could have picked out of the
+    // raw JSON used to be gone the moment the dealer touched a seat.
+    const broken = '{"seats":[{"name":"Ann","stack":250},{"name":"Ben"';
+    const store = withStored(broken);
+
+    HoldemState.load();
+
+    assert.equal(store.get(HoldemState.RECOVERY_KEY), broken);
+});
+
+test("a later save doesn't touch the copy that was set aside", () => {
+    const broken = '{"seats":[{"name":"Ann"';
+    const store = withStored(broken);
+
+    const state = HoldemState.load();
+    state.handNumber = 2;
+    HoldemState.save(state);
+
+    assert.equal(store.get(HoldemState.RECOVERY_KEY), broken);
+    assert.notEqual(store.get(HoldemState.STORAGE_KEY), broken);
+});
+
+test("the listener fires once, not on every read", () => {
+    withStored("{not json");
+    let told = 0;
+    HoldemState.onLoadFailed = () => { told++; };
+
+    HoldemState.load();
+    HoldemState.load();
+    HoldemState.load();
+
+    assert.equal(told, 1);
+});
+
+test("no room to keep the copy is not a crash", () => {
+    // Storage that refuses writes is exactly the storage most likely to hand back a
+    // half-written value in the first place.
+    withStored("{not json", { readOnly: true });
+
+    let state;
+    assert.doesNotThrow(() => { state = HoldemState.load(); });
+    assert.ok(Array.isArray(state.seats));
+    assert.equal(HoldemState.loadFailed, true);
+});
@@ -0,0 +1,95 @@
+// What happens when the browser refuses to save.
+//
+// The table keeps working — that was always true and is still the right behaviour.
+// What was missing is anybody being told, which is the same shape of fault the bank
+// check exists for: silent until it's too late to act on.
+const test = require("node:test");
+const assert = require("node:assert");
+const { HoldemState, makeTable } = require("./load");
+
+function withStorage(behaviour) {
+    const calls = [];
+    globalThis.localStorage = {
+        setItem(key, value) {
+            calls.push({ key, value });
+            if (behaviour === "throw") {
+                const error = new Error("QuotaExceededError");
+                error.name = "QuotaExceededError";
+                throw error;
+            }
+        },
+        getItem: () => null,
+        removeItem() {},
+    };
+    return calls;
+}
+
+test.beforeEach(() => {
+    HoldemState.saveFailed = false;
+    HoldemState.onSaveFailed = null;
+});
+
+test.after(() => {
+    delete globalThis.localStorage;
+    HoldemState.saveFailed = false;
+    HoldemState.onSaveFailed = null;
+});
+
+test("a save that works says so and leaves no mark", () => {
+    withStorage("ok");
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+
+    assert.equal(HoldemState.save(state), true);
+    assert.equal(HoldemState.saveFailed, false);
+});
+
+test("a save that fails says so rather than throwing", () => {
+    withStorage("throw");
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+
+    assert.equal(HoldemState.save(state), false);
+    assert.equal(HoldemState.saveFailed, true);
+});
+
+test("the table is told once, not on every action", () => {
+    // A dealer taps the bar thirty times a hand and doesn't need thirty warnings.
+    withStorage("throw");
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    let told = 0;
+    HoldemState.onSaveFailed = () => { told++; };
+
+    for (let i = 0; i < 20; i++) HoldemState.save(state);
+
+    assert.equal(told, 1);
+});
+
+test("the failure is handed the error, so the reason can be reported later", () => {
+    withStorage("throw");
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    let seen = null;
+    HoldemState.onSaveFailed = error => { seen = error; };
+
+    HoldemState.save(state);
+
+    assert.equal(seen && seen.name, "QuotaExceededError");
+});
+
+test("a failing save still doesn't stop the table", () => {
+    // The chips have already moved in memory; refusing to continue would be worse
+    // than not persisting.
+    withStorage("throw");
+    const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 100 });
+    state.seats[0].stack = 175;
+
+    assert.doesNotThrow(() => HoldemState.save(state));
+    assert.equal(state.seats[0].stack, 175);
+});
+
+test("no listener is not an error", () => {
+    withStorage("throw");
+    const state = makeTable({ seatCount: 6, seated: [0, 1], stack: 100 });
+    HoldemState.onSaveFailed = null;
+
+    assert.doesNotThrow(() => HoldemState.save(state));
+    assert.equal(HoldemState.saveFailed, true);
+});
@@ -0,0 +1,51 @@
+// The legend and the key map must not drift apart.
+//
+// F, C and R are printed on the buttons they drive. A and U were on nothing at all,
+// so a dealer who learned the first three from the action bar had no way to find out
+// the other two existed. The guard against that happening again is this file.
+const test = require("node:test");
+const assert = require("node:assert");
+const path = require("path");
+
+const Shortcuts = require(path.join(
+    __dirname, "..", "..", "JoshHeaps.Net", "wwwroot", "js", "casino", "holdem", "shortcuts.js"));
+
+test("every shortcut has a line in the legend", () => {
+    const documented = new Set(Shortcuts.LEGEND.map(entry => entry.action));
+    const missing = [...new Set(Object.values(Shortcuts.KEYS))].filter(action => !documented.has(action));
+    assert.deepEqual(missing, [], "a shortcut with no legend line is one nobody can find");
+});
+
+test("the legend doesn't describe shortcuts that don't exist", () => {
+    const real = new Set(Object.values(Shortcuts.KEYS));
+    const invented = Shortcuts.LEGEND.map(entry => entry.action).filter(action => !real.has(action));
+    assert.deepEqual(invented, []);
+});
+
+test("every legend line names its keys and says what they do", () => {
+    Shortcuts.LEGEND.forEach(entry => {
+        assert.ok(Array.isArray(entry.keys) && entry.keys.length > 0, `${entry.action} has no keys`);
+        assert.ok(entry.keys.every(key => typeof key === "string" && key.trim()), `${entry.action} has a blank key`);
+        assert.ok(entry.what && entry.what.trim().length > 3, `${entry.action} has no description`);
+    });
+});
+
+test("the keys named match the keys bound", () => {
+    // "Space" and "Enter" both drive advance; the map holds them as " " and "enter".
+    const spoken = { space: " ", enter: "enter", esc: "escape" };
+    Shortcuts.LEGEND.forEach(entry => {
+        entry.keys.forEach(label => {
+            const key = spoken[label.toLowerCase()] || label.toLowerCase();
+            assert.equal(Shortcuts.KEYS[key], entry.action,
+                `the legend says ${label} is ${entry.action}, the map disagrees`);
+        });
+    });
+});
+
+test("no two lines claim the same key", () => {
+    const seen = new Set();
+    Shortcuts.LEGEND.forEach(entry => entry.keys.forEach(key => {
+        assert.ok(!seen.has(key.toLowerCase()), `${key} is listed twice`);
+        seen.add(key.toLowerCase());
+    }));
+});
@@ -180,6 +180,12 @@ const LayoutAudit = {
    collapsedColumns() {
        const offenders = [];
        [...document.querySelectorAll("[class*='Row'], [class*='row']")].forEach(row => {
+            // Nothing inside something the page has hidden. A hidden element's children
+            // all measure zero wide, so the standings header — which is hidden along
+            // with its table until somebody has bought in — was reported as three
+            // collapsed columns on every empty table. A column nobody can see hasn't
+            // collapsed; it isn't there.
+            if (row.closest("[hidden]")) return;
            if (getComputedStyle(row).display !== "grid") return;
            [...row.children].forEach(cell => {
                if (getComputedStyle(cell).display === "none") return;