chesspal 0.3.5 → 0.3.6

package/dist/commands/profiles/past-games.js

@@ -8,19 +8,32 @@ import { defineCommand } from "../registry/index.js";
 export const pastGames = defineCommand({
     name: "past_games",
     description: "Lists the games played with this player, the latest first: when, your colour, the result, the opening, how long, and its name in the "
-        + "archive. With game, that game's PGN with your comments and plans; to comment a game with the player, analyse_game. new_game already gives the "
-        + "last three. Example: past_games {}.",
-    input: z.object({ game: z.string().optional().describe("a game's name, as the list writes it: its PGN") }),
+        + "archive. With search, only the games whose line holds every word of it; the colour and the result are yours, the AI's. With game, that game's "
+        + "PGN with your comments and plans; to comment a game with the player, analyse_game. new_game already gives the last three. Example, the "
+        + 'Sicilians the player lost: past_games {search: "Sicilian won"}.',
+    input: z.object({
+        search: z.string().optional().describe("words the game's line must all hold: a date, your colour, won, lost, drew or unfinished as you did, an opening"),
+        game: z.string().optional().describe("a game's name, as the list writes it: its PGN"),
+    }),
     readOnly: true,
     idempotent: true,
-    run: ({ game }, context) => {
+    run: ({ search, game }, context) => {
         const folder = gameFolder(context.home());
-        return game === undefined ? { games: pastGameLines(folder, listed) } : { pgn: writePgn(archivedGame(folder, game)) };
+        return game === undefined ? { games: pastGameLines(folder, listed, search), searched: search?.trim() ? true : undefined } : { pgn: writePgn(archivedGame(folder, game)) };
+    },
+    format: (past) => {
+        if ("pgn" in past) {
+            return past.pgn;
+        }
+        return past.games.length > 0 ? past.games.join("\n") : past.searched ? "No game played holds all those words." : "No game played yet.";
     },
-    format: (past) => ("pgn" in past ? past.pgn : past.games.length === 0 ? "No game played yet." : past.games.join("\n")),
 });
-/** The latest games of the archive, one line each as the AI reads them: none when there is no archive. A game closed before any move is no game played. */
-export function pastGameLines(folder, count) {
+/**
+ * The latest games of the archive, one line each as the AI reads them, those holding every word searched: none when there is no archive. A game closed
+ * before any move is no game played.
+ */
+export function pastGameLines(folder, count, search = "") {
+    const words = search.toLowerCase().split(/\s+/).filter((word) => word !== "");
     const lines = [];
     for (const name of archivedGames(folder)) {
         if (lines.length === count) {
@@ -28,8 +41,11 @@ export function pastGameLines(folder, count) {
         }
         try {
             const record = archivedGame(folder, name);
-            if (record.moves.length > 0) {
-                lines.push(pastGameLine(name, record));
+            const line = record.moves.length > 0 ? pastGameLine(name, record) : undefined;
+            // The ending names the player's colour too, as "(Black resigns)": a colour searched is the AI's alone.
+            const searched = line?.replace(/ \((?:White|Black) [^)]*\)/, "").toLowerCase();
+            if (line !== undefined && words.every((word) => searched.includes(word))) {
+                lines.push(line);
             }
         }
         catch {

package/dist/commands/talk/ai-say.js

@@ -43,7 +43,7 @@ function afterWords(game, words) {
             return `Next: ${reviewedLine(game.end.archive)} When they want another game, ${newGameStep}`;
         }
         return game.end.analyst === "offer"
-            ? `Next: when the player wants this game gone over, ${analystLine(game.end.archive)} When they want another game, ${newGameStep}`
+            ? `Next: when the player wants this game gone over, ${analystLine(game.end.archive, game.end.codex === true)} When they want another game, ${newGameStep}`
             : `Next: when the player wants another game, ${newGameStep}`;
     }
     if (words.length === 0 && game?.drawOffer === "player" && game.turn !== game.ai) {

package/dist/games/analysis.d.ts

@@ -1,11 +1,13 @@
 /**
  * The game in analysis: its name as the lists write it, when the analysis last changed it, whether the player brought it on the page and the AI has not
- * gone over it yet, the moves whose note the chat corrected with the player, which the analyst leaves (D-101), and the run of the analyst that took it.
+ * gone over it yet, and whether they asked there for a new review of it; the moves whose note the chat corrected with the player, which the analyst leaves
+ * (D-101), and the run of the analyst that took it.
  */
 export interface Analysis {
     readonly game: string;
     readonly at: string;
     readonly brought?: true;
+    readonly redo?: true;
     readonly corrected?: readonly string[];
     readonly analyst?: AnalystRun;
 }
@@ -16,11 +18,12 @@ export interface AnalystRun {
     readonly since: string;
 }
 /**
- * How a game is named in analysis: brought to the page by the player, with the moves the chat just corrected, taken by a run of the analyst, or afresh,
- * without the corrections and the analyst it had.
+ * How a game is named in analysis: brought to the page by the player, for a new review too, with the moves the chat just corrected, taken by a run of the
+ * analyst, or afresh, without the corrections and the analyst it had.
  */
 export interface AnalysisStart {
     readonly brought?: boolean;
+    readonly redo?: boolean;
     readonly corrected?: readonly string[];
     readonly analyst?: AnalystRun;
     readonly afresh?: boolean;
@@ -30,7 +33,7 @@ export interface AnalysisStart {
  * unless it starts afresh, in one write, so that the page never sees it leave the analysis; the analyst stays with the game it took, whichever the page
  * opens meanwhile (Federico), and goes when that game starts afresh.
  */
-export declare function startAnalysis(folder: string, game: string, now: Date, { brought, corrected, analyst, afresh }?: AnalysisStart): void;
+export declare function startAnalysis(folder: string, game: string, now: Date, { brought, redo, corrected, analyst, afresh }?: AnalysisStart): void;
 /** Lets the analyst go from the game it took, when that game's review is deleted while the page shows another. */
 export declare function forgetAnalyst(folder: string): void;
 /** The game in analysis, or none when there is none, or analysis.json cannot be read. */

package/dist/games/analysis.js

@@ -8,7 +8,7 @@ import { writeAtomically } from "./files.js";
  * unless it starts afresh, in one write, so that the page never sees it leave the analysis; the analyst stays with the game it took, whichever the page
  * opens meanwhile (Federico), and goes when that game starts afresh.
  */
-export function startAnalysis(folder, game, now, { brought = false, corrected = [], analyst, afresh = false } = {}) {
+export function startAnalysis(folder, game, now, { brought = false, redo = false, corrected = [], analyst, afresh = false } = {}) {
     const before = gameInAnalysis(folder);
     const same = !afresh && before?.game === game;
     const kept = [...new Set([...(same ? before.corrected ?? [] : []), ...corrected])];
@@ -17,6 +17,7 @@ export function startAnalysis(folder, game, now, { brought = false, corrected =
         game,
         at: now.toISOString(),
         ...(brought ? { brought: true } : {}),
+        ...(brought && redo ? { redo: true } : {}),
         ...(kept.length === 0 ? {} : { corrected: kept }),
         ...withAnalyst(analyst ?? held),
     });
@@ -25,8 +26,8 @@ export function startAnalysis(folder, game, now, { brought = false, corrected =
 export function forgetAnalyst(folder) {
     const analysis = gameInAnalysis(folder);
     if (analysis?.analyst !== undefined) {
-        const { game, at, brought, corrected } = analysis;
-        writeAnalysis(folder, { game, at, ...(brought === undefined ? {} : { brought }), ...(corrected === undefined ? {} : { corrected }) });
+        const { game, at, brought, redo, corrected } = analysis;
+        writeAnalysis(folder, { game, at, ...(brought === undefined ? {} : { brought }), ...(redo === undefined ? {} : { redo }), ...(corrected === undefined ? {} : { corrected }) });
     }
 }
 /** The game in analysis, or none when there is none, or analysis.json cannot be read. */
@@ -39,6 +40,7 @@ export function gameInAnalysis(folder) {
                 game: analysis.game,
                 at: analysis.at,
                 ...(analysis.brought === true ? { brought: true } : {}),
+                ...(analysis.brought === true && analysis.redo === true ? { redo: true } : {}),
                 ...(corrected.length === 0 ? {} : { corrected }),
                 ...withAnalyst(isAnalystRun(analysis.analyst) ? analysis.analyst : undefined),
             }

package/dist/games/index.d.ts

@@ -8,4 +8,4 @@ export { makeFolder, renameOver, writeAtomically } from "./files.ts";
 export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.ts";
 export { endTableTalk, loadTableTalk, saveTableTalk, type TableTalk, tableTalkStamp } from "./table-talk.ts";
 export { type Heard, heardLines, type Sayer, type Talk, talkLimits, talkLine, unheardWords, wakesTheChat, type Words, WordsRefused } from "./talk.ts";
-export { keepThought, notePondering, ponderingOn, type Thought, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.ts";
+export { keepThought, notePondering, ponderingOn, ponderingUntil, type Thought, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.ts";

package/dist/games/index.js

@@ -9,4 +9,4 @@ export { makeFolder, renameOver, writeAtomically } from "./files.js";
 export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.js";
 export { endTableTalk, loadTableTalk, saveTableTalk, tableTalkStamp } from "./table-talk.js";
 export { heardLines, talkLimits, talkLine, unheardWords, wakesTheChat, WordsRefused } from "./talk.js";
-export { keepThought, notePondering, ponderingOn, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.js";
+export { keepThought, notePondering, ponderingOn, ponderingUntil, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.js";

package/dist/games/thoughts.d.ts

@@ -7,8 +7,11 @@ export interface Thought {
 }
 /** The key of the position the player is to move in: the game, by its start, and how many moves it has. */
 export declare function thoughtKey(current: CurrentGame, ply?: number): string;
-/** Keeps a thought for a position, in place of one for the same reply; thoughts of another position go. The thoughts kept now. */
-export declare function keepThought(folder: string, key: string, thought: Thought): Thought[];
+/**
+ * Keeps a thought for a position, in place of one for the same reply; thoughts of another position go. The thoughts kept now. A thought kept while the AI
+ * ponders shows it still at work.
+ */
+export declare function keepThought(folder: string, key: string, thought: Thought, now: Date): Thought[];
 /** The thought for the player's last move, when the AI is to move and thought of it on their time. */
 export declare function thoughtForLastMove(folder: string, current: CurrentGame): Thought | undefined;
 /** Since when the AI has waited for the player's move in a position: the first time it asked, `now` then, kept with its thoughts. */
@@ -17,6 +20,11 @@ export declare function waitingSince(folder: string, key: string, now: Date): Da
  * Notes whether the AI thinks on the player's time in a position now, from its first look until it waits for their move, for the page's sign: in the file,
  * since in Codex the agent that thinks has a process of its own (D-98).
  */
-export declare function notePondering(folder: string, key: string, pondering: boolean): void;
+export declare function notePondering(folder: string, key: string, pondering: boolean, now: Date): void;
+/**
+ * Until when the AI is seen thinking on the player's time in a position, as noted: a while after its last look or thought, so that an agent stopped before
+ * it waits (Esc, its host closed) does not leave the sign on until the player moves.
+ */
+export declare function ponderingUntil(folder: string, key: string): Date | undefined;
 /** Whether the AI thinks on the player's time in a position now, as noted. */
-export declare function ponderingOn(folder: string, key: string): boolean;
+export declare function ponderingOn(folder: string, key: string, now: Date): boolean;

package/dist/games/thoughts.js

@@ -8,14 +8,17 @@ import { writeAtomically } from "./files.js";
 export function thoughtKey(current, ply = current.game.record.moves.length) {
     return `${current.started}#${ply}`;
 }
-/** Keeps a thought for a position, in place of one for the same reply; thoughts of another position go. The thoughts kept now. */
-export function keepThought(folder, key, thought) {
+/**
+ * Keeps a thought for a position, in place of one for the same reply; thoughts of another position go. The thoughts kept now. A thought kept while the AI
+ * ponders shows it still at work.
+ */
+export function keepThought(folder, key, thought, now) {
     const kept = keptAt(folder, key);
     const thoughts = [...kept.thoughts.filter((one) => one.reply !== thought.reply), thought];
     if (thoughts.length > mostThoughts) {
         throw new Error(`You have ${mostThoughts} thoughts for this position already: they are enough. Nothing changed.`);
     }
-    write(folder, { ...kept, thoughts });
+    write(folder, { ...kept, thoughts, ...(kept.pondering === undefined ? {} : { pondering: now.toISOString() }) });
     return thoughts;
 }
 /** The thought for the player's last move, when the AI is to move and thought of it on their time. */
@@ -37,17 +40,30 @@ export function waitingSince(folder, key, now) {
  * Notes whether the AI thinks on the player's time in a position now, from its first look until it waits for their move, for the page's sign: in the file,
  * since in Codex the agent that thinks has a process of its own (D-98).
  */
-export function notePondering(folder, key, pondering) {
+export function notePondering(folder, key, pondering, now) {
     const { pondering: before, ...kept } = keptAt(folder, key);
-    if ((before === true) !== pondering) {
-        write(folder, pondering ? { ...kept, pondering: true } : kept);
+    if (pondering) {
+        write(folder, { ...kept, pondering: now.toISOString() });
+    }
+    else if (before !== undefined) {
+        write(folder, kept);
     }
 }
-/** Whether the AI thinks on the player's time in a position now, as noted. */
-export function ponderingOn(folder, key) {
+/**
+ * Until when the AI is seen thinking on the player's time in a position, as noted: a while after its last look or thought, so that an agent stopped before
+ * it waits (Esc, its host closed) does not leave the sign on until the player moves.
+ */
+export function ponderingUntil(folder, key) {
     const kept = read(folder);
-    return kept?.key === key && kept.pondering === true;
+    return kept?.key === key && typeof kept.pondering === "string" ? new Date(new Date(kept.pondering).getTime() + ponderSignFor) : undefined;
+}
+/** Whether the AI thinks on the player's time in a position now, as noted. */
+export function ponderingOn(folder, key, now) {
+    const until = ponderingUntil(folder, key);
+    return until !== undefined && now < until;
 }
+// An agent thinks on one reply in well under this; one silent for longer has stopped.
+const ponderSignFor = 5 * 60_000;
 /** The most thoughts kept for a position: a few likely replies, not every legal one. */
 const mostThoughts = 8;
 const fileName = "thoughts.json";
@@ -55,7 +71,8 @@ const thoughtsFile = z.object({
     key: z.string(),
     thoughts: z.array(z.object({ reply: z.string(), move: z.string(), why: z.string() })),
     since: z.iso.datetime().optional(),
-    pondering: z.boolean().optional(),
+    // The time of the AI's last look or thought while it ponders; true, from an older Chesspal, is a sign without its time, taken as gone.
+    pondering: z.union([z.iso.datetime(), z.boolean()]).optional(),
 });
 /** What is kept for a position: nothing yet when the file is for another, or missing. */
 function keptAt(folder, key) {

package/dist/home/index.d.ts

@@ -1,2 +1,3 @@
 export { dataFolder, type System, tableFolder } from "./data-folder.ts";
 export { openFolder } from "./open-folder.ts";
+export { samePath } from "./same-path.ts";

package/dist/home/index.js

@@ -1,3 +1,4 @@
 // Where the player's data is (D-71): one folder for every chat, apart from the host's folder. Below the commands, beside the games and the profiles.
 export { dataFolder, tableFolder } from "./data-folder.js";
 export { openFolder } from "./open-folder.js";
+export { samePath } from "./same-path.js";

package/dist/home/same-path.d.ts

@@ -0,0 +1,2 @@
+/** Whether two paths name the same folder: without regard to case on Windows. */
+export declare function samePath(one: string, other: string): boolean;

package/dist/home/same-path.js

@@ -0,0 +1,5 @@
+import { resolve } from "node:path";
+/** Whether two paths name the same folder: without regard to case on Windows. */
+export function samePath(one, other) {
+    return process.platform === "win32" ? resolve(one).toLowerCase() === resolve(other).toLowerCase() : resolve(one) === resolve(other);
+}

package/dist/host-files/host-files.js

@@ -120,7 +120,8 @@ const bellHook = { type: "command", command: "chesspal listen", asyncRewake: tru
 const chatHook = { type: "command", command: "chesspal chat" };
 /**
  * Codex's settings, read once the player trusts the folder: the chesspal server with its tools approved, a table of Chesspal's rewritten but for the
- * environment the player gave it, as CHESSPAL_HOME in a playtest; the rest stays.
+ * environment the player gave it; CHESSPAL_HOME and CHESSPAL_SEAT always passed on to the server, which Codex otherwise starts without them, so that a
+ * playtest's data folder is the one the server reads, and the chat `chesspal play` holds knows it. The rest stays.
  */
 function codexConfigFile(folder, platform) {
     const path = join(folder, ".codex", "config.toml");
@@ -128,8 +129,12 @@ function codexConfigFile(folder, platform) {
     const { command, args } = chesspalServer(platform);
     // The table runs up to the next one, or to the end; a header with a comment after it is the same table.
     const ours = /^\s*\[mcp_servers\.chesspal\]\s*(#.*)?\r?\n[\s\S]*?(?=^\s*\[|(?![\s\S]))/m;
-    const environment = (ours.exec(before)?.[0].match(/^\s*env(?:_vars)?\s*=.*$/gm) ?? []).map((line) => `${line.trim()}\n`).join("");
-    const table = `[mcp_servers.chesspal]\ncommand = ${JSON.stringify(command)}\nargs = [${args.map((arg) => JSON.stringify(arg)).join(", ")}]\ndefault_tools_approval_mode = "approve"\n${environment}`;
+    const given = ours.exec(before)?.[0].match(/^\s*env(?:_vars)?\s*=.*$/gm) ?? [];
+    const environment = given.filter((line) => !/^\s*env_vars\s*=/.test(line)).map((line) => `${line.trim()}\n`).join("");
+    const passed = given.filter((line) => /^\s*env_vars\s*=/.test(line)).flatMap((line) => [...line.matchAll(/["']([^"']+)["']/g)].map((name) => name[1] ?? ""));
+    const names = [...new Set(["CHESSPAL_HOME", "CHESSPAL_SEAT", ...passed])].map((name) => JSON.stringify(name)).join(", ");
+    const table = `[mcp_servers.chesspal]\ncommand = ${JSON.stringify(command)}\nargs = [${args.map((arg) => JSON.stringify(arg)).join(", ")}]\n`
+        + `default_tools_approval_mode = "approve"\nenv_vars = [${names}]\n${environment}`;
     const rest = before.replace(ours, "").trim();
     const text = rest === "" ? table : `${rest}\n\n${table}`;
     return text === before ? undefined : { path, text };

package/dist/page/app/anchor.js

@@ -17,16 +17,16 @@ export function anchorName(name) {
 // A game's name without its folder and .pgn, the time it started, as games/archive.ts writes it: the page cannot import that module.
 const stem = /\d{4}-\d{2}-\d{2}-\d{6}/.source;
 /**
- * What the page does with the place the address names: goes to its move on the game shown; drops it while a game goes on; waits while its game opens in
- * analysis, `asked` already; else opens its game in analysis, but the game just played, which opens on the player's yes alone (D-89): the link waits for
- * it while the table is set (D-77), and goes once another game shows (Zoe).
+ * What the page does with the place the address names: goes to its move on the game shown; refuses it while a game goes on; waits while its game opens
+ * in analysis, `asked` already; else opens its game in analysis, but the game just played, which opens on the player's yes alone (D-89): the link waits
+ * for it while the table is set (D-77), and goes once another game shows (Zoe).
  */
 export function anchorAction(wanted, games, asked) {
     if (wanted.game === games.shown) {
         return "view";
     }
     if (games.going) {
-        return "drop";
+        return "refuse";
     }
     if (wanted.game === games.played) {
         return games.shown === undefined ? "wait" : "drop";
@@ -39,16 +39,16 @@ export function shownHash(games, viewing) {
 }
 /**
  * Keeps the move shown in the address, and goes to the place the address names as the page opens or as the player writes it (anchorAction); `open` opens a
- * game in analysis and says whether it did. A link never shows its move on another game.
+ * game in analysis and says whether it did, and `ignored` says why a link was not followed. A link never shows its move on another game.
  */
-export function useAnchor(games, viewing, view, open) {
+export function useAnchor(games, viewing, view, open, ignored) {
     const { ready, shown, played, going } = games;
-    const [wanted, setWanted] = useState(() => anchorOf(location.hash));
+    const [wanted, setWanted] = useState(() => anchorOf(window.location.hash));
     const asked = useRef(undefined);
     useEffect(() => {
         const heard = () => {
             asked.current = undefined;
-            setWanted(anchorOf(location.hash));
+            setWanted(anchorOf(window.location.hash));
         };
         window.addEventListener("hashchange", heard);
         return () => window.removeEventListener("hashchange", heard);
@@ -61,7 +61,10 @@ export function useAnchor(games, viewing, view, open) {
         if (action === "view") {
             view(wanted.plies);
         }
-        if (action === "view" || action === "drop") {
+        if (action === "refuse") {
+            ignored("going");
+        }
+        if (action === "view" || action === "refuse" || action === "drop") {
             setWanted(undefined);
         }
         if (action !== "open") {
@@ -72,6 +75,7 @@ export function useAnchor(games, viewing, view, open) {
         void open(game).then((opened) => {
             // A place written since stays wanted (Federico).
             if (!opened && asked.current === game) {
+                ignored("gone");
                 setWanted(undefined);
             }
         });
@@ -81,8 +85,8 @@ export function useAnchor(games, viewing, view, open) {
             return;
         }
         const hash = shownHash(games, viewing);
-        if (hash !== location.hash) {
-            history.replaceState(history.state, "", hash === "" ? location.pathname + location.search : hash);
+        if (hash !== window.location.hash) {
+            window.history.replaceState(window.history.state, "", hash === "" ? window.location.pathname + window.location.search : hash);
         }
     }, [ready, shown, going, viewing, wanted]);
 }

package/dist/page/app/app.js

@@ -27,6 +27,7 @@ import { FoldTab } from "../layout/fold-tab.js";
 import { nextFold, rememberFold, startFolds } from "../layout/folds.js";
 import { PageFoot } from "../layout/footer.js";
 import { Header } from "../layout/header.js";
+import { LeadChart } from "../lead/lead.js";
 import { standingsOf } from "../lead/view.js";
 import { MarksLegend } from "../legend/legend.js";
 import { legendOf } from "../legend/view.js";
@@ -94,6 +95,20 @@ export function App({ start }) {
     };
     const [selected, setSelected] = useState(undefined);
     const [refusal, setRefusal] = useState(undefined);
+    // A link the page did not follow says why on the board, in the language of the settings the page has by then, until the player's next click or key.
+    const [linkIgnored, setLinkIgnored] = useState(undefined);
+    useEffect(() => {
+        if (linkIgnored === undefined) {
+            return;
+        }
+        const dismiss = () => setLinkIgnored(undefined);
+        window.addEventListener("pointerdown", dismiss, { once: true });
+        window.addEventListener("keydown", dismiss, { once: true });
+        return () => {
+            window.removeEventListener("pointerdown", dismiss);
+            window.removeEventListener("keydown", dismiss);
+        };
+    }, [linkIgnored]);
     // A pawn taken to the last rank waits for the player to choose what it becomes.
     const [promoting, setPromoting] = useState(undefined);
     const [flipped, setFlipped] = useState(false);
@@ -229,7 +244,7 @@ export function App({ start }) {
     // The move shown stays in the page's address, for a reload and a link to it; after the reset on a new game, which would undo the move it goes to. A
     // game a link opens is there to look at: the analyst starts on the player's yes alone (D-89; Zoe and Federico).
     const playedName = game === undefined || game === null ? undefined : anchorName(game.name);
-    useAnchor({ ready: served !== undefined, shown: studied !== undefined ? anchorName(studied.name) : idle ? undefined : playedName, played: playedName, going }, viewing, (plies) => goTo(plies ?? total), async (wanted) => await post("/api/study", { game: wanted, look: true }, text, name) === undefined);
+    useAnchor({ ready: served !== undefined, shown: studied !== undefined ? anchorName(studied.name) : idle ? undefined : playedName, played: playedName, going }, viewing, (plies) => goTo(plies ?? total), async (wanted) => await post("/api/study", { game: wanted, look: true }, text, name) === undefined, setLinkIgnored);
     // The tab names the game and the move shown, as the cards name its players; between games, Chesspal alone.
     const titled = idle || served === undefined ? undefined : studiedSides(live.record.tags, served.profile.name, playedAs, text.sides, served.profile.accounts, othersOf(served.profiles, served.profile.id));
     useTabTitle(titled === undefined ? undefined : tabTitle(titled.white.name, titled.black.name, at === 0 ? undefined : plies[at - 1]));
@@ -255,11 +270,8 @@ export function App({ start }) {
         canOffer: offer === undefined && pending === undefined && live.position.turn !== played.ai && total >= 2,
         onOffer: () => act("/api/draw", { action: "offer" }),
         onAnswer: (accept) => act("/api/draw", { action: accept ? "accept" : "decline" }),
-        onResign: () => {
-            if (confirm(text.resignGame)) {
-                act("/api/resign", {});
-            }
-        },
+        // The header asks first, in its own words (D-65).
+        onResign: () => act("/api/resign", {}),
     };
     const { kind, verdict } = aborted && phase === "over" ? { kind: "over", verdict: text.aborted } : verdictOf(phase, how, winner, offer, declined, text);
     const header = (_jsx(Header, { text: text, kind: kind, verdict: verdict, ...(!ended && (offer === "ai" || declined) ? { who: name } : {}), actions: actions, onNewGame: served === undefined ? undefined : askNewGame, 
@@ -449,9 +461,9 @@ export function App({ start }) {
                             // Between games the board goes off (D-77): a game the page saw end once its effects are over, its final position less off than the table set.
                             class: between && !justEnded ? "board-wrap off" : "board-wrap", onWheel: wheel, 
                             // A press on the board while the player looks back brings the game as it is: the next one plays.
-                            onPointerDownCapture: viewing === undefined || studied !== undefined ? undefined : (event) => event.button === 0 && goTo(total), children: [_jsx(Board, { fen: shown.position.fen, bottom: flipped ? ai : player, lastMove: shown.lastMove, pointed: pointed, ...(helps === undefined ? {} : { helps }), ...(mapping && helps !== undefined ? { control: helps.strategy.control } : {}), bare: bare && helps !== undefined, ...(review?.badge === undefined ? {} : { badge: { badge: review.badge, name: text.badges[review.badge] } }), ...(drawn === undefined ? {} : { drawn }), nextMove: next, jumped: jumped, check: shown.position.check, end: boardEnd, player: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing === undefined ? refusal : undefined, promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleepNote !== null || clockWaits)
+                            onPointerDownCapture: viewing === undefined || studied !== undefined ? undefined : (event) => event.button === 0 && goTo(total), children: [_jsx(Board, { fen: shown.position.fen, bottom: flipped ? ai : player, lastMove: shown.lastMove, pointed: pointed, ...(helps === undefined ? {} : { helps }), ...(mapping && helps !== undefined ? { control: helps.strategy.control } : {}), bare: bare && helps !== undefined, ...(review?.badge === undefined ? {} : { badge: { badge: review.badge, name: text.badges[review.badge] } }), ...(drawn === undefined ? {} : { drawn }), nextMove: next, jumped: jumped, check: shown.position.check, end: boardEnd, player: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing !== undefined ? undefined : refusal ?? (linkIgnored === undefined ? undefined : { text: text.link[linkIgnored] }), promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleepNote !== null || clockWaits)
                                     ? (_jsxs("div", { class: "over-board", children: [asleepNote, startClocks] }))
-                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : {
+                                    : null] }), studied === undefined ? null : (_jsxs("div", { class: "board-steps", children: [_jsx(Steps, { shown: at, total: total, onStep: step, text: text }), standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: at, onShow: goTo, text: text })] })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : {
                                 analysis: {
                                     by: analyst,
                                     ...(summary === undefined ? {} : { summary }),

package/dist/page/app/served.js

@@ -1,6 +1,7 @@
 // What the page asks the server (D-47): the game of the player's folder, read again each time it changes, and the player's moves, words and choices sent
 // there, refused in the player's language.
 import { useEffect, useRef, useState } from "preact/hooks";
+import { watchServed } from "./watch.js";
 /**
  * The game of the player's folder, read from the server, and read again each time the server says it changed, whoever changed it; `onNewGame` when the chat
  * asks for a new game, which the player chooses on the page.
@@ -11,43 +12,29 @@ export function useServed(onNewGame) {
     const [offline, setOffline] = useState(false);
     // Reads the game again: when the server says it changed, and when a clock runs out on the page.
     const reload = useRef(() => { });
+    // The server says when the game changes, whoever changed it: the page reads it again, and as it connects, the first time or to a new chat's server.
+    // The server lives in the chat's MCP server, or the table: when it is gone the page waits for the next one and says so.
     useEffect(() => {
-        let latest = 0;
-        // The Chesspal version of the first answer: a server of another, after an update, sends data this page may not read.
-        let pageVersion;
-        const load = () => {
-            // Two reads in flight may answer out of order: only the last one asked counts.
-            const asked = ++latest;
-            fetch("/api/game")
-                .then((response) => response.json())
-                .then((body) => {
-                if (asked !== latest) {
-                    return;
-                }
-                pageVersion ??= body.version;
-                if (body.version !== undefined && body.version !== pageVersion) {
-                    window.location.reload();
-                    return;
-                }
-                setProblem(body.error);
-                if (body.error === undefined) {
-                    setData(body);
-                }
-            })
-                .catch((error) => setProblem(String(error)));
-        };
-        // The server says when the game changes, whoever changed it: the page reads it again, and as it connects, the first time or to a new chat's server.
-        // The server lives in the chat's MCP server: when the chat ends, after /clear in Claude's app too, the page waits for the next one and says so.
-        reload.current = load;
-        const events = new EventSource("/api/events");
-        events.onopen = () => {
-            setOffline(false);
-            load();
-        };
-        // The chat asks for a new game: the player chooses it in the New game window, which opens here.
-        events.onmessage = (event) => event.data === "new-game" ? onNewGame() : load();
-        events.onerror = () => setOffline(events.readyState !== EventSource.OPEN);
-        return () => events.close();
+        const watch = watchServed({
+            read: () => fetch("/api/game").then((response) => response.json()),
+            connect: (handlers) => {
+                const events = new EventSource("/api/events");
+                events.onopen = handlers.open;
+                events.onmessage = (event) => handlers.message(event.data);
+                events.onerror = handlers.error;
+                return events;
+            },
+            later: (run, wait) => window.setTimeout(run, wait),
+            cancel: (timer) => window.clearTimeout(timer),
+        }, {
+            read: setData,
+            problem: setProblem,
+            offline: setOffline,
+            newGame: onNewGame,
+            otherVersion: () => window.location.reload(),
+        });
+        reload.current = watch.reload;
+        return watch.stop;
     }, []);
     return { data, problem, offline, reload: () => reload.current() };
 }

package/dist/page/app/watch.js

@@ -0,0 +1,97 @@
+// How the page follows the server's game: it reads it when the server says it changed, tries a read lost on the way again, and connects again when the
+// browser gives the server up for good, as when an old table hands the page to the new one. Without Preact, so that a test drives it with fake timers.
+/** How many times, and how far apart in milliseconds, a read lost on the way is tried again; how long before a stream given up is opened again. */
+export const readTries = 5;
+export const readTryWait = 1000;
+export const reconnectWait = 3000;
+/** Follows the server's game: the first read when the events connect, another at each change, until `stop`. */
+export function watchServed(tools, listener) {
+    let latest = 0;
+    // The Chesspal version of the first answer: a server of another, after an update, sends data this page may not read.
+    let pageVersion;
+    // The reads of the game asked last that failed, and the next try.
+    let failures = 0;
+    let retry;
+    let reconnect;
+    let stopped = false;
+    // Whether the page shows a game: then a read that fails leaves it shown, offline, rather than replacing it with the error.
+    let shown = false;
+    let events = open();
+    function load(again = false) {
+        tools.cancel(retry);
+        failures = again ? failures : 0;
+        // Two reads in flight may answer out of order: only the last one asked counts.
+        const asked = ++latest;
+        tools.read()
+            .then((body) => {
+            if (asked !== latest || stopped) {
+                return;
+            }
+            pageVersion ??= body.version;
+            if (body.version !== undefined && body.version !== pageVersion) {
+                listener.otherVersion();
+                return;
+            }
+            listener.problem(body.error);
+            if (body.error === undefined) {
+                shown = true;
+                listener.offline(false);
+                listener.read(body);
+            }
+        })
+            .catch((error) => {
+            if (asked !== latest || stopped) {
+                return;
+            }
+            // With the server gone the page waits for it and says so: connecting again reads the game.
+            if (events.readyState !== streamOpen) {
+                listener.offline(true);
+                return;
+            }
+            // A read lost on the way while the server is there is tried again shortly.
+            if (++failures <= readTries) {
+                retry = tools.later(() => load(true), readTryWait);
+                return;
+            }
+            if (shown) {
+                listener.offline(true);
+            }
+            else {
+                listener.problem(String(error));
+            }
+        });
+    }
+    function open() {
+        const stream = tools.connect({
+            open: () => {
+                listener.offline(false);
+                load();
+            },
+            // The chat asks for a new game: the player chooses it in the New game window.
+            message: (data) => data === "new-game" ? listener.newGame() : load(),
+            // The browser connects again by itself, but not after a server that answered with an error: then the page does, a little later.
+            error: () => {
+                listener.offline(stream.readyState !== streamOpen);
+                if (stream.readyState === streamClosed && !stopped) {
+                    tools.cancel(reconnect);
+                    reconnect = tools.later(() => {
+                        events = open();
+                    }, reconnectWait);
+                }
+            },
+        });
+        return stream;
+    }
+    return {
+        reload: () => load(),
+        stop: () => {
+            stopped = true;
+            tools.cancel(retry);
+            tools.cancel(reconnect);
+            events.close();
+        },
+    };
+}
+// EventSource's states, which a test's fake stream has no class for.
+const streamOpen = 1;
+const streamClosed = 2;