chesspal 0.3.5 → 0.4.0

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

@@ -2,7 +2,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { makeFolder, writeAtomically } from "../games/index.js";
-import { agentFiles, instructionsFile } from "./agents.js";
+import { agentFiles, agentHosts, instructionsFile } from "./agents.js";
 /**
  * Sets up the player's folder for Claude Code and Codex (D-31): .mcp.json with the chesspal server, AGENTS.md with the lines that start a chat between
  * Chesspal's marks (D-102), CLAUDE.md importing it, the hosts' settings with the server approved, and their hooks. What the player wrote there stays; it returns
@@ -31,6 +31,13 @@ export function outdatedHostFiles(folder, platform) {
 export function codexHooksPath(folder) {
     return join(folder, ".codex", "hooks.json");
 }
+/**
+ * Whether the host runs the doorbell's hook init writes, Claude Code and Codex by the names they give the server, so the player's act on the page wakes
+ * the chat; the command line, which names no host, is taken as one. Elsewhere the player tells the chat in its window.
+ */
+export function hasDoorbell(host) {
+    return host === undefined || agentHosts.includes(host);
+}
 /** The instructions of the AI opponent, read from the package wherever it is installed: the MCP server's `instructions` tool gives them (D-102). */
 export function opponentInstructions() {
     return instructionsFile("opponent");
@@ -88,8 +95,8 @@ function claudeFile(folder) {
     return before.split(/\r?\n/).some((line) => line.trim() === "@AGENTS.md") ? undefined : { path, text: `@AGENTS.md\n${before}` };
 }
 /**
- * Claude Code's settings: the chesspal server of .mcp.json approved and its tools allowed, so that the first chat asks for neither, and the doorbell of the
- * moves on the page (D-47), and the note of how each chat starts (D-57); the player's own stay.
+ * Claude Code's settings: the chesspal server of .mcp.json approved and its tools allowed, so that the first chat asks for neither, the doorbell of the
+ * moves on the page (D-47), the note of how each chat starts (D-57), and the move the player writes alone in the chat (D-36); the player's own stay.
  */
 function claudeSettingsFile(folder) {
     const path = join(folder, ".claude", "settings.json");
@@ -100,7 +107,7 @@ function claudeSettingsFile(folder) {
         ...settings,
         enabledMcpjsonServers: withItem(settings.enabledMcpjsonServers, "chesspal"),
         permissions: { ...permissions, allow: withItem(permissions.allow, "mcp__chesspal") },
-        hooks: withHook(withHook(hooks, "Stop", bellHook), "SessionStart", chatHook),
+        hooks: withHook(withHook(withHook(hooks, "Stop", bellHook), "SessionStart", chatHook), "UserPromptSubmit", promptHook),
     });
 }
 /** The hooks with one of Chesspal's put back beside the player's own whenever it is missing; an event of theirs that is no list stays theirs. */
@@ -118,9 +125,12 @@ function withHook(hooks, event, ours) {
 const bellHook = { type: "command", command: "chesspal listen", asyncRewake: true, timeout: 86_400 };
 // Claude Code's SessionStart hook (D-57): it notes how each chat starts, so that a new game waits for a clean one.
 const chatHook = { type: "command", command: "chesspal chat" };
+// Claude Code's UserPromptSubmit hook (D-36): a message that is one move and nothing else is played before the AI reads it, which then only replies.
+const promptHook = { type: "command", command: "chesspal prompt", timeout: 10 };
 /**
  * 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 +138,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/host-files/index.d.ts

@@ -1,2 +1,2 @@
 export { agentHosts, agentTools, analystAgent, coachAgent, hasAgent, instructionsFile, isCodex, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.ts";
-export { codexHooksPath, opponentInstructions, outdatedHostFiles, setUpHosts, startInstructions } from "./host-files.ts";
+export { codexHooksPath, hasDoorbell, opponentInstructions, outdatedHostFiles, setUpHosts, startInstructions } from "./host-files.ts";

package/dist/host-files/index.js

@@ -1,3 +1,3 @@
 // The files through which an AI host finds Chesspal in the player's folder: the server, the opponent's instructions, the hosts' settings.
 export { agentHosts, agentTools, analystAgent, coachAgent, hasAgent, instructionsFile, isCodex, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.js";
-export { codexHooksPath, opponentInstructions, outdatedHostFiles, setUpHosts, startInstructions } from "./host-files.js";
+export { codexHooksPath, hasDoorbell, opponentInstructions, outdatedHostFiles, setUpHosts, startInstructions } from "./host-files.js";

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useEffect, useMemo, useRef, useState } from "preact/hooks";
-import { aiHostIn, aiModelIn, aiNameOf, annotatorOf, closingOf, Game, gameReviewOf, materialOf, moodAt, movesOnly, openingOf, readPgn, suggestedLevel, timeControlText, writePgn, } from "../../core/index.js";
+import { aiHostIn, aiModelIn, aiNameOf, annotatorOf, closingOf, Game, gameReviewOf, materialOf, moodAt, movesOnly, openingOf, outOfBookMove, readPgn, suggestedLevel, timeControlText, writePgn, } from "../../core/index.js";
 import { PlayerPicture } from "../avatars/avatars.js";
 import { Thinker, Thought } from "../avatars/thought.js";
 import { Torretta } from "../avatars/torretta.js";
@@ -19,7 +19,7 @@ import { GameColumn } from "../game/column.js";
 import { howEnded, useDeclined, useJustEnded, useSawEnd } from "../game/ending.js";
 import { Steps } from "../game/move-list.js";
 import { useOpeningBook } from "../game/opening-book.js";
-import { aiSpoke, aiWords, analysisTalk, judgmentsOf, playerSpent, playerWords, pliesOf, withBook, withJudgments, withoutReviews } from "../game/plies.js";
+import { aiSpoke, aiWords, analysisTalk, judgmentsOf, playerSpent, playerWords, pliesOf, reviewCount, withBook, withJudgments, withoutReviews } from "../game/plies.js";
 import { GuideDialog } from "../guide/guide.js";
 import { BareButton, HelpsCard, HintLine, MapButton } from "../helps/helps.js";
 import { helpsOf } from "../helps/view.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";
@@ -43,7 +44,7 @@ import { textFor } from "../text.js";
 import { anchorName, useAnchor } from "./anchor.js";
 import { useBrowseKeys, useFoldKeys, useLegendKey, useMapKey, useWheelSteps } from "./keys.js";
 import { phaseOf, verdictOf } from "./phase.js";
-import { ask, post, sendMessage, sendMove, useServed } from "./served.js";
+import { ask, post, refusedText, sendMessage, sendMove, useServed } from "./served.js";
 import { tabTitle, useTabTitle } from "./title.js";
 /**
  * The page: the board of the game in the player's folder, where the player moves on their turn, the talk with the AI beside it, and the game's column; in the
@@ -54,6 +55,8 @@ export function App({ start }) {
     const [setting, setSetting] = useState(false);
     const text = useMemo(() => textFor(languagesOf(settings)), [settings.language]);
     const sound = settings.sound;
+    // The sounds off hush the voice too: it is one of them.
+    const voiced = settings.voice && sound;
     useEffect(() => void (document.documentElement.lang = text.language), [text]);
     const apply = (next) => {
         setSettings(next);
@@ -94,6 +97,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);
@@ -117,6 +134,20 @@ export function App({ start }) {
     const name = served?.opponent ?? text.ai;
     // Under it, the model and effort the AI played its last move with (D-82).
     const signed = served?.aiModel === undefined ? undefined : signature(served.aiModel.model, served.aiModel.effort);
+    // A new game that waited for the chat and could not start says why on the board, as one refused at once (D-107): once, and never one from before the
+    // page loaded.
+    const waitRefused = served?.table?.refused;
+    const waitRefusedSeen = useRef(undefined);
+    useEffect(() => {
+        if (served === undefined) {
+            return;
+        }
+        const number = waitRefused?.number ?? 0;
+        if (waitRefused !== undefined && waitRefusedSeen.current !== undefined && number > waitRefusedSeen.current) {
+            setRefusal({ text: refusedText(waitRefused, text, name) ?? "" });
+        }
+        waitRefusedSeen.current = number;
+    }, [served === undefined, waitRefused?.number]);
     // The game is replayed from its PGN once for each one the server sends, not at every click. Once no game goes on, the game in analysis shows in its place
     // (D-69), with the AI's badges and notes: replayed again only when its review changed.
     const game = served?.game;
@@ -138,8 +169,10 @@ export function App({ start }) {
     const analyst = annotator === undefined ? name : aiNameOf(annotator.annotator, annotator.annotator) ?? text.ai;
     const material = useMemo(() => materialOf(live.position.fen), [live]);
     const pieces = useMemo(() => piecesOf(live.position.fen), [live]);
+    // How many of the game's first plies a line of the book reaches, as the server counts them (D-68).
+    const bookPlies = studied !== undefined ? studied.book : game?.book ?? 0;
     // While the game goes on, the book's first moves carry its badge, when the player wants it, as the AI's review gives it after (D-69).
-    const inBook = studied === undefined && settings.book ? game?.book ?? 0 : 0;
+    const inBook = studied === undefined && settings.book ? bookPlies : 0;
     // The judgments of the player's moves, and the AI's drawings, show during a game only with the helps on, always once it is over (D-78); during it the
     // coach's come from its own file, never in the PGN the opponent may read (D-88).
     const judged = !going || settings.helps;
@@ -215,6 +248,8 @@ export function App({ start }) {
     // In analysis, the opening the move shown has reached, while the book knows the moves (D-69).
     const bookAt = studied === undefined || book === undefined || at === 0 || at > studied.book ? undefined : { tags: live.record.tags, moves: live.record.moves.slice(0, at) };
     const shownOpening = useMemo(() => bookAt === undefined || book === undefined ? undefined : openingOf(bookAt, book), [live, book, bookAt === undefined ? 0 : at]);
+    // Whether the move shown is still the book's, whatever the badges show: the card says the move the game left it at, once it is past it.
+    const leftBook = outOfBookMove(at, bookPlies);
     // A jump of more than one move shows the position at once: only a step slides its pieces.
     const shownBefore = useRef(at);
     const jumped = Math.abs(shownBefore.current - at) > 1;
@@ -229,7 +264,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 +290,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, 
@@ -316,6 +348,8 @@ export function App({ start }) {
     // With nobody at it, a review not finished says so, and the player brings the game back to the AI (D-109).
     const completeIt = summary === undefined && studied?.incomplete === true && !offline ? () => void studyGame({ game: studied.name }) : undefined;
     const closing = studied === undefined ? undefined : closingOf(live.record);
+    // How far the review has got, counted as status counts it for the AI: who is ahead after how many of the game's moves.
+    const count = reviewing || completeIt !== undefined ? reviewCount(plies) : undefined;
     // In analysis the AI's card says who played that game, as its PGN keeps it (D-82), not who plays now.
     const playedBy = studied === undefined ? undefined : aiModelIn(live.record);
     const talk = game?.talk ?? served.talk ?? [];
@@ -436,11 +470,11 @@ export function App({ start }) {
                         : null, _jsxs("main", { class: `app${flipped ? " flipped" : ""}${folds.talk === "open" ? "" : ` talk-${folds.talk}`}${folds.game === "folded" ? " folded" : ""}`, inert: offline, children: [header, sides === undefined
                             ? (_jsx(TalkFaces, { name: name, aiPicture: thinker(40), you: profile.name, picture: picture, ...(idle ? {} : { ai, player }), aiMoves: going && !playerToMove, playerMoves: playerToMove, unread: unread || asleep, text: text }))
                             : (_jsx(TalkFaces, { name: sides[ai].name, aiPicture: pictureOf(sides[ai], profile, served.profiles, 40, mood), you: sides[player].name, picture: pictureOf(sides[player], profile, served.profiles, 40, mood), ai: ai, player: player, aiMoves: false, playerMoves: false, unread: asleep, text: text })), _jsx(FoldTab, { column: "talk", folded: folds.talk === "folded", label: thinking === undefined || folds.talk !== "folded" ? text.talk : `${text.talk}: ${text.thinking[thinking]}`, unread: (unread || asleep) && folds.talk === "folded", ...(thinking === undefined || folds.talk !== "folded" ? {} : { mark: _jsx(Thought, { thinking: thinking, words: text.thinking }) }), onFold: fold }), _jsx(FoldTab, { column: "game", folded: folds.game === "folded", label: text.game, onFold: fold }), _jsx("span", { class: "visually-hidden", "aria-live": "polite", children: unread ? text.wrote(name) : "" }), _jsx("div", { class: sides === undefined ? "talk" : "talk studied", id: "talk", children: sides !== undefined && studied !== undefined
-                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(reviewing ? { reviewing: true } : {}), ...(completeIt === undefined ? {} : { onComplete: completeIt }), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
+                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(reviewing ? { reviewing: true } : {}), ...(count === undefined ? {} : { count }), ...(completeIt === undefined ? {} : { onComplete: completeIt }), name: analyst, by: annotator, mood: mood, ...(voiced ? { voice: text } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
                                                             setDraft(words);
                                                             setUnsent(undefined);
                                                         }, onSend: () => sendWords({ game: studied.name, at }), canMove: false, name: name, problem: unsent, about: { ...(at === 0 ? {} : { ply: plies[at - 1] }), onShow: goTo }, text: text }) }), studiedCard(player, "you")] })] }))
-                                : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: table === undefined ? name : _jsx(AiNameButton, { name: name, table: table, onOpen: askChat, text: text }), signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
+                                : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: table === undefined ? name : _jsx(AiNameButton, { name: name, table: table, onOpen: askChat, text: text }), signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(voiced ? { voice: text } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
                                                     // Between games, and before the first, the player writes freely, a line at a time, as the AI does (D-74, D-77).
                                                     spent: going ? playerSpent(plies, ai, talk) : 0, draft: draft, onDraft: (words) => {
                                                         setDraft(words);
@@ -449,13 +483,14 @@ 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, ...(leftBook === undefined ? {} : { outOfBook: leftBook }), 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 }),
                                     ...(reviewing ? { reviewing: true } : {}),
+                                    ...(count === undefined ? {} : { count }),
                                     ...(completeIt === undefined ? {} : { onComplete: completeIt }),
                                 },
                             }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null && replayed.record.moves.length > 0 ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text }), _jsx(PageFoot, { version: served.version, text: text })] })] }) }));

package/dist/page/app/served.js

@@ -1,6 +1,8 @@
 // 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 { closesForNewer, eventsAddress } from "../layout/window.js";
+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 +13,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(eventsAddress());
+                events.onopen = handlers.open;
+                events.onmessage = (event) => closesForNewer(event.data) || 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() };
 }
@@ -67,13 +55,17 @@ export async function ask(path, body, text, name) {
             return { answer: await response.json().catch(() => ({})) };
         }
         const refused = (await response.json());
-        const known = refused.refusal === undefined ? undefined : text.refused[refused.refusal];
-        return { refused: { text: known?.(refused.most ?? 0, name) ?? refused.error ?? response.statusText, words: refused.refusal?.startsWith("words-") === true } };
+        return { refused: { text: refusedText(refused, text, name) ?? response.statusText, words: refused.refusal?.startsWith("words-") === true } };
     }
     catch (error) {
         return { refused: { text: String(error), words: false } };
     }
 }
+/** A refusal of the server's in the player's language when the page knows its code, with the host's name where it sends the player; else its words. */
+export function refusedText(refused, text, name) {
+    const known = refused.refusal === undefined ? undefined : text.refused[refused.refusal];
+    return known?.(refused.most ?? 0, name) ?? refused.error;
+}
 /** Sends the player's move to the server, which plays it as the chat would, with the words written for the AI: the reason it was refused, or undefined. */
 export function sendMove(move, words, text, name) {
     const message = words.trim();

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;

package/dist/page/avatars/torretta.css

@@ -0,0 +1,108 @@
+/* The Torretta, whose eyes blink now and then, and its moods (D-70): a new face that pops in, never fading out, a red light when worried, out when sad, a light that breathes when
+   thoughtful */
+.torretta .antenna {
+    fill: none;
+    stroke: var(--torretta-shade);
+    stroke-width: 4;
+    stroke-linecap: round;
+}
+
+.torretta .light {
+    fill: var(--torretta-light);
+    transition: fill 200ms;
+}
+
+.torretta.mood-worried .light {
+    fill: var(--torretta-alarm);
+}
+
+.torretta.mood-thoughtful .light {
+    animation: ponder 2400ms ease-in-out infinite;
+}
+
+.torretta.mood-sad .light {
+    fill: var(--torretta-shade);
+}
+
+@keyframes ponder {
+    50% {
+        fill: var(--torretta-ponder);
+    }
+}
+
+.torretta .expression.changed {
+    transform-box: fill-box;
+    transform-origin: center;
+    animation: face-in 160ms ease-out;
+}
+
+@keyframes face-in {
+    from {
+        transform: scale(0.8);
+    }
+}
+
+/* Its bust on a player's card: a disc of the player's picture's colour, which cuts what falls out of it */
+.torretta.bust {
+    clip-path: circle(50%);
+}
+
+.torretta .back {
+    fill: var(--say);
+}
+
+.torretta .shade {
+    fill: var(--torretta-shade);
+}
+
+.torretta .body {
+    fill: var(--torretta-body);
+}
+
+.torretta .screen {
+    fill: var(--torretta-screen);
+}
+
+.torretta .eyes,
+.torretta .mouth {
+    fill: var(--torretta-face);
+}
+
+.torretta .expression .line,
+.torretta .brows {
+    fill: none;
+    stroke: var(--torretta-face);
+    stroke-width: 3.4;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+}
+
+.torretta .eyes {
+    transform-box: fill-box;
+    transform-origin: center;
+    animation: blink 6000ms infinite;
+}
+
+@keyframes blink {
+    0%,
+    95%,
+    100% {
+        transform: scaleY(1);
+    }
+
+    97% {
+        transform: scaleY(0.1);
+    }
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .torretta .eyes,
+    .torretta .expression.changed,
+    .torretta.mood-thoughtful .light {
+        animation: none;
+    }
+
+    .torretta .light {
+        transition: none;
+    }
+}