chesspal 0.2.4 → 0.3.1

package/dist/server/page/page.js

@@ -4,40 +4,67 @@ import { watch } from "node:fs";
 import { createServer } from "node:http";
 import { join } from "node:path";
 import { positionIn, samePosition } from "../../commands/index.js";
+import { aiNameOf } from "../../core/index.js";
 import { 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.js";
 import { analysesOf, answerAnalyses } 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 { json, send } from "./http.js";
-import { answerProfiles } from "./profiles.js";
+import { answerProfiles, readRatingsOf } from "./profiles.js";
+import { answerTable, restartWhenAtRest } from "./table.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 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 async function startPage(context, opponent = () => undefined) {
+export async function startPage(context, options = {}) {
     const { folder } = context;
+    const { table } = options;
     const watchers = new Set();
-    const outdated = outdatedHostFiles(folder, context.platform).length > 0;
-    const served = { folder, context, opponent, bell: new Bell(() => hasNews(context), () => tellWatchers(served)), watchers, port: 0, outdated };
+    const chat = table === undefined ? chatSeenOf(context) : attachedSeen(() => served.attached);
+    const served = {
+        folder,
+        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).
+        bell: new Bell(() => hasNews(context, chat), () => {
+            restartWhenAtRest(served);
+            tellWatchers(watchers);
+        }),
+        watchers,
+        port: 0,
+        outdated: outdatedHostFiles(folder, context.platform).length > 0,
+        ...(table === undefined ? {} : { table }),
+    };
     const server = createServer((request, response) => answer(request, response, served));
-    for (const port of [...pagePorts(folder), 0]) {
+    const ports = table === undefined ? [...pagePorts(folder), 0] : pagePorts(folder);
+    for (const port of ports) {
         if (await listened(server, port)) {
             server.unref();
             served.port = portOf(server);
             const stopWatching = watchGame(served);
             return {
                 url: `http://127.0.0.1:${served.port}/`,
-                heard: () => tellWatchers(served),
+                heard: () => tellWatchers(watchers),
                 chatCalls: () => chatCalls(served),
+                toolEnded: () => undefined,
                 open: () => watchers.size > 0,
-                askNewGame: () => askNewGame(served),
+                inUse: () => watchers.size > 0 || served.attached !== undefined,
+                askNewGame: () => askNewGame(watchers),
                 close: () => closed(server, stopWatching),
             };
         }
     }
+    if (table !== undefined) {
+        throw new Error(`The table's ports ${ports.join(", ")} on 127.0.0.1 are taken by other programs: close them, or play from a chat, which serves its own page.`);
+    }
     throw new Error("Chesspal could not open a port for the page on 127.0.0.1: check that a firewall does not block local servers, then try again.");
 }
 /**
@@ -46,20 +73,22 @@ export async function startPage(context, opponent = () => undefined) {
  */
 export function chatHasRead(context, showed) {
     context.seen = gameSeen(context);
-    if (!showed) {
-        return;
-    }
-    const before = context.positionSeen;
-    try {
-        context.positionSeen = positionIn(gameFolder(context.home()));
-    }
-    catch {
-        context.positionSeen = null;
-    }
-    // The chat on another position may now be thinking on its move: the page hears it, which no file tells when no bell woke the chat.
-    if (!sameSeen(before, context.positionSeen)) {
-        context.heard?.();
+    if (showed) {
+        const before = context.positionSeen;
+        try {
+            context.positionSeen = positionIn(gameFolder(context.home()));
+        }
+        catch {
+            context.positionSeen = null;
+        }
+        context.positionFirstSeen ??= context.positionSeen ?? undefined;
+        // The chat on another position may now be thinking on its move: the page hears it, which no file tells when no bell woke the chat.
+        if (!sameSeen(before, context.positionSeen)) {
+            context.heard?.();
+        }
     }
+    // The table the chat is attached to reads it from a copy (D-104).
+    context.toolEnded?.();
 }
 function sameSeen(one, other) {
     return one === other || (one !== undefined && one !== null && other !== undefined && other !== null && samePosition(one, other));
@@ -74,7 +103,13 @@ function answer(request, response, served) {
         send(response, 403, "text/plain; charset=utf-8", "Chesspal's page answers only at its own address on this machine.");
         return;
     }
-    if (answerProfiles(request, response, url, served) || answerGame(request, response, url, served) || answerAnalyses(request, response, url, served)) {
+    // A probe is no use of the table: a chat on its own page looks for it after each tool, and the hooks look for theirs.
+    if (!(path === "/api/bell" && url.searchParams.has("probe"))) {
+        served.table?.used();
+    }
+    const answered = answerProfiles(request, response, url, served) || answerGame(request, response, url, served) || answerAnalyses(request, response, url, served)
+        || answerChat(request, response, url, served) || answerTable(request, response, url, served);
+    if (answered) {
         return;
     }
     // The API answers GET alone: a HEAD at the doorbell would wait there as a hook does.
@@ -90,11 +125,13 @@ function answer(request, response, served) {
         send(response, 200, json, JSON.stringify(analysesOf(served.context.home())));
     }
     else if (path === "/api/events") {
-        keepPosted(request, response, served);
+        keepPosted(request, response, served.watchers);
+        // A page that opens reads the player's ratings again after a day (D-106).
+        readRatingsOf(served);
     }
     else if (path === "/api/bell") {
         if (url.searchParams.has("probe")) {
-            send(response, 200, json, JSON.stringify(bellProbe(served.folder, served.watchers.size > 0)));
+            send(response, 200, json, JSON.stringify(bellProbe(served.folder, served.watchers.size > 0, tableChat(served))));
         }
         else {
             served.bell.listen(request, response);
@@ -104,12 +141,20 @@ function answer(request, response, served) {
         sendFile(response, path);
     }
 }
+/** The chat at the table, as its probe says it: none on a page a chat serves itself. */
+function tableChat(served) {
+    if (served.table === undefined) {
+        return undefined;
+    }
+    const chat = served.attached?.chat;
+    return chat === undefined ? { session: null } : { session: chat.session, chat: chat.folder };
+}
 /**
  * Whether the chat has news from the page: a game changed since the chat's last tool, by the player's move, words, draw or resignation, a new game or a
  * 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) {
-    return gameSeen(context) !== context.seen;
+function hasNews(context, chat) {
+    return gameSeen(context) !== 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.
@@ -124,25 +169,6 @@ ${tableTalkStamp(folder) ?? ""}`;
         return "";
     }
 }
-/** 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. */
-function keepPosted(request, response, served) {
-    response.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
-    response.write(": posted\n\n");
-    served.watchers.add(response);
-    request.on("close", () => served.watchers.delete(response));
-}
-/** The pages open now open their New game window; whether there was one. */
-function askNewGame(served) {
-    for (const watcher of served.watchers) {
-        watcher.write("data: new-game\n\n");
-    }
-    return served.watchers.size > 0;
-}
-function tellWatchers(served) {
-    for (const watcher of served.watchers) {
-        watcher.write("data: changed\n\n");
-    }
-}
 /**
  * Watches the data folder, its profiles and the profile in use for changes to the game and the profiles, whoever makes them (the AI's tools, another chat,
  * the CLI, a hand edit): the pages hear of them. Each folder is watched on its own, never its whole tree, and watched again after each change, since the
@@ -161,7 +187,7 @@ function watchGame(served) {
             waiting = setTimeout(() => {
                 waiting = undefined;
                 watchAll();
-                tellWatchers(served);
+                tellWatchers(served.watchers);
             }, 30);
         }
     };
@@ -195,7 +221,7 @@ function watchFolder(folder, heard) {
 }
 // The current game, what the coach wrote on it, whether the AI thinks on the player's time, the talk before the first, the game in analysis, the profile
 // in use, and what a profile keeps (who plays, their picture, their settings); a folder's name, for a profile made or gone.
-const watched = /^(?:game\.json|coach\.json|thoughts\.json|talk\.json|analysis\.json|active\.json|profile\.md|settings\.json|avatar\.\w+|[a-z0-9-]+)$/;
+const watched = /^(?:game\.json|coach\.json|thoughts\.json|talk\.json|analysis\.json|active\.json|profile\.md|settings\.json|ratings\.json|avatar\.\w+|[a-z0-9-]+)$/;
 function fromHere(request, port, api) {
     const hosts = [`127.0.0.1:${port}`, `localhost:${port}`];
     const origin = request.headers.origin;

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

@@ -17,3 +17,8 @@ export interface ProfilesShown {
 export declare function profilesShown(root: string, userFolder?: string): ProfilesShown;
 /** Answers the page's requests about profiles: true when the request was one. A file that cannot be written is told to the page, and the server goes on. */
 export declare function answerProfiles(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
+/**
+ * Reads the ratings of a profile, the one in use unless named, again a day after the last reading, while the page goes on: the pages hear of them from the
+ * watcher (D-106).
+ */
+export declare function readRatingsOf(served: Served, id?: string): void;

package/dist/server/page/profiles.js

@@ -1,6 +1,6 @@
 import { homedir } from "node:os";
 import { isAbsolute, relative, sep } from "node:path";
-import { chooseDrawnAvatar, GameGoingOn, inputProblems, newProfile, setAccounts, useProfile } from "../../commands/index.js";
+import { chooseDrawnAvatar, editProfile, GameGoingOn, inputProblems, newProfile, ratingsAge, refreshRatings, useProfile } from "../../commands/index.js";
 import { activeProfile, drawnAvatars, imageTypes, listProfiles, ownImage, ownImageStamp, profileFolder, profileSettings, saveOwnImage, saveProfileSettings, sentImageLimit, settingsOf, } from "../../profiles/index.js";
 import { bodyOf, bytesOf, isJson, jsonOf, runRoute, send, sendJson } from "./http.js";
 /** The profiles of the data folder, as the page shows them. */
@@ -25,7 +25,7 @@ const routes = {
     "POST /api/profile/new": newProfileFromPage,
     "POST /api/profile/use": useProfileFromPage,
     "POST /api/profile/avatar": drawnAvatarFromPage,
-    "POST /api/profile/accounts": accountsFromPage,
+    "POST /api/profile/edit": editFromPage,
     "POST /api/profile/image": imageFromPage,
     "GET /api/profile/image": sendImage,
     "POST /api/settings": settingsFromPage,
@@ -48,7 +48,7 @@ async function newProfileFromPage(request, response, served) {
         sendJson(response, 409, refusalOf(error));
     }
 }
-/** Another profile put in use from the menu, once the game going on has ended: the chat is not woken for it (D-66). */
+/** Another profile put in use from the menu, once the game going on has ended: the chat is not woken for it (D-66); its ratings are read again after a day (D-106). */
 async function useProfileFromPage(request, response, served) {
     const profile = isJson(request) ? jsonOf(await bodyOf(request))?.profile : undefined;
     if (typeof profile !== "string") {
@@ -63,6 +63,7 @@ async function useProfileFromPage(request, response, served) {
         return;
     }
     sendJson(response, 200, { profile });
+    readRatingsOf(served, profile);
 }
 /** A drawn avatar for the profile the page shows, in place of the player's own image. */
 async function drawnAvatarFromPage(request, response, served, url) {
@@ -79,21 +80,24 @@ async function drawnAvatarFromPage(request, response, served, url) {
     chooseDrawnAvatar(served.context, profile.id, drawn);
     sendJson(response, 200, { avatar: drawn });
 }
-/** The player's names on Lichess and chess.com for the profile the page shows (D-93), in a game or in analysis too: they change only which side is theirs. */
-async function accountsFromPage(request, response, served, url) {
+/**
+ * What the player changes in the profile window for the profile the page shows, in a game or in analysis too: their name, how they play, their names on
+ * Lichess and chess.com (D-93), each saved once changed; the profile keeps its folder (D-106).
+ */
+async function editFromPage(request, response, served, url) {
     const body = isJson(request) ? jsonOf(await bodyOf(request)) : undefined;
-    const input = setAccounts.input.safeParse(body ?? {});
+    const input = editProfile.input.safeParse(body ?? {});
     const profile = profileInUse(served, url, response);
     if (profile === undefined) {
         return;
     }
     if (body === undefined || !input.success) {
-        const problems = input.success ? "" : ` ${inputProblems("set_accounts", input.error.issues, body ?? {}, (name) => name)}`;
-        sendJson(response, 400, { error: `Send the names as JSON, {"lichess": "…", "chesscom": "…"}.${problems}` });
+        const problems = input.success ? "" : ` ${inputProblems("edit_profile", input.error.issues, body ?? {}, (name) => name)}`;
+        sendJson(response, 400, { error: `Send the changes as JSON, {"name": "…", "level": "regular", "lichess": "…", "chesscom": "…", "fide": 1650}.${problems}` });
         return;
     }
-    const { accounts } = await setAccounts.run(input.data, served.context);
-    sendJson(response, 200, { accounts: accounts ?? {} });
+    const edited = await editProfile.run(input.data, served.context);
+    sendJson(response, 200, { profile: shown(served.context.home(), edited) });
 }
 /**
  * The player's own image for a profile, as the page made it from their photo: a PNG, JPEG or WebP of 1 MB at most. The one in use, or one just added while a
@@ -168,6 +172,18 @@ async function openDataFolder(request, response, served) {
     }
     sendJson(response, 200, { opened: true });
 }
+/**
+ * Reads the ratings of a profile, the one in use unless named, again a day after the last reading, while the page goes on: the pages hear of them from the
+ * watcher (D-106).
+ */
+export function readRatingsOf(served, id) {
+    try {
+        void refreshRatings(served.context, id ?? activeProfile(served.context.home()).id, ratingsAge).catch(() => false);
+    }
+    catch {
+        // No data folder yet: the page says why as it loads.
+    }
+}
 /**
  * The profile in use, when it is the one the page shows (?profile=): a page that has not yet heard of another put in use elsewhere is refused, so that its
  * choices never go to the wrong player.

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

@@ -0,0 +1,58 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+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 {
+    readonly name: string;
+    readonly installed: boolean;
+    readonly models: readonly string[];
+    readonly efforts: readonly string[];
+    readonly command: string;
+}
+/**
+ * How the table opens a chat: the hosts it offers, and a terminal with one of them, whether one opened; the chat `chesspal play` holds in a folder, with
+ * the model and effort it started with, and how it is asked to start it again.
+ */
+export interface TableChats {
+    hosts(): readonly ChatHost[];
+    open(host: string): Promise<boolean>;
+    held(folder: string): HeldChat | undefined;
+    relaunch(folder: string, host?: string): boolean;
+}
+/** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own. */
+export interface HeldChat {
+    readonly model?: string | undefined;
+    readonly effort?: string | undefined;
+}
+/** 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 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. */
+    readonly chat: boolean;
+    readonly host?: string;
+    /** Whether `chesspal play` holds the chat, which the page can then start again; one opened by hand it cannot. With the model and effort it started with. */
+    readonly held: boolean;
+    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;
+}
+/** 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;
+};
+/** Answers the table's own routes, under /api/table/; false for any other, and for every request to a page a chat serves itself. */
+export declare function answerTable(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
+/**
+ * Whether a new game starts the chat at the table again, clean (D-57): `chesspal play` holds it, it waits for the bell, no analyst of it is at work, and it
+ * has seen a game move since it was first shown one; one that only greeted the player stays, as one opened from the chat's window before a new game.
+ */
+export declare function chatToRelaunch(served: Served): boolean;
+/**
+ * Asks `chesspal play` to start the chat at the table again: once the new game has started, or with another model or host in its place (D-107). Whether
+ * 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;

package/dist/server/page/table.js

@@ -0,0 +1,210 @@
+import { samePosition } from "../../commands/index.js";
+import { gameInAnalysis } from "../../games/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { tellWatchers } from "./events.js";
+import { bodyOf, isJson, jsonOf, runRoute, sendJson } from "./http.js";
+/** 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 function tableShown(served) {
+    const { table, attached } = served;
+    if (table === undefined) {
+        return {};
+    }
+    const host = hostAtTable(served);
+    const held = heldChat(served);
+    const now = opening(served);
+    return {
+        table: {
+            chat: attached !== undefined,
+            ...(host === undefined ? {} : { host }),
+            held: held !== undefined,
+            ...(held === undefined ? {} : { started: held }),
+            hosts: table.chats?.hosts() ?? [],
+            ...(now === undefined ? {} : { opening: now }),
+            ...(served.restartWanted === undefined ? {} : { waiting: true }),
+        },
+    };
+}
+/** Answers the table's own routes, under /api/table/; false for any other, and for every request to a page a chat serves itself. */
+export function answerTable(request, response, url, served) {
+    const path = url.pathname;
+    if (served.table === undefined || request.method !== "POST" || !path.startsWith("/api/table/") || !isJson(request)) {
+        return false;
+    }
+    if (path === "/api/table/quit") {
+        // Another Chesspal version asks the table to quit, to start its own in its place.
+        sendJson(response, 200, { quitting: true });
+        served.table.quit();
+    }
+    else if (path === "/api/table/chat") {
+        runRoute(response, () => openChat(request, response, served));
+    }
+    else if (path === "/api/table/restart") {
+        runRoute(response, () => restartChat(request, response, served));
+    }
+    else if (path === "/api/table/waiting") {
+        runRoute(response, () => endWaiting(request, response, served));
+    }
+    else {
+        sendJson(response, 404, { error: `${path} is no route of the table's: it answers POST /api/table/chat, /api/table/restart, /api/table/waiting and /api/table/quit.` });
+    }
+    return true;
+}
+/**
+ * Whether a new game starts the chat at the table again, clean (D-57): `chesspal play` holds it, it waits for the bell, no analyst of it is at work, and it
+ * has seen a game move since it was first shown one; one that only greeted the player stays, as one opened from the chat's window before a new game.
+ */
+export function chatToRelaunch(served) {
+    const { positionSeen, positionFirstSeen } = served.chat;
+    const played = positionSeen?.started !== undefined && (positionFirstSeen === undefined || !samePosition(positionSeen, positionFirstSeen));
+    return played && heldChat(served) !== undefined && chatAtRest(served);
+}
+/**
+ * Asks `chesspal play` to start the chat at the table again: once the new game has started, or with another model or host in its place (D-107). Whether
+ * it was asked; the pages then show it opening.
+ */
+export function relaunchChat(served, how = "again", host) {
+    const folder = served.attached?.chat.folder;
+    // Another host may first ask whether it trusts the table's folder: the pages say so, as for a chat opened.
+    const switching = how === "restart" && host !== undefined && host !== hostAtTable(served);
+    if (folder === undefined || served.table?.chats?.relaunch(folder, host) !== true) {
+        return false;
+    }
+    noteOpening(served, switching ? "chat" : how);
+    return true;
+}
+/** 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 function restartWhenAtRest(served) {
+    const wanted = served.restartWanted;
+    if (wanted === undefined) {
+        return;
+    }
+    if (heldChat(served) === undefined) {
+        served.restartWanted = undefined;
+    }
+    else if (chatAtRest(served)) {
+        served.restartWanted = undefined;
+        relaunchChat(served, "restart", wanted.host);
+    }
+}
+// A terminal takes a few seconds to open and its chat to attach: a second click meanwhile would open a second chat, which serves a page of its own.
+const openingFor = 30_000;
+/**
+ * Opens a chat in a terminal, asked by the table's own page alone, which a browser marks with its origin: never while a chat is at the table, or one is
+ * opening. Whether it opened; else the page shows the command to type.
+ */
+async function openChat(request, response, served) {
+    const offered = hostOffered(served, jsonOf(await bodyOf(request))?.host);
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page opens a chat." });
+    }
+    else if (offered === undefined || served.table?.chats === undefined) {
+        sendJson(response, 400, { error: hostsOffered(served) });
+    }
+    else if (served.attached !== undefined || opening(served) !== undefined) {
+        sendJson(response, 409, { error: "A chat is at the table, or opening: play there." });
+    }
+    else {
+        const opened = noteOpening(served, "chat");
+        const started = await served.table.chats.open(offered.name);
+        if (!started && served.chatOpened === opened) {
+            served.chatOpened = undefined;
+        }
+        sendJson(response, 200, { opened: started });
+        tellWatchers(served.watchers);
+    }
+}
+/**
+ * Starts the chat `chesspal play` holds again, clean, with the host the page names and the model and effort it keeps for it (D-107): at once when it is at
+ * rest, else once it has ended its answer. Asked by the table's own page alone; a chat opened by hand changes its model with /model.
+ */
+async function restartChat(request, response, served) {
+    const offered = hostOffered(served, jsonOf(await bodyOf(request))?.host);
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page starts the chat again." });
+    }
+    else if (offered === undefined) {
+        sendJson(response, 400, { error: hostsOffered(served) });
+    }
+    else if (heldChat(served) === undefined) {
+        sendJson(response, 409, { error: "No chat the table opened is at it: open one from the page, or change the model with /model in a chat opened by hand." });
+    }
+    else if (chatAtRest(served)) {
+        sendJson(response, 200, { restarting: relaunchChat(served, "restart", offered.name) });
+    }
+    else {
+        served.restartWanted = { host: offered.name };
+        tellWatchers(served.watchers);
+        sendJson(response, 200, { waiting: true });
+    }
+}
+/**
+ * Ends a start again the page asked while the chat was at work (D-107): `now` starts it at once, cutting the answer it gives, as after an Esc, when it would
+ * never end; else the request is let go. Asked by the table's own page alone.
+ */
+async function endWaiting(request, response, served) {
+    const now = jsonOf(await bodyOf(request))?.now;
+    const wanted = served.restartWanted;
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page ends a start again that waits." });
+    }
+    else if (typeof now !== "boolean") {
+        sendJson(response, 400, { error: "Say now: true to start the chat again at once, cutting its answer, or now: false to let the request go." });
+    }
+    else if (wanted === undefined) {
+        sendJson(response, 409, { error: "No start again waits: ask for one from the chat's window." });
+    }
+    else {
+        served.restartWanted = undefined;
+        const restarting = now && heldChat(served) !== undefined && relaunchChat(served, "restart", wanted.host);
+        tellWatchers(served.watchers);
+        sendJson(response, 200, now ? { restarting } : { waiting: false });
+    }
+}
+// The browser marks a request of the table's own page with its origin.
+function fromTablePage(request, served) {
+    return request.headers.origin === `http://127.0.0.1:${served.port}` || request.headers.origin === `http://localhost:${served.port}`;
+}
+function hostOffered(served, host) {
+    return served.table?.chats?.hosts().find((one) => one.name === host && one.installed);
+}
+function hostsOffered(served) {
+    return `Name a host the table offers and this computer has: ${served.table?.chats?.hosts().filter((one) => one.installed).map((one) => one.name).join(", ") || "none"}.`;
+}
+// The host of the chat at the table, among those offered: it says its name as its MCP client does, «claude-code» or «codex-mcp-client».
+function hostAtTable(served) {
+    const said = served.chat.host()?.toLowerCase() ?? "";
+    return served.attached === undefined ? undefined : served.table?.chats?.hosts().find((one) => said.includes(one.name))?.name;
+}
+// The chat at the table when `chesspal play` holds it, which the table can start again: the model and effort it started with.
+function heldChat(served) {
+    const { attached } = served;
+    return attached === undefined ? undefined : served.table?.chats?.held(attached.chat.folder);
+}
+// The chat waits for the doorbell, out of a turn, and no analyst of it is at work: starting it again loses nothing.
+function chatAtRest(served) {
+    const { bell } = served;
+    return bell.listening && !bell.inTurn && gameInAnalysis(gameFolder(served.context.home()))?.analyst === undefined;
+}
+// The pages show a chat opening from now until it attaches; one that has not by then lets them open another. The opening noted.
+function noteOpening(served, how) {
+    const opened = { at: served.context.now().getTime(), how };
+    served.chatOpened = opened;
+    tellWatchers(served.watchers);
+    setTimeout(() => {
+        if (served.chatOpened === opened) {
+            tellWatchers(served.watchers);
+        }
+    }, openingFor).unref();
+    return opened;
+}
+// A chat opening, with none at the table: one noted lately, or one chesspal play holds the seat for, as at a trust prompt longer than the wait.
+function opening(served) {
+    const { attached, chatOpened, context } = served;
+    if (attached !== undefined) {
+        return undefined;
+    }
+    if (chatOpened !== undefined && context.now().getTime() - chatOpened.at < openingFor) {
+        return chatOpened.how;
+    }
+    return served.table?.chats?.held(context.folder) === undefined ? undefined : "chat";
+}

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

@@ -0,0 +1,6 @@
+/** Opens an address in a window of its own, else in a tab of the default browser, without waiting for it: whether a browser started. */
+export declare function openInBrowser(url: string, platform: string): Promise<boolean>;
+/** The address of the window the table opens, marked so that the page sizes it the first time (page/layout/window.ts). */
+export declare function openedAddress(url: string): string;
+/** Chrome or Edge, where each system installs them: the first there is; none when neither is. */
+export declare function appBrowser(platform: string, env: NodeJS.ProcessEnv, exists?: (path: string) => boolean): string | undefined;

package/dist/server/table/browser.js

@@ -0,0 +1,48 @@
+// The table's page opened in the player's browser (D-104): in a window of its own, as an application, when Chrome or Edge is installed, which open one with
+// --app; else in a tab of the system's default browser.
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { posix, win32 } from "node:path";
+import { openFolder } from "../../home/index.js";
+/** Opens an address in a window of its own, else in a tab of the default browser, without waiting for it: whether a browser started. */
+export async function openInBrowser(url, platform) {
+    const browser = appBrowser(platform, process.env);
+    // Explorer, open and xdg-open take an address as they take a folder, and hand it to the default browser.
+    return (browser !== undefined && await started(browser, [`--app=${openedAddress(url)}`])) || openFolder(url, platform);
+}
+/** The address of the window the table opens, marked so that the page sizes it the first time (page/layout/window.ts). */
+export function openedAddress(url) {
+    const address = new URL(url);
+    address.searchParams.set("opened", "");
+    return address.href;
+}
+/** Chrome or Edge, where each system installs them: the first there is; none when neither is. */
+export function appBrowser(platform, env, exists = existsSync) {
+    return browserPaths(platform, env).find(exists);
+}
+// Chrome before Edge: Chrome is the one tried, and Edge may be missing even on Windows.
+function browserPaths(platform, env) {
+    if (platform === "win32") {
+        const roots = [env.ProgramFiles, env["ProgramFiles(x86)"], env.LOCALAPPDATA].filter((root) => root !== undefined && root !== "");
+        const programs = [["Google", "Chrome", "Application", "chrome.exe"], ["Microsoft", "Edge", "Application", "msedge.exe"]];
+        return programs.flatMap((program) => roots.map((root) => win32.join(root, ...program)));
+    }
+    if (platform === "darwin") {
+        const roots = ["/Applications", ...(env.HOME === undefined ? [] : [posix.join(env.HOME, "Applications")])];
+        return ["Google Chrome", "Microsoft Edge"].flatMap((name) => roots.map((root) => posix.join(root, `${name}.app`, "Contents", "MacOS", name)));
+    }
+    const folders = (env.PATH ?? "").split(":").filter((folder) => folder !== "");
+    const names = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "microsoft-edge-stable"];
+    return names.flatMap((name) => folders.map((folder) => posix.join(folder, name)));
+}
+// A browser started apart from this process, which it outlives: whether it started.
+function started(browser, args) {
+    return new Promise((done) => {
+        const opened = spawn(browser, args, { detached: true, stdio: "ignore" });
+        opened.once("spawn", () => {
+            opened.unref();
+            done(true);
+        });
+        opened.once("error", () => done(false));
+    });
+}

package/dist/server/table/hosts/chats.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from "../../../commands/index.ts";
+import type { TableChats } from "../../page/table.ts";
+/**
+ * The chats of a real table: the hosts installed, looked for again once a while has passed, since the player may install one with the page open; a
+ * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's.
+ */
+export declare function terminalChats(context: Context, chesspal?: readonly string[], env?: NodeJS.ProcessEnv): TableChats;