chesspal 0.0.1 → 0.2.0

package/dist/server/caller.js

@@ -0,0 +1,132 @@
+// Who makes a tool call (D-81): only what the host ties to that call, never what the AI says of itself nor a setting the chat may have changed.
+// Codex sends the model and the effort with each call; Claude Code writes them into the chat's transcript, on the line of the call.
+import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { lastChatStart } from "../games/index.js";
+/** Who made the call with these metadata: the model and effort the host ties to it, else the host's name; undefined without a host. */
+export async function callerOf(meta, client, folder, wait = 50) {
+    const turn = objectOf(meta?.["x-codex-turn-metadata"]);
+    if (typeof turn?.model === "string") {
+        return withEffort(turn.model, turn.reasoning_effort);
+    }
+    const call = meta?.["claudecode/toolUseId"];
+    const transcript = lastChatStart(folder)?.transcript;
+    if (typeof call === "string" && transcript !== undefined) {
+        const found = await lineOfCall(transcript, call, wait);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return client === undefined ? undefined : { annotator: client.title ?? client.name, hostOnly: true };
+}
+/**
+ * Who in Claude Code made a tool call: the chat, when its line is in the chat's transcript, or the agent whose file has it, by the type Claude Code notes
+ * beside that file (Priya). Undefined when it cannot be told: another host, no chat noted, no line, or no type.
+ */
+export async function callingAgent(meta, folder, wait = 50) {
+    const call = meta?.["claudecode/toolUseId"];
+    const transcript = lastChatStart(folder)?.transcript;
+    const found = typeof call === "string" && transcript !== undefined ? await foundCall(transcript, call, wait) : undefined;
+    if (found === undefined) {
+        return undefined;
+    }
+    if (found.file === transcript) {
+        return { chat: true };
+    }
+    const type = objectOf(textOf(found.file.replace(/\.jsonl$/, ".meta.json")))?.agentType;
+    return typeof type === "string" ? { agent: type } : undefined;
+}
+/** Whether an agent's tool may answer this caller: one of its agents, or a caller that cannot be told, since the tool's description is the first guard. */
+export function allowedCaller(caller, agents) {
+    return caller === undefined || ("agent" in caller && agents.includes(caller.agent));
+}
+/** The model and effort on the transcript's line of a tool call, in the chat's file or its subagents'; Claude Code writes it a few milliseconds late. */
+async function lineOfCall(transcript, call, wait = 50) {
+    return (await foundCall(transcript, call, wait))?.caller;
+}
+// Three seconds at most: the line comes 30 or 40 milliseconds after a short call, but over 300 after annotate_game's long one. Nobody waits for it on the
+// AI's clock: annotate_game runs with no game going on, and the AI's move is read after its answer.
+const attempts = 60;
+// The line of a call just made is near the end of its file.
+const tailBytes = 512 * 1024;
+// A subagent's file is one written in the last minute.
+const recentFiles = 60_000;
+/** Who made a tool call, and the file its line is in, the chat's own or a subagent's; none when no line has it. */
+async function foundCall(transcript, call, wait) {
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        for (const file of [transcript, ...subagentFiles(transcript)]) {
+            const found = callerIn(tailOf(file), call);
+            if (found !== undefined) {
+                return { caller: found, file };
+            }
+        }
+        if (attempt < attempts - 1) {
+            await new Promise((done) => setTimeout(done, wait));
+        }
+    }
+    return undefined;
+}
+function callerIn(text, call) {
+    const marker = `"id":"${call}"`;
+    for (const line of text.split("\n").reverse()) {
+        if (!line.includes(marker)) {
+            continue;
+        }
+        const entry = objectOf(line);
+        const message = objectOf(entry?.message);
+        if (entry?.type === "assistant" && typeof message?.model === "string" && message.model !== "<synthetic>") {
+            return withEffort(message.model, entry.effort);
+        }
+    }
+    return undefined;
+}
+function withEffort(model, effort) {
+    return typeof effort === "string" && effort !== "" ? { annotator: model, effort } : { annotator: model };
+}
+function subagentFiles(transcript) {
+    const folder = join(dirname(transcript), basename(transcript, ".jsonl"), "subagents");
+    try {
+        const since = Date.now() - recentFiles;
+        return readdirSync(folder).filter((name) => name.endsWith(".jsonl")).map((name) => join(folder, name)).filter((file) => statSync(file).mtimeMs >= since);
+    }
+    catch {
+        return [];
+    }
+}
+function tailOf(file) {
+    try {
+        const descriptor = openSync(file, "r");
+        try {
+            const size = statSync(file).size;
+            const length = Math.min(size, tailBytes);
+            const buffer = Buffer.alloc(length);
+            readSync(descriptor, buffer, 0, length, size - length);
+            return buffer.toString("utf8");
+        }
+        finally {
+            closeSync(descriptor);
+        }
+    }
+    catch {
+        return "";
+    }
+}
+function textOf(file) {
+    try {
+        return readFileSync(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function objectOf(value) {
+    if (typeof value === "string") {
+        try {
+            return objectOf(JSON.parse(value));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}

package/dist/server/mcp.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type AnyCommand, type Context } from "../commands/index.ts";
+/** What the host reads as the server starts, before any tool: where to begin, and the rule of every move (D-27). Short, since hosts may cut it. */
+export declare const serverInstructions: string;
+/** The MCP server for an AI host: every command of the registry as a tool, with its description and parameters (D-5). */
+export declare function createMcpServer(context?: Context, list?: AnyCommand[]): McpServer;
+/**
+ * Serves the tools over standard input and output, as AI hosts expect: stdout carries the protocol alone, so nothing else may print there. It ends when the
+ * host goes and its input closes, once the calls still running have answered: a move half made would be lost.
+ */
+export declare function startMcpServer(context?: Context, list?: AnyCommand[]): Promise<void>;
+/** The opponent's name for the page, from the host's: Claude Code and the desktop app are Claude, Codex is Codex; another host is unnamed. */
+export declare function opponentOf(host: string | undefined): string | undefined;

package/dist/server/mcp.js

@@ -0,0 +1,207 @@
+// The MCP server an AI host starts: every command as a tool (D-5), and the board page served for as long as the chat lasts (D-47).
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { aiMove, commands, defaultContext, inputProblems, isBoolean, PositionChanged } from "../commands/index.js";
+import { endOf, loadGame, noteAiModel } from "../games/index.js";
+import { hasAgent } from "../host-files/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { version } from "../version.js";
+import { pagePorts } from "./bell.js";
+import { allowedCaller, callerOf, callingAgent } from "./caller.js";
+import { chatHasRead, startPage } from "./page/page.js";
+/** What the host reads as the server starts, before any tool: where to begin, and the rule of every move (D-27). Short, since hosts may cut it. */
+export const serverInstructions = "Chesspal keeps the chess for you: the rules, the board, the clock, the games and the player's memory. Call `status` at the start of every "
+    + "chat. Every move goes through Chesspal's tools: never keep the board in your head or invent a position.";
+/** The MCP server for an AI host: every command of the registry as a tool, with its description and parameters (D-5). */
+export function createMcpServer(context = defaultContext(), list = commands) {
+    const server = new McpServer({ name: "chesspal", version }, { instructions: serverInstructions });
+    // The server keeps what it told the chat, the instructions a tool gives once, and the position it showed: none yet (D-71).
+    context.told ??= new Set();
+    context.positionSeen ??= null;
+    const forOneHost = [];
+    for (const command of list.filter((each) => each.cliOnly !== true)) {
+        const tool = server.registerTool(command.name, toolConfig(command), async (input, extra) => {
+            // An agent's tool called by the chat, or by another agent, would give what only that agent may see (Priya).
+            if (command.byAgents !== undefined && !allowedCaller(await callingAgent(extra._meta, context.folder), command.byAgents)) {
+                // It names no agent to start: the chat that asked would start one itself (Priya).
+                return { content: [{ type: "text", text: `${command.name} is not yours to call: the player reads what it gives on the board page. Nothing changed.` }], isError: true };
+            }
+            // Each call knows who makes it, for the commands that write it down (D-81).
+            const caller = () => callerOf(extra._meta, server.server.getClientVersion(), context.folder);
+            const result = await track(runTool(command, input, context, caller, extra._meta));
+            if (command === aiMove && result.isError !== true) {
+                noteTheAi(context, caller);
+            }
+            return result;
+        });
+        if (command.host !== undefined) {
+            tool.disable();
+            forOneHost.push({ host: command.host, tool });
+        }
+    }
+    // A tool for one host is offered once the host has said its name, before it lists the tools.
+    server.server.oninitialized = () => {
+        const host = server.server.getClientVersion()?.name;
+        for (const { tool } of forOneHost.filter((each) => each.host === host)) {
+            tool.enable();
+        }
+    };
+    return server;
+}
+/**
+ * Serves the tools over standard input and output, as AI hosts expect: stdout carries the protocol alone, so nothing else may print there. It ends when the
+ * host goes and its input closes, once the calls still running have answered: a move half made would be lost.
+ */
+export async function startMcpServer(context = defaultContext(), list = commands) {
+    const leave = async () => {
+        // A tool stuck on something that never ends must not keep the server alive once the host has gone.
+        await Promise.race([Promise.allSettled(running), new Promise((done) => setTimeout(done, 5_000))]);
+        // The SDK sends the answer a moment after the call ends: it must reach stdout before the process goes.
+        setImmediate(() => process.stdout.write("", () => process.exit(0)));
+    };
+    process.stdin.on("end", leave);
+    process.stdin.on("close", leave);
+    const server = createMcpServer(context, list);
+    context.host = () => server.server.getClientVersion()?.name;
+    context.page = await pageOf(context, () => opponentOf(context.host?.()));
+    await server.connect(new StdioServerTransport());
+}
+/** The opponent's name for the page, from the host's: Claude Code and the desktop app are Claude, Codex is Codex; another host is unnamed. */
+export function opponentOf(host) {
+    return /claude/i.test(host ?? "") ? "Claude" : /codex/i.test(host ?? "") ? "Codex" : undefined;
+}
+/** The board page of the player's folder, served by this process for as long as the chat lasts (D-47); without it the game goes on in the chat. */
+async function pageOf(context, opponent) {
+    try {
+        const { url, heard, chatCalls, ponders, open, askNewGame } = await startPage(context, opponent);
+        // Words the AI is given change no file: the pages hear of them from the commands.
+        context.heard = heard;
+        context.calls = chatCalls;
+        context.ponders = ponders;
+        context.pageOpen = open;
+        context.askNewGame = askNewGame;
+        if (!pagePorts(context.folder).includes(Number(new URL(url).port))) {
+            process.stderr.write(`The board page is at ${url}, off its usual ports: the doorbell cannot find it, so moves on the page do not wake the chat.\n`);
+        }
+        return url;
+    }
+    catch (error) {
+        // The host keeps what the server writes on stderr in its logs.
+        process.stderr.write(`${error.message}\n`);
+        return undefined;
+    }
+}
+/**
+ * Who played the AI's move, read once the move has gone back to the chat, and kept in memory (D-82): the AI's card on the page shows it, and the game's
+ * PGN once it ends; a change shows from the next move. A host that ties no model to the call leaves the last one known.
+ */
+function noteTheAi(context, caller) {
+    // Claude Code writes the call's line a few milliseconds late: read after the answer, it costs the AI's clock nothing (D-13).
+    setImmediate(() => {
+        // Nothing that fails here may stop the server: the move is played and answered.
+        caller().then((found) => {
+            if (found === undefined || found.hostOnly === true) {
+                return;
+            }
+            if (noteAiModel(gameFolder(context.home()), { model: found.annotator, ...(found.effort === undefined ? {} : { effort: found.effort }) })) {
+                context.heard?.();
+            }
+        }).catch(() => undefined);
+    });
+}
+// The tool calls still running, which the server waits for before it leaves.
+const running = new Set();
+function track(call) {
+    running.add(call);
+    void call.finally(() => running.delete(call));
+    return call;
+}
+/** Every hint stated, since the spec reads a missing one as the worst case: everything is local, so no tool reaches the open world. */
+function toolConfig(command) {
+    const readOnly = command.readOnly === true;
+    const annotations = { readOnlyHint: readOnly, destructiveHint: command.destructive === true, idempotentHint: readOnly || command.idempotent === true, openWorldHint: false };
+    const meta = command.alwaysLoad ? { "anthropic/alwaysLoad": true } : undefined;
+    // The SDK writes the draft's address in every schema: it says nothing to an AI, and costs tokens in every tool.
+    return { description: command.description, inputSchema: z.looseObject({}).meta({ ...shownInput(command), $schema: undefined }), annotations, _meta: meta };
+}
+async function runTool(command, input, context, caller, meta) {
+    const agent = await sharingAgent(command, meta, context);
+    const chat = command.byAgents === undefined && agent === undefined;
+    let refused = false;
+    try {
+        if (chat) {
+            context.calls?.();
+        }
+        const result = await command.run(checkedInput(command, input), { ...context, caller, ...(agent === undefined ? {} : { agent }) });
+        return { content: [{ type: "text", text: command.format(result, context) }] };
+    }
+    catch (error) {
+        refused = error instanceof PositionChanged;
+        return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true };
+    }
+    finally {
+        // What the tool read or wrote, the chat has seen: the doorbell rings it only for what changes after, and it may move on the game a tool showed it,
+        // unless that tool was refused for a position it had not seen. An agent's call is not the chat's.
+        if (chat) {
+            chatHasRead(context, command.showsGame === true && !refused);
+        }
+    }
+}
+/**
+ * The agent that calls a tool it shares with the chat, as the analyst (D-89), by its type: looked up only in a folder where one may run and while no game
+ * goes on, so that no call of the chat's waits for it while it plays; none for the chat, or when it cannot be told.
+ */
+async function sharingAgent(command, meta, context) {
+    const agents = command.sharedWith?.filter((agent) => hasAgent(context.folder, agent)) ?? [];
+    if (agents.length === 0 || gameGoingOn(context)) {
+        return undefined;
+    }
+    const caller = await callingAgent(meta, context.folder);
+    return caller !== undefined && "agent" in caller && agents.includes(caller.agent) ? caller.agent : undefined;
+}
+/** Whether a game goes on, or may: a game that cannot be read is the command's to report, as the chat's call (Federico). */
+function gameGoingOn(context) {
+    try {
+        const current = loadGame(gameFolder(context.home()));
+        return current !== undefined && endOf(current.game) === undefined;
+    }
+    catch {
+        return true;
+    }
+}
+// The JSON schema of each command's input, as the SDK would write it from the strict schema: the tool takes any object, and the command checks it, so that
+// what is wrong comes back in words an AI can act on.
+const shownInputs = new WeakMap();
+function shownInput(command) {
+    let shown = shownInputs.get(command);
+    if (shown === undefined) {
+        shown = z.toJSONSchema(command.input.strict(), { target: "draft-7", io: "input" });
+        shownInputs.set(command, shown);
+    }
+    return shown;
+}
+/** The command's input, checked as its schema says; what is wrong comes with every parameter the tool takes, for a call made without the schema. */
+function checkedInput(command, input) {
+    const parsed = command.input.strict().safeParse(withFlags(command, input ?? {}));
+    if (parsed.success) {
+        return parsed.data;
+    }
+    const given = typeof input === "object" && input !== null ? input : {};
+    const shown = shownInput(command);
+    const required = shown.required ?? [];
+    const parameters = Object.entries(shown.properties ?? {}).map(([name, field]) => `- ${name}${required.includes(name) ? "" : " (optional)"}${field.description === undefined ? "" : `: ${field.description}`}`);
+    const again = parameters.length === 0 ? "call it again with no parameters." : `call it again with its parameters.\n${command.name} takes:\n${parameters.join("\n")}`;
+    throw new Error(`${inputProblems(command.name, parsed.error.issues, given, (name) => name)} Nothing changed: ${again}`);
+}
+/** The input with "true" and "false" as flags where the command takes one: some hosts send every value as text. */
+function withFlags(command, input) {
+    if (typeof input !== "object" || input === null) {
+        return input;
+    }
+    const { shape } = command.input;
+    return Object.fromEntries(Object.entries(input).map(([name, value]) => {
+        const field = shape[name];
+        return [name, field !== undefined && isBoolean(field) && (value === "true" || value === "false") ? value === "true" : value];
+    }));
+}

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

@@ -0,0 +1,23 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type AiModel } from "../../core/index.ts";
+import type { Served } from "./page.ts";
+/** An analysis as the page lists it: who played, with the AI's model (D-82), when, how it ended, its opening, how long, and whether the AI has reviewed it. */
+export interface AnalysisItem {
+    readonly name: string;
+    readonly white: string;
+    readonly black: string;
+    readonly aiModel?: AiModel;
+    readonly date?: string;
+    readonly result: string;
+    readonly opening?: string;
+    readonly moves: number;
+    readonly reviewed: boolean;
+    /** Who reviewed it (D-81). */
+    readonly annotator?: AiModel;
+    /** Where a game loaded from elsewhere was played, as its Site tag says: the player's name there makes it theirs (D-93). */
+    readonly site?: string;
+}
+/** The games to analyse in the profile in use, the latest first, all of them for the page's search: those kept to study and those played, reviewed or not. */
+export declare function analysesOf(home: string): AnalysisItem[];
+/** Answers the page's deletions, of a game or of its review alone, done as the command line does them: true when the request was one. */
+export declare function answerAnalyses(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;

package/dist/server/page/analyses.js

@@ -0,0 +1,65 @@
+import { bookOpening, deleteGame, deleteReview } from "../../commands/index.js";
+import { aiModelIn, annotatorOf, isReviewed } from "../../core/index.js";
+import { archivedGame, archivedGames, gameStemOf, keptGame, keptGames } from "../../games/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { bodyOf, isJson, jsonOf, runRoute, sendJson, textOf } from "./http.js";
+/** The games to analyse in the profile in use, the latest first, all of them for the page's search: those kept to study and those played, reviewed or not. */
+export function analysesOf(home) {
+    const folder = gameFolder(home);
+    // By the time in their names, which orders kept and played games together.
+    const stamp = (name) => gameStemOf(name) ?? "";
+    const names = [...keptGames(folder), ...archivedGames(folder)].sort((one, other) => stamp(other).localeCompare(stamp(one)));
+    return names.flatMap((name) => itemOf(name, () => name.startsWith("study/") ? keptGame(folder, name) : archivedGame(folder, name)));
+}
+/** Answers the page's deletions, of a game or of its review alone, done as the command line does them: true when the request was one. */
+export function answerAnalyses(request, response, url, served) {
+    const command = request.method === "POST" ? deletions[url.pathname] : undefined;
+    if (command === undefined) {
+        return false;
+    }
+    runRoute(response, async () => {
+        const game = textOf(jsonOf(isJson(request) ? await bodyOf(request) : undefined)?.game);
+        if (game === undefined) {
+            sendJson(response, 400, { error: 'Send the game as JSON: {"game": "games/2026-11-02-153012.pgn"}.' });
+            return;
+        }
+        try {
+            sendJson(response, 200, await command.run({ game }, served.context));
+        }
+        catch (error) {
+            sendJson(response, 409, { error: error.message });
+        }
+    });
+    return true;
+}
+const deletions = { "/api/delete-game": deleteGame, "/api/delete-review": deleteReview };
+function itemOf(name, read) {
+    let record;
+    try {
+        record = read();
+    }
+    catch {
+        // A game that cannot be read stays out of the list.
+        return [];
+    }
+    const { tags } = record;
+    const date = tags.Date === undefined || tags.Date.includes("?") ? undefined : tags.Date;
+    const opening = bookOpening(record)?.name;
+    const aiModel = aiModelIn(record);
+    const site = tags.Site === undefined || /^[?\-\s]*$/.test(tags.Site) ? undefined : tags.Site;
+    const signed = annotatorOf(record);
+    const annotator = signed === undefined ? undefined : { model: signed.annotator, ...(signed.effort === undefined ? {} : { effort: signed.effort }) };
+    return [{
+            name,
+            white: tags.White ?? "?",
+            black: tags.Black ?? "?",
+            ...(aiModel === undefined ? {} : { aiModel }),
+            ...(date === undefined ? {} : { date }),
+            result: tags.Result ?? "*",
+            ...(opening === undefined ? {} : { opening }),
+            moves: Math.ceil(record.moves.length / 2),
+            reviewed: isReviewed(record),
+            ...(annotator === undefined ? {} : { annotator }),
+            ...(site === undefined ? {} : { site }),
+        }];
+}

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

@@ -0,0 +1,5 @@
+import type { ServerResponse } from "node:http";
+/** The page's HTML, which runs only its own files and its import map. */
+export declare function sendHtml(response: ServerResponse): void;
+/** 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. */
+export declare function sendFile(response: ServerResponse, path: string): void;

package/dist/server/page/files.js

@@ -0,0 +1,92 @@
+// The page's files: its HTML with the import map, its scripts, styles, pictures and sounds, the chess core and the packages they import, each only from its
+// folder and of the types the page uses.
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { send } from "./http.js";
+/** The page's HTML, which runs only its own files and its import map. */
+export function sendHtml(response) {
+    send(response, 200, "text/html; charset=utf-8", html, { "Content-Security-Policy": policy });
+}
+/** 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. */
+export 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: 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" } : {});
+}
+// The built page and core: dist/, from src/server/page and from dist/server/page 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 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;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Served } from "./page.ts";
+/** Answers the page's requests about the game: true when the request was one. */
+export declare function answerGame(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
+/** The chat calls a tool: when nobody heard the player before, the AI's clock, held since, starts now, with the time it was held given back. */
+export declare function chatCalls(served: Served): void;