chesspal 0.3.1 → 0.3.3

package/dist/page/table/update.js

@@ -0,0 +1,82 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "preact/jsx-runtime";
+// A newer Chesspal (D-108): on the table's page the header's mark opens this window, which installs it between games; the table and its chat then start
+// again from it, and the page loads again by itself.
+import { useEffect, useState } from "preact/hooks";
+import { Dialog } from "../dialogs/dialog.js";
+/**
+ * The window that installs the newer Chesspal: its button waits while a game goes on and while npm installs; installed, the table waits for the game to
+ * end; when npm fails, a cross and the commands to type.
+ */
+export function UpdateDialog({ open, version, current, installing, installed, going, chat, name, onClose, text }) {
+    const [sent, setSent] = useState(false);
+    const [answer, setAnswer] = useState(undefined);
+    useEffect(() => setAnswer(undefined), [open]);
+    const words = text.update;
+    // Once npm has installed it the table closes to start again: the page waits for it, and loads again.
+    const waiting = installing || (sent && answer === undefined) || (answer?.installed === true && !installed);
+    const failed = answer?.installed === false;
+    const install = async () => {
+        setSent(true);
+        setAnswer(undefined);
+        setAnswer(await askToInstall(text, name));
+        setSent(false);
+    };
+    const stopped = waiting || installed || going;
+    return (_jsxs(Dialog, { open: open, title: words.title, onClose: onClose, text: text, children: [_jsxs("p", { class: "note update-offer", children: [words.offer(version, current), chat === "held" ? ` ${words.chatAgain(name)}` : chat === "byHand" ? ` ${words.byHand(name)}` : ""] }), _jsx("button", { class: `command${failed ? "" : " primary"}`, type: "button", "aria-disabled": stopped, onClick: stopped ? undefined : () => void install(), children: words.install }), _jsx("p", { class: "chat-state update-state", role: "status", children: waiting
+                    ? (_jsxs(_Fragment, { children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), words.installing(version)] }))
+                    : installed
+                        ? words.installed
+                        : answer?.refused ?? (going ? words.whilePlaying : null) }), failed
+                ? (_jsxs("div", { class: "update-failed", role: "alert", children: [_jsxs("p", { children: [_jsx("span", { class: "update-cross", "aria-hidden": "true", children: "\u2715" }), " ", words.failed] }), _jsx("code", { children: "npm install -g chesspal" }), _jsx("code", { children: "chesspal" })] }))
+                : null] }));
+}
+/** The header's mark of a newer Chesspal, on the table's page: it opens the window that installs it; while npm installs, or the table waits, it spins. */
+export function UpdateMark({ version, installing, onOpen, text }) {
+    const title = installing ? text.update.installing(version) : text.update.mark(version);
+    return (_jsx("button", { class: "icon-button update-button", type: "button", title: title, "aria-label": title, "aria-haspopup": "dialog", onClick: onOpen, children: installing ? _jsx("span", { class: "spinner", "aria-hidden": "true" }) : (_jsxs("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: [_jsx("circle", { cx: "12", cy: "12", r: "10" }), _jsx("path", { d: "M12 16.5V7.5M8 11.5L12 7.5L16 11.5" })] })) }));
+}
+/** On a chat's own page, the strip with the command that installs the newer Chesspal; its × hides it until a newer one still is out. */
+export function UpdateNotice({ version, name, text }) {
+    const [hidden, setHidden] = useState(hiddenVersion);
+    if (hidden === version) {
+        return null;
+    }
+    const hide = () => {
+        rememberHidden(version);
+        setHidden(version);
+    };
+    return (_jsxs("p", { class: "outdated update-notice", role: "status", children: [_jsxs("span", { children: [text.update.notice(version, name), _jsx("code", { children: "npm install -g chesspal" })] }), _jsx("button", { class: "icon-button", type: "button", title: text.update.hide, "aria-label": text.update.hide, onClick: hide, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M6 6L18 18M18 6L6 18" }) }) })] }));
+}
+const hiddenKey = "chesspal-update-hidden";
+function hiddenVersion() {
+    try {
+        return localStorage.getItem(hiddenKey) ?? undefined;
+    }
+    catch {
+        // A browser that keeps nothing for the page: the strip shows.
+        return undefined;
+    }
+}
+function rememberHidden(version) {
+    try {
+        localStorage.setItem(hiddenKey, version);
+    }
+    catch {
+        // Hidden as long as the page.
+    }
+}
+async function askToInstall(text, name) {
+    try {
+        const response = await fetch("/api/table/update", { method: "POST", headers: { "Content-Type": "application/json" }, body: "{}" });
+        const body = (await response.json());
+        if (response.ok) {
+            return { installed: body.installed === true };
+        }
+        const known = body.refusal === undefined ? undefined : text.refused[body.refusal];
+        return { refused: known?.(0, name) ?? body.error ?? response.statusText };
+    }
+    catch {
+        // The table closed to start again before its answer came.
+        return { installed: true };
+    }
+}

package/dist/page/table/window.js

@@ -2,8 +2,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useEffect, useState } from "preact/hooks";
 import { Dialog } from "../dialogs/dialog.js";
 import { checkIcon } from "../dialogs/profiles.js";
-/** The chat's window: closed once a chat opens or starts again, the page then saying where it stands. */
-export function ChatDialog({ open, table, settings, onChange, name, onClose, text }) {
+/** The chat's window: closed once a chat opens or starts again, the page then saying where it stands; `review` when it opened to have a game analysed. */
+export function ChatDialog({ open, review = false, table, settings, onChange, name, onClose, text }) {
     const [sending, setSending] = useState(false);
     const [failed, setFailed] = useState(false);
     useEffect(() => setFailed(false), [open]);
@@ -25,20 +25,21 @@ export function ChatDialog({ open, table, settings, onChange, name, onClose, tex
         }
     };
     // While a chat opens or waits to start again, the rows wait too, and the note says why.
+    const chooseNote = review ? words.reviewChoose : words.choose;
     const note = installed.length === 0
         ? words.install(name)
         : busy
-            ? chatState(table, name, text) ?? words.choose
+            ? chatState(table, name, text) ?? chooseNote
             : byHand
                 ? words.byHand(name)
                 : table.chat
                     ? words.restartHint
-                    : words.choose;
+                    : chooseNote;
     const offersChoices = installed.some((host) => host.models.length > 0 || host.efforts.length > 0);
     // The chat at the table started with other choices than the ones kept now: its row starts it again with these, else it only closes the window.
     const started = table.held ? table.started : undefined;
     const changed = (host) => started !== undefined && (chosen(host, "model", settings) !== (started.model ?? "") || chosen(host, "effort", settings) !== (started.effort ?? ""));
-    return (_jsxs(Dialog, { open: open, title: words.title, onClose: onClose, text: text, children: [_jsx("p", { class: "note", children: note }), _jsxs("div", { class: "chat-hosts", role: "group", "aria-label": words.title, children: [offersChoices
+    return (_jsxs(Dialog, { open: open, title: review ? words.reviewTitle : words.title, onClose: onClose, text: text, children: [_jsx("p", { class: "note", children: note }), _jsxs("div", { class: "chat-hosts", role: "group", "aria-label": review ? words.reviewTitle : words.title, children: [offersChoices
                         ? (_jsxs("div", { class: "chat-head", "aria-hidden": "true", children: [_jsx("span", {}), _jsx("span", { children: words.model }), _jsx("span", { children: words.effort })] }))
                         : null, installed.map((host) => {
                         const atTable = table.chat && table.host === host.name;

package/dist/page/talk/chat.css

@@ -5,15 +5,13 @@
     max-height: none;
 }
 
-/* A line apart from the AI's note, which another voice signed (Zoe) */
+/* Under the AI's note, with no line between them (Stefano) */
 .talk.studied > section > .chat {
     display: flex;
     flex-direction: column;
     flex: 1 1 auto;
     min-height: 0;
     margin-top: 12px;
-    padding-top: 10px;
-    border-top: 1px solid var(--line);
 }
 
 .chat > .compose {
@@ -49,9 +47,11 @@
 
     .flipped .talk.studied > section > .chat {
         margin: 0 0 12px;
-        padding: 0 0 10px;
-        border-top: 0;
-        border-bottom: 1px solid var(--line);
+    }
+
+    /* Turned round, the note's room goes under its bubbles, which would touch the AI's card or the note that no chat listens (Zoe) */
+    .flipped .talk.studied .ai-note {
+        margin: 0 0 12px;
     }
 }
 

package/dist/page/talk/talk.css

@@ -233,65 +233,6 @@
     background: var(--say);
 }
 
-.me {
-    position: relative;
-    flex: none;
-    padding: 0;
-    border: 0;
-    border-radius: 50%;
-    background: none;
-    line-height: 0;
-    cursor: pointer;
-}
-
-.me-cover {
-    position: absolute;
-    inset: 0;
-    display: grid;
-    place-items: center;
-    border-radius: 50%;
-    background: rgba(0, 0, 0, 0.45);
-    color: #fff;
-    opacity: 0;
-    transition: opacity 0.12s;
-}
-
-.me-cover .icon {
-    width: 45%;
-    height: 45%;
-}
-
-.me:hover .me-cover,
-.me:focus-visible .me-cover {
-    opacity: 1;
-}
-
-/* Where nothing hovers, a camera in the corner says the picture changes */
-.me-badge {
-    position: absolute;
-    right: -2px;
-    bottom: -2px;
-    display: none;
-    place-items: center;
-    width: 18px;
-    height: 18px;
-    border-radius: 50%;
-    background: var(--accent);
-    color: var(--on-accent);
-    box-shadow: 0 0 0 2px var(--card);
-}
-
-.me-badge .icon {
-    width: 12px;
-    height: 12px;
-}
-
-@media (hover: none) {
-    .me-badge {
-        display: grid;
-    }
-}
-
 .profile-name {
     display: inline-flex;
     align-items: center;
@@ -369,6 +310,15 @@
     }
 }
 
+/* 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);
 }
@@ -701,23 +651,23 @@
     overflow-wrap: anywhere;
 }
 
-/* Only the note's last bubble has a tail, pointing down at the Torretta beside the AI's name, the board turned round or not */
+/* Only the note's first bubble has a tail, pointing up at the Torretta beside the AI's name, the board turned round or not (Stefano) */
 .ai-note > .say::before,
 .ai-note > .say::after {
     content: none;
 }
 
-.ai-note > .say:has(+ .who)::after {
+.ai-note > .who + .say::before {
     content: "";
     position: absolute;
     left: 8px;
-    bottom: -9px;
+    top: -9px;
     border: 10px solid transparent;
-    border-bottom: 0;
-    border-top-color: var(--say);
+    border-top: 0;
+    border-bottom-color: var(--say);
 }
 
-.ai-note > .say + .who {
+.ai-note > .who + .say {
     margin-top: 4px;
 }
 
@@ -866,8 +816,8 @@
     margin: 0 0 var(--between);
 }
 
-.ai-block:has(> .asleep) .say::before,
-.ai-block:has(> .asleep) .say::after {
+.ai-block:has(> .asleep) .says .say::before,
+.ai-block:has(> .asleep) .says .say::after {
     content: none;
 }
 

package/dist/page/talk/talk.js

@@ -16,10 +16,10 @@ export function AiWords({ words, newestFirst, voice }) {
     return (_jsx("ol", { ref: list, class: "says", "aria-live": "polite", children: inOrder(words.map((word, index) => (_jsx("li", { class: "say", style: aged(words.length - 1 - index), children: _jsx(Marked, { text: word }) }, index))), newestFirst) }));
 }
 /**
- * The AI's word on the move shown of a game in analysis (D-69), in a bubble that points down at the Torretta beside the AI's name: the move, its badge by name,
+ * The AI's word on the move shown of a game in analysis (D-69), in a bubble under the Torretta beside the AI's name, pointing up at it: the move, its badge by name,
  * and its note when it wrote one; read out as the player steps through the game. The Torretta and the name stay when the move has no word.
  */
-export function AiNote({ ply, opening, closing, summary, reviewing, name, by, mood, voice, text }) {
+export function AiNote({ ply, opening, closing, summary, reviewing, onComplete, name, by, mood, voice, text }) {
     // On a move of the book without the AI's note, the AI reports what the book says: the opening in the title, the variation under it.
     const book = ply?.review?.note === undefined ? opening : undefined;
     const shown = ply?.review ?? (book === undefined ? undefined : { badge: "book" });
@@ -32,10 +32,10 @@ export function AiNote({ ply, opening, closing, summary, reviewing, name, by, mo
         }
         return hush;
     }, [spoken, voice]);
-    // The Torretta stays in sight through the whole analysis, under its bubbles, which show only where it wrote something.
-    return (_jsxs("div", { class: "ai-note", "aria-live": "polite", children: [ply === undefined || shown === undefined ? null : (_jsxs("p", { class: `say move-note ${shown.badge ?? ""}`, children: [_jsxs("span", { class: "head", children: [shown.badge === undefined ? _jsx(NoteIcon, {}) : _jsx(BadgeIcon, { badge: shown.badge }), _jsxs("b", { children: [_jsxs("span", { class: "visually-hidden", children: [ply.number, ply.side === "white" ? "." : "...", ply.san] }), _jsxs("span", { "aria-hidden": "true", children: [_jsxs("span", { class: "move-number", children: [ply.number, ply.side === "white" ? "." : "..."] }), _jsx(Figurines, { san: ply.san, side: ply.side })] })] }), " ", title] }), note === undefined ? null : (_jsx("span", { class: "note", children: _jsx(Marked, { text: note }) })), shown.arrows === undefined && shown.squares === undefined ? null : _jsx(Legend, { review: shown, words: text.drawn })] })), summary === undefined ? null : _jsx(GameReview, { by: name, summary: summary, text: text }), closing === undefined ? null : (_jsx("p", { class: "say closing", children: _jsx(Marked, { text: closing }) })), reviewing === true
+    // The Torretta stays in sight through the whole analysis, over its bubbles, which show only where it wrote something.
+    return (_jsxs("div", { class: "ai-note", "aria-live": "polite", children: [_jsxs("p", { class: "who", children: [_jsx(Torretta, { size: 36, mood: mood }), _jsxs("span", { class: "signed", children: [name, by === undefined ? null : _jsx("small", { children: signature(by.annotator, by.effort) })] })] }), ply === undefined || shown === undefined ? null : (_jsxs("p", { class: `say move-note ${shown.badge ?? ""}`, children: [_jsxs("span", { class: "head", children: [shown.badge === undefined ? _jsx(NoteIcon, {}) : _jsx(BadgeIcon, { badge: shown.badge }), _jsxs("b", { children: [_jsxs("span", { class: "visually-hidden", children: [ply.number, ply.side === "white" ? "." : "...", ply.san] }), _jsxs("span", { "aria-hidden": "true", children: [_jsxs("span", { class: "move-number", children: [ply.number, ply.side === "white" ? "." : "..."] }), _jsx(Figurines, { san: ply.san, side: ply.side })] })] }), " ", title] }), note === undefined ? null : (_jsx("span", { class: "note", children: _jsx(Marked, { text: note }) })), shown.arrows === undefined && shown.squares === undefined ? null : _jsx(Legend, { review: shown, words: text.drawn })] })), summary === undefined ? null : _jsx(GameReview, { by: name, summary: summary, text: text }), closing === undefined ? null : (_jsx("p", { class: "say closing", children: _jsx(Marked, { text: closing }) })), reviewing === true
                 ? (_jsxs("p", { class: "say reviewing", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(name)] }))
-                : null, _jsxs("p", { class: "who", children: [_jsx(Torretta, { size: 36, mood: mood }), _jsxs("span", { class: "signed", children: [name, by === undefined ? null : _jsx("small", { children: signature(by.annotator, by.effort) })] })] })] }));
+                : null, onComplete === undefined ? null : (_jsxs("p", { class: "say incomplete", children: [_jsx("span", { role: "status", children: text.incomplete }), _jsx("button", { type: "button", title: text.completeHint, "aria-label": text.completeHint, onClick: onComplete, children: text.complete })] }))] }));
 }
 /** The squares and moves in the AI's words, such as e3, Cxe4, 7.Nd4 or O-O: in bold, as the player looks for them on the board. */
 export function Marked({ text }) {
@@ -94,7 +94,7 @@ export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, can
  * whoever moves and a dot on the Torretta when the AI spoke meanwhile.
  */
 export function TalkFaces({ name, aiPicture, you, picture, ai, player, aiMoves, playerMoves, unread, text }) {
-    return (_jsxs("div", { class: "faces", children: [_jsx(RailPlayer, { place: "ai", picture: aiPicture ?? _jsx(Torretta, { size: 40 }), name: name, ...(ai === undefined ? {} : { side: text.sides[ai] }), moves: aiMoves, unread: unread }), _jsx(RailPlayer, { place: "you", picture: picture, name: you, ...(player === undefined ? {} : { side: text.sides[player] }), moves: playerMoves })] }));
+    return (_jsxs("div", { class: "faces", children: [_jsx(RailPlayer, { place: "ai", picture: aiPicture ?? _jsx(Torretta, { size: 40, bust: true }), name: name, ...(ai === undefined ? {} : { side: text.sides[ai] }), moves: aiMoves, unread: unread }), _jsx(RailPlayer, { place: "you", picture: picture, name: you, ...(player === undefined ? {} : { side: text.sides[player] }), moves: playerMoves })] }));
 }
 /** The move a line of the player's was written on, 14.♘f3, small at the line's head: a press shows it on the board again (Zoe). */
 function ShownMove({ move, onShow, text }) {

package/dist/page/talk/voice.js

@@ -28,6 +28,18 @@ export function hush() {
         speechSynthesis.cancel();
     }
 }
+/** Whether the browser has a voice for the language: without one the words cannot be read. */
+export function hasVoice(language) {
+    return typeof speechSynthesis !== "undefined" && readerFor(language) !== undefined;
+}
+/** Calls the listener whenever the browser's voices change, since Chrome lists them late: what it returns stops it. */
+export function onVoices(listener) {
+    if (typeof speechSynthesis === "undefined") {
+        return () => undefined;
+    }
+    speechSynthesis.addEventListener("voiceschanged", listener);
+    return () => speechSynthesis.removeEventListener("voiceschanged", listener);
+}
 /**
  * The words with each move the AI wrote said in words, since a voice reads ♟g4 as "chess pawn g4": ♞xf6+, Nxf6+, exd5, O-O, e8=♛. A square alone, e4,
  * stays as it is; a pawn's move becomes words only with its figurine, a capture, a promotion or a check, and without the file it takes from.

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",
@@ -86,7 +87,7 @@ const english = {
     saveMoves: "PGN",
     saveMovesHint: "The moves alone, to open on Lichess or chess.com",
     noGameNow: "No game in progress",
-    analysing: "Analysis in progress",
+    analysing: "Analysis",
     badges: {
         brilliant: "Brilliant",
         great: "Great move",
@@ -114,6 +115,9 @@ const english = {
         mated: (side) => `${side === "white" ? "White" : "Black"} is mated`,
     },
     reviewing: (name) => `${name} is going over the game…`,
+    incomplete: "Analysis not complete",
+    complete: "Complete it",
+    completeHint: "Complete the analysis",
     you: "You",
     ai: "AI",
     sides: { white: "White", black: "Black" },
@@ -147,6 +151,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" },
@@ -155,6 +173,8 @@ const english = {
     table: {
         title: "Who are you playing?",
         choose: "Choose the chat to play with: it opens in a window of its own, to keep open.",
+        reviewTitle: "Who reviews the game?",
+        reviewChoose: "Choose the chat that reviews the game: 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",
@@ -190,6 +210,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 +269,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 +373,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 +419,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 +429,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 +441,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",
@@ -469,7 +499,7 @@ const italian = {
     saveMoves: "PGN",
     saveMovesHint: "Solo le mosse, da aprire su Lichess o chess.com",
     noGameNow: "Nessuna partita in corso",
-    analysing: "Analisi in corso",
+    analysing: "Analisi",
     badges: {
         brilliant: "Geniale",
         great: "Ottima mossa",
@@ -497,6 +527,9 @@ const italian = {
         mated: (side) => `Matto al ${side === "white" ? "Bianco" : "Nero"}`,
     },
     reviewing: (name) => `${name} sta analizzando la partita…`,
+    incomplete: "Analisi non completa",
+    complete: "Completa",
+    completeHint: "Completa l'analisi",
     you: "Tu",
     ai: "AI",
     sides: { white: "Bianco", black: "Nero" },
@@ -530,6 +563,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" },
@@ -538,6 +585,8 @@ const italian = {
     table: {
         title: "Contro chi giochi?",
         choose: "Scegli la chat con cui giocare: parte in una finestra a parte, da tenere aperta.",
+        reviewTitle: "Chi analizza la partita?",
+        reviewChoose: "Scegli la chat che analizza la partita: 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",
@@ -573,6 +622,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 +682,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 +786,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 +832,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 +842,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;