chesspal 0.3.5 → 0.4.0

package/dist/server/page/game.js

@@ -1,12 +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, ponderingOn, 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) {
@@ -26,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);
@@ -111,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;
@@ -138,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.
@@ -150,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".';
@@ -233,6 +283,8 @@ async function studyFromPage(request, response, served) {
     const last = body?.last === true;
     // A game a link of the page opens is there to look at: the chat is not asked to go over it.
     const look = body?.look === true;
+    // «Analyse again», the review just deleted: the chat starts the analyst without asking, even after one was stopped (Priya).
+    const redo = body?.redo === true;
     if (pgn === undefined && game === undefined && !last) {
         send(response, 400, json, JSON.stringify({ error: asked, refusal: "pgn-unreadable" }));
         return;
@@ -249,10 +301,10 @@ 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, 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) {
@@ -289,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,
@@ -305,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),
@@ -327,7 +381,21 @@ function thinkingShown(served, current) {
         const onIt = served.bell.woke || (seen !== undefined && seen !== null && samePosition(seen, position));
         return served.bell.inTurn && onIt ? { thinking: "move" } : {};
     }
-    return ponderingOn(gameFolder(served.context.home()), thoughtKey(current)) ? { thinking: "ponder" } : {};
+    const until = ponderingUntil(gameFolder(served.context.home()), thoughtKey(current));
+    const left = until === undefined ? 0 : until.getTime() - served.context.now().getTime();
+    if (left <= 0) {
+        return {};
+    }
+    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) {
+    clearTimeout(signTimers.get(served));
+    signTimers.set(served, setTimeout(() => tellWatchers(served.watchers), wait + 100).unref());
 }
 /**
  * What the coach wrote that the player may see now, in a game going on with the helps on (D-88): its judgments, those whose note names a move they may still
@@ -353,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.
@@ -372,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);

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

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { type Refused } from "./http.ts";
 import type { Served } from "./page.ts";
 /** A host the table offers a chat in: whether it is installed, the models and efforts the player may choose, and the command to open one by hand. */
 export interface ChatHost {
@@ -19,13 +20,26 @@ export interface TableChats {
     /** Asks for the chat again: with another host, or `updated`, from the Chesspal just installed (D-108). */
     relaunch(folder: string, host?: string, updated?: boolean): boolean;
 }
-/** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own. */
+/** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own, and the seat, the play's process. */
 export interface HeldChat {
     readonly model?: string | undefined;
     readonly effort?: string | undefined;
+    readonly seat?: number;
 }
 /** A chat opening at the table: one the page asked for, the one started again for a new game, or with another model or host (D-107). */
 export type Opening = "chat" | "again" | "restart";
+/**
+ * What waits for the chat at the table to end its answer (D-107): a start again with another host, or a new game that wants a clean chat, which starts
+ * it again; the later request replaces the earlier. `start` starts the new game with the choices kept: whether the chat starts again for it; one that
+ * cannot start says why to the pages.
+ */
+export type ChatWait = {
+    readonly for: "restart";
+    readonly host: string;
+} | {
+    readonly for: "new-game";
+    readonly start: () => boolean;
+};
 /** What the table's page shows of its chat (D-104, D-107). */
 export interface TableShown {
     /** Whether a chat is at the table, and its host among those offered, when it says one. */
@@ -36,9 +50,15 @@ export interface TableShown {
     readonly started?: HeldChat;
     readonly hosts: readonly ChatHost[];
     readonly opening?: Opening;
-    /** A start again asked while the chat was at work, waiting for it to end its answer, or to be started at once or let go from the page. */
-    readonly waiting?: true;
+    /** A start again or a new game asked while the chat was at work, waiting for it to end its answer, or to be started at once or let go from the page. */
+    readonly waiting?: ChatWait["for"];
+    /** Why the last new game that waited for the chat could not start, numbered so that each page says it once. */
+    readonly refused?: WaitRefused;
 }
+/** A new game that waited for the chat and could not start: why, and its number, larger for each. */
+export type WaitRefused = Refused & {
+    readonly number: number;
+};
 /** What the table's page shows of its chat: whether one is at the table, with which host, the hosts it can open one in, and one opening. */
 export declare function tableShown(served: Served): {
     table?: TableShown;
@@ -55,10 +75,25 @@ export declare function chatToRelaunch(served: Served): boolean;
  * it was asked; the pages then show it opening.
  */
 export declare function relaunchChat(served: Served, how?: "again" | "restart", host?: string): boolean;
-/** Starts the chat again as the page asked while it was at work, now that it has ended its answer; a chat gone meanwhile takes the request with it. */
-export declare function restartWhenAtRest(served: Served): void;
+/**
+ * Whether a new game that wants a clean chat waits for the chat at the table to end its answer, then starts it again (D-57, D-107): `chesspal play` holds
+ * it, it is at work, and no analyst of it is; with an analyst at work the player is asked for /clear, as with a chat opened by hand.
+ */
+export declare function chatToWaitFor(served: Served): boolean;
+/**
+ * Does what the page asked while the chat was at work, now that it has ended its answer. A chat gone meanwhile takes a start again with it; a new game
+ * starts without it, and loses nothing: the next chat at the table is a clean one.
+ */
+export declare function startWhenAtRest(served: Served): void;
+/** A new game that waited for the chat could not start (D-107): the pages say why, each once. */
+export declare function refuseWaited(served: Served, refused: Refused): void;
 /**
  * Once npm has installed the newer Chesspal (D-108), and no game goes on and the chat is at rest, as a game or a chat may have started while npm worked:
  * the chat `chesspal play` holds starts again from it, clean, and once it has left the table, the table closes to start again from it too.
  */
 export declare function updateWhenAtRest(served: Served): void;
+/**
+ * Whether the chat's analyst is at work, on `game` when named: one whose chat started again since it took its game, or that has written nothing for half an
+ * hour, is gone (D-109). The chat's starts are in its own folder: on the table, the attached chat's.
+ */
+export declare function analystAtWork(served: Served, game?: string | undefined): boolean;