chesspal 0.3.1 → 0.3.2

package/dist/page/text.js

@@ -29,6 +29,7 @@ const english = {
     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",
@@ -147,6 +148,20 @@ 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" },
@@ -190,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}` : ""}`,
@@ -247,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?",
@@ -352,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`,
@@ -394,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.",
@@ -405,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",
@@ -412,6 +436,7 @@ 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",
@@ -530,6 +555,20 @@ 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" },
@@ -573,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")}`,
@@ -631,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?",
@@ -736,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`,
@@ -778,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.",
@@ -789,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 = {

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/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
@@ -73,6 +79,9 @@ export interface Served {
     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

package/dist/server/page/page.js

@@ -8,7 +8,7 @@ import { aiNameOf } from "../../core/index.js";
 import { gameStamp, tableTalkStamp } from "../../games/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
-import { Bell, bellProbe, pagePorts } from "../bell.js";
+import { Bell, bellProbe, pagePorts } from "../bell/index.js";
 import { analysesOf, answerAnalyses } from "./analyses.js";
 import { answerChat } from "./attach.js";
 import { attachedSeen, chatSeenOf, pageContext } from "./chat.js";
@@ -17,7 +17,8 @@ import { sendFile, sendHtml } from "./files.js";
 import { answerGame, chatCalls } from "./game.js";
 import { json, send } from "./http.js";
 import { answerProfiles, readRatingsOf } from "./profiles.js";
-import { answerTable, restartWhenAtRest } from "./table.js";
+import { answerTable, restartWhenAtRest, updateWhenAtRest } from "./table.js";
+import { watchForUpdates } from "./update.js";
 /**
  * Serves the page of the context's folder on 127.0.0.1, on a port of its own when free, else on any free one, where the doorbell cannot find it; the
  * table's on its own ports alone, which keep two tables apart. The page reads the chat from the context in the chat's process, and on the table from
@@ -33,9 +34,10 @@ export async function startPage(context, options = {}) {
         context: pageContext(context),
         chat,
         opponent: options.opponent ?? (() => aiNameOf(chat.host())),
-        // A start again asked while the chat was at work comes once it has ended its answer (D-107).
+        // A start again asked while the chat was at work comes once it has ended its answer (D-107), as an update installed meanwhile (D-108).
         bell: new Bell(() => hasNews(context, chat), () => {
             restartWhenAtRest(served);
+            updateWhenAtRest(served);
             tellWatchers(watchers);
         }),
         watchers,
@@ -49,7 +51,12 @@ export async function startPage(context, options = {}) {
         if (await listened(server, port)) {
             server.unref();
             served.port = portOf(server);
-            const stopWatching = watchGame(served);
+            const stopWatchingGame = watchGame(served);
+            const stopAskingNpm = watchForUpdates(served);
+            const stopWatching = () => {
+                stopWatchingGame();
+                stopAskingNpm();
+            };
             return {
                 url: `http://127.0.0.1:${served.port}/`,
                 heard: () => tellWatchers(watchers),
@@ -188,6 +195,8 @@ function watchGame(served) {
                 waiting = undefined;
                 watchAll();
                 tellWatchers(served.watchers);
+                // A game that has ended lets an update installed meanwhile start the table again (D-108).
+                updateWhenAtRest(served);
             }, 30);
         }
     };

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

@@ -16,7 +16,8 @@ export interface TableChats {
     hosts(): readonly ChatHost[];
     open(host: string): Promise<boolean>;
     held(folder: string): HeldChat | undefined;
-    relaunch(folder: string, host?: string): boolean;
+    /** 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. */
 export interface HeldChat {
@@ -56,3 +57,8 @@ export declare function chatToRelaunch(served: Served): boolean;
 export declare function relaunchChat(served: Served, how?: "again" | "restart", host?: string): boolean;
 /** Starts the chat again as the page asked while it was at work, now that it has ended its answer; a chat gone meanwhile takes the request with it. */
 export declare function restartWhenAtRest(served: Served): void;
+/**
+ * Once npm has installed the newer Chesspal (D-108), and no game goes on and the chat is at rest, as a game or a chat may have started while npm worked:
+ * the chat `chesspal play` holds starts again from it, clean, and once it has left the table, the table closes to start again from it too.
+ */
+export declare function updateWhenAtRest(served: Served): void;

package/dist/server/page/table.js

@@ -1,5 +1,6 @@
-import { samePosition } from "../../commands/index.js";
-import { gameInAnalysis } from "../../games/index.js";
+import { setTimeout as delay } from "node:timers/promises";
+import { gameAt, samePosition } from "../../commands/index.js";
+import { endOf, gameInAnalysis } from "../../games/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { tellWatchers } from "./events.js";
 import { bodyOf, isJson, jsonOf, runRoute, sendJson } from "./http.js";
@@ -44,8 +45,13 @@ export function answerTable(request, response, url, served) {
     else if (path === "/api/table/waiting") {
         runRoute(response, () => endWaiting(request, response, served));
     }
+    else if (path === "/api/table/update") {
+        runRoute(response, () => updateChesspal(request, response, served));
+    }
     else {
-        sendJson(response, 404, { error: `${path} is no route of the table's: it answers POST /api/table/chat, /api/table/restart, /api/table/waiting and /api/table/quit.` });
+        sendJson(response, 404, {
+            error: `${path} is no route of the table's: it answers POST /api/table/chat, /api/table/restart, /api/table/waiting, /api/table/update and /api/table/quit.`,
+        });
     }
     return true;
 }
@@ -160,6 +166,76 @@ async function endWaiting(request, response, served) {
         sendJson(response, 200, now ? { restarting } : { waiting: false });
     }
 }
+/**
+ * Once npm has installed the newer Chesspal (D-108), and no game goes on and the chat is at rest, as a game or a chat may have started while npm worked:
+ * the chat `chesspal play` holds starts again from it, clean, and once it has left the table, the table closes to start again from it too.
+ */
+export function updateWhenAtRest(served) {
+    if (served.updating !== "installed" || gameGoingOn(served) || !tableAtRest(served)) {
+        return;
+    }
+    served.updating = "restarting";
+    tellWatchers(served.watchers);
+    const relaunched = served.table?.chats?.relaunch(served.folder, undefined, true) === true;
+    void restartOnceLeft(served, relaunched);
+}
+/**
+ * Installs the newer Chesspal npm has (D-108), asked by the table's own page alone, never while a game goes on, the chat is at work or one is opening;
+ * the table then starts again from it as soon as it is at rest. Whether npm installed it; when it did not, the page gives the command to type.
+ */
+async function updateChesspal(request, response, served) {
+    await bodyOf(request);
+    const { newer, table } = served;
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page updates Chesspal." });
+    }
+    else if (newer === undefined || table?.update === undefined) {
+        sendJson(response, 409, { error: "No newer Chesspal to install: this one is the latest npm has." });
+    }
+    else if (served.updating !== undefined) {
+        sendJson(response, 409, { error: "Chesspal is being updated already: wait for the table to start again." });
+    }
+    else if (gameGoingOn(served)) {
+        sendJson(response, 409, { error: "A game is going on: finish it, then update Chesspal.", refusal: "update-game" });
+    }
+    else if (!tableAtRest(served)) {
+        sendJson(response, 409, { error: "The chat is at work, or opening: update Chesspal once it is at rest.", refusal: "update-chat" });
+    }
+    else {
+        served.updating = "installing";
+        tellWatchers(served.watchers);
+        let installed = false;
+        try {
+            installed = await table.update.install(newer);
+        }
+        finally {
+            served.updating = installed ? "installed" : undefined;
+        }
+        // Starting again ends every connection: once this answer has gone, or the page that asked has.
+        response.once("close", () => updateWhenAtRest(served));
+        tellWatchers(served.watchers);
+        sendJson(response, 200, { installed });
+    }
+}
+// The chat started again leaves the table as `chesspal play` ends its host: a table closed before would leave its server to serve its own page on the
+// table's ports, where the new table would then find them taken (Priya). One that does not leave in time is left to it.
+async function restartOnceLeft(served, relaunched) {
+    for (let tries = 0; relaunched && served.attached !== undefined && tries < leaveTries; tries++) {
+        await delay(100);
+    }
+    served.table?.update?.restart();
+}
+// `chesspal play` sees the request within half a second and ends its host in a few more.
+const leaveTries = 100;
+// A game with moves still to come, a new one too: never an update meanwhile (D-108).
+function gameGoingOn(served) {
+    const current = gameAt(gameFolder(served.context.home()), served.context.now());
+    return current !== undefined && endOf(current.game) === undefined;
+}
+// No chat is at work at the table, and none is opening.
+function tableAtRest(served) {
+    return (served.attached === undefined || chatAtRest(served)) && opening(served) === undefined;
+}
 // The browser marks a request of the table's own page with its origin.
 function fromTablePage(request, served) {
     return request.headers.origin === `http://127.0.0.1:${served.port}` || request.headers.origin === `http://localhost:${served.port}`;

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

@@ -0,0 +1,18 @@
+import type { Served } from "./page.ts";
+/**
+ * What the page shows of a newer Chesspal: its version, and on the table whether it is being installed, or installed and waiting for the game to end and
+ * the chat to be at rest.
+ */
+export interface UpdateShown {
+    readonly version: string;
+    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. */
+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): {
+    update?: UpdateShown;
+};
+/** Chesspal's latest version on npm, none when npm cannot be reached in time or answers something else. */
+export declare function latestVersion(fetch: typeof globalThis.fetch): Promise<string | undefined>;