chesspal 0.2.3 → 0.3.0

package/dist/server/page/attach.js

@@ -0,0 +1,112 @@
+// The table's end of the chat attached to it (D-104): the chat attaches and stays while its process lives, says when it calls a tool, sends a copy of what
+// it saw, and asks for the New game window. One chat at a time, of this version alone; a page a chat serves itself has none of these routes.
+import { randomUUID } from "node:crypto";
+import { forgetTheAi, noteAiHost, noteAiModel } from "../../games/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { version } from "../../version.js";
+import { chatAttach, chatCopy } from "./chat.js";
+import { askNewGame, tellWatchers } from "./events.js";
+import { chatCalls } from "./game.js";
+import { bytesOf, isJson, jsonOf, runRoute, sendJson } from "./http.js";
+/** Answers the chat's requests to the table, under /api/chat; false for any other, and for every request to a page a chat serves itself. */
+export function answerChat(request, response, url, served) {
+    const path = url.pathname;
+    if (served.table === undefined || request.method !== "POST" || (path !== "/api/chat" && !path.startsWith("/api/chat/"))) {
+        return false;
+    }
+    runRoute(response, async () => {
+        const body = isJson(request) ? jsonOf((await bytesOf(request, copyLimit))?.toString("utf8")) : undefined;
+        if (body === undefined) {
+            sendJson(response, 400, { error: `${path} takes a JSON object.` });
+        }
+        else if (path === "/api/chat") {
+            attach(body, response, served);
+        }
+        else if (served.attached === undefined || body.token !== served.attached.token) {
+            sendJson(response, 409, { error: "This chat is not the one at the table: attach to it again." });
+        }
+        else {
+            answerAttached(path, body, response, served, served.attached);
+        }
+    });
+    return true;
+}
+// A copy holds the player's words the chat was given in its whole life: a long game's are well within this.
+const copyLimit = 1_000_000;
+/**
+ * A chat attaches: refused when another is at the table, or its version is another (the older yields, D-104); else it gets its token, and the answer stays
+ * open while its process lives. When the connection closes the chat has left, and the table is nobody's again.
+ */
+function attach(body, response, served) {
+    const parsed = chatAttach.safeParse(body);
+    if (!parsed.success) {
+        sendJson(response, 400, { error: `A chat attaches with its version, session, folder and host: ${parsed.error.message}` });
+        return;
+    }
+    if (parsed.data.version !== version) {
+        sendJson(response, 409, { error: `The table runs Chesspal ${version}, the chat ${parsed.data.version}.`, version });
+        return;
+    }
+    if (served.attached !== undefined) {
+        sendJson(response, 409, { error: "Another chat is at the table: this one serves its own page." });
+        return;
+    }
+    const attached = { token: randomUUID(), chat: parsed.data, copy: undefined, given: new Set() };
+    served.attached = attached;
+    served.chatOpened = undefined;
+    served.outdated = parsed.data.outdated;
+    response.writeHead(200, { "Content-Type": "application/x-ndjson; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+    response.write(`${JSON.stringify({ token: attached.token, open: served.watchers.size > 0 })}\n`);
+    response.on("close", () => {
+        if (served.attached === attached) {
+            served.attached = undefined;
+            served.outdated = false;
+            forgetChat(served);
+            served.bell.chatLeft();
+        }
+    });
+    tellWatchers(served.watchers);
+}
+/** The next chat may play in another host, with another model: the AI's card shows its own from its first move (Federico). */
+function forgetChat(served) {
+    try {
+        forgetTheAi(gameFolder(served.context.home()));
+    }
+    catch {
+        // A data folder that cannot be read keeps no notes to forget.
+    }
+}
+/** The attached chat's requests:it calls a tool, sends a copy of what it saw, or asks for the New game window. */
+function answerAttached(path, body, response, served, attached) {
+    if (path === "/api/chat/call") {
+        chatCalls(served);
+        sendJson(response, 200, { open: served.watchers.size > 0 });
+    }
+    else if (path === "/api/chat/read") {
+        readCopy(body, response, served, attached);
+    }
+    else if (path === "/api/chat/new-game") {
+        sendJson(response, 200, { opened: askNewGame(served.watchers) });
+    }
+    else {
+        sendJson(response, 404, { error: `${path} is no route of the table's: the chat attaches at /api/chat, then calls /api/chat/call, /read and /new-game.` });
+    }
+}
+/** Keeps the chat's copy; the AI's model and host noted, as the chat's process notes them, and the pages told when it says they have news. */
+function readCopy(body, response, served, attached) {
+    const parsed = chatCopy.safeParse(body);
+    if (!parsed.success) {
+        sendJson(response, 400, { error: `A copy holds what the chat saw: ${parsed.error.message}` });
+        return;
+    }
+    const copy = parsed.data;
+    attached.copy = copy;
+    attached.given = new Set(copy.given);
+    const folder = gameFolder(served.context.home());
+    const host = copy.aiHost !== undefined && noteAiHost(folder, copy.aiHost);
+    const model = copy.aiModel !== undefined && noteAiModel(folder, copy.aiModel);
+    if (copy.news || host || model) {
+        tellWatchers(served.watchers);
+    }
+    sendJson(response, 200, { open: served.watchers.size > 0 });
+}

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

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import type { Context, SeenPosition } from "../../commands/index.ts";
+/**
+ * What the page reads of the chat it serves: the player's words the AI was given (D-53), the game it saw at its last tool, which the doorbell rings it for,
+ * the position it moves on, and its host, for the AI's sign and the clean chat a new game asks for (D-57). The page never changes it.
+ */
+export interface ChatSeen {
+    readonly given: ReadonlySet<string>;
+    readonly seen: string | undefined;
+    readonly positionSeen: SeenPosition | null | undefined;
+    host(): string | undefined;
+}
+/** The chat as the page reads it, in the chat's own process: read from its context at each request, so always as the chat left it. */
+export declare function chatSeenOf(chat: Context): ChatSeen;
+/**
+ * The context the page runs its commands with: the chat's folders, time, randomness and fetch, and nothing that is the chat's own, as the position it saw, which
+ * would refuse the player's resignation while the AI thinks, or what it was told.
+ */
+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. */
+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;
+}, z.core.$strip>;
+export type ChatAttach = z.infer<typeof chatAttach>;
+/**
+ * What the chat attached to the table tells it after each tool, and when the page has news no file holds (`news`): what it saw, the words it was given,
+ * its host, and the AI's model and host, which the table notes for a game that ends on the page (D-82, D-97).
+ */
+export declare const chatCopy: z.ZodObject<{
+    token: z.ZodString;
+    seen: z.ZodOptional<z.ZodString>;
+    positionSeen: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        started: z.ZodOptional<z.ZodString>;
+        plies: z.ZodInt;
+    }, z.core.$strip>>>;
+    given: z.ZodArray<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    aiModel: z.ZodOptional<z.ZodObject<{
+        model: z.ZodString;
+        effort: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    aiHost: z.ZodOptional<z.ZodString>;
+    news: z.ZodBoolean;
+}, z.core.$strip>;
+export type ChatCopy = z.infer<typeof chatCopy>;
+/** The chat attached to the table: the token of its requests, what it said as it attached, and its last copy, with the words given as a set. */
+export interface Attached {
+    readonly token: string;
+    readonly chat: ChatAttach;
+    copy: ChatCopy | undefined;
+    given: ReadonlySet<string>;
+}
+/** The chat attached to the table as the page reads it; nobody's while none is: no words given, no game or position seen, no host. */
+export declare function attachedSeen(attached: () => Attached | undefined): ChatSeen;

package/dist/server/page/chat.js

@@ -0,0 +1,79 @@
+// What the page knows of the chat, and what it runs commands with: its own context, as the command line's, since the chat's refusals are the chat's (D-71).
+// The table knows the chat attached to it from what the chat tells it (D-104).
+import { z } from "zod";
+/** The chat as the page reads it, in the chat's own process: read from its context at each request, so always as the chat left it. */
+export function chatSeenOf(chat) {
+    return {
+        get given() {
+            return chat.given;
+        },
+        get seen() {
+            return chat.seen;
+        },
+        get positionSeen() {
+            return chat.positionSeen;
+        },
+        host: () => chat.host?.(),
+    };
+}
+/**
+ * The context the page runs its commands with: the chat's folders, time, randomness and fetch, and nothing that is the chat's own, as the position it saw, which
+ * would refuse the player's resignation while the AI thinks, or what it was told.
+ */
+export function pageContext(chat) {
+    const { folder, home, random, now, pause, platform, language, openFolder, fetch } = chat;
+    return {
+        folder,
+        home,
+        random,
+        now,
+        platform,
+        given: new Set(),
+        ...(pause === undefined ? {} : { pause }),
+        ...(language === undefined ? {} : { language }),
+        ...(openFolder === undefined ? {} : { openFolder }),
+        ...(fetch === undefined ? {} : { fetch }),
+    };
+}
+/** 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 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. */
+export const chatAttach = z.object({
+    version: z.string(),
+    session: z.string().nullable(),
+    folder: z.string(),
+    host: z.string().optional(),
+    outdated: z.boolean(),
+});
+/**
+ * What the chat attached to the table tells it after each tool, and when the page has news no file holds (`news`): what it saw, the words it was given,
+ * its host, and the AI's model and host, which the table notes for a game that ends on the page (D-82, D-97).
+ */
+export const chatCopy = z.object({
+    token: z.string(),
+    seen: z.string().optional(),
+    positionSeen: z.object({ started: z.string().optional(), plies: z.int().min(0) }).nullable().optional(),
+    given: z.array(z.string()),
+    host: z.string().optional(),
+    aiModel: z.object({ model: z.string(), effort: z.string().optional() }).optional(),
+    aiHost: z.string().optional(),
+    news: z.boolean(),
+});
+/** The chat attached to the table as the page reads it; nobody's while none is: no words given, no game or position seen, no host. */
+export function attachedSeen(attached) {
+    const none = new Set();
+    return {
+        get given() {
+            return attached()?.given ?? none;
+        },
+        get seen() {
+            return attached()?.copy?.seen;
+        },
+        get positionSeen() {
+            return attached()?.copy?.positionSeen;
+        },
+        host: () => attached()?.copy?.host ?? attached()?.chat.host,
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/** A page that waits to hear the game has changed: a stream of events, one "changed" for each change, after which the page reads the game again. */
+export declare function keepPosted(request: IncomingMessage, response: ServerResponse, watchers: Set<ServerResponse>): void;
+/** The pages open now hear the game, or what they show of the chat, has changed. */
+export declare function tellWatchers(watchers: Set<ServerResponse>): void;
+/** The pages open now open their New game window; whether there was one. */
+export declare function askNewGame(watchers: Set<ServerResponse>): boolean;

package/dist/server/page/events.js

@@ -0,0 +1,20 @@
+/** A page that waits to hear the game has changed: a stream of events, one "changed" for each change, after which the page reads the game again. */
+export function keepPosted(request, response, watchers) {
+    response.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+    response.write(": posted\n\n");
+    watchers.add(response);
+    request.on("close", () => watchers.delete(response));
+}
+/** The pages open now hear the game, or what they show of the chat, has changed. */
+export function tellWatchers(watchers) {
+    for (const watcher of watchers) {
+        watcher.write("data: changed\n\n");
+    }
+}
+/** The pages open now open their New game window; whether there was one. */
+export function askNewGame(watchers) {
+    for (const watcher of watchers) {
+        watcher.write("data: new-game\n\n");
+    }
+    return watchers.size > 0;
+}

package/dist/server/page/files.js

@@ -52,13 +52,22 @@ const html = [
     '<meta name="viewport" content="width=device-width, initial-scale=1">',
     '<meta name="color-scheme" content="light dark">',
     "<title>Chesspal</title>",
+    '<link rel="icon" type="image/svg+xml" href="/page/layout/favicon.svg">',
     '<link rel="stylesheet" href="/page/style.css">',
     `<script type="importmap">${importMap}</script>`,
     '<script type="module" src="/page/main.js"></script>',
     '<div id="app"></div>',
     "",
 ].join("\n");
-const types = { ".js": "text/javascript; charset=utf-8", ".css": "text/css; charset=utf-8", ".svg": "image/svg+xml", ".webp": "image/webp", ".json": "application/json; charset=utf-8", ".ogg": "audio/ogg" };
+const types = {
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".json": "application/json; charset=utf-8",
+    ".ogg": "audio/ogg",
+    ".md": "text/markdown; charset=utf-8",
+};
 function builtFile(path) {
     const area = /^\/(page|core)\//.exec(path)?.[1];
     if (area === undefined) {

package/dist/server/page/game.js

@@ -1,9 +1,11 @@
-import { analyseGame, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, startNewGame, } from "../../commands/index.js";
+import { analyseGame, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, shownPosition, startNewGame, } from "../../commands/index.js";
 import { clockStarted, isReviewed, writePgn } from "../../core/index.js";
-import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, heardLines, loadGame, loadTableTalk, playerPgn, ponderingOn, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
+import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, heardLines, loadGame, loadTableTalk, playerPgn, ponderingOn, rerunIfChanged, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
 import { gameFolder, helpsIn } from "../../profiles/index.js";
+import { asTheChatSees } from "./chat.js";
 import { bodyOf, bytesOf, isJson, json, jsonOf, runRoute, send, textOf } from "./http.js";
 import { profilesShown } from "./profiles.js";
+import { chatToRelaunch, relaunchChat, tableShown } from "./table.js";
 /** Answers the page's requests about the game: true when the request was one. */
 export function answerGame(request, response, url, served) {
     const route = routes[`${request.method ?? ""} ${url.pathname}`];
@@ -19,6 +21,13 @@ export function chatCalls(served) {
     const current = loadGame(folder);
     const held = current !== undefined && aiHeld(served, current);
     if (served.bell.chatCalls() && held) {
+        rerunIfChanged(() => giveHeldTime(served, folder));
+    }
+}
+/** The AI's clock, held while nobody heard the player, starts now: the time it was held is not the AI's. */
+function giveHeldTime(served, folder) {
+    const current = loadGame(folder);
+    if (current?.clock !== undefined && endOf(current.game) === undefined) {
         saveGame(folder, { ...current, clock: { ...current.clock, since: served.context.now().toISOString() } });
     }
 }
@@ -61,7 +70,7 @@ async function moveFromPage(request, response, served) {
             illegal = true;
             return problem;
         };
-        playMove(gameFolder(served.context.home()), now, "player", move, refuse, message === undefined ? {} : { said: { text: message, at: now } });
+        rerunIfChanged(() => playMove(gameFolder(served.context.home()), now, "player", move, refuse, message === undefined ? {} : { said: { text: message, at: now } }));
     }
     catch (error) {
         // The game may have changed since the page read it: the move refused, the AI's turn, a flag fallen.
@@ -72,39 +81,47 @@ async function moveFromPage(request, response, served) {
     served.bell.ring();
     send(response, 200, json, JSON.stringify({ played: true }));
 }
-/** The player's words from the page, without a move: saved with the game as player_say saves them, refused in the player's words, the doorbell rung for the first. */
+/**
+ * The player's words from the page, without a move: saved with the game as player_say saves them, refused in the player's words, the doorbell rung for the
+ * first; in analysis with the position the page shows, and the doorbell rung for each (D-101).
+ */
 async function messageFromPage(request, response, served) {
     if (!isJson(request)) {
         send(response, 415, json, JSON.stringify({ error: 'Send the message as JSON: {"text": "…"}.' }));
         return;
     }
-    const text = textOf(jsonOf(await bodyOf(request))?.text);
+    const body = jsonOf(await bodyOf(request));
+    const text = textOf(body?.text);
+    const shown = typeof body?.game === "string" && typeof body.at === "number" ? shownPosition(served.context, body.game, body.at) : undefined;
     if (text === undefined) {
         send(response, 400, json, JSON.stringify({ error: `Send the message as JSON, ${talkLimits.player} characters at most: {"text": "…"}.` }));
         return;
     }
     let current;
     try {
-        current = say(gameFolder(served.context.home()), "player", text, served.context.now());
+        current = rerunIfChanged(() => say(gameFolder(served.context.home()), "player", text, served.context.now(), undefined, shown));
     }
     catch (error) {
         const noGame = refusalOf(served)?.refusal === "no-game";
         send(response, 409, json, JSON.stringify(refusalFrom(error, noGame ? "no-game" : undefined)));
         return;
     }
-    // The first words of a move wake the chat, and between games the first since the AI spoke; the AI finds the rest at its next call (D-54, D-74).
-    if (wakesTheChat(current)) {
+    // The first words of a move wake the chat, and between games the first since the AI spoke; the AI finds the rest at its next call (D-54, D-74). In
+    // analysis every line does: a chat that answered in its own window would not hear the next (Priya).
+    if (shown !== undefined || wakesTheChat(current)) {
         served.bell.ring();
     }
     send(response, 200, json, JSON.stringify({ said: true }));
 }
 /**
  * A new game from the page, with the sides, the level and the clock the player chose: the sides and the level they leave out are as in the game
- * before, and no clock means a game without one. One going on goes to the archive unfinished, and the doorbell tells the chat.
+ * before, and no clock means a game without one. One going on goes to the archive unfinished, and the doorbell tells the chat, unless the table starts
+ * it again.
  */
 async function newGameFromPage(request, response, served) {
     const asked = 'Send the new game as JSON: {"ai_colour": "black", "level": "club", "clock": "10+5"}, each one optional; no clock for a game without one.';
     const body = isJson(request) ? jsonOf(await bodyOf(request)) : undefined;
+    let relaunching = false;
     if (body === undefined) {
         send(response, isJson(request) ? 400 : 415, json, JSON.stringify({ error: asked }));
         return;
@@ -116,14 +133,19 @@ async function newGameFromPage(request, response, served) {
             send(response, 400, json, JSON.stringify({ error: asked }));
             return;
         }
-        // The game starts from the page, open: its clocks wait for the player's Start there.
-        startNewGame(input.data, { ...served.context, pageOpen: () => true }, "page");
+        // The game starts from the page, open: its clocks wait for the player's Start there. A chat the table starts again is clean: no /clear is asked.
+        relaunching = chatToRelaunch(served);
+        const sight = relaunching ? served.context : asTheChatSees(served.context, served.chat);
+        rerunIfChanged(() => startNewGame(input.data, { ...sight, pageOpen: () => true }, "page"));
     }
     catch (error) {
         send(response, 409, json, JSON.stringify(refusalFrom(error)));
         return;
     }
-    served.bell.ring();
+    // A seat lost meanwhile leaves the chat as it is: the doorbell tells it.
+    if (!(relaunching && relaunchChat(served))) {
+        served.bell.ring();
+    }
     send(response, 200, json, JSON.stringify({ started: true }));
 }
 /** The player's draw from the page (D-65): an offer on their turn, which rings the doorbell, or their answer to the AI's, which rings it when accepted. */
@@ -139,12 +161,7 @@ async function drawFromPage(request, response, served) {
         return;
     }
     try {
-        if (action === "offer") {
-            offerDraw(served.context);
-        }
-        else {
-            answerDraw(served.context, action === "accept");
-        }
+        rerunIfChanged(() => action === "offer" ? offerDraw(served.context) : answerDraw(served.context, action === "accept"));
     }
     catch (error) {
         send(response, 409, json, JSON.stringify(refusalFrom(error, refusalOf(served)?.refusal)));
@@ -161,18 +178,26 @@ function startFromPage(request, response, served) {
         send(response, 415, json, JSON.stringify({ error: "Send the request as JSON: {}." }));
         return;
     }
-    const folder = gameFolder(served.context.home());
-    const current = loadGame(folder);
-    if (current?.clock?.waiting !== true || endOf(current.game) !== undefined) {
+    const current = rerunIfChanged(() => startClocks(served));
+    if (current === undefined) {
         send(response, 409, json, JSON.stringify({ error: "No clock waits to start: start a game with a clock first." }));
         return;
     }
-    saveGame(folder, { ...current, clock: clockStarted(current.clock, served.context.now()) });
     if (current.game.position.turn === current.ai) {
         served.bell.ring();
     }
     send(response, 200, json, JSON.stringify({ started: true }));
 }
+/** Starts the clocks of the game, which wait from its start: the game started, or none when no clock waits. */
+function startClocks(served) {
+    const folder = gameFolder(served.context.home());
+    const current = loadGame(folder);
+    if (current?.clock?.waiting !== true || endOf(current.game) !== undefined) {
+        return undefined;
+    }
+    saveGame(folder, { ...current, clock: clockStarted(current.clock, served.context.now()) });
+    return current;
+}
 /** The player resigns from the page (D-65), whoever is to move: the game ends and goes to the archive, and the doorbell tells the chat. */
 function resignFromPage(request, response, served) {
     if (!isJson(request)) {
@@ -180,7 +205,7 @@ function resignFromPage(request, response, served) {
         return;
     }
     try {
-        endGame.run({ result: "player_resigns" }, served.context);
+        rerunIfChanged(() => endGame.run({ result: "player_resigns" }, served.context));
     }
     catch (error) {
         send(response, 409, json, JSON.stringify(refusalFrom(error, refusalOf(served)?.refusal === "no-game" ? "no-game" : undefined)));
@@ -222,7 +247,7 @@ async function studyFromPage(request, response, served) {
         reviewed = isReviewed(opened.record);
         brought = !reviewed && !look;
         // A game not yet reviewed is marked as brought, for status to ask the AI to go over it; one reviewed is ready, and the chat sleeps on.
-        startAnalysis(gameFolder(served.context.home()), opened.name, served.context.now(), brought);
+        startAnalysis(gameFolder(served.context.home()), opened.name, served.context.now(), { brought });
     }
     catch (error) {
         send(response, 400, json, JSON.stringify({ error: error.message, refusal: "pgn-unreadable" }));
@@ -243,8 +268,15 @@ function sendGame(response, served) {
     const current = gameNow(served);
     // With no game the page still shows the talk before the first (D-77).
     const spoken = current ?? loadTableTalk(folder);
-    const heard = heardLines(spoken, served.context.given);
-    const talk = spoken.talk.map(({ who, text, ply }, index) => heard[index] === undefined ? { who, text, ply } : { who, text, ply, heard: heard[index] });
+    const heard = heardLines(spoken, served.chat.given);
+    const talk = spoken.talk.map(({ who, text, ply, shown }, index) => ({
+        who,
+        text,
+        ply,
+        ...(heard[index] === undefined ? {} : { heard: heard[index] }),
+        // In analysis the page goes back to the move the player wrote about (D-101).
+        ...(shown === undefined ? {} : { shown }),
+    }));
     const offer = current === undefined ? undefined : drawOfferOf(current);
     const coach = coachOn(folder, current);
     const game = current === undefined ? null : {
@@ -271,6 +303,7 @@ function sendGame(response, served) {
         listening: served.bell.listening,
         ...thinkingShown(served, current),
         ...(served.outdated ? { outdated: true } : {}),
+        ...tableShown(served),
         ...profilesShown(served.context.home()),
     };
     send(response, 200, json, JSON.stringify(body));
@@ -285,7 +318,7 @@ function thinkingShown(served, current) {
     }
     const position = { started: current.started, plies: current.game.record.moves.length };
     if (current.game.position.turn === current.ai) {
-        const seen = served.context.positionSeen;
+        const seen = served.chat.positionSeen;
         const onIt = served.bell.woke || (seen !== undefined && seen !== null && samePosition(seen, position));
         return served.bell.inTurn && onIt ? { thinking: "move" } : {};
     }
@@ -329,7 +362,7 @@ function lastPlayed(context) {
 }
 /** A game brought as a PGN, kept to study as analyse_game keeps it: the one already kept when it is the same game, with its review. */
 function kept(served, pgn) {
-    analyseGame.run({ pgn }, { ...served.context, told: undefined });
+    analyseGame.run({ pgn }, served.context);
     return namedGame(served.context, gameInAnalysis(gameFolder(served.context.home())).game);
 }
 /** The longest PGN the page brings: a long game with its clocks, and the comments a site adds, which go. */
@@ -369,7 +402,7 @@ function gameNow(served) {
     if (before !== undefined && aiHeld(served, before)) {
         return before;
     }
-    const current = gameAt(folder, served.context.now());
+    const current = rerunIfChanged(() => gameAt(folder, served.context.now()));
     if (before !== undefined && endOf(before.game) === undefined && current !== undefined && endOf(current.game) !== undefined) {
         served.bell.ring();
     }

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

@@ -1,34 +1,74 @@
 import { type ServerResponse } from "node:http";
 import { type Context } from "../../commands/index.ts";
 import { Bell } from "../bell.ts";
-/** The page of a player's folder, served: its address, how to tell it the AI was given words, which change no file, and how to stop it. */
+import { type Attached, type ChatSeen } from "./chat.ts";
+import { type Opening, type TableChats } from "./table.ts";
+/**
+ * The page of a player's folder, served by the chat's process or by the table it is attached to (D-104): its address, how to tell it what the chat does
+ * and was given, which change no file, and how to stop it.
+ */
 export interface Page {
     readonly url: string;
+    /** The page has news no file holds: words the AI was given, which it shows read (D-53), the position the chat moves on, the AI's model (D-82). */
     heard(): void;
     /** The chat calls a tool: the page hears it listens, and the AI's clock, held while nobody heard the player, starts now. */
-    chatCalls(): void;
+    chatCalls(): void | Promise<void>;
+    /** A tool of the chat's has ended: the table gets a copy of what the chat saw; the chat's own page reads it from the chat. */
+    toolEnded(): void;
     /** Whether a browser has the page open now: one listens to the game's changes. */
     open(): boolean;
+    /** Whether the page is in use: open in a browser, or, on the table, with a chat attached. */
+    inUse(): boolean;
     /** Opens the New game window on every page open now, for the player to choose the game there: whether one was open. */
     askNewGame(): boolean;
     close(): Promise<void>;
 }
+/** How a page is served, besides its context: the opponent's name, as the host gives it, and the table that serves it, when one does (D-104). */
+export interface PageOptions {
+    readonly opponent?: () => string | undefined;
+    readonly table?: TableEnd;
+}
+/**
+ * What the page tells the table that serves it: a request came, so the table is in use, or another Chesspal version asked it to quit; and how the table
+ * opens a chat, which the page offers while none is at the table.
+ */
+export interface TableEnd {
+    used(): void;
+    quit(): void;
+    readonly chats?: TableChats | undefined;
+}
 /**
- * Serves the page of the context's folder on 127.0.0.1, on a port of its own when free, else on any free one, where the doorbell cannot find it. The page
- * names the opponent as the host does, once it has connected; the doorbell knows from the context what the chat has read of the player's words.
+ * Serves the page of the context's folder on 127.0.0.1, on a port of its own when free, else on any free one, where the doorbell cannot find it; the
+ * table's on its own ports alone, which keep two tables apart. The page reads the chat from the context in the chat's process, and on the table from
+ * what the chat attached to it tells it (D-104); it names the opponent as the chat's host does. The doorbell knows what the chat has read.
  */
-export declare function startPage(context: Context, opponent?: () => string | undefined): Promise<Page>;
+export declare function startPage(context: Context, options?: PageOptions): Promise<Page>;
 /** What the server keeps of its folder: the doorbell, and the pages that wait to hear the game has changed. */
 export interface Served {
     /** The host's folder, which gives the page its ports and the doorbell its chat; the game is in the context's data folder (D-71). */
     readonly folder: string;
+    /** What the page runs its commands with: never the chat's own (D-71). */
     readonly context: Context;
+    /** What the page reads of the chat: the words it was given, the game and the position it saw, its host; on the table, the attached chat's, or nobody's. */
+    readonly chat: ChatSeen;
     readonly opponent: () => string | undefined;
     readonly bell: Bell;
     readonly watchers: Set<ServerResponse>;
     port: number;
-    /** The folder was set up by an older init: the page asks the player to run it again. Read once, as init runs with the chat closed. */
-    readonly outdated: boolean;
+    /**
+     * The chat's folder was set up by an older init: the page asks the player to run it again. Read once, as init runs with the chat closed; on the table,
+     * as the chat attached to it says it.
+     */
+    outdated: boolean;
+    /** The table that serves the page, when one does (D-104). */
+    readonly table?: TableEnd;
+    /** The chat attached to the table, while one is. */
+    attached?: Attached;
+    /** When the table last opened a chat from the page, which has not attached yet: no second one meanwhile. */
+    chatOpened?: {
+        readonly at: number;
+        readonly how: Opening;
+    } | undefined;
 }
 /**
  * The chat has read the game as it is now, at the end of a tool's call: the doorbell wakes it only for what changes it after; and, when the tool `showed` it