chesspal 0.3.5 → 0.4.0

package/dist/server/bell/bell.js

@@ -1,13 +1,11 @@
 // The doorbell for the page (D-47): `chesspal listen`, the Stop hook init writes for Claude Code and Codex, waits at the page of its chat and, when
 // the player moves or writes there, tells the chat to call status. It never carries the move, the words or the position: status reads them fresh.
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-import { get } from "node:http";
-import { join, resolve } from "node:path";
-import { writeAtomically } from "../../games/index.js";
-import { dataFolder, tableFolder } from "../../home/index.js";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { positionShownNote, writeAtomically } from "../../games/index.js";
+import { samePath } from "../../home/index.js";
 import { analystAgent } from "../../host-files/index.js";
-import { version } from "../../version.js";
+import { askPage, chatFolder, findChatPage, notedFolder, notedPagePorts, pageNote, probeOf, probeWait } from "../ports/index.js";
 /** What the chat hears from the doorbell: one line for whatever the player did, never what, only where to read it. */
 export const bellLine = "The player acted on the board page: call status to see it.";
 /**
@@ -17,10 +15,13 @@ export const bellLine = "The player acted on the board page: call status to see
 export class Bell {
     listener;
     pending = false;
-    // The chat is in a turn: it called a tool, or a hook woke it, and its turn has not ended yet. A chat never started, or just cleared, is not.
+    // The chat is in a turn: the player's message started it, it called a tool, or a hook woke it, and its turn has not ended yet. A chat never started,
+    // or just cleared, is not.
     busy = false;
     // The doorbell woke the chat in this turn: the player acted on the page, and the chat goes to see it.
     woken = false;
+    // A hook has waited for the bell since the chat came: its host runs Chesspal's hooks, and only they tell where a turn ends.
+    hooked = false;
     news;
     changed;
     /**
@@ -50,10 +51,31 @@ export class Bell {
         this.tellIf(asleep);
         return asleep;
     }
-    /** The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. */
-    ring() {
+    /**
+     * The player's message, or one the host sent for the doorbell or an agent, starts the chat's turn, as the prompt hook says: the hook of the turn
+     * before is let go without a ring, and what the player does on the page meanwhile waits for the turn's end, as during a tool. A chat nobody heard
+     * stays unheard until its first tool, which starts the AI's clock, held till then: the message moves no clock.
+     */
+    chatPrompted() {
+        if (this.listener === undefined) {
+            return;
+        }
+        this.listener.end("dismissed");
+        this.listener = undefined;
+        this.busy = true;
+        this.changed();
+    }
+    /**
+     * The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. In a host that runs no hook nothing tells the end of
+     * a turn: an act the chat waits for finds it out of its turn, and nobody hears the player, unless the chat `mayBeAtWork` on the AI's move meanwhile.
+     */
+    ring(mayBeAtWork = false) {
         if (this.listener === undefined) {
             this.pending = true;
+            if (!this.hooked && !mayBeAtWork && this.busy) {
+                this.busy = false;
+                this.changed();
+            }
             return;
         }
         this.listener.end("ring");
@@ -62,10 +84,14 @@ export class Bell {
         this.woken = true;
         this.changed();
     }
-    /** A hook waits for the bell, so the chat's turn has ended; the hook before it, of a turn already ended, is let go. */
-    listen(request, response) {
+    /**
+     * A hook waits for the bell, so the chat's turn has ended; the hook before it, of a turn already ended, is let go. A ring no hook heard is dropped when
+     * the chat is `told` all of it otherwise: by the player's message that came with the move the prompt hook played.
+     */
+    listen(request, response, told = false) {
         response.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
-        const missed = this.pending;
+        this.hooked = true;
+        const missed = this.pending && !told;
         this.pending = false;
         if (missed && this.news()) {
             response.end("ring");
@@ -89,6 +115,7 @@ export class Bell {
     }
     /** The chat left the table (D-104): its process ended, and nobody is in a turn or waits for the bell; a ring no hook heard is no longer news for anyone. */
     chatLeft() {
+        this.hooked = false;
         this.busy = false;
         this.woken = false;
         this.pending = false;
@@ -103,21 +130,27 @@ export class Bell {
     }
 }
 /**
- * Whose page answers at a port, for the hook to find its own: the chat's session, the player's folder, whether a browser has the page open, Chesspal's
- * version, and whether the table serves it (D-104), with the session and the folder of the chat attached to it, never its own process's.
+ * Notes in the data folder the port a chat's page took off its folder's usual ports, one file per page, for the hook to find it there; then forgets, off
+ * the caller's clock, the notes of its folder whose page is gone: nobody listens at the port, or another folder's page does. A page that answers late
+ * is busy, not gone, and keeps its note. It throws when the note cannot be written.
  */
-export function bellProbe(folder, open = false, table) {
-    const session = table === undefined ? process.env.CLAUDE_CODE_SESSION_ID ?? null : table.session;
-    return { session, folder: resolve(folder), open, version, ...(table === undefined ? {} : { table: true, ...(table.chat === undefined ? {} : { chat: table.chat }) }) };
-}
-/** What the page at a port of this computer says of itself; undefined when none answers there. */
-export async function pageAt(port) {
-    return probeOf(await body(port, "/api/bell?probe", probeWait));
+export function notePagePort(home, folder, port, wait = probeWait) {
+    const note = pageNote(home, port);
+    mkdirSync(dirname(note), { recursive: true });
+    writeAtomically(note, JSON.stringify({ folder: resolve(folder) }));
+    return forgetGonePages(home, folder, port, wait);
 }
-/** The ports a folder's page tries first: one in each of a few ranges, by its path, since Windows may reserve a range. The hook looks for it there. */
-export function pagePorts(folder) {
-    const offset = createHash("sha256").update(resolve(folder).toLowerCase()).digest()[0] % 10;
-    return [5870, 6870, 7870].map((base) => base + offset);
+/** Forgets the note of a page that closes, unless another folder's page took its port since; a note that cannot go is left for the next page to clear. */
+export function forgetPagePort(home, folder, port) {
+    const noted = notedFolder(home, port);
+    if (noted !== undefined && samePath(noted, folder)) {
+        try {
+            rmSync(pageNote(home, port), { force: true });
+        }
+        catch {
+            // The next page of the folder clears it.
+        }
+    }
 }
 /** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
 export const codexBellAnswer = JSON.stringify({ decision: "block", reason: bellLine });
@@ -159,68 +192,32 @@ export async function waitForBell(input, ports) {
  */
 export async function bellHeard(input, ports) {
     const hook = hookInput(input);
-    const folder = chatFolder(hook);
-    const tried = ports ?? pagePorts(folder);
-    const [probes, table] = await Promise.all([Promise.all(tried.map(async (port) => ({ port, said: await pageAt(port) }))), ports === undefined ? tableOf(folder, hook.session) : undefined]);
-    const pages = probes.flatMap(({ port, said }) => (said !== undefined && samePath(said.folder, folder) ? [{ port, said }] : []));
-    // A chat opened in the table's own folder finds the table among the pages of its folder already.
-    const ours = table === undefined || pages.some(({ port }) => port === table.port) ? pages : [...pages, table];
-    const port = chatPage(ours, hook.session)?.port;
+    const found = await findChatPage(hook, ports);
+    const { folder, port } = found;
     if (port === undefined) {
-        const others = probes.flatMap((one) => (one.said === undefined ? [] : [`${one.port} is ${one.said.folder}'s`]));
-        const open = ours.filter(({ said }) => said.open).length;
-        const pages = ours.length > 1 ? `${ours.length} pages of it, none of this chat's session, ${open} open in a browser` : "no page of it";
-        return { folder, rang: false, why: `${pages} at ports ${tried.join(", ")}${others.length > 0 ? `; ${others.join(", ")}` : ""}` };
+        return { folder, rang: false, why: found.why };
     }
-    // The page lets the analyst go as the hook starts waiting, when none runs any more.
-    const said = await body(port, hook.analystGone === true ? "/api/bell?analyst=gone" : "/api/bell");
+    // The page lets the analyst go as the hook starts waiting, when none runs any more; and it rings for nothing older than the move the prompt hook played
+    // for this chat, which hears it from the player's message itself.
+    const shown = hook.session === undefined ? undefined : positionShownNote(folder);
+    const told = shown !== undefined && shown.session === hook.session ? shown.stamp : undefined;
+    const query = new URLSearchParams({ ...(hook.analystGone === true ? { analyst: "gone" } : {}), ...(told === undefined ? {} : { shown: told }) });
+    const said = (await askPage(port, `/api/bell${query.size === 0 ? "" : `?${query}`}`)).text;
     return said === "ring" ? { folder, rang: true } : { folder, rang: false, why: said === undefined ? `the page at port ${port} did not answer` : `the page at port ${port} said "${said}"` };
 }
-// How long a port may take to say whose page it is: one of this computer answers at once.
-const probeWait = 1000;
 /**
- * The table, when the chat attached to it is the hook's: of its folder, or of its session; none when the data folder cannot be found, or no table has
- * this chat. Finding the data folder costs some tens of milliseconds on Windows, off the AI's clock: the hook waits after the turn.
+ * Forgets the notes of a folder's pages that are gone, but the one at `kept`: a page closed without forgetting its own, when nobody listens at its port or
+ * another folder's page took it. A page that does not answer in time, or not as a page, may only be busy, and its note stays.
  */
-async function tableOf(folder, session) {
-    let ports;
-    try {
-        ports = pagePorts(tableFolder(serverHome(folder) ?? dataFolder()));
-    }
-    catch {
-        return undefined;
-    }
-    const probes = await Promise.all(ports.map(async (port) => ({ port, said: await pageAt(port) })));
-    return probes.find((one) => one.said?.table === true && ((one.said.chat !== undefined && samePath(one.said.chat, folder)) || (session !== undefined && one.said.session === session)));
-}
-/**
- * The data folder the chat's server is given in its folder's settings, as CHESSPAL_HOME in a playtest: the hook runs in the host's environment, not the
- * server's (Federico). Claude Code's .mcp.json first, then Codex's config.
- */
-function serverHome(folder) {
-    const chosen = [claudeHome(folder), codexHome(folder)].find((one) => one !== undefined && one.trim() !== "");
-    return chosen === undefined ? undefined : resolve(chosen.trim());
-}
-function claudeHome(folder) {
-    try {
-        const config = JSON.parse(readFileSync(join(folder, ".mcp.json"), "utf8"));
-        const home = config.mcpServers?.chesspal?.env?.CHESSPAL_HOME;
-        return typeof home === "string" ? home : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-// The setting as init keeps it in Codex's table: a basic string, whose escapes are JSON's for a path, or a literal one.
-function codexHome(folder) {
-    try {
-        const config = readFileSync(join(folder, ".codex", "config.toml"), "utf8");
-        const [, basic, literal] = /\bCHESSPAL_HOME\s*=\s*(?:("(?:[^"\\]|\\.)*")|'([^']*)')/.exec(config) ?? [];
-        return basic === undefined ? literal : JSON.parse(basic);
-    }
-    catch {
-        return undefined;
-    }
+async function forgetGonePages(home, folder, kept, wait) {
+    const others = notedPagePorts(home, folder).filter((port) => port !== kept);
+    await Promise.all(others.map(async (port) => {
+        const { refused, text } = await askPage(port, "/api/bell?probe", wait);
+        const said = probeOf(text);
+        if (refused || (said !== undefined && !samePath(said.folder, folder))) {
+            forgetPagePort(home, folder, port);
+        }
+    }));
 }
 // The log of Codex's hooks that heard no bell, in the chat's folder: its last lines only.
 const silenceLog = "listen.log";
@@ -236,10 +233,6 @@ export function noteSilence(folder, why, now = new Date()) {
         // The log only explains; the hook ends the same.
     }
 }
-/** The chat's folder, where its server started: Claude Code names it, and the hook's cwd follows the cd's of the chat. */
-function chatFolder(hook) {
-    return resolve(process.env.CLAUDE_PROJECT_DIR ?? hook.cwd ?? process.cwd());
-}
 function hookInput(input) {
     try {
         const parsed = JSON.parse(input);
@@ -263,50 +256,3 @@ function analystGone(tasks) {
         return agent === analystAgent && status === "running";
     });
 }
-/**
- * The chat's page among those of its folder: the one of its session; else the only one, or the only one a browser has open, where the player plays. Codex
- * gives the page no session, and a chat closed may leave its page behind for a while.
- */
-function chatPage(pages, session) {
-    const open = pages.filter(({ said }) => said.open);
-    return pages.find(({ said }) => session !== undefined && said.session === session) ?? (pages.length === 1 ? pages[0] : open.length === 1 ? open[0] : undefined);
-}
-function probeOf(said) {
-    try {
-        const parsed = said === undefined ? undefined : JSON.parse(said);
-        return parsed === undefined || typeof parsed.folder !== "string" ? undefined : {
-            session: typeof parsed.session === "string" ? parsed.session : null,
-            folder: parsed.folder,
-            open: parsed.open === true,
-            ...(typeof parsed.version === "string" ? { version: parsed.version } : {}),
-            ...(parsed.table === true ? { table: true } : {}),
-            ...(typeof parsed.chat === "string" ? { chat: parsed.chat } : {}),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-/** 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);
-}
-/** The body a page of this computer answers with, once it ends; undefined when it does not answer, or not with 200. */
-function body(port, path, wait) {
-    return new Promise((done) => {
-        // A connection of its own: Node's shared one ends a request idle for five seconds, and the doorbell waits for hours.
-        const request = get({ host: "127.0.0.1", port, path, agent: false, ...(wait === undefined ? {} : { timeout: wait }) }, (response) => {
-            let text = "";
-            response.setEncoding("utf8");
-            response.on("data", (chunk) => {
-                text += chunk;
-            });
-            response.on("end", () => done(response.statusCode === 200 ? text : undefined));
-            response.on("error", () => done(undefined));
-        });
-        if (wait !== undefined) {
-            request.on("timeout", () => request.destroy());
-        }
-        request.on("error", () => done(undefined));
-    });
-}

package/dist/server/bell/index.d.ts

@@ -1 +1 @@
-export { Bell, bellProbe, listen, pageAt, pagePorts, samePath, type TableChat } from "./bell.ts";
+export { Bell, forgetPagePort, listen, notePagePort } from "./bell.ts";

package/dist/server/bell/index.js

@@ -1,2 +1,2 @@
-// The doorbell that wakes a chat when the player acts on the page (D-47), and the ports where a folder's page answers.
-export { Bell, bellProbe, listen, pageAt, pagePorts, samePath } from "./bell.js";
+// The doorbell that wakes a chat when the player acts on the page (D-47), and the notes of the ports a folder's page took off its usual ones.
+export { Bell, forgetPagePort, listen, notePagePort } from "./bell.js";

package/dist/server/mcp/mcp.js

@@ -3,13 +3,12 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { aiMove, commands, defaultContext, inputProblems, isBoolean, PositionChanged } from "../../commands/index.js";
+import { aiMove, commands, defaultContext, homeForOneCall, inputProblems, isBoolean, PositionChanged, positionIn, samePosition } from "../../commands/index.js";
 import { aiNameOf } from "../../core/index.js";
-import { endOf, loadGame, noteAiHost, noteAiModel, rerunIfChanged } from "../../games/index.js";
+import { endOf, forgetPositionShown, hostProcess, lastChatStart, loadGame, noteAiHost, noteAiModel, positionShownNote, rerunIfChanged } from "../../games/index.js";
 import { agentTools, hasAgent, startInstructions } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { version } from "../../version.js";
-import { pagePorts } from "../bell/index.js";
 import { chatHasRead, startPage } from "../page/index.js";
 import { attachTable, tableToJoin } from "../table/index.js";
 import { allowedCaller, callerOf, callingAgent, fromCodexAgent } from "./caller.js";
@@ -108,8 +107,8 @@ async function pageOf(context, opponent, again) {
         context.toolEnded = table === undefined ? lookForTable(context, again) : page.toolEnded;
         context.pageOpen = page.open;
         context.askNewGame = page.askNewGame;
-        if (table === undefined && !pagePorts(context.folder).includes(Number(new URL(page.url).port))) {
-            process.stderr.write(`The board page is at ${page.url}, off its usual ports: the doorbell cannot find it, so moves on the page do not wake the chat.\n`);
+        if (!page.findable) {
+            process.stderr.write(`The board page is at ${page.url}, off its usual ports, and its port could not be noted in the data folder: the doorbell cannot find it, so moves on the page do not wake the chat.\n`);
         }
         return page;
     }
@@ -203,15 +202,17 @@ async function runTool(command, input, context, caller, meta) {
     const calling = await sharingCaller(command, meta, context);
     const agent = calling !== undefined && "agent" in calling ? calling.agent : undefined;
     const chat = command.byAgents === undefined && agent === undefined;
+    const home = homeForOneCall(context);
     let refused = false;
     try {
         if (chat) {
+            takePositionShown(context, home);
             await context.calls?.();
         }
         const run = calling !== undefined && "run" in calling ? calling.run : undefined;
         const who = agent !== undefined ? { agent, ...(run === undefined ? {} : { agentRun: run }) } : calling !== undefined ? { chat: true } : {};
         // A game another process changed under the call is read again, and the call made once more.
-        const result = await rerunIfChanged(() => command.run(checkedInput(command, input), { ...context, caller, ...who }));
+        const result = await rerunIfChanged(() => command.run(checkedInput(command, input), { ...context, home, caller, ...who }));
         return { content: [{ type: "text", text: command.format(result, context) }] };
     }
     catch (error) {
@@ -222,10 +223,51 @@ async function runTool(command, input, context, caller, meta) {
         // What the tool read or wrote, the chat has seen: the doorbell rings it only for what changes after, and it may move on the game a tool showed it,
         // unless that tool was refused for a position it had not seen. An agent's call is not the chat's.
         if (chat) {
-            chatHasRead(context, command.showsGame === true && !refused);
+            chatHasRead(context, command.showsGame === true && !refused, home);
         }
     }
 }
+/**
+ * The position the prompt hook showed the chat with the move the player wrote alone (D-71), taken before the chat's tool runs as if a tool had shown it,
+ * while the game is still there: the AI moves on it without a status, and the player's words the hook gave count as given, which the page hears. A note
+ * on another position goes; one of another chat's stays for it.
+ */
+function takePositionShown(context, home) {
+    const shown = positionShownNote(context.folder);
+    if (shown === undefined) {
+        return;
+    }
+    let current;
+    try {
+        current = samePosition(shown, positionIn(gameFolder(home())));
+    }
+    catch {
+        // A game that cannot be read is the tool's to report.
+        return;
+    }
+    if (current && !chatsNote(shown, context.folder)) {
+        return;
+    }
+    forgetPositionShown(context.folder);
+    if (!current) {
+        return;
+    }
+    shown.given.forEach((key) => context.given.add(key));
+    // The position is new to the chat, a move later than any it saw: the page hears of it, and of the words read with it.
+    chatHasRead(context, true, home);
+}
+/**
+ * Whether a note of the hooks is this server's chat's: by the Claude Code process, which names itself alike to the server and its hooks, when both have its
+ * name. Else by the session: the server's is the one Claude Code started it with, and the hooks get a new one after /clear, which the chat's start notes;
+ * a chat started or resumed since in the folder is taken for another Claude Code.
+ */
+function chatsNote({ process: noted, session }, folder, own = hostProcess(), ownSession = process.env.CLAUDE_CODE_SESSION_ID) {
+    if (noted !== undefined && own !== undefined) {
+        return noted === own;
+    }
+    const start = lastChatStart(folder);
+    return session === ownSession || (start?.session === session && start.source !== "startup" && start.source !== "resume");
+}
 /**
  * Who calls a tool the chat shares with an agent, as the analyst (D-89): the chat, or the agent by its type; looked up only in a folder where one may run
  * and while no game goes on, so that no call of the chat's waits for it while it plays. None when it cannot be told, or for an agent the tool is not shared with.

package/dist/server/page/analyses.js

@@ -1,6 +1,6 @@
 import { bookOpening, deleteGame, deleteReview, siteGames, SiteGamesRefused } from "../../commands/index.js";
 import { aiModelIn, annotatorOf, isReviewed, leadOf, reviewOf } from "../../core/index.js";
-import { archivedGame, archivedGames, gameInAnalysis, gameStemOf, keptGame, keptGames } from "../../games/index.js";
+import { archivedGame, archivedGames, archivedGameUnplayed, gameInAnalysis, gameStemOf, hasListTags, keptGame, keptGames } from "../../games/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { bodyOf, isJson, jsonOf, runRoute, sendJson, textOf } from "./http.js";
 /** The games to analyse in the profile in use, the latest first, all of them for the page's search: those kept to study and those played, reviewed or not. */
@@ -10,7 +10,7 @@ export function analysesOf(home) {
     const stamp = (name) => gameStemOf(name) ?? "";
     const names = [...keptGames(folder), ...archivedGames(folder)].sort((one, other) => stamp(other).localeCompare(stamp(one)));
     const taken = gameInAnalysis(folder)?.analyst?.game;
-    return names.flatMap((name) => itemOf(name, () => name.startsWith("study/") ? keptGame(folder, name) : archivedGame(folder, name), taken === name));
+    return names.flatMap((name) => itemOf(name, () => name.startsWith("study/") ? withBookOpening(keptGame(folder, name)) : archivedListed(folder, name), taken === name));
 }
 /** Answers the page's deletions, of a game or of its review alone, done as the command line does them: true when the request was one. */
 export function answerAnalyses(request, response, url, served) {
@@ -51,10 +51,22 @@ export function sendSiteGames(response, served) {
     });
 }
 const deletions = { "/api/delete-game": deleteGame, "/api/delete-review": deleteReview };
+/**
+ * A game of the archive for the list: its moves taken as written, not played, when the archive wrote its PlyCount, with its opening's tags, none for a game
+ * that has none; a game an older Chesspal archived is read whole, its opening looked up.
+ */
+function archivedListed(folder, name) {
+    const unplayed = archivedGameUnplayed(folder, name);
+    return hasListTags(unplayed.tags) ? { record: unplayed, opening: unplayed.tags.Opening } : withBookOpening(archivedGame(folder, name));
+}
+function withBookOpening(record) {
+    return { record, opening: bookOpening(record)?.name };
+}
 function itemOf(name, read, taken) {
     let record;
+    let opening;
     try {
-        record = read();
+        ({ record, opening } = read());
     }
     catch {
         // A game that cannot be read stays out of the list.
@@ -66,7 +78,6 @@ function itemOf(name, read, taken) {
     }
     const { tags } = record;
     const date = tags.Date === undefined || tags.Date.includes("?") ? undefined : tags.Date;
-    const opening = bookOpening(record)?.name;
     const aiModel = aiModelIn(record);
     const site = tags.Site === undefined || /^[?\-\s]*$/.test(tags.Site) ? undefined : tags.Site;
     const signed = annotatorOf(record);

package/dist/server/page/chat.d.ts

@@ -20,13 +20,17 @@ export declare function chatSeenOf(chat: Context): ChatSeen;
 export declare function pageContext(chat: Context): Context;
 /** The context of a new game started on the page: the page's, with what the chat saw and its host, by which the game before asks for a clean chat (D-57). */
 export declare function asTheChatSees(context: Context, chat: ChatSeen): Context;
-/** What a chat says of itself as it attaches to the table (D-104): its version, its session, its folder, its host, and whether its folder needs init again. */
+/**
+ * What a chat says of itself as it attaches to the table (D-104): its version, its session, its folder, its host, whether its folder needs init again,
+ * and the seat of the `chesspal play` that started it, if one did.
+ */
 export declare const chatAttach: z.ZodObject<{
     version: z.ZodString;
     session: z.ZodNullable<z.ZodString>;
     folder: z.ZodString;
     host: z.ZodOptional<z.ZodString>;
     outdated: z.ZodBoolean;
+    seat: z.ZodOptional<z.ZodInt>;
 }, z.core.$strip>;
 export type ChatAttach = z.infer<typeof chatAttach>;
 /**

package/dist/server/page/chat.js

@@ -42,13 +42,17 @@ export function pageContext(chat) {
 export function asTheChatSees(context, chat) {
     return { ...context, host: () => chat.host(), positionSeen: chat.positionSeen };
 }
-/** What a chat says of itself as it attaches to the table (D-104): its version, its session, its folder, its host, and whether its folder needs init again. */
+/**
+ * What a chat says of itself as it attaches to the table (D-104): its version, its session, its folder, its host, whether its folder needs init again,
+ * and the seat of the `chesspal play` that started it, if one did.
+ */
 export const chatAttach = z.object({
     version: z.string(),
     session: z.string().nullable(),
     folder: z.string(),
     host: z.string().optional(),
     outdated: z.boolean(),
+    seat: z.int().optional(),
 });
 const seenPosition = z.object({ started: z.string().optional(), plies: z.int().min(0) });
 /**

package/dist/server/page/files.js

@@ -47,8 +47,10 @@ const policy = `default-src 'self'; script-src 'self' 'sha256-${createHash("sha2
     + "base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
 const html = [
     "<!doctype html>",
-    '<html lang="en">',
+    '<html lang="en" translate="no">',
     '<meta charset="utf-8">',
+    // The page speaks the player's language, set once the app starts, and moves are never translated: no browser offers to.
+    '<meta name="google" content="notranslate">',
     '<meta name="viewport" content="width=device-width, initial-scale=1">',
     '<meta name="color-scheme" content="light dark">',
     "<title>Chesspal</title>",

package/dist/server/page/game.d.ts

@@ -4,3 +4,8 @@ import type { Served } from "./page.ts";
 export declare function answerGame(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
 /** The chat calls a tool: when nobody heard the player before, the AI's clock, held since, starts now, with the time it was held given back. */
 export declare function chatCalls(served: Served): void;
+/**
+ * Whether the AI's sign on the page is not the one the pages were last given: the ponder agent's every thought rewrites thoughts.json, and only the sign
+ * that comes or goes is news for them. True when the game cannot be read: they read it again.
+ */
+export declare function thinkingChanged(served: Served): boolean;