chesspal 0.3.4 → 0.3.6

package/dist/page/lead/lead.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 // Who is ahead as the AI estimates it (D-90): a two-colour bar in the game's card, with the helps on and in analysis, and in analysis a chart of the game,
 // as chess.com draws them, that goes to the move clicked. The page draws the AI's figures, never computes them (D-6, D-19).
+import { useRef, useState } from "preact/hooks";
 import { FoldButton, useCardFold } from "../game/card-fold.js";
 import { chartBadges, sideAhead } from "./view.js";
 /**
@@ -15,10 +16,14 @@ export function LeadBar({ standing, shown, text }) {
 }
 /**
  * The chart of the game in analysis, in a card that folds: White's share as the white area, the moves marked by a badge as dots, kept whole inside its
- * edges, the move shown as a line.
+ * edges, the move shown as a line, and under the mouse a fainter line on the move a click would show. A finger or the mouse drawn along it runs through the
+ * game.
  */
 export function LeadChart({ plies, standings, shown, onShow, text }) {
     const [folded, fold] = useCardFold("chart");
+    const [pointed, setPointed] = useState(undefined);
+    // A finger or the pressed mouse on the chart: where it went down, whether it runs through the game yet, and the move it showed last.
+    const pressed = useRef(undefined);
     const width = Math.max(plies.length, 1);
     const heightOf = (share) => 1 - share;
     const first = standings[0];
@@ -34,11 +39,43 @@ export function LeadChart({ plies, standings, shown, onShow, text }) {
         const at = standings.find((standing) => standing.plies === index + 1);
         return badge === undefined || at === undefined || !chartBadges.has(badge) ? [] : [{ badge, at }];
     });
-    const go = (event) => {
+    // The move at the pointer: how many moves the board would show.
+    const plyAt = (event) => {
         const box = event.currentTarget.getBoundingClientRect();
-        onShow(Math.round(((event.clientX - box.left) / box.width) * width));
+        return Math.min(width, Math.max(0, Math.round(((event.clientX - box.left) / box.width) * width)));
     };
-    return (_jsxs("section", { class: `card lead-card${folded ? " folded" : ""}`, children: [_jsx("h3", { class: "card-title", children: _jsxs(FoldButton, { folded: folded, onFold: fold, text: text, children: [_jsx(ChartIcon, {}), text.lead.chart] }) }), folded ? null : (_jsxs("div", { class: "lead-chart", role: "img", "aria-label": text.lead.chartHint, title: text.lead.chartHint, onClick: go, children: [_jsxs("svg", { viewBox: `0 0 ${width} 2`, preserveAspectRatio: "none", "aria-hidden": "true", children: [_jsx("path", { class: "white-area", d: area }), last.plies < width ? _jsx("rect", { class: "pending", x: last.plies, y: "0", width: width - last.plies, height: "2" }) : null, _jsx("path", { class: "even", d: `M0 1 L${width} 1`, "vector-effect": "non-scaling-stroke" })] }), _jsx("span", { class: "shown", style: { left: inside((shown / width) * 100, 2) }, "aria-hidden": "true" }), dots.map(({ badge, at }) => (_jsx("span", { class: `dot ${badge}`, style: { left: inside((at.plies / width) * 100, 6), top: inside((heightOf(at.share) / 2) * 100, 6) }, "aria-hidden": "true" }, at.plies)))] }))] }));
+    const showAt = (at) => {
+        if (pressed.current !== undefined && pressed.current.showed !== at) {
+            pressed.current.showed = at;
+            onShow(at);
+        }
+    };
+    // The mouse shows its move as it goes down; a finger once it runs across, as one that runs up or down scrolls the page, or as it lifts, a tap.
+    const press = (event) => {
+        event.currentTarget.setPointerCapture(event.pointerId);
+        pressed.current = { x: event.clientX, y: event.clientY, along: event.pointerType === "mouse" };
+        setPointed(undefined);
+        if (pressed.current.along) {
+            showAt(plyAt(event));
+        }
+    };
+    const point = (event) => {
+        const press = pressed.current;
+        if (press === undefined) {
+            setPointed(event.pointerType === "mouse" ? plyAt(event) : undefined);
+            return;
+        }
+        const across = Math.abs(event.clientX - press.x);
+        press.along ||= across > 8 && across > Math.abs(event.clientY - press.y);
+        if (press.along) {
+            showAt(plyAt(event));
+        }
+    };
+    const lift = (event) => {
+        showAt(plyAt(event));
+        pressed.current = undefined;
+    };
+    return (_jsxs("section", { class: `card lead-card${folded ? " folded" : ""}`, children: [_jsx("h3", { class: "card-title", children: _jsxs(FoldButton, { folded: folded, onFold: fold, text: text, children: [_jsx(ChartIcon, {}), text.lead.chart] }) }), folded ? null : (_jsxs("div", { class: "lead-chart", role: "img", "aria-label": text.lead.chartHint, title: text.lead.chartHint, onPointerDown: press, onPointerMove: point, onPointerUp: lift, onPointerCancel: () => void (pressed.current = undefined), onPointerLeave: () => setPointed(undefined), children: [_jsxs("svg", { viewBox: `0 0 ${width} 2`, preserveAspectRatio: "none", "aria-hidden": "true", children: [_jsx("path", { class: "white-area", d: area }), last.plies < width ? _jsx("rect", { class: "pending", x: last.plies, y: "0", width: width - last.plies, height: "2" }) : null, _jsx("path", { class: "even", d: `M0 1 L${width} 1`, "vector-effect": "non-scaling-stroke" })] }), pointed === undefined || pointed === shown ? null : _jsx("span", { class: "shown ghost", style: { left: inside((pointed / width) * 100, 2) }, "aria-hidden": "true" }), _jsx("span", { class: "shown", style: { left: inside((shown / width) * 100, 2) }, "aria-hidden": "true" }), dots.map(({ badge, at }) => (_jsx("span", { class: `dot ${badge}`, style: { left: inside((at.plies / width) * 100, 6), top: inside((heightOf(at.share) / 2) * 100, 6) }, "aria-hidden": "true" }, at.plies)))] }))] }));
 }
 /** A place along the chart, in percent, kept whole inside its edges by so many pixels. */
 function inside(percent, pixels) {

package/dist/page/sounds/sounds.js

@@ -18,7 +18,7 @@ export function endSoundOf(how) {
 /** Lets the page play sounds: loads the recordings, and since a browser plays none before the player has touched the page, the first touch wakes them. */
 export function wakeSounds() {
     loadRecordings();
-    addEventListener("pointerdown", () => void audio()?.resume(), { once: true });
+    window.addEventListener("pointerdown", () => void audio()?.resume(), { once: true });
 }
 /** Plays a sound: its recordings together, else its tone; a browser without Web Audio plays none. */
 export function playSound(sound) {

package/dist/page/style.css

@@ -3,6 +3,7 @@
 @import "base.css";
 @import "layout/layout.css";
 @import "board/board.css";
+@import "avatars/torretta.css";
 @import "talk/talk.css";
 @import "talk/chat.css";
 @import "table/table.css";

package/dist/page/talk/talk.css

@@ -266,115 +266,6 @@
     color: var(--accent);
 }
 
-/* The Torretta, whose eyes blink now and then, and its moods (D-70): a new face that pops in, never fading out, a red light when worried, out when sad, a light that breathes when
-   thoughtful */
-.torretta .antenna {
-    fill: none;
-    stroke: var(--torretta-shade);
-    stroke-width: 4;
-    stroke-linecap: round;
-}
-
-.torretta .light {
-    fill: var(--torretta-light);
-    transition: fill 0.2s;
-}
-
-.torretta.mood-worried .light {
-    fill: var(--torretta-alarm);
-}
-
-.torretta.mood-thoughtful .light {
-    animation: ponder 2.4s ease-in-out infinite;
-}
-
-.torretta.mood-sad .light {
-    fill: var(--torretta-shade);
-}
-
-@keyframes ponder {
-    50% {
-        fill: var(--torretta-ponder);
-    }
-}
-
-.torretta .expression.changed {
-    transform-box: fill-box;
-    transform-origin: center;
-    animation: face-in 0.16s ease-out;
-}
-
-@keyframes face-in {
-    from {
-        transform: scale(0.8);
-    }
-}
-
-/* Its bust on a player's card: a disc of the player's picture's colour, which cuts what falls out of it */
-.torretta.bust {
-    clip-path: circle(50%);
-}
-
-.torretta .back {
-    fill: var(--say);
-}
-
-.torretta .shade {
-    fill: var(--torretta-shade);
-}
-
-.torretta .body {
-    fill: var(--torretta-body);
-}
-
-.torretta .screen {
-    fill: var(--torretta-screen);
-}
-
-.torretta .eyes,
-.torretta .mouth {
-    fill: var(--torretta-face);
-}
-
-.torretta .expression .line,
-.torretta .brows {
-    fill: none;
-    stroke: var(--torretta-face);
-    stroke-width: 3.4;
-    stroke-linecap: round;
-    stroke-linejoin: round;
-}
-
-.torretta .eyes {
-    transform-box: fill-box;
-    transform-origin: center;
-    animation: blink 6s infinite;
-}
-
-@keyframes blink {
-    0%,
-    95%,
-    100% {
-        transform: scaleY(1);
-    }
-
-    97% {
-        transform: scaleY(0.1);
-    }
-}
-
-@media (prefers-reduced-motion: reduce) {
-    .torretta .eyes,
-    .torretta .expression.changed,
-    .torretta.mood-thoughtful .light {
-        animation: none;
-    }
-
-    .torretta .light {
-        transition: none;
-    }
-}
-
 /* The bubbles: the AI's under its card, the tail under the Torretta's centre (14 px of padding, 48 px picture), and the player's above their box */
 .says,
 .sent {

package/dist/page/text.js

@@ -40,6 +40,7 @@ const english = {
     declineDrawTitle: "Decline: moving declines it too",
     resign: "Resign",
     resignGame: "Resign this game?",
+    keepPlaying: "Play on",
     settings: "Settings",
     close: "Close",
     look: "Look",
@@ -195,6 +196,10 @@ const english = {
         typeIt: "Or type in a terminal:",
     },
     commandHere: (name) => `/clear and the other commands go in the window where you opened ${name}, not here.`,
+    link: {
+        going: "A game is going on: finish it, then open the link again.",
+        gone: "The game of this link is not here: it was deleted, or it is another profile's.",
+    },
     refused: {
         "no-game": () => "There is no game going on: press + to start one, or ask for one in the chat.",
         "ai-to-move": () => "Wait for the AI's move.",
@@ -465,6 +470,7 @@ const italian = {
     declineDrawTitle: "Rifiuta: anche muovere rifiuta",
     resign: "Abbandona",
     resignGame: "Abbandonare la partita?",
+    keepPlaying: "Continua",
     settings: "Impostazioni",
     close: "Chiudi",
     look: "Aspetto",
@@ -620,6 +626,10 @@ const italian = {
         typeIt: "Oppure scrivi in un terminale:",
     },
     commandHere: (name) => `/clear e gli altri comandi vanno scritti nella finestra dove hai aperto ${name}, non qui.`,
+    link: {
+        going: "C'è una partita in corso: finiscila, poi riapri il link.",
+        gone: "La partita di questo link non c'è: è stata cancellata, o è di un altro profilo.",
+    },
     refused: {
         "no-game": () => "Nessuna partita in corso: premi + per iniziarne una, o chiedila nella chat.",
         "ai-to-move": () => "Aspetta la mossa dell'AI.",

package/dist/page/theme.css

@@ -62,6 +62,19 @@
     --badge-mistake: #d4650f;
     --badge-miss: #c2407d;
     --badge-blunder: #d22c2c;
+    /* The kings' badges on a game over, the same in both themes: the winner's gold crown, the mate in red on white, the flag that fell, the draw */
+    --king-crown: #e0a526;
+    --king-crown-ink: #3b2a00;
+    --king-mate: #c81e1e;
+    --king-flag: #4a4f57;
+    --king-draw: #69727d;
+    /* The two sides as the game's column draws them, in the bar and the chart of who is ahead and in the helps' bars and tiles, the same in both themes:
+       White, Black, and both, each half 3:1 at least with the tile's green tick; their edge keeps the white half in sight on a light card and the black one
+       on a dark card. The board's map and counts keep their own, darker on the squares (Zoe) */
+    --side-white: #f5f5f2;
+    --side-black: #33383f;
+    --side-both: #8a9099;
+    --side-edge: color-mix(in srgb, var(--side-both) 60%, transparent);
     --shadow: 0 1px 2px rgba(29, 39, 51, 0.06), 0 6px 18px rgba(29, 39, 51, 0.06);
     /* On a light page the board keeps a thin edge in its dark squares colour, and a deeper shadow, so its light squares do not melt into the page */
     --board-shadow: 0 0 0 1px color-mix(in oklab, var(--dark-square) 55%, transparent), 0 2px 4px rgba(29, 39, 51, 0.1), 0 10px 28px rgba(29, 39, 51, 0.12);

package/dist/profiles/profiles.js

@@ -23,8 +23,12 @@ export function listProfiles(root) {
  * together make one: the second finds its folder taken.
  */
 export function ensureProfile(root, account) {
+    // Every command asks, so the common answer comes first: a profile is there.
+    if (profileIds(root).length > 0) {
+        return;
+    }
     const id = freeId(root, slugOf(account));
-    if (profileIds(root).length === 0 && claimed(root, id)) {
+    if (claimed(root, id)) {
         fillProfile(root, id, { name: account }, true);
     }
 }

package/dist/server/bell/bell.d.ts

@@ -85,5 +85,3 @@ export type BellHeard = {
 export declare function bellHeard(input: string, ports?: number[]): Promise<BellHeard>;
 /** Adds a line to the log of the hooks that heard no bell, keeping its last lines; a log that cannot be written never stops the hook. */
 export declare function noteSilence(folder: string, why: string, now?: Date): void;
-/** Whether two paths name the same folder: without regard to case on Windows. */
-export declare function samePath(one: string, other: string): boolean;

package/dist/server/bell/bell.js

@@ -5,7 +5,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { get } from "node:http";
 import { join, resolve } from "node:path";
 import { writeAtomically } from "../../games/index.js";
-import { dataFolder, tableFolder } from "../../home/index.js";
+import { dataFolder, samePath, tableFolder } from "../../home/index.js";
 import { analystAgent } from "../../host-files/index.js";
 import { version } from "../../version.js";
 /** What the chat hears from the doorbell: one line for whatever the player did, never what, only where to read it. */
@@ -287,15 +287,11 @@ function probeOf(said) {
         return undefined;
     }
 }
-/** Whether two paths name the same folder: without regard to case on Windows. */
-export function samePath(one, other) {
-    return process.platform === "win32" ? resolve(one).toLowerCase() === resolve(other).toLowerCase() : resolve(one) === resolve(other);
-}
 /** The body a page of this computer answers with, once it ends; undefined when it does not answer, or not with 200. */
 function body(port, path, wait) {
     return new Promise((done) => {
         // A connection of its own: Node's shared one ends a request idle for five seconds, and the doorbell waits for hours.
-        const request = get({ host: "127.0.0.1", port, path, agent: false, ...(wait === undefined ? {} : { timeout: wait }) }, (response) => {
+        const request = get({ host: "127.0.0.1", port, path, agent: false }, (response) => {
             let text = "";
             response.setEncoding("utf8");
             response.on("data", (chunk) => {
@@ -305,8 +301,22 @@ function body(port, path, wait) {
             response.on("error", () => done(undefined));
         });
         if (wait !== undefined) {
-            request.on("timeout", () => request.destroy());
+            giveUpAfterTurns(request, wait);
         }
         request.on("error", () => done(undefined));
     });
 }
+/**
+ * Ends a request still unanswered after `wait`, counted in ten turns of this process's clock: after a stall (a busy computer, one waking up), a timer
+ * fires before the answer waiting is read, and a page of this process, or one that answered meanwhile, would be taken for one that does not answer.
+ */
+function giveUpAfterTurns(request, wait) {
+    let turns = 0;
+    const timer = setInterval(() => {
+        turns++;
+        if (turns === 10) {
+            request.destroy();
+        }
+    }, wait / 10);
+    request.on("close", () => clearInterval(timer));
+}

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

@@ -1 +1 @@
-export { Bell, bellProbe, listen, pageAt, pagePorts, samePath, type TableChat } from "./bell.ts";
+export { Bell, bellProbe, listen, pageAt, pagePorts, type TableChat } from "./bell.ts";

package/dist/server/bell/index.js

@@ -1,2 +1,2 @@
 // The doorbell that wakes a chat when the player acts on the page (D-47), and the ports where a folder's page answers.
-export { Bell, bellProbe, listen, pageAt, pagePorts, samePath } from "./bell.js";
+export { Bell, bellProbe, listen, pageAt, pagePorts } from "./bell.js";

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

@@ -20,13 +20,17 @@ export declare function chatSeenOf(chat: Context): ChatSeen;
 export declare function pageContext(chat: Context): Context;
 /** The context of a new game started on the page: the page's, with what the chat saw and its host, by which the game before asks for a clean chat (D-57). */
 export declare function asTheChatSees(context: Context, chat: ChatSeen): Context;
-/** What a chat says of itself as it attaches to the table (D-104): its version, its session, its folder, its host, and whether its folder needs init again. */
+/**
+ * What a chat says of itself as it attaches to the table (D-104): its version, its session, its folder, its host, whether its folder needs init again,
+ * and the seat of the `chesspal play` that started it, if one did.
+ */
 export declare const chatAttach: z.ZodObject<{
     version: z.ZodString;
     session: z.ZodNullable<z.ZodString>;
     folder: z.ZodString;
     host: z.ZodOptional<z.ZodString>;
     outdated: z.ZodBoolean;
+    seat: z.ZodOptional<z.ZodInt>;
 }, z.core.$strip>;
 export type ChatAttach = z.infer<typeof chatAttach>;
 /**

package/dist/server/page/chat.js

@@ -42,13 +42,17 @@ export function pageContext(chat) {
 export function asTheChatSees(context, chat) {
     return { ...context, host: () => chat.host(), positionSeen: chat.positionSeen };
 }
-/** What a chat says of itself as it attaches to the table (D-104): its version, its session, its folder, its host, and whether its folder needs init again. */
+/**
+ * What a chat says of itself as it attaches to the table (D-104): its version, its session, its folder, its host, whether its folder needs init again,
+ * and the seat of the `chesspal play` that started it, if one did.
+ */
 export const chatAttach = z.object({
     version: z.string(),
     session: z.string().nullable(),
     folder: z.string(),
     host: z.string().optional(),
     outdated: z.boolean(),
+    seat: z.int().optional(),
 });
 const seenPosition = z.object({ started: z.string().optional(), plies: z.int().min(0) });
 /**

package/dist/server/page/game.js

@@ -1,9 +1,10 @@
 import { analyseGame, analystOf, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, shownPosition, startNewGame, } from "../../commands/index.js";
 import { clockStarted, isReviewed, writePgn } from "../../core/index.js";
-import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, heardLines, loadGame, loadTableTalk, playerPgn, ponderingOn, rerunIfChanged, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
+import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, heardLines, loadGame, loadTableTalk, playerPgn, ponderingUntil, rerunIfChanged, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
 import { gameFolder, helpsIn } from "../../profiles/index.js";
 import { version } from "../../version.js";
 import { asTheChatSees } from "./chat.js";
+import { tellWatchers } from "./events.js";
 import { bodyOf, bytesOf, isJson, json, jsonOf, runRoute, send, textOf } from "./http.js";
 import { profilesShown } from "./profiles.js";
 import { chatToRelaunch, relaunchChat, tableShown } from "./table.js";
@@ -233,6 +234,8 @@ async function studyFromPage(request, response, served) {
     const last = body?.last === true;
     // A game a link of the page opens is there to look at: the chat is not asked to go over it.
     const look = body?.look === true;
+    // «Analyse again», the review just deleted: the chat starts the analyst without asking, even after one was stopped (Priya).
+    const redo = body?.redo === true;
     if (pgn === undefined && game === undefined && !last) {
         send(response, 400, json, JSON.stringify({ error: asked, refusal: "pgn-unreadable" }));
         return;
@@ -249,7 +252,7 @@ async function studyFromPage(request, response, served) {
         reviewed = isReviewed(opened.record);
         brought = !reviewed && !look;
         // A game not yet reviewed is marked as brought, for status to ask the AI to go over it; one reviewed is ready, and the chat sleeps on.
-        startAnalysis(gameFolder(served.context.home()), opened.name, served.context.now(), { brought });
+        startAnalysis(gameFolder(served.context.home()), opened.name, served.context.now(), { brought, redo });
     }
     catch (error) {
         send(response, 400, json, JSON.stringify({ error: error.message, refusal: "pgn-unreadable" }));
@@ -327,7 +330,19 @@ function thinkingShown(served, current) {
         const onIt = served.bell.woke || (seen !== undefined && seen !== null && samePosition(seen, position));
         return served.bell.inTurn && onIt ? { thinking: "move" } : {};
     }
-    return ponderingOn(gameFolder(served.context.home()), thoughtKey(current)) ? { thinking: "ponder" } : {};
+    const until = ponderingUntil(gameFolder(served.context.home()), thoughtKey(current));
+    const left = until === undefined ? 0 : until.getTime() - served.context.now().getTime();
+    if (left <= 0) {
+        return {};
+    }
+    signGoesIn(served, left);
+    return { thinking: "ponder" };
+}
+// The pages hear when the sign of an agent that stopped pondering without a word goes, which no file tells: one timer a table, the latest.
+const signTimers = new WeakMap();
+function signGoesIn(served, wait) {
+    clearTimeout(signTimers.get(served));
+    signTimers.set(served, setTimeout(() => tellWatchers(served.watchers), wait + 100).unref());
 }
 /**
  * What the coach wrote that the player may see now, in a game going on with the helps on (D-88): its judgments, those whose note names a move they may still

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

@@ -19,10 +19,11 @@ export interface TableChats {
     /** Asks for the chat again: with another host, or `updated`, from the Chesspal just installed (D-108). */
     relaunch(folder: string, host?: string, updated?: boolean): boolean;
 }
-/** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own. */
+/** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own, and the seat, the play's process. */
 export interface HeldChat {
     readonly model?: string | undefined;
     readonly effort?: string | undefined;
+    readonly seat?: number;
 }
 /** A chat opening at the table: one the page asked for, the one started again for a new game, or with another model or host (D-107). */
 export type Opening = "chat" | "again" | "restart";

package/dist/server/page/table.js

@@ -72,7 +72,7 @@ export function relaunchChat(served, how = "again", host) {
     const folder = served.attached?.chat.folder;
     // Another host may first ask whether it trusts the table's folder: the pages say so, as for a chat opened.
     const switching = how === "restart" && host !== undefined && host !== hostAtTable(served);
-    if (folder === undefined || served.table?.chats?.relaunch(folder, host) !== true) {
+    if (folder === undefined || heldChat(served) === undefined || served.table?.chats?.relaunch(folder, host) !== true) {
         return false;
     }
     noteOpening(served, switching ? "chat" : how);
@@ -252,9 +252,11 @@ function hostAtTable(served) {
     return served.attached === undefined ? undefined : served.table?.chats?.hosts().find((one) => said.includes(one.name))?.name;
 }
 // The chat at the table when `chesspal play` holds it, which the table can start again: the model and effort it started with.
+// The chat at the table when it is the one `chesspal play` holds: in its folder and started by it, not another opened there by hand.
 function heldChat(served) {
     const { attached } = served;
-    return attached === undefined ? undefined : served.table?.chats?.held(attached.chat.folder);
+    const held = attached === undefined ? undefined : served.table?.chats?.held(attached.chat.folder);
+    return held === undefined || held.seat !== attached?.chat.seat ? undefined : { model: held.model, effort: held.effort };
 }
 // The chat waits for the doorbell, out of a turn, and no analyst of it is at work: starting it again loses nothing.
 function chatAtRest(served) {

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

@@ -8,7 +8,7 @@ export interface UpdateShown {
     readonly installing?: true;
     readonly installed?: true;
 }
-/** Asks npm for Chesspal's latest version now and once a day after, the pages told when it is newer than this one; how to stop. None in the tests. */
+/** Asks npm for Chesspal's latest version now and every hour after, the pages told when it is newer than this one; how to stop. None in the tests. */
 export declare function watchForUpdates(served: Served, every?: number): () => void;
 /** The newer Chesspal the page shows, when npm has one. */
 export declare function updateShown(served: Served): {

package/dist/server/page/update.js

@@ -1,10 +1,10 @@
-// A newer Chesspal on npm (D-108): the page's server asks as it starts and once a day after; the table's page offers to install it, a chat's own page says
+// A newer Chesspal on npm (D-108): the page's server asks as it starts and every hour after; the table's page offers to install it, a chat's own page says
 // the command to type.
 import { answerTime, askSite } from "../../sites/index.js";
 import { isOlder, version } from "../../version.js";
 import { tellWatchers } from "./events.js";
-/** Asks npm for Chesspal's latest version now and once a day after, the pages told when it is newer than this one; how to stop. None in the tests. */
-export function watchForUpdates(served, every = aDay) {
+/** Asks npm for Chesspal's latest version now and every hour after, the pages told when it is newer than this one; how to stop. None in the tests. */
+export function watchForUpdates(served, every = anHour) {
     const fetch = served.context.fetch;
     if (fetch === undefined) {
         return () => undefined;
@@ -37,4 +37,4 @@ export async function latestVersion(fetch) {
     return answer?.status === 200 && typeof said === "string" && /^\d+\.\d+\.\d+$/.test(said) ? said : undefined;
 }
 const latestUrl = "https://registry.npmjs.org/chesspal/latest";
-const aDay = 24 * 60 * 60 * 1000;
+const anHour = 60 * 60 * 1000;

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

@@ -5,3 +5,8 @@ import type { TableChats } from "../../page/index.ts";
  * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's.
  */
 export declare function terminalChats(context: Context, chesspal?: readonly string[], env?: NodeJS.ProcessEnv): TableChats;
+/**
+ * What the terminal runs: `chesspal play <host>`, with the table's data folder when it has one of its own, as a playtest's: Terminal.app and Windows
+ * Terminal start the chat without the table's environment.
+ */
+export declare function playCommand(chesspal: readonly string[], host: string, env: NodeJS.ProcessEnv): string[];

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

@@ -1,5 +1,4 @@
-import { tableFolder } from "../../../home/index.js";
-import { samePath } from "../../bell/index.js";
+import { samePath, tableFolder } from "../../../home/index.js";
 import { programPath } from "./find.js";
 import { hostChoices, hostNames, isHostName } from "./hosts.js";
 import { askAgain, seatHeld } from "./seat.js";
@@ -18,15 +17,23 @@ export function terminalChats(context, chesspal = [process.execPath, ...process.
             }
             return found.hosts;
         },
-        open: async (host) => isHostName(host) && await openTerminal(tableFolder(context.home()), [...chesspal, "play", host], context.platform, env),
+        open: async (host) => isHostName(host) && await openTerminal(tableFolder(context.home()), playCommand(chesspal, host, env), context.platform, env),
         // Only a chat in the table's folder can be the one chesspal play holds.
         held: (folder) => {
             const seat = samePath(folder, tableFolder(context.home())) ? seatHeld(folder, context.now()) : undefined;
-            return seat === undefined ? undefined : { model: seat.model, effort: seat.effort };
+            return seat === undefined ? undefined : { model: seat.model, effort: seat.effort, seat: seat.pid };
         },
         relaunch: (folder, host, updated) => samePath(folder, tableFolder(context.home())) && askAgain(folder, context.now(), { ...(host === undefined ? {} : { host }), ...(updated === true ? { updated } : {}) }),
     };
 }
+/**
+ * What the terminal runs: `chesspal play <host>`, with the table's data folder when it has one of its own, as a playtest's: Terminal.app and Windows
+ * Terminal start the chat without the table's environment.
+ */
+export function playCommand(chesspal, host, env) {
+    const home = env.CHESSPAL_HOME?.trim();
+    return [...chesspal, "play", host, ...(home ? ["--home", home] : [])];
+}
 // Looking on the PATH takes a few milliseconds, and the page asks at every change of the game.
 const lookAgain = 10_000;
 function chatHost(name, platform, env) {

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

@@ -1,5 +1,5 @@
 import { type ChildProcess } from "node:child_process";
-import type { Context } from "../../../commands/index.ts";
+import { type Context } from "../../../commands/index.ts";
 import { type HostChoice, type HostName } from "./hosts.ts";
 /**
  * What `chesspal play` starts: the host's program, its arguments, folder and environment, whether it needs cmd, as a .cmd shim does on Windows, and the
@@ -12,6 +12,8 @@ export interface HostLaunch {
     readonly env: NodeJS.ProcessEnv;
     readonly shell: boolean;
     readonly choice: HostChoice;
+    /** Codex's hooks were there and Chesspal wrote them again: Codex runs them only once the player trusts them again. */
+    readonly hooksChanged?: true;
 }
 /**
  * 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),

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

@@ -3,8 +3,9 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { win32 } from "node:path";
+import { speaksItalian } from "../../../commands/index.js";
 import { tableFolder } from "../../../home/index.js";
-import { setUpHosts } from "../../../host-files/index.js";
+import { codexHooksPath, setUpHosts } from "../../../host-files/index.js";
 import { activeProfile, gameFolder, languageIn, profileSettings } from "../../../profiles/index.js";
 import { programPath } from "./find.js";
 import { choiceIn, hostArgs, isHostName, startMessage } from "./hosts.js";
@@ -120,23 +121,34 @@ export function hostLaunch(context, host, env = process.env, exists) {
     if (found === undefined) {
         throw new Error(`${hostTitle[host]} is not installed on this computer, or not on its PATH: install it (${installHint[host]}), then try again.`);
     }
-    setUpHosts(folder, context.platform);
+    const hooks = codexHooksPath(folder);
+    const hadHooks = host === "codex" && existsSync(hooks);
+    const hooksChanged = setUpHosts(folder, context.platform).includes(hooks) && hadHooks ? { hooksChanged: true } : {};
     const choice = choiceIn(profileSettings(home, activeProfile(home).id), host);
     const args = hostArgs(host, startMessage(languageIn(gameFolder(home), context.language)), choice);
     // An effort the player set for every chat would win over the one chosen on the page: spawn leaves out a variable that is undefined.
     const effort = host === "claude" && choice.effort !== undefined ? { CLAUDE_CODE_EFFORT_LEVEL: undefined } : {};
-    const childEnv = { ...env, ...Object.fromEntries(sessionMarks.map((name) => [name, undefined])), ...effort };
+    // The seat this play holds, by which its chat's server tells the table it is the chat held, and not another opened in the same folder.
+    const childEnv = { ...env, ...Object.fromEntries(sessionMarks.map((name) => [name, undefined])), ...effort, CHESSPAL_SEAT: String(process.pid) };
     const script = npmScript(host, found, context.platform, exists ?? existsSync);
     if (script !== undefined) {
-        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice };
+        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice, ...hooksChanged };
     }
-    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice };
+    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice, ...hooksChanged };
 }
 const hostTitle = { claude: "Claude Code", codex: "Codex" };
+const hooksChangedWords = {
+    english: "Chesspal's hooks for Codex have changed: when Codex asks about them, choose Trust all again.",
+    italian: "Gli «hook» di Chesspal per Codex sono cambiati: quando Codex te lo chiede, scegli di nuovo Trust all.",
+};
 // 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 });
+    // After an update the player is asked about the hooks again: said here, above the host's question, as init says it.
+    if (launch.hooksChanged === true) {
+        process.stdout.write(`${speaksItalian(context.language) ? hooksChangedWords.italian : hooksChangedWords.english}\n`);
+    }
     return runHost(launch, again, context.platform).catch((error) => {
         throw new Error(`${hostTitle[host]} did not start: ${error.message}`);
     });

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

@@ -25,6 +25,8 @@ export declare function iconAsked(home: string, machine?: string): boolean;
 export declare function noteIconAsked(home: string, machine?: string): void;
 /** Notes the icon made on this machine, its command and files, which asks no more there. */
 export declare function noteIconMade(home: string, command: IconCommand, files: readonly string[], machine?: string): void;
+/** Takes Chesspal's icon off the desktop and the menu of this machine, the files noted when it was made: those it removed. */
+export declare function removeIcons(home: string, machine?: string): string[];
 /**
  * Whether the icon made on this machine runs another Node or script than `command`, which a Node manager or an update may have taken away, and is still
  * there: then it is made again. One the player removed stays removed.