chesspal 0.3.0 → 0.3.2

package/dist/page/text.js

@@ -5,12 +5,32 @@ export function textFor(languages) {
 }
 const englishNames = { K: "king", Q: "queen", R: "rook", B: "bishop", N: "knight", P: "pawn" };
 const italianNames = { K: "re", Q: "donna", R: "torre", B: "alfiere", N: "cavallo", P: "pedone" };
+const englishMoveWords = {
+    names: englishNames,
+    castles: { short: "castles short", long: "castles long" },
+    from: "from",
+    to: "to",
+    takes: "takes",
+    promotes: "promotes to",
+    check: { check: "check", mate: "checkmate" },
+};
+const italianMoveWords = {
+    names: italianNames,
+    castles: { short: "arrocco corto", long: "arrocco lungo" },
+    from: "da",
+    to: "in",
+    takes: "prende",
+    promotes: "promuove a",
+    check: { check: "scacco", mate: "scacco matto" },
+};
 const english = {
     language: "en",
     flip: "Flip",
     theme: "Light or dark theme",
     sounds: "Sounds",
     voice: "Read the AI's words aloud",
+    noVoice: "This browser has no voice for this language: add one in your system's settings",
+    saidMove: (move) => moveInWords(englishMoveWords, move),
     newGame: "New game",
     offerDraw: "Offer a draw",
     offerDrawWhen: "Offer a draw: on your turn, once each side has moved",
@@ -128,21 +148,45 @@ const english = {
     boardLabel: (turn, lastMove) => `Chessboard, ${english.toMove(turn)}${lastMove === undefined ? "" : `, last move ${lastMove}`}`,
     clearChat: (name) => `Before a new game, clear your chat with ${name}: in the window where you opened ${name}, not here, write /clear, then a message such as "new game". A clean chat plays faster.`,
     outdated: (name) => `Chesspal has been updated, but this folder still has its old files: close the chat with ${name}, run chesspal init in this folder, and open a new chat.`,
+    update: {
+        mark: (version) => `Chesspal ${version} is out: update`,
+        title: "Update Chesspal",
+        offer: (version, current) => `Chesspal ${version} is out${current === undefined ? "" : `; this is ${current}`}. The table installs it and starts again by itself.`,
+        chatAgain: (name) => `The chat with ${name} starts again too, clean.`,
+        byHand: (name) => `You opened the chat with ${name} yourself: afterwards, close it and open a new one.`,
+        whilePlaying: "A game is going on: finish it, then update.",
+        install: "Update",
+        installing: (version) => `Installing ${version}…`,
+        installed: "Installed: the table starts again by itself once the game is over.",
+        failed: "Chesspal was not updated: close the chat, then type in a terminal, one after the other:",
+        notice: (version, name) => `Chesspal ${version} is out: close the chat with ${name}, type this command in a terminal, then open a new chat.`,
+        hide: "Hide until the next version",
+    },
     offline: (name) => `${name} is not connected. Write it a message in the window where you opened ${name}, not in this page's chat: the page connects again by itself.`,
     startClocks: "Start",
     thinking: { move: "Thinking about its move", ponder: "Thinking while you play" },
     asleep: (name) => `${name} is not listening: write a message, such as "hi", in the window where you opened ${name}, not here. Its clock waits until it answers.`,
     asleepInAnalysis: (name) => `${name} is not listening: write to it in the window where you opened it, not here.`,
     table: {
-        label: "Open a chat",
-        noChat: (name) => `To play with ${name}, open its chat: it starts in a window of its own, to keep open.`,
+        title: "Who are you playing?",
+        choose: "Choose the chat to play with: it opens in a window of its own, to keep open.",
+        restartHint: "Choose the model and effort, then press Claude Code or Codex: the chat starts again, clean, in the same window, once it has ended its answer. The game stays as it is.",
+        byHand: (name) => `You opened this chat yourself: change ${name}'s model with /model in its window, or close it and open one from here, with the choices below.`,
+        noChat: "No chat at the table: choose one",
+        change: "Change the chat or its model",
         install: (name) => `To play with ${name}, install Claude Code or Codex, then open this page again.`,
         model: "Model",
         effort: "Effort",
         asHost: (host) => `as set in ${host}`,
         opening: "Opening the chat… In the terminal, if it asks whether you trust the folder, choose Yes with the arrow keys and press Enter.",
         again: (name) => `${name} starts again with a clean chat for the new game…`,
+        restart: "The chat starts again, clean…",
+        waiting: (name) => `${name} starts again once it has ended its answer…`,
+        restartChanged: "Starts again, clean, with the new choices",
+        restartNow: "Start again now: it cuts the answer it is giving",
+        cancel: "Do not start again",
         failed: "The terminal did not open: type the command below in a terminal.",
+        notRestarted: "The chat did not start again: close its window, then open another from here.",
         typeIt: "Or type in a terminal:",
     },
     commandHere: (name) => `/clear and the other commands go in the window where you opened ${name}, not here.`,
@@ -161,6 +205,8 @@ const english = {
         "profile-game": () => english.profile.whilePlaying,
         "game-going": () => "A game is going on: finish it before you bring another to analyse.",
         "pgn-unreadable": () => "Chesspal cannot read this PGN: check you copied the whole game, its tags and its moves.",
+        "update-game": () => english.update.whilePlaying,
+        "update-chat": (most, name) => `${name} is answering: update once it has done.`,
     },
     piece: (letter, side) => `${side} ${englishNames[letter]}`,
     taken: (pieces, ahead) => `Pieces taken: ${pieces.length === 0 ? "none" : pieces.join(", ")}${ahead > 0 ? `; ahead by ${ahead}` : ""}`,
@@ -218,7 +264,6 @@ const english = {
         back: "Back",
         yourProfile: "Your profile",
         editProfile: "Edit your profile",
-        yourPicture: "Your picture: edit your profile",
         avatars: { "short-hair": "Short hair", bun: "Bun", glasses: "Glasses", beanie: "Beanie", beard: "Beard", curls: "Curls", moustache: "Moustache", "silver-bob": "Silver bob", cat: "Cat", owl: "Owl" },
         whilePlaying: "Finish the game, or resign, before changing player.",
         accounts: "Do you play on Lichess, Chess.com or in FIDE tournaments?",
@@ -323,25 +368,29 @@ const english = {
             backward: ["Backward pawns", "A pawn left behind the pawns beside it, with the square in front of it attacked by an enemy pawn."],
             passed: ["Passed pawns", "No enemy pawn in front of it, on its file or the files beside it."],
             islands: ["Pawn islands", "Groups of pawns on neighbouring files, apart from each other."],
+            openFiles: ["Open files", "Files with no pawn of either side."],
             halfOpen: ["Half-open files", "Files with enemy pawns and none of one's own."],
             heavyOnFiles: ["Rooks and queens on open files", "Rooks and queens on open or half-open files."],
             onSeventh: ["Rooks and queens on the seventh", "Rooks and queens on the enemy's second rank: the seventh for White, the second for Black."],
             outposts: ["Outposts", "Squares on one's ranks 4 to 6, defended by a pawn, that no enemy pawn can ever attack."],
             bishopPair: ["Bishop pair", "Both bishops still on the board."],
-            space: ["Space (squares in the enemy's half)", "How many squares of the enemy's half one's pieces attack."],
+            space: ["Space", "How many squares of the enemy's half one's pieces attack."],
             undeveloped: ["Minor pieces not developed", "Knights and bishops still on their first squares."],
             castled: ["Castling", "How it castled; a dash while it still can, a cross once the king or the rooks have moved."],
             kingAttacks: ["Enemy attacks around the king", "How many enemy attacks fall on the squares next to the king."],
         },
-        groups: { pawns: "Pawns", pieces: "Pieces", king: "King" },
         yes: "yes",
         notYet: "not yet",
         noMore: "no more",
         phases: { opening: "Opening", middlegame: "Middlegame", endgame: "Endgame" },
-        openFiles: "Open files",
-        control: "Squares controlled",
-        both: "both",
         controlled: (white, black, both) => `Squares only White's ${white}, only Black's ${black}, both ${both}`,
+        controlledBy: (who, count, you) => {
+            if (who === "both") {
+                return `Squares both control: ${count}`;
+            }
+            return `Squares only ${who === "white" ? "White" : "Black"}${you ? " (you)" : ""} controls: ${count}`;
+        },
+        bothSides: "both sides",
         oppositeBishops: "Bishops of opposite colours",
         repetitions: (times) => `This position has stood ${times} times`,
         fiftyMoves: (halfMoves) => `${halfMoves} half-moves left before the fifty-move draw`,
@@ -365,9 +414,8 @@ const english = {
     guide: {
         title: "Guide",
         contents: "Contents",
-        onGitHub: "Chesspal on GitHub",
-        onNpm: "Chesspal on npm",
-        support: "Support Chesspal",
+        previous: "Previous page",
+        next: "Next page",
         credits: "Credits",
         creditLines: [
             "The rules: [chess.js](https://github.com/jhlywa/chess.js), under the BSD 2-Clause license.",
@@ -376,6 +424,11 @@ const english = {
             "The sounds: Chesspal's own.",
         ],
     },
+    foot: {
+        onGitHub: "Chesspal on GitHub",
+        onNpm: "Chesspal on npm",
+        support: "Support Chesspal",
+    },
 };
 const italian = {
     language: "it",
@@ -383,6 +436,8 @@ const italian = {
     theme: "Tema chiaro o scuro",
     sounds: "Suoni",
     voice: "Leggi ad alta voce le parole dell'AI",
+    noVoice: "Questo browser non ha una voce per questa lingua: aggiungila nelle impostazioni del sistema",
+    saidMove: (move) => moveInWords(italianMoveWords, move),
     newGame: "Nuova partita",
     offerDraw: "Proponi patta",
     offerDrawWhen: "Proponi patta: nel tuo turno, dopo una mossa a testa",
@@ -500,21 +555,45 @@ const italian = {
     boardLabel: (turn, lastMove) => `Scacchiera, ${italian.toMove(turn)}${lastMove === undefined ? "" : `, ultima mossa ${lastMove}`}`,
     clearChat: (name) => `Prima di una nuova partita azzera la conversazione con ${name}: nella finestra dove hai aperto ${name}, non qui, scrivi /clear e poi un messaggio, per esempio "nuova partita". Con la chat pulita l'AI gioca più veloce.`,
     outdated: (name) => `Chesspal è stato aggiornato, ma questa cartella ha ancora i file di prima: chiudi la chat con ${name}, esegui chesspal init in questa cartella e apri una chat nuova.`,
+    update: {
+        mark: (version) => `È uscito Chesspal ${version}: aggiorna`,
+        title: "Aggiorna Chesspal",
+        offer: (version, current) => `È uscita la versione ${version} di Chesspal${current === undefined ? "" : `; questa è la ${current}`}. Il tavolo la installa e riparte da solo.`,
+        chatAgain: (name) => `Anche la chat con ${name} riparte pulita.`,
+        byHand: (name) => `La chat con ${name} l'hai aperta tu: dopo, chiudila e aprine una nuova.`,
+        whilePlaying: "C'è una partita in corso: finiscila, poi aggiorna.",
+        install: "Aggiorna",
+        installing: (version) => `Installo la ${version}…`,
+        installed: "Installata: il tavolo riparte da solo a fine partita.",
+        failed: "Chesspal non si è aggiornato: chiudi la chat, poi scrivi in un terminale, uno dopo l'altro:",
+        notice: (version, name) => `È uscita la versione ${version} di Chesspal: chiudi la chat con ${name}, scrivi questo comando in un terminale e apri una chat nuova.`,
+        hide: "Nascondi fino alla prossima versione",
+    },
     offline: (name) => `${name} è scollegato. Scrivigli un messaggio nella finestra dove hai aperto ${name}, non nella chat di questa pagina: la pagina si ricollega da sola.`,
     startClocks: "Inizia",
     thinking: { move: "Sta pensando alla sua mossa", ponder: "Pensa mentre giochi tu" },
     asleep: (name) => `${name} non ti sta ascoltando: scrivi un messaggio, per esempio "ciao", nella finestra dove hai aperto ${name}, non qui. Il suo orologio aspetta che risponda.`,
     asleepInAnalysis: (name) => `${name} non ti sta ascoltando: scrivigli nella finestra dove l'hai aperto, non qui.`,
     table: {
-        label: "Apri una chat",
-        noChat: (name) => `Per giocare con ${name}, apri la sua chat: parte in una finestra a parte, da tenere aperta.`,
+        title: "Contro chi giochi?",
+        choose: "Scegli la chat con cui giocare: parte in una finestra a parte, da tenere aperta.",
+        restartHint: "Scegli modello e ragionamento, poi premi Claude Code o Codex: la chat riparte pulita nella stessa finestra, appena ha finito di rispondere. La partita resta com'è.",
+        byHand: (name) => `Questa chat l'hai aperta tu: cambia il modello di ${name} con /model nella sua finestra, oppure chiudila e aprine una da qui, con le scelte qui sotto.`,
+        noChat: "Nessuna chat al tavolo: scegline una",
+        change: "Cambia la chat o il modello",
         install: (name) => `Per giocare con ${name}, installa Claude Code o Codex, poi apri di nuovo questa pagina.`,
         model: "Modello",
         effort: "Ragionamento",
         asHost: (host) => `come è impostato in ${host}`,
         opening: "Apro la chat… Nel terminale, se ti chiede se ti fidi della cartella, scegli Yes con le frecce e premi Invio.",
         again: (name) => `${name} riparte con una chat pulita per la nuova partita…`,
+        restart: "La chat riparte pulita…",
+        waiting: (name) => `${name} riparte appena ha finito di rispondere…`,
+        restartChanged: "Riparte pulita con le nuove scelte",
+        restartNow: "Riparti adesso: interrompe la risposta in corso",
+        cancel: "Non ripartire",
         failed: "Il terminale non si è aperto: scrivi il comando qui sotto in un terminale.",
+        notRestarted: "La chat non è ripartita: chiudi la sua finestra, poi aprine un'altra da qui.",
         typeIt: "Oppure scrivi in un terminale:",
     },
     commandHere: (name) => `/clear e gli altri comandi vanno scritti nella finestra dove hai aperto ${name}, non qui.`,
@@ -533,6 +612,8 @@ const italian = {
         "profile-game": () => italian.profile.whilePlaying,
         "game-going": () => "C'è una partita in corso: finiscila prima di portarne un'altra da analizzare.",
         "pgn-unreadable": () => "Chesspal non riesce a leggere questo PGN: controlla di aver copiato la partita intera, intestazioni e mosse.",
+        "update-game": () => italian.update.whilePlaying,
+        "update-chat": (most, name) => `${name} sta rispondendo: aggiorna quando ha finito.`,
     },
     // Queen and rook are feminine in Italian.
     piece: (letter, side) => `${italianNames[letter]} ${side === "white" ? (letter === "Q" || letter === "R" ? "bianca" : "bianco") : (letter === "Q" || letter === "R" ? "nera" : "nero")}`,
@@ -591,7 +672,6 @@ const italian = {
         back: "Indietro",
         yourProfile: "Il tuo profilo",
         editProfile: "Modifica il profilo",
-        yourPicture: "La tua immagine: modifica il profilo",
         avatars: { "short-hair": "Capelli corti", bun: "Chignon", glasses: "Occhiali", beanie: "Berretto", beard: "Barba", curls: "Ricci", moustache: "Baffi", "silver-bob": "Caschetto grigio", cat: "Gatto", owl: "Gufo" },
         whilePlaying: "Finisci la partita, o abbandona, prima di cambiare giocatore.",
         accounts: "Giochi su Lichess, Chess.com o nei tornei FIDE?",
@@ -696,25 +776,29 @@ const italian = {
             backward: ["Pedoni arretrati", "Un pedone rimasto indietro rispetto a quelli accanto, con la casa davanti attaccata da un pedone nemico."],
             passed: ["Pedoni passati", "Nessun pedone nemico davanti a lui, né sulla sua colonna né su quelle accanto."],
             islands: ["Isole di pedoni", "Gruppi di pedoni su colonne vicine, separati fra loro."],
+            openFiles: ["Colonne aperte", "Colonne senza pedoni di nessuno dei due."],
             halfOpen: ["Colonne semiaperte", "Colonne con pedoni nemici e nessuno dei propri."],
             heavyOnFiles: ["Torri e donna su colonne aperte", "Torri e donna su colonne aperte o semiaperte."],
             onSeventh: ["Torri e donna in settima", "Torri e donna sulla seconda traversa del nemico: la settima per il Bianco, la seconda per il Nero."],
             outposts: ["Avamposti", "Case sulle proprie traverse dalla quarta alla sesta, difese da un pedone, che nessun pedone nemico potrà mai attaccare."],
             bishopPair: ["Coppia degli alfieri", "Tutti e due gli alfieri ancora sulla scacchiera."],
-            space: ["Spazio (case nella metà avversaria)", "Quante case della metà avversaria attaccano i propri pezzi."],
+            space: ["Spazio", "Quante case della metà avversaria attaccano i propri pezzi."],
             undeveloped: ["Pezzi minori non sviluppati", "Cavalli e alfieri ancora sulle case di partenza."],
             castled: ["Arrocco", "Come ha arroccato; un trattino finché può ancora farlo, una croce quando il re o le torri si sono già mossi."],
             kingAttacks: ["Attacchi nemici attorno al re", "Quanti attacchi nemici cadono sulle case accanto al re."],
         },
-        groups: { pawns: "Pedoni", pieces: "Pezzi", king: "Re" },
         yes: "sì",
         notYet: "non ancora",
         noMore: "non più",
         phases: { opening: "Apertura", middlegame: "Mediogioco", endgame: "Finale" },
-        openFiles: "Colonne aperte",
-        control: "Case controllate",
-        both: "tutti e due",
         controlled: (white, black, both) => `Case solo del Bianco ${white}, solo del Nero ${black}, di tutti e due ${both}`,
+        controlledBy: (who, count, you) => {
+            if (who === "both") {
+                return `Case controllate da tutti e due: ${count}`;
+            }
+            return `Case controllate solo dal ${who === "white" ? "Bianco" : "Nero"}${you ? " (tu)" : ""}: ${count}`;
+        },
+        bothSides: "tutti e due",
         oppositeBishops: "Alfieri di colore contrario",
         repetitions: (times) => `Questa posizione si è vista ${times} volte`,
         fiftyMoves: (halfMoves) => `Mancano ${halfMoves} semimosse alla patta delle cinquanta mosse`,
@@ -738,9 +822,8 @@ const italian = {
     guide: {
         title: "Guida",
         contents: "Indice",
-        onGitHub: "Chesspal su GitHub",
-        onNpm: "Chesspal su npm",
-        support: "Sostieni Chesspal",
+        previous: "Pagina precedente",
+        next: "Pagina seguente",
         credits: "Crediti",
         creditLines: [
             "Le regole: [chess.js](https://github.com/jhlywa/chess.js), con licenza BSD 2-Clause.",
@@ -749,6 +832,11 @@ const italian = {
             "I suoni: di Chesspal.",
         ],
     },
+    foot: {
+        onGitHub: "Chesspal su GitHub",
+        onNpm: "Chesspal su npm",
+        support: "Sostieni Chesspal",
+    },
 };
 // How each piece moves, said when it was taken where it cannot go (Anatolij's words).
 const englishMoves = {
@@ -811,6 +899,14 @@ function italianCulprit(by) {
 function italianWith(preposition, letter) {
     return italianThe[letter].replace(/^il /, `${preposition}l `).replace(/^la /, `${preposition}lla `).replace(/^l'/, `${preposition}ll'`);
 }
+/** A move in words: "knight from b takes d7, check", "cavallo in f3", "arrocco corto". */
+function moveInWords(words, move) {
+    const promotion = "castles" in move || move.promotion === undefined ? undefined : `${words.promotes} ${words.names[move.promotion]}`;
+    const played = "castles" in move
+        ? words.castles[move.castles]
+        : [words.names[move.piece], ...(move.from === undefined ? [] : [words.from, move.from]), move.takes ? words.takes : words.to, move.square].join(" ");
+    return [played, promotion, move.check === undefined ? undefined : words.check[move.check]].filter((part) => part !== undefined).join(", ");
+}
 /** The words with their first letter capital, to open a sentence. */
 function capital(words) {
     return words.charAt(0).toUpperCase() + words.slice(1);

package/dist/page/theme.css

@@ -77,6 +77,8 @@
     --ear: 36px;
     --tuck: 10px;
     --bar: 36px;
+    /* The page's foot under the board */
+    --foot: 18px;
     /* The cards' corners, as the board's; the room between the cards, and between them and the board */
     --radius: 6px;
     --between: 10px;

package/dist/server/{bell.js → bell/bell.js}

@@ -4,9 +4,9 @@ import { createHash } from "node:crypto";
 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 { version } from "../version.js";
+import { writeAtomically } from "../../games/index.js";
+import { dataFolder, tableFolder } from "../../home/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. */
 export const bellLine = "The player acted on the board page: call status to see it.";
 /**

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

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

package/dist/server/bell/index.js

@@ -0,0 +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";

package/dist/server/{caller.d.ts → mcp/caller.d.ts}

@@ -1,4 +1,4 @@
-import type { Caller } from "../commands/index.ts";
+import type { Caller } from "../../commands/index.ts";
 /** The host as it names itself to the server. */
 export interface Client {
     name: string;

package/dist/server/{caller.js → mcp/caller.js}

@@ -3,7 +3,7 @@
 import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
-import { lastChatStart } from "../games/index.js";
+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"]);

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

@@ -0,0 +1 @@
+export { startMcpServer } from "./mcp.ts";

package/dist/server/mcp/index.js

@@ -0,0 +1,2 @@
+// The MCP server an AI host starts, every command as a tool (D-5); it loads the MCP SDK, so only `chesspal mcp` imports it.
+export { startMcpServer } from "./mcp.js";

package/dist/server/{mcp.d.ts → mcp/mcp.d.ts}

@@ -1,5 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type AnyCommand, type Context } from "../commands/index.ts";
+import { type AnyCommand, type Context } from "../../commands/index.ts";
 /**
  * What the host reads as the server starts, before any tool: the lines that start a chat, `instructions` then `status`, and the rule of every move (D-27,
  * D-102). Short, since hosts cut them or copy them into every tool.

package/dist/server/{mcp.js → mcp/mcp.js}

@@ -3,16 +3,16 @@
 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 { aiNameOf } from "../core/index.js";
-import { endOf, loadGame, noteAiHost, noteAiModel, rerunIfChanged } from "../games/index.js";
-import { agentTools, hasAgent, startInstructions } from "../host-files/index.js";
-import { gameFolder } from "../profiles/index.js";
-import { version } from "../version.js";
-import { pagePorts } from "./bell.js";
+import { aiMove, commands, defaultContext, inputProblems, isBoolean, PositionChanged } from "../../commands/index.js";
+import { aiNameOf } from "../../core/index.js";
+import { endOf, loadGame, noteAiHost, noteAiModel, rerunIfChanged } from "../../games/index.js";
+import { agentTools, hasAgent, startInstructions } from "../../host-files/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { version } from "../../version.js";
+import { pagePorts } from "../bell/index.js";
+import { chatHasRead, startPage } from "../page/index.js";
+import { attachTable, tableToJoin } from "../table/index.js";
 import { allowedCaller, callerOf, callingAgent, fromCodexAgent } from "./caller.js";
-import { chatHasRead, startPage } from "./page/page.js";
-import { attachTable, tableToJoin } from "./table/index.js";
 /**
  * What the host reads as the server starts, before any tool: the lines that start a chat, `instructions` then `status`, and the rule of every move (D-27,
  * D-102). Short, since hosts cut them or copy them into every tool.

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

@@ -8,6 +8,7 @@ export interface ChatSeen {
     readonly given: ReadonlySet<string>;
     readonly seen: string | undefined;
     readonly positionSeen: SeenPosition | null | undefined;
+    readonly positionFirstSeen: SeenPosition | undefined;
     host(): string | undefined;
 }
 /** The chat as the page reads it, in the chat's own process: read from its context at each request, so always as the chat left it. */
@@ -39,6 +40,10 @@ export declare const chatCopy: z.ZodObject<{
         started: z.ZodOptional<z.ZodString>;
         plies: z.ZodInt;
     }, z.core.$strip>>>;
+    positionFirstSeen: z.ZodOptional<z.ZodObject<{
+        started: z.ZodOptional<z.ZodString>;
+        plies: z.ZodInt;
+    }, z.core.$strip>>;
     given: z.ZodArray<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
     aiModel: z.ZodOptional<z.ZodObject<{

package/dist/server/page/chat.js

@@ -13,6 +13,9 @@ export function chatSeenOf(chat) {
         get positionSeen() {
             return chat.positionSeen;
         },
+        get positionFirstSeen() {
+            return chat.positionFirstSeen;
+        },
         host: () => chat.host?.(),
     };
 }
@@ -47,6 +50,7 @@ export const chatAttach = z.object({
     host: z.string().optional(),
     outdated: z.boolean(),
 });
+const seenPosition = z.object({ started: z.string().optional(), plies: z.int().min(0) });
 /**
  * What the chat attached to the table tells it after each tool, and when the page has news no file holds (`news`): what it saw, the words it was given,
  * its host, and the AI's model and host, which the table notes for a game that ends on the page (D-82, D-97).
@@ -54,7 +58,8 @@ export const chatAttach = z.object({
 export const chatCopy = z.object({
     token: z.string(),
     seen: z.string().optional(),
-    positionSeen: z.object({ started: z.string().optional(), plies: z.int().min(0) }).nullable().optional(),
+    positionSeen: seenPosition.nullable().optional(),
+    positionFirstSeen: seenPosition.optional(),
     given: z.array(z.string()),
     host: z.string().optional(),
     aiModel: z.object({ model: z.string(), effort: z.string().optional() }).optional(),
@@ -74,6 +79,9 @@ export function attachedSeen(attached) {
         get positionSeen() {
             return attached()?.copy?.positionSeen;
         },
+        get positionFirstSeen() {
+            return attached()?.copy?.positionFirstSeen;
+        },
         host: () => attached()?.copy?.host ?? attached()?.chat.host,
     };
 }

package/dist/server/page/game.js

@@ -1,11 +1,13 @@
-import { analyseGame, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, shownPosition, startNewGame, } from "../../commands/index.js";
+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 { gameFolder, helpsIn } from "../../profiles/index.js";
+import { version } from "../../version.js";
 import { asTheChatSees } from "./chat.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";
+import { updateShown } from "./update.js";
 /** Answers the page's requests about the game: true when the request was one. */
 export function answerGame(request, response, url, served) {
     const route = routes[`${request.method ?? ""} ${url.pathname}`];
@@ -295,6 +297,8 @@ function sendGame(response, served) {
     const analysis = current === undefined || endOf(current.game) !== undefined ? analysisShown(served) : undefined;
     const aiModel = aiModelOf(folder);
     const body = {
+        // The page loaded from another version loads again, its files and all (Federico).
+        version,
         game,
         ...(game === null && talk.length > 0 ? { talk } : {}),
         ...(analysis === undefined ? {} : { analysis }),
@@ -303,6 +307,7 @@ function sendGame(response, served) {
         listening: served.bell.listening,
         ...thinkingShown(served, current),
         ...(served.outdated ? { outdated: true } : {}),
+        ...updateShown(served),
         ...tableShown(served),
         ...profilesShown(served.context.home()),
     };
@@ -336,7 +341,10 @@ function coachOn(folder, current) {
     const shown = coachShown(coachWords(folder, current), current);
     return shown.judgments.length === 0 && shown.hint === undefined && shown.leads === undefined ? undefined : shown;
 }
-/** The game in analysis, once no game goes on (D-69): its name and its PGN with the AI's review; none without one, or when it cannot be read. */
+/**
+ * The game in analysis, once no game goes on (D-69): its name and its PGN with the AI's review, and whether an AI is going over it now; none without one,
+ * or when it cannot be read.
+ */
 function analysisShown(served) {
     const analysis = gameInAnalysis(gameFolder(served.context.home()));
     if (analysis === undefined) {
@@ -344,8 +352,13 @@ function analysisShown(served) {
     }
     try {
         const { name, record } = namedGame(served.context, analysis.game);
+        // Without a review, an AI is at it only while the chat is in a turn, or hears the player while its analyst holds the game (D-89): one the chat has
+        // started again since is gone (Priya). On the table the chat's start is in the chat's own folder.
+        const { bell } = served;
+        const chat = { ...served.context, folder: served.attached?.chat.folder ?? served.folder };
+        const reviewing = !isReviewed(record) && (bell.inTurn || (bell.listening && analystOf(chat, analysis.game) !== undefined));
         // How far the book goes, which the page cannot tell without the book's moves: its card names the opening on those moves.
-        return { name, pgn: writePgn(record), book: bookPlies(record) };
+        return { name, pgn: writePgn(record), book: bookPlies(record), ...(reviewing ? { reviewing: true } : {}) };
     }
     catch {
         // A game gone from the archive is no longer shown.

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

@@ -8,7 +8,7 @@ export declare const json = "application/json; charset=utf-8";
  */
 export interface Refused {
     readonly error: string;
-    readonly refusal?: "no-game" | "ai-to-move" | "illegal" | "clear-chat" | `words-${WordsRefused["reason"]}` | `draw-${DrawRefused["reason"]}` | "profile-game" | "game-going" | "pgn-unreadable";
+    readonly refusal?: "no-game" | "ai-to-move" | "illegal" | "clear-chat" | `words-${WordsRefused["reason"]}` | `draw-${DrawRefused["reason"]}` | "profile-game" | "game-going" | "pgn-unreadable" | "update-game" | "update-chat";
     readonly most?: number;
 }
 /** Answers a request, with nothing cached, sniffed or referred, and the page's policy unless the headers give another. */

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

@@ -0,0 +1,3 @@
+export { jsonOf } from "./http.ts";
+export { chatHasRead, type Page, startPage } from "./page.ts";
+export type { ChatHost, TableChats } from "./table.ts";

package/dist/server/page/index.js

@@ -0,0 +1,3 @@
+// The board page's server (D-8, D-47): its files, its routes, the events the pages listen to and the chat attached to the table. Below the table and the MCP server.
+export { jsonOf } from "./http.js";
+export { chatHasRead, startPage } from "./page.js";

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

@@ -1,6 +1,6 @@
 import { type ServerResponse } from "node:http";
 import { type Context } from "../../commands/index.ts";
-import { Bell } from "../bell.ts";
+import { Bell } from "../bell/index.ts";
 import { type Attached, type ChatSeen } from "./chat.ts";
 import { type Opening, type TableChats } from "./table.ts";
 /**
@@ -29,13 +29,19 @@ export interface PageOptions {
     readonly table?: TableEnd;
 }
 /**
- * What the page tells the table that serves it: a request came, so the table is in use, or another Chesspal version asked it to quit; and how the table
- * opens a chat, which the page offers while none is at the table.
+ * What the page tells the table that serves it: a request came, so the table is in use, or another Chesspal version asked it to quit; how the table
+ * opens a chat, which the page offers while none is at the table, and how it updates Chesspal.
  */
 export interface TableEnd {
     used(): void;
     quit(): void;
     readonly chats?: TableChats | undefined;
+    readonly update?: TableUpdate | undefined;
+}
+/** How the table updates Chesspal (D-108): npm installs a version, whether it did, and the table closes to start again from it. */
+export interface TableUpdate {
+    install(version: string): Promise<boolean>;
+    restart(): void;
 }
 /**
  * Serves the page of the context's folder on 127.0.0.1, on a port of its own when free, else on any free one, where the doorbell cannot find it; the
@@ -69,6 +75,13 @@ export interface Served {
         readonly at: number;
         readonly how: Opening;
     } | undefined;
+    /** The host the page asked the chat to start again with while it was at work (D-107). */
+    restartWanted?: {
+        readonly host: string;
+    } | undefined;
+    /** The newer Chesspal npm has (D-108); the table installing it, installed and waiting to be at rest, or starting again from it. */
+    newer?: string;
+    updating?: "installing" | "installed" | "restarting" | undefined;
 }
 /**
  * The chat has read the game as it is now, at the end of a tool's call: the doorbell wakes it only for what changes it after; and, when the tool `showed` it