chesspal 0.3.6 → 0.4.0

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/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;

package/dist/server/page/game.js

@@ -1,13 +1,13 @@
-import { analyseGame, analystOf, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, shownPosition, 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, ponderingUntil, rerunIfChanged, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
+import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, GameMissing, heardLines, loadGame, loadTableTalk, playerPgn, ponderingUntil, rerunIfChanged, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
 import { gameFolder, helpsIn } from "../../profiles/index.js";
 import { version } from "../../version.js";
 import { asTheChatSees } from "./chat.js";
 import { tellWatchers } from "./events.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";
+import { analystAtWork, chatToRelaunch, chatToWaitFor, refuseWaited, relaunchChat, tableShown } from "./table.js";
 import { updateShown } from "./update.js";
 /** Answers the page's requests about the game: true when the request was one. */
 export function answerGame(request, response, url, served) {
@@ -27,6 +27,18 @@ export function chatCalls(served) {
         rerunIfChanged(() => giveHeldTime(served, folder));
     }
 }
+/**
+ * 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 function thinkingChanged(served) {
+    try {
+        return thinkingShown(served, loadGame(gameFolder(served.context.home()))).thinking !== thinkingSent.get(served);
+    }
+    catch {
+        return true;
+    }
+}
 /** 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);
@@ -112,19 +124,21 @@ async function messageFromPage(request, response, served) {
     // 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();
+        // Words may come while the chat thinks on the AI's move, which they do not end.
+        served.bell.ring("game" in current && endOf(current.game) === undefined && current.game.position.turn === current.ai);
     }
     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, unless the table starts
- * it again.
+ * it again. A chat the table holds that must be clear for it, and is at work, has the game wait with the choices kept until it has ended its answer (D-107).
  */
 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;
+    let chosen;
     if (body === undefined) {
         send(response, isJson(request) ? 400 : 415, json, JSON.stringify({ error: asked }));
         return;
@@ -139,10 +153,17 @@ async function newGameFromPage(request, response, served) {
         // 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);
+        chosen = input.data;
         rerunIfChanged(() => startNewGame(input.data, { ...sight, pageOpen: () => true }, "page"));
     }
     catch (error) {
-        send(response, 409, json, JSON.stringify(refusalFrom(error)));
+        if (error instanceof ChatNotClear && chosen !== undefined && chatToWaitFor(served)) {
+            waitForChat(served, chosen);
+            send(response, 200, json, JSON.stringify({ waiting: true }));
+        }
+        else {
+            send(response, 409, json, JSON.stringify(refusalFrom(error)));
+        }
         return;
     }
     // A seat lost meanwhile leaves the chat as it is: the doorbell tells it.
@@ -151,6 +172,34 @@ async function newGameFromPage(request, response, served) {
     }
     send(response, 200, json, JSON.stringify({ started: true }));
 }
+/**
+ * The new game waits, with the player's choices, for the chat at the table to end its answer; then it starts and the chat starts again, clean, for it, or
+ * one gone meanwhile hears the doorbell when another comes. It starts in the profile it was asked in: with another in use by then it is dropped. A game
+ * that cannot start leaves everything as it was, and the pages say why.
+ */
+function waitForChat(served, chosen) {
+    const askedIn = gameFolder(served.context.home());
+    const start = () => {
+        try {
+            if (gameFolder(served.context.home()) !== askedIn) {
+                refuseWaited(served, { error: "Another profile is in use since the new game was asked: ask for it again in this one.", refusal: "new-game-profile" });
+                return false;
+            }
+            rerunIfChanged(() => startNewGame(chosen, { ...served.context, pageOpen: () => true }, "page"));
+        }
+        catch (error) {
+            refuseWaited(served, refusalFrom(error));
+            return false;
+        }
+        const relaunching = relaunchChat(served);
+        if (!relaunching) {
+            served.bell.ring();
+        }
+        return relaunching;
+    };
+    served.chatWait = { for: "new-game", start };
+    tellWatchers(served.watchers);
+}
 /** 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. */
 async function drawFromPage(request, response, served) {
     const asked = 'Send the draw as JSON: {"action": "offer"}, "accept" or "decline".';
@@ -255,7 +304,7 @@ async function studyFromPage(request, response, served) {
         startAnalysis(gameFolder(served.context.home()), opened.name, served.context.now(), { brought, redo });
     }
     catch (error) {
-        send(response, 400, json, JSON.stringify({ error: error.message, refusal: "pgn-unreadable" }));
+        send(response, 400, json, JSON.stringify({ error: error.message, refusal: refusalOfStudy(error) }));
         return;
     }
     if (brought) {
@@ -292,13 +341,15 @@ function sendGame(response, served) {
         name: archiveName(current),
         talk,
         // How many of its first moves are the book's: the page marks them while the game goes on, as the AI's review does after.
-        book: bookPlies(current.game.record),
+        book: bookPlies(current.game),
         ...(current.clock === undefined ? {} : { clock: current.clock }),
         ...(offer === undefined ? {} : { drawOffer: offer }),
         ...(coach === undefined ? {} : { coach }),
     };
     const analysis = current === undefined || endOf(current.game) !== undefined ? analysisShown(served) : undefined;
     const aiModel = aiModelOf(folder);
+    const thinking = thinkingShown(served, current);
+    thinkingSent.set(served, thinking.thinking);
     const body = {
         // The page loaded from another version loads again, its files and all (Federico).
         version,
@@ -308,7 +359,7 @@ function sendGame(response, served) {
         opponent: served.opponent(),
         ...(aiModel === undefined ? {} : { aiModel }),
         listening: served.bell.listening,
-        ...thinkingShown(served, current),
+        ...thinking,
         ...(served.outdated ? { outdated: true } : {}),
         ...updateShown(served),
         ...tableShown(served),
@@ -338,6 +389,8 @@ function thinkingShown(served, current) {
     signGoesIn(served, left);
     return { thinking: "ponder" };
 }
+// The AI's sign the pages were last given, one a table.
+const thinkingSent = new WeakMap();
 // The pages hear when the sign of an agent that stopped pondering without a word goes, which no file tells: one timer a table, the latest.
 const signTimers = new WeakMap();
 function signGoesIn(served, wait) {
@@ -368,11 +421,10 @@ function analysisShown(served) {
     try {
         const { name, record } = namedGame(served.context, analysis.game);
         // Without a review, an AI is at it only while the chat is in a turn, or hears the player while its analyst holds the game (D-89): one the chat has
-        // started again since is gone (Priya). On the table the chat's start is in the chat's own folder.
+        // started again since is gone (Priya).
         const { bell } = served;
-        const chat = { ...served.context, folder: served.attached?.chat.folder ?? served.folder };
         const reviewed = isReviewed(record);
-        const reviewing = !reviewed && (bell.inTurn || (bell.listening && analystOf(chat, analysis.game) !== undefined));
+        const reviewing = !reviewed && (bell.inTurn || (bell.listening && analystAtWork(served, analysis.game)));
         // Without a review and with nobody at it, the analysis is incomplete: the page offers to bring it back to the AI (D-109).
         const state = reviewed ? {} : reviewing ? { reviewing: true } : { incomplete: true };
         // How far the book goes, which the page cannot tell without the book's moves: its card names the opening on those moves.
@@ -387,10 +439,23 @@ function analysisShown(served) {
 function lastPlayed(context) {
     const { name, record } = gameToStudy(context);
     if (name === undefined) {
-        throw new Error("The game just over is not in the archive yet: try again in a moment.");
+        throw new GameNotArchived();
     }
     return { name, record };
 }
+/** The refusal of the game just over asked to analyse before the archive keeps it. */
+class GameNotArchived extends Error {
+    constructor() {
+        super("The game just over is not in the archive yet: try again in a moment.");
+    }
+}
+/** Why a game to study was refused, for the page to say it: a name no game has, the game just over not kept yet, or a game that cannot be read. */
+function refusalOfStudy(error) {
+    if (error instanceof GameMissing) {
+        return "game-missing";
+    }
+    return error instanceof GameNotArchived ? "game-not-archived" : "pgn-unreadable";
+}
 /** 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. */
 async function kept(served, pgn) {
     await analyseGame.run({ pgn }, served.context);

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

@@ -8,7 +8,7 @@ export declare const json = "application/json; charset=utf-8";
  */
 export interface Refused {
     readonly error: string;
-    readonly refusal?: "no-game" | "ai-to-move" | "illegal" | "clear-chat" | `words-${WordsRefused["reason"]}` | `draw-${DrawRefused["reason"]}` | "profile-game" | "game-going" | "pgn-unreadable" | "update-game" | "update-chat";
+    readonly refusal?: "no-game" | "ai-to-move" | "illegal" | "clear-chat" | "new-game-profile" | `words-${WordsRefused["reason"]}` | `draw-${DrawRefused["reason"]}` | "profile-game" | "game-going" | "pgn-unreadable" | "game-missing" | "game-not-archived" | "update-game" | "update-chat";
     readonly most?: number;
 }
 /** Answers a request, with nothing cached, sniffed or referred, and the page's policy unless the headers give another. */

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

@@ -2,7 +2,8 @@ import { type ServerResponse } from "node:http";
 import { type Context } from "../../commands/index.ts";
 import { Bell } from "../bell/index.ts";
 import { type Attached, type ChatSeen } from "./chat.ts";
-import { type Opening, type TableChats } from "./table.ts";
+import { type ChatWait, type Opening, type TableChats, type WaitRefused } from "./table.ts";
+import { type TableWindows } from "./windows.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.
@@ -15,6 +16,8 @@ export interface Page {
     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 the doorbell finds the page: on its folder's usual ports, at the port it noted in the data folder, or at the table. */
+    readonly findable: boolean;
     /** 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. */
@@ -44,8 +47,8 @@ export interface TableUpdate {
     restart(): void;
 }
 /**
- * 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
+ * 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, which it notes in the data folder for the
+ * doorbell to find it there; 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, options?: PageOptions): Promise<Page>;
@@ -75,16 +78,18 @@ export interface Served {
         readonly at: number;
         readonly how: Opening;
     } | undefined;
-    /** The host the page asked the chat to start again with while it was at work (D-107). */
-    restartWanted?: {
-        readonly host: string;
-    } | undefined;
+    /** What the page asked while the chat was at work, waiting for it to end its answer: a start again with another host, or a new game (D-107). */
+    chatWait?: ChatWait | undefined;
+    /** Why the last new game that waited for the chat could not start, numbered so that each page says it once. */
+    waitRefused?: WaitRefused | undefined;
     /** The newer Chesspal npm has (D-108); the table installing it, installed and waiting to be at rest, or starting again from it. */
     newer?: string;
     updating?: "installing" | "installed" | "restarting" | undefined;
+    /** The windows the table opened: the newest stays, the others close (D-104). */
+    windows?: TableWindows;
 }
 /**
  * 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
- * the game, it moves on that position and no other until a tool shows it another (D-71). A game that cannot be read shows none.
+ * the game, it moves on that position and no other until a tool shows it another (D-71). A game that cannot be read shows none. The data folder is the call's.
  */
-export declare function chatHasRead(context: Context, showed: boolean): void;
+export declare function chatHasRead(context: Context, showed: boolean, home?: () => string): void;

package/dist/server/page/page.js

@@ -2,26 +2,28 @@
 // kept up to date as the game changes; the doorbell wakes the chat when the player acts there.
 import { watch } from "node:fs";
 import { createServer } from "node:http";
-import { join } from "node:path";
-import { positionIn, samePosition } from "../../commands/index.js";
+import { basename, join } from "node:path";
+import { analystQuietAt, positionIn, samePosition } from "../../commands/index.js";
 import { aiNameOf } from "../../core/index.js";
 import { forgetAnalyst, gameStamp, tableTalkStamp } from "../../games/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
-import { Bell, bellProbe, pagePorts } from "../bell/index.js";
+import { Bell, forgetPagePort, notePagePort } from "../bell/index.js";
+import { bellProbe, pagePorts } from "../ports/index.js";
 import { analysesOf, answerAnalyses, sendSiteGames } from "./analyses.js";
 import { answerChat } from "./attach.js";
 import { attachedSeen, chatSeenOf, pageContext } from "./chat.js";
 import { askNewGame, keepPosted, tellWatchers } from "./events.js";
 import { sendFile, sendHtml } from "./files.js";
-import { answerGame, chatCalls } from "./game.js";
+import { answerGame, chatCalls, thinkingChanged } from "./game.js";
 import { json, send } from "./http.js";
 import { answerProfiles, readRatingsOf } from "./profiles.js";
-import { answerTable, restartWhenAtRest, updateWhenAtRest } from "./table.js";
+import { answerTable, startWhenAtRest, updateWhenAtRest } from "./table.js";
 import { watchForUpdates } from "./update.js";
+import { windowConnected } from "./windows.js";
 /**
- * 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
+ * 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, which it notes in the data folder for the
+ * doorbell to find it there; 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 async function startPage(context, options = {}) {
@@ -34,9 +36,9 @@ export async function startPage(context, options = {}) {
         context: pageContext(context),
         chat,
         opponent: options.opponent ?? (() => aiNameOf(chat.host())),
-        // A start again asked while the chat was at work comes once it has ended its answer (D-107), as an update installed meanwhile (D-108).
+        // A start again or a new game asked while the chat was at work comes once it has ended its answer (D-107), as an update installed meanwhile (D-108).
         bell: new Bell(() => hasNews(context, chat), () => {
-            restartWhenAtRest(served);
+            startWhenAtRest(served);
             updateWhenAtRest(served);
             tellWatchers(watchers);
         }),
@@ -46,19 +48,36 @@ export async function startPage(context, options = {}) {
         ...(table === undefined ? {} : { table }),
     };
     const server = createServer((request, response) => answer(request, response, served));
-    const ports = table === undefined ? [...pagePorts(folder), 0] : pagePorts(folder);
+    // The folder's real path is read once: it costs a call to the disk for each part of the path.
+    const usual = pagePorts(folder);
+    const ports = table === undefined ? [...usual, 0] : usual;
     for (const port of ports) {
         if (await listened(server, port)) {
             server.unref();
             served.port = portOf(server);
+            // Noted before the game is watched: the notes' folder, made in the data folder, is no news for the pages.
+            const offPorts = table === undefined && !usual.includes(served.port);
+            const noted = offPorts ? notePort(served) : undefined;
             const stopWatchingGame = watchGame(served);
             const stopAskingNpm = watchForUpdates(served);
+            // A chat's process ends without closing its page: the note goes with it.
+            const forgetPort = () => {
+                if (noted !== undefined) {
+                    forgetPagePort(noted, folder, served.port);
+                }
+            };
+            if (noted !== undefined) {
+                process.once("exit", forgetPort);
+            }
             const stopWatching = () => {
                 stopWatchingGame();
                 stopAskingNpm();
+                forgetPort();
+                process.off("exit", forgetPort);
             };
             return {
                 url: `http://127.0.0.1:${served.port}/`,
+                findable: !offPorts || noted !== undefined,
                 heard: () => tellWatchers(watchers),
                 chatCalls: () => chatCalls(served),
                 toolEnded: () => undefined,
@@ -76,14 +95,14 @@ export async function startPage(context, options = {}) {
 }
 /**
  * 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
- * the game, it moves on that position and no other until a tool shows it another (D-71). A game that cannot be read shows none.
+ * the game, it moves on that position and no other until a tool shows it another (D-71). A game that cannot be read shows none. The data folder is the call's.
  */
-export function chatHasRead(context, showed) {
-    context.seen = gameSeen(context);
+export function chatHasRead(context, showed, home = context.home) {
+    context.seen = gameSeen(home);
     if (showed) {
         const before = context.positionSeen;
         try {
-            context.positionSeen = positionIn(gameFolder(context.home()));
+            context.positionSeen = positionIn(gameFolder(home()));
         }
         catch {
             context.positionSeen = null;
@@ -136,6 +155,7 @@ function answer(request, response, served) {
     }
     else if (path === "/api/events") {
         keepPosted(request, response, served.watchers);
+        windowConnected(served, url);
         // A page that opens reads the player's ratings again after a day (D-106).
         readRatingsOf(served);
     }
@@ -147,13 +167,29 @@ function answer(request, response, served) {
             if (url.searchParams.get("analyst") === "gone") {
                 forgetGoneAnalyst(served);
             }
-            served.bell.listen(request, response);
+            // Nothing changed the game since the prompt hook played the move for the chat: the chat hears of it from the player's message.
+            const shown = url.searchParams.get("shown");
+            served.bell.listen(request, response, shown !== null && shown === stampNow(served));
         }
     }
+    else if (path === "/api/bell/prompt") {
+        // The prompt hook: a message starts the chat's turn. A path of its own, which a page of an older Chesspal answers with a 404, not as a hook waiting.
+        served.bell.chatPrompted();
+        send(response, 200, "text/plain; charset=utf-8", "at work");
+    }
     else {
         sendFile(response, path);
     }
 }
+/** The stamp of the game in the data folder now; none when there is none or the folder cannot be read. */
+function stampNow(served) {
+    try {
+        return gameStamp(gameFolder(served.context.home()));
+    }
+    catch {
+        return undefined;
+    }
+}
 /** The chat's hook says no analyst runs any more (D-109): the game it held is free, and its review, unless finished, incomplete. */
 function forgetGoneAnalyst(served) {
     try {
@@ -176,13 +212,13 @@ function tableChat(served) {
  * flag that fell, or another profile in use, which wakes the chat at the next ring (D-66). The player's words the chat was given change nothing it has not read.
  */
 function hasNews(context, chat) {
-    return gameSeen(context) !== chat.seen;
+    return gameSeen(context.home) !== chat.seen;
 }
 // The game the chat sees: the profile's folder, and the stamps of its game.json and of the talk with no game, where the player's words go in analysis
 // before any game was played here (Priya); none while the data folder cannot be made.
-function gameSeen(context) {
+function gameSeen(home) {
     try {
-        const folder = gameFolder(context.home());
+        const folder = gameFolder(home());
         return `${folder}
 ${gameStamp(folder) ?? ""}
 ${tableTalkStamp(folder) ?? ""}`;
@@ -198,19 +234,46 @@ ${tableTalkStamp(folder) ?? ""}`;
  */
 function watchGame(served) {
     let waiting;
+    let quiet;
     let watching = [];
+    let game;
+    // An analyst that writes nothing for half an hour counts as gone, which no file tells: the pages, and what waits for the chat at rest, hear it then.
+    const analystGoesQuiet = () => {
+        clearTimeout(quiet);
+        const left = analystQuietIn(served);
+        quiet = left === undefined ? undefined : setTimeout(() => {
+            tellWatchers(served.watchers);
+            startWhenAtRest(served);
+            updateWhenAtRest(served);
+        }, left + 100).unref();
+    };
     const watchAll = () => {
         watching.forEach((watcher) => watcher.close());
-        watching = watchedFolders(served).flatMap((folder) => watchFolder(folder, heard));
+        const folders = watchedFolders(served);
+        game = folders.length === 0 ? undefined : basename(folders.at(-1));
+        watching = folders.flatMap((folder) => watchFolder(folder, heard));
+        analystGoesQuiet();
     };
-    // A save writes a new file and renames it: the events of one save come together, and the pages hear of it once.
-    const heard = (name) => {
-        if ((name === null || watched.test(name)) && waiting === undefined) {
+    // A save writes a new file and renames it: the events of one save come together, and the pages hear of it once. Of the ponder agent's thoughts,
+    // only its sign coming or going.
+    let news = false;
+    // On Windows the profiles' folder hears every write in the game's folder, as a change of it: the game folder's own watcher hears what it was.
+    const heard = (name, event) => {
+        if (name !== null && (!watched.test(name) || (event === "change" && name === game))) {
+            return;
+        }
+        news ||= name !== "thoughts.json";
+        if (waiting === undefined) {
             waiting = setTimeout(() => {
                 waiting = undefined;
+                const tell = news || thinkingChanged(served);
+                news = false;
                 watchAll();
-                tellWatchers(served.watchers);
-                // A game that has ended lets an update installed meanwhile start the table again (D-108).
+                if (tell) {
+                    tellWatchers(served.watchers);
+                }
+                // An analyst that has ended lets what waited for the chat start (D-107), and a game that has ended an update installed meanwhile (D-108).
+                startWhenAtRest(served);
                 updateWhenAtRest(served);
             }, 30);
         }
@@ -218,10 +281,21 @@ function watchGame(served) {
     watchAll();
     return () => {
         clearTimeout(waiting);
+        clearTimeout(quiet);
         watching.forEach((watcher) => watcher.close());
     };
 }
-// None while the data folder cannot be made: each tool call tells the chat why, and the page reads the game as it loads.
+// How long the analyst at work may still write nothing before it counts as gone; none without one, one gone already, or while the data folder cannot be made.
+function analystQuietIn(served) {
+    try {
+        const left = (analystQuietAt(served.context)?.getTime() ?? 0) - served.context.now().getTime();
+        return left > 0 ? left : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// None while the data folder cannot be made: each tool call tells the chat why, and the page reads the game as it loads. The game's folder last.
 function watchedFolders(served) {
     try {
         const home = served.context.home();
@@ -234,7 +308,7 @@ function watchedFolders(served) {
 // A folder watched, without its subfolders; none when it cannot be, or is not there yet: the pages see its files only as they load them.
 function watchFolder(folder, heard) {
     try {
-        const watcher = watch(folder, (event, name) => heard(name));
+        const watcher = watch(folder, (event, name) => heard(name, event));
         watcher.on("error", () => watcher.close());
         watcher.unref();
         return [watcher];
@@ -254,6 +328,17 @@ function fromHere(request, port, api) {
     return hosts.includes(request.headers.host ?? "") && (origin === undefined || hosts.some((host) => origin === `http://${host}`))
         && (!api || site === undefined || site === "same-origin" || site === "none");
 }
+/** Notes the port of a page off its folder's usual ports in the data folder: the data folder it noted it in, or none when it could not. */
+function notePort(served) {
+    try {
+        const home = served.context.home();
+        void notePagePort(home, served.folder, served.port);
+        return home;
+    }
+    catch {
+        return undefined;
+    }
+}
 function listened(server, port) {
     return new Promise((done) => {
         const failed = () => done(false);