chesspal 0.3.0 → 0.3.2

package/dist/server/table/hosts/play.js

@@ -7,12 +7,13 @@ import { tableFolder } from "../../../home/index.js";
 import { setUpHosts } from "../../../host-files/index.js";
 import { activeProfile, gameFolder, languageIn, profileSettings } from "../../../profiles/index.js";
 import { programPath } from "./find.js";
-import { choiceIn, hostArgs, startMessage } from "./hosts.js";
+import { choiceIn, hostArgs, isHostName, startMessage } from "./hosts.js";
 import { askedAgain, leaveSeat, refreshSeat, seatTimes, takeSeat } from "./seat.js";
 import { cmdQuoted } from "./terminal.js";
 /**
- * Runs the host in the table's folder, in this terminal, until it ends: its exit code; started again, clean, when the table asks for a new game (D-57).
- * Ctrl+C is the host's: this process ignores it, or the terminal would close with the chat.
+ * Runs the host in the table's folder, in this terminal, until it ends: its exit code; started again, clean, when the table asks for a new game (D-57),
+ * or for another model or host, which then takes its place (D-107); after an update, by the Chesspal installed (D-108). Ctrl+C is the host's: this
+ * process ignores it, or the terminal would close with the chat.
  */
 export async function playHost(context, host) {
     const folder = tableFolder(context.home());
@@ -24,24 +25,53 @@ export async function playHost(context, host) {
         process.exit(129);
     });
     const terminal = savedTerminal(context.platform);
+    let playing = host;
+    let next = host;
+    // The host before one asked in its place, until that one has started: it goes on when the other does not start.
+    let before;
     let refreshed = Date.now();
+    // Chesspal was updated under this process (D-108): the new one plays on.
+    let updated = false;
     const asked = () => {
         if (Date.now() - refreshed >= seatTimes.refresh) {
             refreshed = Date.now();
             refreshSeat(folder, process.pid);
         }
-        return askedAgain(folder, process.pid);
+        const again = askedAgain(folder, process.pid);
+        next = again?.host !== undefined && isHostName(again.host) ? again.host : playing;
+        updated ||= again?.updated === true;
+        return again !== undefined;
     };
     try {
         for (;;) {
             // A request left from a second click while the host before was ending is not for this one.
             askedAgain(folder, process.pid);
-            const ran = await runHost(hostLaunch(context, host), asked, context.platform).catch((error) => {
-                throw new Error(`${hostTitle[host]} did not start: ${error.message}`);
+            const ran = await started(context, playing, asked).catch((error) => {
+                if (before === undefined) {
+                    throw error;
+                }
+                process.stderr.write(`${error.message} ${hostTitle[before]} goes on.\n`);
+                return undefined;
             });
+            if (ran === undefined) {
+                playing = before ?? playing;
+                before = undefined;
+                continue;
+            }
+            before = undefined;
             if (!ran.again) {
                 return ran.code;
             }
+            if (updated) {
+                terminal.restore();
+                process.stdout.write(cleanScreen);
+                leaveSeat(folder, process.pid);
+                return await playUpdated(playing);
+            }
+            if (next !== playing) {
+                before = playing;
+                playing = next;
+            }
             terminal.restore();
             process.stdout.write(cleanScreen);
         }
@@ -98,19 +128,53 @@ export function hostLaunch(context, host, env = process.env, exists) {
     const childEnv = { ...env, ...Object.fromEntries(sessionMarks.map((name) => [name, undefined])), ...effort };
     const script = npmScript(host, found, context.platform, exists ?? existsSync);
     if (script !== undefined) {
-        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false };
+        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice };
     }
-    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found) };
+    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice };
 }
 const hostTitle = { claude: "Claude Code", codex: "Codex" };
+// Runs the host as runHost does, the seat noting the model and effort it is given; one not installed, or that could not start, fails saying so.
+async function started(context, host, again) {
+    const launch = hostLaunch(context, host);
+    takeSeat(launch.folder, { pid: process.pid, host, ...launch.choice });
+    return runHost(launch, again, context.platform).catch((error) => {
+        throw new Error(`${hostTitle[host]} did not start: ${error.message}`);
+    });
+}
+// The Chesspal just installed plays on in this terminal, in a process of its own with all its files new (D-108), which takes the seat; this one, with
+// the code it started with, waits for it to end.
+function playUpdated(host) {
+    return new Promise((done) => {
+        const startedAt = Date.now();
+        const play = spawn(process.execPath, [...process.execArgv, process.argv[1] ?? "", "play", host], { stdio: "inherit" });
+        const failed = (why) => {
+            process.stderr.write(`Chesspal did not start again after its update (${why}): run chesspal play ${host}.\n`);
+        };
+        play.once("error", (error) => {
+            failed(error.message);
+            done(1);
+        });
+        // One that ended at once, failing, never showed its host: the player is told how to start it (Priya).
+        play.once("exit", (code) => {
+            if (code !== 0 && Date.now() - startedAt < quickExit) {
+                failed(`exit code ${code ?? "none"}`);
+            }
+            done(code ?? 1);
+        });
+    });
+}
 // A host that has not ended this long after it was asked is killed.
 const killAfter = 3_000;
+// A play process that ends sooner never got to its host.
+const quickExit = 10_000;
 // A host ended in the middle leaves the modes it set: colours, scroll region, synchronized output, bracketed paste, focus and mouse reports, kitty's
 // keyboard flags, its own screen, a hidden cursor (Priya). All off, and the screen cleared, as a new chat.
 const cleanScreen = "\x1b[0m\x1b[r\x1b[?2026l\x1b[?2004l\x1b[?1004l\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[<99u\x1b[?1049l\x1b[?25h\x1b[2J\x1b[3J\x1b[H";
-// The host and what it started, its MCP server among them: on Windows its whole tree, which taskkill ends, never the console (Priya); else the host,
-// which ends its own. A taskkill that failed leaves it to the kill that follows.
-function endTree(chat, platform) {
+/**
+ * Ends a process and what it started, a host's MCP server among them: on Windows its whole tree, which taskkill ends, never the console (Priya); else the
+ * process, which ends its own. A taskkill that failed leaves it to a kill.
+ */
+export function endTree(chat, platform) {
     if (platform !== "win32" || chat.pid === undefined) {
         chat.kill("SIGTERM");
         return;

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

@@ -1,7 +1,9 @@
-/** The play process in the seat: its process id and its host. */
+/** The play process in the seat: its process id, its host, and the model and effort it started that host with, none for the host's own. */
 export interface Seat {
     readonly pid: number;
     readonly host: string;
+    readonly model?: string | undefined;
+    readonly effort?: string | undefined;
 }
 /**
  * Takes the seat for this play process, over a request left for one before it; it throws while another one holds it. A seat is held while its play
@@ -14,10 +16,20 @@ export declare function refreshSeat(folder: string, pid: number, now?: Date): vo
 export declare function leaveSeat(folder: string, pid: number): void;
 /** Whether a play process holds the seat. */
 export declare function seatTaken(folder: string, now?: Date): boolean;
-/** Asks the play process in the seat to start its host again: whether one holds it, and was asked. */
-export declare function askAgain(folder: string, now?: Date): boolean;
-/** Whether the table asked this play process to start its host again; the request is taken. */
-export declare function askedAgain(folder: string, pid: number): boolean;
+/** The play process that holds the seat, with the model and effort it started its host with; none when no one holds it. */
+export declare function seatHeld(folder: string, now?: Date): Seat | undefined;
+/** Asks the play process in the seat to start its host again, or `again.host` in its place: whether one holds it, and was asked. */
+export declare function askAgain(folder: string, now?: Date, again?: Again): boolean;
+/**
+ * What the table asks the play process in the seat: to start its host again, or the host named in its place (D-107); `updated`, from the Chesspal just
+ * installed, whose `chesspal play` then takes the seat (D-108).
+ */
+export interface Again {
+    readonly host?: string;
+    readonly updated?: true;
+}
+/** What the table asked this play process, when it asked it to start its host again; the request is taken. */
+export declare function askedAgain(folder: string, pid: number): Again | undefined;
 /** How often a play process refreshes its seat, and how long the seat stays held without it. */
 export declare const seatTimes: {
     refresh: number;

package/dist/server/table/hosts/seat.js

@@ -33,36 +33,42 @@ export function leaveSeat(folder, pid) {
 export function seatTaken(folder, now = new Date()) {
     return seatHeld(folder, now) !== undefined;
 }
-/** Asks the play process in the seat to start its host again: whether one holds it, and was asked. */
-export function askAgain(folder, now = new Date()) {
+/** The play process that holds the seat, with the model and effort it started its host with; none when no one holds it. */
+export function seatHeld(folder, now = new Date()) {
+    const seat = seatIn(folder);
+    // A file's time is finer than a Date's: it is compared to the millisecond, as the Date is.
+    const refreshed = statSync(join(folder, seatFile), { throwIfNoEntry: false })?.mtimeMs;
+    return seat !== undefined && refreshed !== undefined && now.getTime() - Math.floor(refreshed) < seatTimes.heldFor ? seat : undefined;
+}
+/** Asks the play process in the seat to start its host again, or `again.host` in its place: whether one holds it, and was asked. */
+export function askAgain(folder, now = new Date(), again = {}) {
     const held = seatHeld(folder, now);
     if (held === undefined) {
         return false;
     }
-    writeAtomically(join(folder, againFile), `${JSON.stringify({ pid: held.pid })}\n`);
+    writeAtomically(join(folder, againFile), `${JSON.stringify({ pid: held.pid, ...again })}\n`);
     return true;
 }
-/** Whether the table asked this play process to start its host again; the request is taken. */
+/** What the table asked this play process, when it asked it to start its host again; the request is taken. */
 export function askedAgain(folder, pid) {
-    const asked = jsonIn(join(folder, againFile))?.pid === pid;
-    if (asked) {
-        rmSync(join(folder, againFile), { force: true });
+    const asked = jsonIn(join(folder, againFile));
+    if (asked?.pid !== pid) {
+        return undefined;
     }
-    return asked;
+    rmSync(join(folder, againFile), { force: true });
+    return { ...(typeof asked.host === "string" ? { host: asked.host } : {}), ...(asked.updated === true ? { updated: true } : {}) };
 }
 /** How often a play process refreshes its seat, and how long the seat stays held without it. */
 export const seatTimes = { refresh: 5_000, heldFor: 15_000 };
 const seatFile = "play.json";
 const againFile = "play-again.json";
-function seatHeld(folder, now) {
-    const seat = seatIn(folder);
-    // A file's time is finer than a Date's: it is compared to the millisecond, as the Date is.
-    const refreshed = statSync(join(folder, seatFile), { throwIfNoEntry: false })?.mtimeMs;
-    return seat !== undefined && refreshed !== undefined && now.getTime() - Math.floor(refreshed) < seatTimes.heldFor ? seat : undefined;
-}
 function seatIn(folder) {
     const seat = jsonIn(join(folder, seatFile));
-    return typeof seat?.pid === "number" && typeof seat.host === "string" ? { pid: seat.pid, host: seat.host } : undefined;
+    if (typeof seat?.pid !== "number" || typeof seat.host !== "string") {
+        return undefined;
+    }
+    const text = (value) => (typeof value === "string" ? value : undefined);
+    return { pid: seat.pid, host: seat.host, model: text(seat.model), effort: text(seat.effort) };
 }
 function jsonIn(path) {
     try {

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

@@ -1,6 +1,7 @@
 export { appBrowser, openedAddress } from "./browser.ts";
 export { hostLaunch, isHostName, playHost, terminalChats } from "./hosts/index.ts";
 export { iconAsked, type IconCommand, iconCommand, type IconPlaces, iconToRemake, makeIcons, noteIconAsked, noteIconMade } from "./icon/index.ts";
-export { noteOpenFailed, openTable, processLauncher, type TableLauncher } from "./launch.ts";
+export { noteFailure, openTable, processLauncher, type TableLauncher } from "./launch.ts";
 export { attachTable, tableToJoin } from "./link.ts";
-export { isOlder, startTable, type Table, type TableTimes, tableTimes } from "./table.ts";
+export { startTable, type Table, type TableTimes, tableTimes } from "./table.ts";
+export { npmInstall, npmUpdater, type TableUpdater } from "./update.ts";

package/dist/server/table/index.js

@@ -2,6 +2,7 @@
 export { appBrowser, openedAddress } from "./browser.js";
 export { hostLaunch, isHostName, playHost, terminalChats } from "./hosts/index.js";
 export { iconAsked, iconCommand, iconToRemake, makeIcons, noteIconAsked, noteIconMade } from "./icon/index.js";
-export { noteOpenFailed, openTable, processLauncher } from "./launch.js";
+export { noteFailure, openTable, processLauncher } from "./launch.js";
 export { attachTable, tableToJoin } from "./link.js";
-export { isOlder, startTable, tableTimes } from "./table.js";
+export { startTable, tableTimes } from "./table.js";
+export { npmInstall, npmUpdater } from "./update.js";

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

@@ -13,7 +13,10 @@ export interface TableLauncher {
  * within ten seconds throws.
  */
 export declare function openTable(context: Context, launcher?: TableLauncher): Promise<string>;
-/** Notes why the icon could not open the table, whose console nobody sees, in open.log of the table's folder: the last of them. */
-export declare function noteOpenFailed(context: Context, message: string): void;
+/**
+ * Notes what went wrong where nobody reads a console, in a log of the table's folder, the last time alone: open.log, why the icon could not open the table;
+ * update.log, why npm did not update Chesspal (D-108).
+ */
+export declare function noteFailure(context: Context, log: "open.log" | "update.log", message: string): void;
 /** The launcher of a real `chesspal`: the table started with the same Node and script, the page opened in the default browser. */
 export declare function processLauncher(platform: string, command?: string[]): TableLauncher;

package/dist/server/table/launch.js

@@ -39,12 +39,15 @@ export async function openTable(context, launcher = processLauncher(context.plat
         await launcher.wait(every);
     }
 }
-/** Notes why the icon could not open the table, whose console nobody sees, in open.log of the table's folder: the last of them. */
-export function noteOpenFailed(context, message) {
+/**
+ * Notes what went wrong where nobody reads a console, in a log of the table's folder, the last time alone: open.log, why the icon could not open the table;
+ * update.log, why npm did not update Chesspal (D-108).
+ */
+export function noteFailure(context, log, message) {
     try {
         const folder = tableFolder(context.home());
         mkdirSync(folder, { recursive: true });
-        writeFileSync(join(folder, "open.log"), `${context.now().toISOString()} ${message}\n`);
+        writeFileSync(join(folder, log), `${context.now().toISOString()} ${message}\n`);
     }
     catch {
         // A data folder that cannot be written has no other place for it.

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

@@ -1,5 +1,5 @@
 import type { Context } from "../../commands/index.ts";
-import type { Page } from "../page/page.ts";
+import { type Page } from "../page/index.ts";
 /**
  * Attaches the chat to the table of its data folder, when one of its version answers and no other chat is at it: the page the chat then uses, whose `lost`
  * is told once the table is gone or no longer knows the chat. An older table is asked to quit; with none, a newer one or another chat at it, none, and

package/dist/server/table/link.js

@@ -5,9 +5,9 @@ import { aiHostOf, aiModelOf } from "../../games/index.js";
 import { tableFolder } from "../../home/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
-import { version } from "../../version.js";
-import { jsonOf } from "../page/http.js";
-import { askToQuit, isOlder, tableAt } from "./table.js";
+import { isOlder, version } from "../../version.js";
+import { jsonOf } from "../page/index.js";
+import { askToQuit, tableAt } from "./table.js";
 /**
  * Attaches the chat to the table of its data folder, when one of its version answers and no other chat is at it: the page the chat then uses, whose `lost`
  * is told once the table is gone or no longer knows the chat. An older table is asked to quit; with none, a newer one or another chat at it, none, and
@@ -214,6 +214,7 @@ function seenBy(context) {
     return {
         seen: context.seen,
         positionSeen: context.positionSeen,
+        positionFirstSeen: context.positionFirstSeen,
         given: [...context.given],
         host: context.host?.(),
         aiModel: folder === undefined ? undefined : aiModelOf(folder),

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

@@ -1,5 +1,6 @@
 import type { Context } from "../../commands/index.ts";
-import type { TableChats } from "../page/table.ts";
+import { type TableChats } from "../page/index.ts";
+import type { TableUpdater } from "./update.ts";
 /** A table served: its address, and how to close it. */
 export interface Table {
     readonly url: string;
@@ -24,12 +25,10 @@ export interface TableFound {
 /**
  * Starts the table on the context's data folder, its folder set up as init does, its page opening chats through `chats`: undefined when another table
  * started at the same time took a lower port, since a table's ports are its lock. It closes once no page has been open, no chat attached and no request
- * come, for `times.idle`.
+ * come, for `times.idle`; with `updater`, its page updates Chesspal, and a new table starts from it once this one has closed (D-108).
  */
-export declare function startTable(context: Context, times?: TableTimes, chats?: TableChats): Promise<Table | undefined>;
+export declare function startTable(context: Context, times?: TableTimes, chats?: TableChats, updater?: TableUpdater): Promise<Table | undefined>;
 /** The table of a folder that answers on its ports, the lowest of them; its ports are asked together. */
 export declare function tableAt(folder: string): Promise<TableFound | undefined>;
 /** Asks the table at a port to quit; it answers before it goes, and a table that cannot be reached, or does not answer within a second or so, is let be. */
 export declare function askToQuit(port: number): Promise<void>;
-/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
-export declare function isOlder(one: string, other: string): boolean;

package/dist/server/table/table.js

@@ -3,16 +3,16 @@
 import { request } from "node:http";
 import { tableFolder } from "../../home/index.js";
 import { setUpHosts } from "../../host-files/index.js";
-import { pageAt, pagePorts, samePath } from "../bell.js";
-import { startPage } from "../page/page.js";
+import { pageAt, pagePorts, samePath } from "../bell/index.js";
+import { startPage } from "../page/index.js";
 /** Five minutes with no browser and no chat, looked at every fifteen seconds (D-104). */
 export const tableTimes = { idle: 5 * 60_000, every: 15_000 };
 /**
  * Starts the table on the context's data folder, its folder set up as init does, its page opening chats through `chats`: undefined when another table
  * started at the same time took a lower port, since a table's ports are its lock. It closes once no page has been open, no chat attached and no request
- * come, for `times.idle`.
+ * come, for `times.idle`; with `updater`, its page updates Chesspal, and a new table starts from it once this one has closed (D-108).
  */
-export async function startTable(context, times = tableTimes, chats) {
+export async function startTable(context, times = tableTimes, chats, updater) {
     const folder = tableFolder(context.home());
     setUpHosts(folder, context.platform);
     let quit = () => undefined;
@@ -20,10 +20,16 @@ export async function startTable(context, times = tableTimes, chats) {
         quit = done;
     });
     let lastUsed = context.now().getTime();
+    let startAgain = false;
     const used = () => {
         lastUsed = context.now().getTime();
     };
-    const page = await startPage({ ...context, folder }, { table: { used, quit, chats } });
+    const restart = () => {
+        startAgain = true;
+        quit();
+    };
+    const update = updater === undefined ? undefined : { install: (version) => updater.install(version), restart };
+    const page = await startPage({ ...context, folder }, { table: { used, quit, chats, update } });
     if (await lostTo(page.url, folder)) {
         await page.close();
         return undefined;
@@ -31,7 +37,11 @@ export async function startTable(context, times = tableTimes, chats) {
     const watch = closeWhenIdle(page, () => context.now().getTime() - lastUsed, used, times, quit);
     const closed = quitting.then(async () => {
         clearInterval(watch);
+        // Its ports free, the new table takes the first of them, where the pages open look for it.
         await page.close();
+        if (startAgain) {
+            updater?.startAgain();
+        }
     });
     return {
         url: page.url,
@@ -64,13 +74,6 @@ export function askToQuit(port) {
 }
 // A table answers at once: one stuck must not hold the chat's first tool, nor `chesspal`.
 const quitWait = 1_500;
-/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
-export function isOlder(one, other) {
-    const parts = (version) => version.split(/[.+-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
-    const [mine, theirs] = [parts(one), parts(other)];
-    const differs = mine.findIndex((part, index) => part !== theirs[index]);
-    return differs !== -1 && mine[differs] < theirs[differs];
-}
 /** Whether a table of the same folder answers on a lower port than this one's: the other won, and this one goes. */
 async function lostTo(url, folder) {
     const port = Number(new URL(url).port);

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

@@ -0,0 +1,17 @@
+import type { Context } from "../../commands/index.ts";
+import { type TableLauncher } from "./launch.ts";
+/** How a table updates Chesspal: npm installs a version, whether it did, and once the table has closed a new one starts from it. */
+export interface TableUpdater {
+    install(version: string): Promise<boolean>;
+    startAgain(): void;
+}
+/**
+ * A real table's updater: npm on the PATH, and `chesspal table` started apart, as `chesspal` starts it. A Chesspal npm did not install, run from its
+ * source or linked to it, npm leaves alone: it would put another in its place for the whole computer.
+ */
+export declare function npmUpdater(context: Context, launcher?: TableLauncher): TableUpdater;
+/**
+ * Installs a version of Chesspal for the whole computer with the npm on the PATH: whether it is now the one on disk where this one runs from, which an npm
+ * of another Node does not reach. What npm said when it failed goes in update.log of the table's folder.
+ */
+export declare function npmInstall(context: Context, onDisk?: () => string, env?: NodeJS.ProcessEnv): (version: string) => Promise<boolean>;

package/dist/server/table/update.js

@@ -0,0 +1,77 @@
+// The table updates Chesspal (D-108): the npm on the PATH installs the version, as the player would type it, and a new table starts from it once this one
+// has closed; what npm said when it failed goes in update.log of the table's folder.
+import { spawn } from "node:child_process";
+import { basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { installedVersion } from "../../version.js";
+import { endTree } from "./hosts/index.js";
+import { noteFailure, processLauncher } from "./launch.js";
+/**
+ * A real table's updater: npm on the PATH, and `chesspal table` started apart, as `chesspal` starts it. A Chesspal npm did not install, run from its
+ * source or linked to it, npm leaves alone: it would put another in its place for the whole computer.
+ */
+export function npmUpdater(context, launcher = processLauncher(context.platform)) {
+    const root = fileURLToPath(new URL("../../../", import.meta.url));
+    const fromNpm = basename(root) === "chesspal" && basename(dirname(root)) === "node_modules";
+    const install = fromNpm ? npmInstall(context) : () => {
+        noteFailure(context, "update.log", `Chesspal runs from ${root}, which npm did not install: update it the way it was installed.`);
+        return Promise.resolve(false);
+    };
+    return { install, startAgain: () => launcher.start(context.home()) };
+}
+/**
+ * Installs a version of Chesspal for the whole computer with the npm on the PATH: whether it is now the one on disk where this one runs from, which an npm
+ * of another Node does not reach. What npm said when it failed goes in update.log of the table's folder.
+ */
+export function npmInstall(context, onDisk = installedVersion, env = process.env) {
+    const { platform } = context;
+    return (version) => new Promise((done) => {
+        // A plain release alone: on Windows the version goes through cmd.
+        if (!/^\d+\.\d+\.\d+$/.test(version)) {
+            done(false);
+            return;
+        }
+        const words = ["install", "--global", `chesspal@${version}`];
+        // cmd would look for npm in the table's folder first, where anything may lie (Federico).
+        const options = { stdio: ["ignore", "ignore", "pipe"], windowsHide: true, env: { ...env, NoDefaultCurrentDirectoryInExePath: "1" } };
+        // npm is a .cmd shim on Windows, which only cmd runs.
+        const npm = platform === "win32" ? spawn(`npm ${words.join(" ")}`, { ...options, shell: true }) : spawn("npm", words, options);
+        let said = "";
+        let settled = false;
+        const end = (installed, why) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            if (!installed) {
+                noteFailure(context, "update.log", `npm ${words.join(" ")}: ${why}\n${said}`);
+            }
+            done(installed);
+        };
+        // On Windows killing cmd leaves npm running under it: its whole tree goes (Federico).
+        const timer = setTimeout(() => {
+            endTree(npm, platform);
+            end(false, `no answer in ${installWait / 60_000} minutes`);
+        }, installWait);
+        npm.stderr.on("data", (chunk) => {
+            said = (said + chunk.toString()).slice(-logLength);
+        });
+        npm.once("error", (error) => end(false, error.message));
+        npm.once("close", (code) => {
+            const now = code === 0 ? versionOnDisk(onDisk) : undefined;
+            end(now === version, code === 0 ? `Chesspal ${now ?? "unreadable"} is on disk where this table runs from` : `exit code ${code ?? "none"}`);
+        });
+    });
+}
+// npm downloads and installs in a few seconds, or a minute on a slow line; one that takes longer is stuck.
+const installWait = 5 * 60_000;
+const logLength = 4000;
+function versionOnDisk(onDisk) {
+    try {
+        return onDisk();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/sites/index.d.ts

@@ -1,2 +1,2 @@
-export { type Fetch } from "./request.ts";
+export { answerTime, askSite, type Fetch } from "./request.ts";
 export { readingsStale, readSites } from "./sites.ts";

package/dist/sites/index.js

@@ -1,4 +1,4 @@
 // The sites the player plays on (D-24, D-105): their public ratings on Lichess and chess.com, read from the names in their profile, without a key. Below
-// the commands, beside the profiles, whose types it fills; never asked by a tool of the AI's (D-106).
-export {} from "./request.js";
+// the commands, beside the profiles, whose types it fills; never asked by a tool of the AI's (D-106). Its request asks npm too, for a newer Chesspal (D-108).
+export { answerTime, askSite } from "./request.js";
 export { readingsStale, readSites } from "./sites.js";

package/dist/version.d.ts

@@ -1,2 +1,6 @@
 /** The version of the package that runs, read from its package.json: one folder above both src/ and dist/, so this module stays at their root. */
 export declare const version: string;
+/** The version of the package on disk now, which an update installs under the one that runs (D-108). */
+export declare function installedVersion(): string;
+/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
+export declare function isOlder(one: string, other: string): boolean;

package/dist/version.js

@@ -1,3 +1,14 @@
 import { readFileSync } from "node:fs";
 /** The version of the package that runs, read from its package.json: one folder above both src/ and dist/, so this module stays at their root. */
-export const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+export const version = installedVersion();
+/** The version of the package on disk now, which an update installs under the one that runs (D-108). */
+export function installedVersion() {
+    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+}
+/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
+export function isOlder(one, other) {
+    const parts = (version) => version.split(/[.+-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+    const [mine, theirs] = [parts(one), parts(other)];
+    const differs = mine.findIndex((part, index) => part !== theirs[index]);
+    return differs !== -1 && mine[differs] < theirs[differs];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chesspal",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Play chess against an AI with a character, and learn with an AI coach: Chesspal keeps the rules, the board, the games and the memory; the AI plays, reasons and talks.",
   "type": "module",
   "bin": {

package/dist/page/table/opener.css

@@ -1,65 +0,0 @@
-/* The table with no chat at it (D-104): the asleep note's box, with a row for each host, its button and its choices, and the command to type instead */
-.opener {
-    display: grid;
-    grid-template-columns: minmax(0, 1fr) auto auto;
-    gap: 8px 6px;
-}
-
-.opener > p {
-    grid-column: 1 / -1;
-    margin: 0;
-}
-
-/* One row a host, its columns shared with the other's through the subgrid: the choices as wide as their longest name, the button takes the rest, all as tall */
-.opener-host {
-    display: grid;
-    grid-column: 1 / -1;
-    grid-template-columns: subgrid;
-}
-
-.opener-host > .command {
-    justify-content: center;
-    padding: 6px 8px;
-    overflow: hidden;
-    white-space: nowrap;
-}
-
-.opener-host > .command:disabled,
-.opener-host > .command:disabled:hover {
-    cursor: default;
-    opacity: 0.5;
-    background: var(--accent);
-    border-color: var(--accent);
-}
-
-.opener-host select {
-    padding: 4px;
-    border: 1px solid var(--line);
-    border-radius: 6px;
-    background: var(--card);
-    color: var(--ink);
-    font: inherit;
-    font-size: 13px;
-}
-
-/* Empty, the state takes no room: its margin gives back the row's gap */
-.opener-state:empty {
-    margin-bottom: -8px;
-}
-
-.opener-command {
-    color: var(--soft);
-    font-size: 12.5px;
-}
-
-/* Each command whole on its line; two families, so the browser does not shrink the monospace */
-.opener-command code {
-    font-family: ui-monospace, monospace;
-    white-space: nowrap;
-    user-select: all;
-}
-
-/* Over the board, where the note lets clicks through to the squares, only its buttons, choices and commands take them */
-.over-board > .opener :is(button, select, code) {
-    pointer-events: auto;
-}