chesspal 0.1.0 → 0.2.1

package/dist/server/page.js

@@ -1,657 +0,0 @@
-// The page on localhost (D-8, D-47): its HTML with the import map, its scripts, the chess core and the packages they import, the game it shows and keeps
-// up to date, the player's moves and words (T-65), draws and resignations (D-65), and the doorbell that wakes the chat when the player acts there.
-import { createHash } from "node:crypto";
-import { readFileSync, watch } from "node:fs";
-import { createServer } from "node:http";
-import { createRequire } from "node:module";
-import { extname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { analyseGame } from "../commands/analyse-game.js";
-import { gameAt } from "../commands/clock.js";
-import { answerDraw, DrawRefused, offerDraw } from "../commands/draw-offer.js";
-import { endGame } from "../commands/end-game.js";
-import { ChatNotClear, newGame, startNewGame } from "../commands/new-game.js";
-import { bookPlies } from "../commands/opening-book.js";
-import { playMove, positionIn } from "../commands/play-move.js";
-import { say } from "../commands/say.js";
-import { gameToStudy, namedGame } from "../commands/study.js";
-import { clockStarted, writePgn } from "../core/index.js";
-import { aiModelOf, drawOfferOf, endOf, gameInAnalysis, gameStamp, heardLines, loadGame, loadTableTalk, playerPgn, saveGame, startAnalysis, talkLimits, wakesTheChat, WordsRefused } from "../games/index.js";
-import { gameFolder } from "../profiles/index.js";
-import { analysesOf, isReviewed } from "./analyses.js";
-import { Bell, bellProbe, pagePorts } from "./bell.js";
-import { bodyOf, bytesOf, isJson, json, jsonOf, send, textOf } from "./http.js";
-import { answerProfiles, profilesShown } from "./profile-routes.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.
- */
-export async function startPage(context, opponent = () => undefined) {
-    const { folder } = context;
-    const watchers = new Set();
-    const served = { folder, context, opponent, bell: new Bell(() => hasNews(context), () => tellWatchers(served)), watchers, port: 0 };
-    const server = createServer((request, response) => answer(request, response, served));
-    for (const port of [...pagePorts(folder), 0]) {
-        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),
-                chatCalls: () => chatCalls(served),
-                open: () => watchers.size > 0,
-                askNewGame: () => askNewGame(served),
-                close: () => closed(server, stopWatching),
-            };
-        }
-    }
-    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.");
-}
-// The built page and core: dist/, from src/server and from dist/server alike.
-const built = fileURLToPath(new URL("../../dist/", import.meta.url));
-// The modules the page imports from packages, by the names the import map gives them: a package, and its file.
-const vendorModules = {
-    "preact.js": ["preact", "dist/preact.module.js"],
-    "hooks.js": ["preact", "hooks/dist/hooks.module.js"],
-    "jsx-runtime.js": ["preact", "jsx-runtime/dist/jsxRuntime.module.js"],
-    "chess.js": ["chess.js", "dist/esm/chess.js"],
-};
-const importMap = JSON.stringify({
-    imports: { "preact": "/vendor/preact.js", "preact/hooks": "/vendor/hooks.js", "preact/jsx-runtime": "/vendor/jsx-runtime.js", "chess.js": "/vendor/chess.js" },
-});
-// The page runs only its own files and the import map written in it, known by its hash.
-const policy = `default-src 'self'; script-src 'self' 'sha256-${createHash("sha256").update(importMap).digest("base64")}'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; `
-    + "base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
-const html = [
-    "<!doctype html>",
-    '<html lang="en">',
-    '<meta charset="utf-8">',
-    '<meta name="viewport" content="width=device-width, initial-scale=1">',
-    '<meta name="color-scheme" content="light dark">',
-    "<title>Chesspal</title>",
-    '<link rel="stylesheet" href="/page/style.css">',
-    `<script type="importmap">${importMap}</script>`,
-    '<script type="module" src="/page/main.js"></script>',
-    '<div id="app"></div>',
-    "",
-].join("\n");
-const types = { ".js": "text/javascript; charset=utf-8", ".css": "text/css; charset=utf-8", ".svg": "image/svg+xml", ".webp": "image/webp", ".json": "application/json; charset=utf-8", ".ogg": "audio/ogg" };
-function answer(request, response, served) {
-    const url = new URL(request.url ?? "/", "http://127.0.0.1");
-    const path = url.pathname;
-    // Only this machine's pages: another site the browser shows can neither read the game nor move through the player's browser. A link from another site,
-    // such as the chat's, still opens the page.
-    if (!fromHere(request, served.port, path.startsWith("/api/"))) {
-        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)) {
-        return;
-    }
-    if (request.method === "POST" && path === "/api/move") {
-        void moveFromPage(request, response, served);
-        return;
-    }
-    if (request.method === "POST" && path === "/api/message") {
-        void messageFromPage(request, response, served);
-        return;
-    }
-    if (request.method === "POST" && path === "/api/new") {
-        void newGameFromPage(request, response, served);
-        return;
-    }
-    if (request.method === "POST" && path === "/api/draw") {
-        void drawFromPage(request, response, served);
-        return;
-    }
-    if (request.method === "POST" && path === "/api/resign") {
-        resignFromPage(request, response, served);
-        return;
-    }
-    if (request.method === "POST" && path === "/api/start") {
-        startFromPage(request, response, served);
-        return;
-    }
-    if (request.method === "POST" && path === "/api/study") {
-        void studyFromPage(request, response, served);
-        return;
-    }
-    // The API answers GET alone: a HEAD at the doorbell would wait there as a hook does.
-    if (request.method !== "GET" && (request.method !== "HEAD" || path.startsWith("/api/"))) {
-        send(response, 405, "text/plain; charset=utf-8", "The page only reads, moves with POST /api/move, writes with POST /api/message, starts a game with POST /api/new and its clocks with POST /api/start, "
-            + "offers or answers a draw with POST /api/draw, resigns with POST /api/resign, brings a game to analyse or opens one again with POST /api/study, and keeps the profiles with POST /api/profile/… and /api/settings.");
-        return;
-    }
-    if (path === "/") {
-        send(response, 200, "text/html; charset=utf-8", html, { "Content-Security-Policy": policy });
-    }
-    else if (path === "/api/game") {
-        sendGame(response, served);
-    }
-    else if (path === "/api/analyses") {
-        send(response, 200, json, JSON.stringify(analysesOf(served.context.home())));
-    }
-    else if (path === "/api/events") {
-        keepPosted(request, response, served);
-    }
-    else if (path === "/api/bell") {
-        if (url.searchParams.has("probe")) {
-            send(response, 200, json, JSON.stringify(bellProbe(served.folder, served.watchers.size > 0)));
-        }
-        else {
-            served.bell.listen(request, response);
-        }
-    }
-    else {
-        sendFile(response, path);
-    }
-}
-/**
- * The player's move from the page, with their words when they wrote some: played as player_move plays it (D-47) and saved with the words, refused in the
- * player's words, and the doorbell rung for the chat.
- */
-async function moveFromPage(request, response, served) {
-    // A form of another site can post text, never JSON without asking first: the type keeps it out, with the origin.
-    if (!isJson(request)) {
-        send(response, 415, json, JSON.stringify({ error: 'Send the move as JSON: {"move": "e2e4"}.' }));
-        return;
-    }
-    const body = jsonOf(await bodyOf(request));
-    const move = textOf(body?.move);
-    if (move === undefined || (body?.message !== undefined && typeof body.message !== "string")) {
-        send(response, 400, json, JSON.stringify({ error: 'Send the move as JSON, in SAN or as squares, with your words if you like: {"move": "e2e4", "message": "…"}.' }));
-        return;
-    }
-    const refused = refusalOf(served);
-    if (refused !== undefined) {
-        send(response, 409, json, JSON.stringify(refused));
-        return;
-    }
-    const message = textOf(body?.message);
-    let illegal = false;
-    try {
-        const now = served.context.now();
-        const refuse = (problem) => {
-            illegal = true;
-            return problem;
-        };
-        playMove(gameFolder(served.context.home()), now, "player", move, refuse, message === undefined ? {} : { said: { text: message, at: now } });
-    }
-    catch (error) {
-        // The game may have changed since the page read it: the move refused, the AI's turn, a flag fallen.
-        send(response, 409, json, JSON.stringify(refusalFrom(error, illegal ? "illegal" : refusalOf(served)?.refusal)));
-        return;
-    }
-    // The pages hear of the move from the watcher, as of every other.
-    served.bell.ring();
-    send(response, 200, json, JSON.stringify({ played: true }));
-}
-/** The player's words from the page, without a move: saved with the game as player_say saves them, refused in the player's words, the doorbell rung for the first. */
-async function messageFromPage(request, response, served) {
-    if (!isJson(request)) {
-        send(response, 415, json, JSON.stringify({ error: 'Send the message as JSON: {"text": "…"}.' }));
-        return;
-    }
-    const text = textOf(jsonOf(await bodyOf(request))?.text);
-    if (text === undefined) {
-        send(response, 400, json, JSON.stringify({ error: `Send the message as JSON, ${talkLimits.player} characters at most: {"text": "…"}.` }));
-        return;
-    }
-    let current;
-    try {
-        current = say(gameFolder(served.context.home()), "player", text, served.context.now());
-    }
-    catch (error) {
-        const noGame = refusalOf(served)?.refusal === "no-game";
-        send(response, 409, json, JSON.stringify(refusalFrom(error, noGame ? "no-game" : undefined)));
-        return;
-    }
-    // The first words of a move wake the chat, and between games the first since the AI spoke; the AI finds the rest at its next call (D-54, D-74).
-    if (wakesTheChat(current)) {
-        served.bell.ring();
-    }
-    send(response, 200, json, JSON.stringify({ said: true }));
-}
-/**
- * A new game from the page, with the sides, the level and the clock the player chose (T-64, T-58): 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.
- */
-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;
-    if (body === undefined) {
-        send(response, isJson(request) ? 400 : 415, json, JSON.stringify({ error: asked }));
-        return;
-    }
-    try {
-        const before = loadGame(gameFolder(served.context.home()));
-        const input = newGame.input.safeParse({ ai_colour: body.ai_colour ?? before?.ai ?? "black", level: body.level, clock: body.clock, replace: true });
-        if (!input.success) {
-            send(response, 400, json, JSON.stringify({ error: asked }));
-            return;
-        }
-        // The game starts from the page, open: its clocks wait for the player's Start there.
-        startNewGame(input.data, { ...served.context, pageOpen: () => true }, "page");
-    }
-    catch (error) {
-        send(response, 409, json, JSON.stringify(refusalFrom(error)));
-        return;
-    }
-    served.bell.ring();
-    send(response, 200, json, JSON.stringify({ started: true }));
-}
-/** The player's draw from the page (D-65): an offer on their turn, which rings the doorbell, or their answer to the AI's, which rings it when accepted. */
-async function drawFromPage(request, response, served) {
-    const asked = 'Send the draw as JSON: {"action": "offer"}, "accept" or "decline".';
-    if (!isJson(request)) {
-        send(response, 415, json, JSON.stringify({ error: asked }));
-        return;
-    }
-    const action = jsonOf(await bodyOf(request))?.action;
-    if (action !== "offer" && action !== "accept" && action !== "decline") {
-        send(response, 400, json, JSON.stringify({ error: asked }));
-        return;
-    }
-    try {
-        if (action === "offer") {
-            offerDraw(served.context);
-        }
-        else {
-            answerDraw(served.context, action === "accept");
-        }
-    }
-    catch (error) {
-        send(response, 409, json, JSON.stringify(refusalFrom(error, refusalOf(served)?.refusal)));
-        return;
-    }
-    if (action !== "decline") {
-        served.bell.ring();
-    }
-    send(response, 200, json, JSON.stringify({ done: true }));
-}
-/** The player starts the clocks from the page, which wait from the game's start; the doorbell wakes the chat when its move is first, waiting for this. */
-function startFromPage(request, response, served) {
-    if (!isJson(request)) {
-        send(response, 415, json, JSON.stringify({ error: "Send the request as JSON: {}." }));
-        return;
-    }
-    const folder = gameFolder(served.context.home());
-    const current = loadGame(folder);
-    if (current?.clock?.waiting !== true || endOf(current.game) !== undefined) {
-        send(response, 409, json, JSON.stringify({ error: "No clock waits to start: start a game with a clock first." }));
-        return;
-    }
-    saveGame(folder, { ...current, clock: clockStarted(current.clock, served.context.now()) });
-    if (current.game.position.turn === current.ai) {
-        served.bell.ring();
-    }
-    send(response, 200, json, JSON.stringify({ started: true }));
-}
-/** The player resigns from the page (D-65), whoever is to move: the game ends and goes to the archive, and the doorbell tells the chat. */
-function resignFromPage(request, response, served) {
-    if (!isJson(request)) {
-        send(response, 415, json, JSON.stringify({ error: "Send the request as JSON: {}." }));
-        return;
-    }
-    try {
-        endGame.run({ result: "player_resigns" }, served.context);
-    }
-    catch (error) {
-        send(response, 409, json, JSON.stringify(refusalFrom(error, refusalOf(served)?.refusal === "no-game" ? "no-game" : undefined)));
-        return;
-    }
-    served.bell.ring();
-    send(response, 200, json, JSON.stringify({ resigned: true }));
-}
-/**
- * A game the player brings from elsewhere to analyse (T-92): kept to study and put in analysis as analyse_game does with a PGN, the page showing it at once,
- * and the doorbell rung for the chat to go over it. Never while a game goes on.
- */
-async function studyFromPage(request, response, served) {
-    const asked = 'Send the game as JSON: {"pgn": "[White \\"…\\"] … 1. e4 e5 …"}, one to open again by its name: {"game": "study/2026-11-04-153012.pgn"}, '
-        + 'or the game just over: {"last": true}.';
-    if (!isJson(request)) {
-        send(response, 415, json, JSON.stringify({ error: asked }));
-        return;
-    }
-    const body = jsonOf((await bytesOf(request, pgnLimit))?.toString("utf8"));
-    const pgn = textOf(body?.pgn);
-    const game = textOf(body?.game);
-    const last = body?.last === true;
-    if (pgn === undefined && game === undefined && !last) {
-        send(response, 400, json, JSON.stringify({ error: asked, refusal: "pgn-unreadable" }));
-        return;
-    }
-    if (refusalOf(served)?.refusal !== "no-game") {
-        send(response, 409, json, JSON.stringify({ error: "A game is going on: finish it before you bring another to analyse.", refusal: "game-going" }));
-        return;
-    }
-    let reviewed;
-    try {
-        // Without what the chat was told: the analyst's instructions stay for the AI's own analyse_game.
-        const opened = last ? lastPlayed(served.context) : game === undefined ? kept(served, pgn) : namedGame(served.context, game);
-        reviewed = isReviewed(opened.record);
-        // A game not yet reviewed is marked as brought, for status to ask the AI to go over it (T-92); one reviewed is ready, and the chat sleeps on (T-106).
-        startAnalysis(gameFolder(served.context.home()), opened.name, served.context.now(), !reviewed);
-    }
-    catch (error) {
-        send(response, 400, json, JSON.stringify({ error: error.message, refusal: "pgn-unreadable" }));
-        return;
-    }
-    if (!reviewed) {
-        served.bell.ring();
-    }
-    send(response, 200, json, JSON.stringify({ kept: true, reviewed }));
-}
-/** The game just over, or else the last one played, as analyse_game takes it without a name: always one of the archive. */
-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.");
-    }
-    return { name, record };
-}
-/** A game brought as a PGN, kept to study as analyse_game keeps it: the one already kept when it is the same game, with its review. */
-function kept(served, pgn) {
-    analyseGame.run({ pgn }, { ...served.context, told: undefined });
-    return namedGame(served.context, gameInAnalysis(gameFolder(served.context.home())).game);
-}
-/** The longest PGN the page brings: a long game with its clocks, and the comments a site adds, which go. */
-const pgnLimit = 256 * 1024;
-/** Why the player cannot move now; undefined when they can. */
-function refusalOf(served) {
-    try {
-        const current = gameNow(served);
-        if (current === undefined || endOf(current.game) !== undefined) {
-            return { error: "There is no game going on: start one in the chat.", refusal: "no-game" };
-        }
-        return current.game.position.turn === current.ai ? { error: "Wait for the AI's move.", refusal: "ai-to-move" } : undefined;
-    }
-    catch (error) {
-        return { error: error.message };
-    }
-}
-/** The refusal of an error thrown by a command, with its code when the error or the caller knows it. */
-function refusalFrom(error, refusal) {
-    const message = error.message;
-    if (error instanceof ChatNotClear) {
-        return { error: message, refusal: "clear-chat" };
-    }
-    if (error instanceof WordsRefused) {
-        return { error: message, refusal: `words-${error.reason}`, most: error.most };
-    }
-    if (error instanceof DrawRefused) {
-        return { error: message, refusal: `draw-${error.reason}` };
-    }
-    return refusal === undefined ? { error: message } : { error: message, refusal };
-}
-/** The game as the page reads it now: a flag that has fallen ends it (D-13), and the doorbell tells the chat, which hears how from status (T-37). */
-function gameNow(served) {
-    const folder = gameFolder(served.context.home());
-    const before = loadGame(folder);
-    // The AI's clock is held while nobody hears the player: its flag cannot fall before the chat is there to move.
-    if (before !== undefined && aiHeld(served, before)) {
-        return before;
-    }
-    const current = gameAt(folder, served.context.now());
-    if (before !== undefined && endOf(before.game) === undefined && current !== undefined && endOf(current.game) !== undefined) {
-        served.bell.ring();
-    }
-    return current;
-}
-/** Whether the AI's clock is held: a game with a clock, going on, the AI to move, and nobody hearing the player. */
-function aiHeld(served, current) {
-    return !served.bell.listening && current.clock !== undefined && endOf(current.game) === undefined && current.game.position.turn === current.ai;
-}
-/** 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. */
-function chatCalls(served) {
-    const folder = gameFolder(served.context.home());
-    const current = loadGame(folder);
-    const held = current !== undefined && aiHeld(served, current);
-    if (served.bell.chatCalls() && held) {
-        saveGame(folder, { ...current, clock: { ...current.clock, since: served.context.now().toISOString() } });
-    }
-}
-/**
- * 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.
- */
-export function chatHasRead(context, showed) {
-    context.seen = gameSeen(context);
-    if (!showed) {
-        return;
-    }
-    try {
-        context.positionSeen = positionIn(gameFolder(context.home()));
-    }
-    catch {
-        context.positionSeen = null;
-    }
-}
-/**
- * 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;
-}
-// The game the chat sees: the profile's folder, and the stamp of its game.json; none while the data folder cannot be made.
-function gameSeen(context) {
-    try {
-        const folder = gameFolder(context.home());
-        return `${folder}
-${gameStamp(folder) ?? ""}`;
-    }
-    catch {
-        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
- * profile in use may be another. It returns how to stop watching.
- */
-function watchGame(served) {
-    let waiting;
-    let watching = [];
-    const watchAll = () => {
-        watching.forEach((watcher) => watcher.close());
-        watching = watchedFolders(served).flatMap((folder) => watchFolder(folder, heard));
-    };
-    // 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) {
-            waiting = setTimeout(() => {
-                waiting = undefined;
-                watchAll();
-                tellWatchers(served);
-            }, 30);
-        }
-    };
-    watchAll();
-    return () => {
-        clearTimeout(waiting);
-        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.
-function watchedFolders(served) {
-    try {
-        const home = served.context.home();
-        return [home, join(home, "profiles"), gameFolder(home)];
-    }
-    catch {
-        return [];
-    }
-}
-// 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));
-        watcher.on("error", () => watcher.close());
-        watcher.unref();
-        return [watcher];
-    }
-    catch {
-        return [];
-    }
-}
-// The current game, 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|talk\.json|analysis\.json|active\.json|profile\.md|settings\.json|avatar\.\w+|[a-z0-9-]+)$/;
-/**
- * The game in progress or just ended, as the player may see it: its PGN without the AI's plans while it goes on, the AI's side, when it started, and the
- * talk on the page, each line of the player's with how far it got (D-53), and the draw offer that stands (D-65); the AI's name and model (D-82); and the
- * profiles.
- */
-function sendGame(response, served) {
-    try {
-        const current = gameNow(served);
-        // With no game the page still shows the talk before the first (D-77).
-        const spoken = current ?? loadTableTalk(gameFolder(served.context.home()));
-        const heard = heardLines(spoken, served.context.given);
-        const talk = spoken.talk.map(({ who, text, ply }, index) => heard[index] === undefined ? { who, text, ply } : { who, text, ply, heard: heard[index] });
-        const offer = current === undefined ? undefined : drawOfferOf(current);
-        const game = current === undefined ? null : {
-            pgn: playerPgn(current),
-            ai: current.ai,
-            started: current.started,
-            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),
-            ...(current.clock === undefined ? {} : { clock: current.clock }),
-            ...(offer === undefined ? {} : { drawOffer: offer }),
-        };
-        const analysis = current === undefined || endOf(current.game) !== undefined ? analysisShown(served) : undefined;
-        const aiModel = aiModelOf(gameFolder(served.context.home()));
-        const body = {
-            game,
-            ...(game === null && talk.length > 0 ? { talk } : {}),
-            ...(analysis === undefined ? {} : { analysis }),
-            opponent: served.opponent(),
-            ...(aiModel === undefined ? {} : { aiModel }),
-            listening: served.bell.listening,
-            ...profilesShown(served.context.home()),
-        };
-        send(response, 200, json, JSON.stringify(body));
-    }
-    catch (error) {
-        send(response, 500, json, JSON.stringify({ error: error.message }));
-    }
-}
-/** The game in analysis, once no game goes on (D-69): its name and its PGN with the AI's review; none without one, or when it cannot be read. */
-function analysisShown(served) {
-    const analysis = gameInAnalysis(gameFolder(served.context.home()));
-    if (analysis === undefined) {
-        return undefined;
-    }
-    try {
-        const { name, record } = namedGame(served.context, analysis.game);
-        // How far the book goes, which the page cannot tell without the book's moves: its card names the opening on those moves.
-        return { name, pgn: writePgn(record), book: bookPlies(record) };
-    }
-    catch {
-        // A game gone from the archive is no longer shown.
-        return undefined;
-    }
-}
-/** A script, style, picture or sound of the page, a module of the core, or a package's module: only from their folders, and only of the types the page uses. */
-function sendFile(response, path) {
-    const file = path.startsWith("/vendor/") ? vendorModule(path.slice("/vendor/".length)) : builtFile(path);
-    const type = file === undefined ? undefined : types[extname(file)];
-    let bytes;
-    try {
-        bytes = file === undefined || type === undefined ? undefined : readFileSync(file);
-    }
-    catch {
-        bytes = undefined;
-    }
-    if (bytes === undefined || type === undefined) {
-        send(response, 404, "text/plain; charset=utf-8", `Nothing at ${path}.`);
-        return;
-    }
-    // A pieces' set loaded again for each piece that moves blanks the pieces drawn from it, at times until the next move (T-88): the browser keeps it an hour,
-    // and the drawn avatars too, all at once in the profile's dialog.
-    const kept = type === types[".svg"] || type === types[".webp"];
-    send(response, 200, type, bytes, kept ? { "Cache-Control": "max-age=3600" } : {});
-}
-function builtFile(path) {
-    const area = /^\/(page|core)\//.exec(path)?.[1];
-    if (area === undefined) {
-        return undefined;
-    }
-    try {
-        const root = join(built, area);
-        const file = resolve(built, `.${decodeURIComponent(path)}`);
-        const inside = relative(root, file);
-        return inside === "" || inside.startsWith("..") || isAbsolute(inside) ? undefined : file;
-    }
-    catch {
-        // An address that does not decode.
-        return undefined;
-    }
-}
-function vendorModule(name) {
-    const module = vendorModules[name];
-    if (module === undefined) {
-        return undefined;
-    }
-    try {
-        // The package's folder, from where its main file is: node_modules/<package>.
-        const main = createRequire(import.meta.url).resolve(module[0]);
-        const marker = join("node_modules", module[0]);
-        return join(main.slice(0, main.lastIndexOf(marker) + marker.length), module[1]);
-    }
-    catch {
-        return undefined;
-    }
-}
-function fromHere(request, port, api) {
-    const hosts = [`127.0.0.1:${port}`, `localhost:${port}`];
-    const origin = request.headers.origin;
-    // An image or a script of another site sends no origin, but the browser says where it comes from: such a request could take the doorbell's place.
-    const site = request.headers["sec-fetch-site"];
-    return hosts.includes(request.headers.host ?? "") && (origin === undefined || hosts.some((host) => origin === `http://${host}`))
-        && (!api || site === undefined || site === "same-origin" || site === "none");
-}
-function listened(server, port) {
-    return new Promise((done) => {
-        const failed = () => done(false);
-        server.once("error", failed);
-        server.listen(port, "127.0.0.1", () => {
-            server.off("error", failed);
-            done(true);
-        });
-    });
-}
-function portOf(server) {
-    const address = server.address();
-    return typeof address === "object" && address !== null ? address.port : 0;
-}
-function closed(server, stopWatching) {
-    stopWatching();
-    return new Promise((done) => {
-        server.close(() => done());
-        server.closeAllConnections();
-    });
-}