chesspal 0.3.1 → 0.3.3

package/dist/commands/{profiles.d.ts → profiles/profiles.d.ts}

@@ -1,12 +1,12 @@
 import { z } from "zod";
-import { type DrawnAvatar, type PlayerProfile } from "../profiles/index.ts";
-import type { Context } from "./context.ts";
+import { type DrawnAvatar, type PlayerProfile } from "../../profiles/index.ts";
+import { type Context } from "../registry/index.ts";
 /** A change of profile refused while a game goes on: the page says it in the player's language. */
 export declare class GameGoingOn extends Error {
     constructor();
 }
 /** The profiles, the one in use first. */
-export declare const profiles: import("./registry.ts").Command<z.ZodObject<{}, z.core.$strip>, {
+export declare const profiles: import("../registry/registry.ts").Command<z.ZodObject<{}, z.core.$strip>, {
     profiles: PlayerProfile[];
     active: string;
 }>;
@@ -15,7 +15,7 @@ export declare const profiles: import("./registry.ts").Command<z.ZodObject<{}, z
  * the first start, while new, becomes it, game and all (D-71). With the player's names on Lichess and Chess.com, their ratings are read there; their
  * FIDE rating they type (D-106).
  */
-export declare const newProfile: import("./registry.ts").Command<z.ZodObject<{
+export declare const newProfile: import("../registry/registry.ts").Command<z.ZodObject<{
     name: z.ZodString;
     level: z.ZodOptional<z.ZodEnum<{
         learning: "learning";
@@ -43,11 +43,11 @@ export declare const newProfile: import("./registry.ts").Command<z.ZodObject<{
     readonly inUse: boolean;
 }>;
 /** Another profile put in use, once the game going on has ended. */
-export declare const useProfile: import("./registry.ts").Command<z.ZodObject<{
+export declare const useProfile: import("../registry/registry.ts").Command<z.ZodObject<{
     profile: z.ZodString;
 }, z.core.$strip>, PlayerProfile>;
 /** The picture of the profile in use: a drawn avatar, or an image of the player's, which replaces any before. */
-export declare const setAvatar: import("./registry.ts").Command<z.ZodObject<{
+export declare const setAvatar: import("../registry/registry.ts").Command<z.ZodObject<{
     avatar: z.ZodString;
 }, z.core.$strip>, {
     profile: string;
@@ -57,7 +57,7 @@ export declare const setAvatar: import("./registry.ts").Command<z.ZodObject<{
  * What the player tells of themselves in the profile in use: their name, how they play, their names on Lichess and Chess.com, by which the games they
  * load are theirs (D-93), and their FIDE rating. Each one given is written, an empty one goes; the profile's folder keeps its name (D-106).
  */
-export declare const editProfile: import("./registry.ts").Command<z.ZodObject<{
+export declare const editProfile: import("../registry/registry.ts").Command<z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     level: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         learning: "learning";

package/dist/commands/{profiles.js → profiles/profiles.js}

@@ -2,11 +2,11 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { z } from "zod";
-import { endOf } from "../games/index.js";
-import { activateProfile, activeProfile, createProfile, drawnAvatars, fideHighest, fideLowest, gameFolder, levels, listProfiles, nameLimit, removeOwnImage, saveOwnImage, updateProfile, } from "../profiles/index.js";
-import { gameAt } from "./clock.js";
+import { endOf } from "../../games/index.js";
+import { activateProfile, activeProfile, createProfile, drawnAvatars, fideHighest, fideLowest, gameFolder, levels, listProfiles, nameLimit, removeOwnImage, saveOwnImage, updateProfile, } from "../../profiles/index.js";
+import { gameAt } from "../answers/index.js";
+import { defineCommand } from "../registry/index.js";
 import { refreshRatings } from "./ratings.js";
-import { defineCommand } from "./registry.js";
 /** A change of profile refused while a game goes on: the page says it in the player's language. */
 export class GameGoingOn extends Error {
     constructor() {

package/dist/commands/{ratings.d.ts → profiles/ratings.d.ts}

@@ -1,4 +1,4 @@
-import type { Context } from "./context.ts";
+import type { Context } from "../registry/index.ts";
 /** A day, in milliseconds: the page reads the ratings again once they are older. */
 export declare const ratingsAge: number;
 /**

package/dist/commands/{ratings.js → profiles/ratings.js}

@@ -1,7 +1,7 @@
 // The player's ratings read again from the sites (D-105, D-106): when their names there change, and when the page opens a day after the last reading;
 // never from a tool of the AI's.
-import { listProfiles, profileFolder, saveReadings } from "../profiles/index.js";
-import { readingsStale, readSites } from "../sites/index.js";
+import { listProfiles, profileFolder, saveReadings } from "../../profiles/index.js";
+import { readingsStale, readSites } from "../../sites/index.js";
 /** A day, in milliseconds: the page reads the ratings again once they are older. */
 export const ratingsAge = 24 * 60 * 60 * 1000;
 /**

package/dist/commands/{context.js → registry/context.js}

@@ -1,7 +1,7 @@
 // What every command runs with besides its input, injected by the command line, the MCP server or the tests: the folders, the time, the randomness.
 import { userInfo } from "node:os";
-import { dataFolder, openFolder } from "../home/index.js";
-import { ensureProfile } from "../profiles/index.js";
+import { dataFolder, openFolder } from "../../home/index.js";
+import { ensureProfile } from "../../profiles/index.js";
 /** The context of a process started in the player's folder: the data folder is found at the first command that needs it, once. */
 export function defaultContext() {
     let found;

package/dist/commands/registry/index.d.ts

@@ -0,0 +1,2 @@
+export { type Caller, type Context, defaultContext, type SeenPosition, speaksItalian } from "./context.ts";
+export { type AnyCommand, baseType, type Command, commandLineFieldProblem, defineCommand, inputProblems, isBoolean, isList, sentence, takesNumbers } from "./registry.ts";

package/dist/commands/registry/index.js

@@ -0,0 +1,3 @@
+// What a command is and what it runs with: the definition and the reading of its input, and the context of folders, time and randomness.
+export { defaultContext, speaksItalian } from "./context.js";
+export { baseType, commandLineFieldProblem, defineCommand, inputProblems, isBoolean, isList, sentence, takesNumbers } from "./registry.js";

package/dist/commands/setup/index.d.ts

@@ -0,0 +1,2 @@
+export { init } from "./init.ts";
+export { instructions, instructionsRead } from "./instructions.ts";

package/dist/commands/setup/index.js

@@ -0,0 +1,3 @@
+// The setting up of a player's folder for the hosts, and the opponent's instructions the MCP server gives.
+export { init } from "./init.js";
+export { instructions, instructionsRead } from "./instructions.js";

package/dist/commands/{init.d.ts → setup/init.d.ts}

@@ -9,7 +9,7 @@ interface FolderSetUp {
     hooksChanged?: true;
 }
 /** Makes a folder the player's chess table: the files through which Claude Code and Codex find Chesspal and the opponent's instructions (D-31). */
-export declare const init: import("./registry.ts").Command<z.ZodObject<{
+export declare const init: import("../registry/registry.ts").Command<z.ZodObject<{
     folder: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, FolderSetUp>;
 export {};

package/dist/commands/{init.js → setup/init.js}

@@ -3,9 +3,8 @@ import { relative, resolve } from "node:path";
 // Colours only on a terminal that shows them: none in a file, a pipe or with NO_COLOR.
 import { styleText } from "node:util";
 import { z } from "zod";
-import { codexHooksPath, setUpHosts } from "../host-files/index.js";
-import { speaksItalian } from "./context.js";
-import { defineCommand } from "./registry.js";
+import { codexHooksPath, setUpHosts } from "../../host-files/index.js";
+import { defineCommand, speaksItalian } from "../registry/index.js";
 /** Makes a folder the player's chess table: the files through which Claude Code and Codex find Chesspal and the opponent's instructions (D-31). */
 export const init = defineCommand({
     name: "init",

package/dist/commands/{instructions.d.ts → setup/instructions.d.ts}

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import type { Context } from "./context.ts";
+import { type Context } from "../registry/index.ts";
 /** How to play as the player's opponent, which the chat reads before its first reply and again after a summary (D-102). */
-export declare const instructions: import("./registry.ts").Command<z.ZodObject<{}, z.core.$strip>, string>;
+export declare const instructions: import("../registry/registry.ts").Command<z.ZodObject<{}, z.core.$strip>, string>;
 /**
  * Whether the chat has read the opponent's instructions since it started, or was cleared or summarized, as its start keys them (D-57); without the host's
  * note of it, since the MCP server started. Always on the command line, which keeps nothing.

package/dist/commands/{instructions.js → setup/instructions.js}

@@ -1,8 +1,8 @@
 // The opponent's instructions, which the MCP server gives so that they follow the version installed (D-102).
 import { z } from "zod";
-import { lastChatStart } from "../games/index.js";
-import { opponentInstructions } from "../host-files/index.js";
-import { defineCommand } from "./registry.js";
+import { lastChatStart } from "../../games/index.js";
+import { opponentInstructions } from "../../host-files/index.js";
+import { defineCommand } from "../registry/index.js";
 /** How to play as the player's opponent, which the chat reads before its first reply and again after a summary (D-102). */
 export const instructions = defineCommand({
     name: "instructions",

package/dist/commands/{ai-say.d.ts → talk/ai-say.d.ts}

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { type GameSummary } from "./game-summary.ts";
-import { type Written } from "./say.ts";
+import { type GameSummary, type Written } from "../answers/index.ts";
 interface Said {
     /** The game, none when the AI spoke before the first (D-77). */
     game?: GameSummary;
@@ -9,7 +8,7 @@ interface Said {
     coach?: true;
 }
 /** The AI's words on the board page without a move, read only there, on the player's time: an answer, or a word it has to say (D-54, D-72). */
-export declare const aiSay: import("./registry.ts").Command<z.ZodObject<{
+export declare const aiSay: import("../registry/registry.ts").Command<z.ZodObject<{
     text: z.ZodString;
     mood: z.ZodOptional<z.ZodEnum<{
         neutral: "neutral";

package/dist/commands/{ai-say.js → talk/ai-say.js}

@@ -1,13 +1,9 @@
 import { z } from "zod";
-import { moods } from "../core/index.js";
-import { archivedName, talkLimits } from "../games/index.js";
-import { gameFolder } from "../profiles/index.js";
-import { analystLine, coachOnEnd, coachOnEndLine, reviewedLine, withAnalyst } from "./agents.js";
-import { newGameStep, nextStep, wordLines } from "./answer-lines.js";
-import { summaryOf } from "./game-summary.js";
-import { refuseOtherGame } from "./play-move.js";
-import { defineCommand } from "./registry.js";
-import { give, say, waitingWords } from "./say.js";
+import { moods } from "../../core/index.js";
+import { archivedName, talkLimits } from "../../games/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { analystLine, coachOnEnd, coachOnEndLine, give, newGameStep, nextStep, refuseOtherGame, reviewedLine, say, summaryOf, waitingWords, withAnalyst, wordLines } from "../answers/index.js";
+import { defineCommand } from "../registry/index.js";
 /** The AI's words on the board page without a move, read only there, on the player's time: an answer, or a word it has to say (D-54, D-72). */
 export const aiSay = defineCommand({
     name: "ai_say",

package/dist/commands/talk/index.d.ts

@@ -0,0 +1,2 @@
+export { aiSay } from "./ai-say.ts";
+export { playerSay } from "./player-say.ts";

package/dist/commands/talk/index.js

@@ -0,0 +1,3 @@
+// The talk at the table: the AI's words and the player's, said beside the moves.
+export { aiSay } from "./ai-say.js";
+export { playerSay } from "./player-say.js";

package/dist/commands/{player-say.d.ts → talk/player-say.d.ts}

@@ -1,5 +1,5 @@
 import { z } from "zod";
 /** The player's words to the AI, as the board page sends them: on the command line only, since the AI never writes for the player. */
-export declare const playerSay: import("./registry.ts").Command<z.ZodObject<{
+export declare const playerSay: import("../registry/registry.ts").Command<z.ZodObject<{
     text: z.ZodString;
 }, z.core.$strip>, string>;

package/dist/commands/{player-say.js → talk/player-say.js}

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { talkLimits } from "../games/index.js";
-import { gameFolder } from "../profiles/index.js";
-import { defineCommand } from "./registry.js";
-import { say } from "./say.js";
+import { talkLimits } from "../../games/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { say } from "../answers/index.js";
+import { defineCommand } from "../registry/index.js";
 /** The player's words to the AI, as the board page sends them: on the command line only, since the AI never writes for the player. */
 export const playerSay = defineCommand({
     name: "player_say",

package/dist/page/app/app.js

@@ -9,7 +9,7 @@ import { explain } from "../board/explain.js";
 import { kingSigns } from "../board/signs.js";
 import { piecesOf } from "../board/squares.js";
 import { NewGameDialog } from "../dialogs/new-game.js";
-import { NameButton, PictureButton, ProfileDialog, ProfilesDialog, Wizard } from "../dialogs/profiles.js";
+import { NameButton, ProfileDialog, ProfilesDialog, Wizard } from "../dialogs/profiles.js";
 import { SettingsPanel } from "../dialogs/settings.js";
 import { playerIn, studiedSides } from "../dialogs/studied.js";
 import { StudyDialog } from "../dialogs/study.js";
@@ -25,6 +25,7 @@ import { BareButton, HelpsCard, HintLine, MapButton } from "../helps/helps.js";
 import { helpsOf } from "../helps/view.js";
 import { FoldTab } from "../layout/fold-tab.js";
 import { nextFold, rememberFold, startFolds } from "../layout/folds.js";
+import { PageFoot } from "../layout/footer.js";
 import { Header } from "../layout/header.js";
 import { standingsOf } from "../lead/view.js";
 import { MarksLegend } from "../legend/legend.js";
@@ -35,13 +36,14 @@ import { signature } from "../players/model-name.js";
 import { keepSettings } from "../profile/profile.js";
 import { languagesOf, saveSettings, settingsFrom, showSettings } from "../profile/settings.js";
 import { endSoundOf, playSound, soundOf, wakeSounds } from "../sounds/sounds.js";
+import { UpdateDialog, UpdateNotice } from "../table/update.js";
 import { AiNameButton, ChatDialog, tableNote } from "../table/window.js";
 import { AiNote, AiWords, Compose, PointSquare, TalkFaces } from "../talk/talk.js";
 import { textFor } from "../text.js";
 import { anchorName, useAnchor } from "./anchor.js";
 import { useBrowseKeys, useFoldKeys, useLegendKey, useMapKey, useWheelSteps } from "./keys.js";
 import { phaseOf, verdictOf } from "./phase.js";
-import { post, sendMessage, sendMove, useServed } from "./served.js";
+import { ask, post, sendMessage, sendMove, useServed } from "./served.js";
 import { tabTitle, useTabTitle } from "./title.js";
 /**
  * The page: the board of the game in the player's folder, where the player moves on their turn, the talk with the AI beside it, and the game's column; in the
@@ -69,12 +71,23 @@ export function App({ start }) {
     const { data: served, problem, offline, reload } = useServed(() => setDialog("new-game"));
     // Nuova partita with no chat at the table asks for one first (D-107): the chat's window, then the new game's, however the first closes.
     const [chatFirst, setChatFirst] = useState(false);
-    const askNewGame = () => {
+    // At the table with no chat, and none opening: what asks for the AI opens the chat's window first, to choose its host and model (D-107, D-109).
+    const chatMissing = () => {
         const table = offline ? undefined : served?.table;
-        const first = table !== undefined && !table.chat && table.opening === undefined;
+        return table !== undefined && !table.chat && table.opening === undefined;
+    };
+    // The chat's window opened for an analysis asks who reviews the game, not whom the player plays (Rosa, Zoe).
+    const [chatToReview, setChatToReview] = useState(false);
+    const askNewGame = () => {
+        const first = chatMissing();
         setChatFirst(first);
+        setChatToReview(false);
         setDialog(first ? "chat" : "new-game");
     };
+    const askChat = () => {
+        setChatToReview(false);
+        setDialog("chat");
+    };
     const closeChat = () => {
         setDialog(chatFirst ? "new-game" : undefined);
         setChatFirst(false);
@@ -251,7 +264,7 @@ export function App({ start }) {
     const { kind, verdict } = aborted && phase === "over" ? { kind: "over", verdict: text.aborted } : verdictOf(phase, how, winner, offer, declined, text);
     const header = (_jsx(Header, { text: text, kind: kind, verdict: verdict, ...(!ended && (offer === "ai" || declined) ? { who: name } : {}), actions: actions, onNewGame: served === undefined ? undefined : askNewGame, 
         // Between games the new one stands out in the player's card (D-77): in the header only when the talk, and the card with it, is folded away.
-        standOut: studied !== undefined || (between && folds.talk !== "open"), onStudy: served === undefined || going ? undefined : () => setDialog("study"), flipped: flipped, onFlip: () => setFlipped(!flipped), sound: sound, onSound: () => change({ ...settings, sound: !sound }), onTheme: switchTheme, onSettings: () => setSetting(true), onGuide: () => setDialog("guide"), ...(served === undefined ? {} : { profile: served.profile, onProfile: () => setDialog("profiles") }) }));
+        standOut: studied !== undefined || (between && folds.talk !== "open"), onStudy: served === undefined || going ? undefined : () => setDialog("study"), flipped: flipped, onFlip: () => setFlipped(!flipped), sound: sound, onSound: () => change({ ...settings, sound: !sound }), onTheme: switchTheme, onSettings: () => setSetting(true), onGuide: () => setDialog("guide"), ...(served === undefined ? {} : { profile: served.profile, onProfile: () => setDialog("profiles") }), ...(served?.update === undefined || served.table === undefined || offline ? {} : { update: { version: served.update.version, installing: served.update.installing === true }, onUpdate: () => setDialog("update") }) }));
     const panel = _jsx(SettingsPanel, { open: setting, settings: settings, onChange: change, onClose: () => setSetting(false), text: text });
     // The guide opens before the page has its data too.
     const guide = _jsx(GuideDialog, { open: dialog === "guide", onClose: () => setDialog(undefined), text: text });
@@ -298,6 +311,10 @@ export function App({ start }) {
     const legendAt = (under) => (_jsx(MarksLegend, { rows: legendRows, open: legendOpen, onOpen: setLegendOpen, drawn: { words: drawnByCoach ? text.helpsCard.drawn : text.drawn, by: drawer }, onPoint: setPointed, under: under, text: text }));
     const legend = legendAt(false);
     const summary = studied === undefined ? undefined : gameReviewOf(live.record);
+    // An AI is going over the game only when the server says so: with no chat at it, nobody is (Stefano).
+    const reviewing = summary === undefined && studied?.reviewing === true && !offline;
+    // With nobody at it, a review not finished says so, and the player brings the game back to the AI (D-109).
+    const completeIt = summary === undefined && studied?.incomplete === true && !offline ? () => void studyGame({ game: studied.name }) : undefined;
     const closing = studied === undefined ? undefined : closingOf(live.record);
     // In analysis the AI's card says who played that game, as its PGN keeps it (D-82), not who plays now.
     const playedBy = studied === undefined ? undefined : aiModelIn(live.record);
@@ -309,14 +326,14 @@ export function App({ start }) {
     const asleep = served.listening === false && !offline;
     // What the AI thinks on, a cloud at the Torretta's corner (Zoe): only in a game going on, and never while no chat hears the player, which the note says.
     const thinking = going && !asleep && !offline && studied === undefined ? served.thinking : undefined;
-    const thinker = (size) => (_jsx(Thinker, { thinking: thinking, words: text.thinking, children: _jsx(Torretta, { size: size, mood: mood }) }));
+    const thinker = (size) => (_jsx(Thinker, { thinking: thinking, words: text.thinking, children: _jsx(Torretta, { size: size, mood: mood, bust: true }) }));
     // The clocks wait for the player from the game's start: when the AI moves first, a button gives it the start; else the player's first move does (Stefano).
     const clockWaits = clock?.waiting === true && !ended && studied === undefined && viewing === undefined && live.position.turn === ai;
     const clockOf = (side) => clock === undefined ? undefined : (_jsx(ClockFace, { clock: clock, side: side, toMove: !ended && live.position.turn === side, held: pending !== undefined || (asleep && side === ai), onFlag: reload, text: text }));
     // Where to wake the chat, under the AI's card (over the board when the talk is folded); the button that starts the clocks, under the player's (Zoe).
     // On the table, what its chat is doing stands there, and in a game with no chat at it a line that opens the chat's window (D-107).
     const table = offline ? undefined : served.table;
-    const atTable = table === undefined ? null : tableNote({ table, name, inGame: going, onOpen: () => setDialog("chat"), text });
+    const atTable = table === undefined ? null : tableNote({ table, name, inGame: going, onOpen: askChat, text });
     const asleepNote = atTable !== null
         ? atTable
         : asleep && table?.chat !== false
@@ -397,40 +414,55 @@ export function App({ start }) {
         act("/api/new", { ai_colour: colour === "random" ? "random" : colour === "white" ? "black" : "white", level: chosen, ...(control === undefined ? {} : { clock: control }) });
     };
     // In analysis the AI's note goes with the other side's card and the talk with the player's, turned round with the board as in a game (D-101, Zoe).
-    const studiedCard = (side, place) => sides === undefined ? null : (_jsx(PlayerCard, { place: place, 
-        // The player opens their profile in analysis too, from their own side's card.
-        picture: sides[side].who === "player" ? _jsx(PictureButton, { profile: profile, onOpen: () => setDialog("profile"), text: text }) : pictureOf(sides[side], profile, 48, mood), name: sides[side].name, signed: sides[side].who === "ai" && playedBy !== undefined ? signature(playedBy.model, playedBy.effort) : undefined, side: side, taken: material.taken[side], ahead: ahead(side), badges: _jsx(BadgeCounts, { plies: plies, side: side, names: text.badges }), text: text }));
-    // A game brought to analyse: the page shows it once the server has it in analysis; a refusal stays in the dialog.
+    const studiedCard = (side, place) => sides === undefined ? null : (_jsx(PlayerCard, { place: place, picture: pictureOf(sides[side], profile, 48, mood), name: sides[side].name, signed: sides[side].who === "ai" && playedBy !== undefined ? signature(playedBy.model, playedBy.effort) : undefined, side: side, taken: material.taken[side], ahead: ahead(side), badges: _jsx(BadgeCounts, { plies: plies, side: side, names: text.badges }), text: text }));
+    // A game brought to analyse: the page shows it once the server has it in analysis; a refusal stays in the dialog. One the AI has to go over, with no
+    // chat at the table, opens the chat's window: the analyst works with the chat's model (D-109).
     const studyGame = async (studied) => {
-        const refused = await post("/api/study", studied, text, name);
-        if (refused === undefined) {
-            setDialog(undefined);
+        const sent = await ask("/api/study", studied, text, name);
+        if ("refused" in sent) {
+            return sent.refused.text;
         }
-        return refused?.text;
+        const toReview = sent.answer.reviewed === false && chatMissing();
+        setChatToReview(toReview);
+        setDialog(toReview ? "chat" : undefined);
+        return undefined;
     };
-    return (_jsx(ChosenSet.Provider, { value: settings.set, children: _jsxs(PointSquare.Provider, { value: pointSquare, children: [panel, _jsx(ProfileDialog, { open: dialog === "profile", profile: profile, onClose: () => setDialog(undefined), text: text }), _jsx(ProfilesDialog, { open: dialog === "profiles", profiles: served.profiles, active: profile, locked: going ? text.profile.whilePlaying : undefined, dataFolder: served.dataFolder, onEdit: () => setDialog("profile"), onClose: () => setDialog(undefined), text: text }), table === undefined ? null : _jsx(ChatDialog, { open: dialog === "chat", table: table, settings: settings, onChange: change, name: name, onClose: closeChat, text: text }), _jsx(NewGameDialog, { open: dialog === "new-game", choice: choice, going: going, onStart: startNewGame, onClose: () => setDialog(undefined), text: text }), guide, _jsx(StudyDialog, { open: dialog === "study", onStudy: studyGame, onClose: () => setDialog(undefined), you: profile.name, accounts: profile.accounts, ai: name, text: text }), offline ? _jsx("p", { class: "offline", role: "alert", children: text.offline(name) }) : null, served.outdated === true ? _jsx("p", { class: "outdated", role: "status", children: text.outdated(name) }) : null, _jsxs("main", { class: `app${flipped ? " flipped" : ""}${folds.talk === "open" ? "" : ` talk-${folds.talk}`}${folds.game === "folded" ? " folded" : ""}`, inert: offline, children: [header, sides === undefined
+    return (_jsx(ChosenSet.Provider, { value: settings.set, children: _jsxs(PointSquare.Provider, { value: pointSquare, children: [panel, _jsx(ProfileDialog, { open: dialog === "profile", profile: profile, onClose: () => setDialog(undefined), text: text }), _jsx(ProfilesDialog, { open: dialog === "profiles", profiles: served.profiles, active: profile, locked: going ? text.profile.whilePlaying : undefined, dataFolder: served.dataFolder, onEdit: () => setDialog("profile"), onClose: () => setDialog(undefined), text: text }), table === undefined ? null : _jsx(ChatDialog, { open: dialog === "chat", review: chatToReview, table: table, settings: settings, onChange: change, name: name, onClose: closeChat, text: text }), _jsx(NewGameDialog, { open: dialog === "new-game", choice: choice, going: going, onStart: startNewGame, onClose: () => setDialog(undefined), text: text }), guide, _jsx(StudyDialog, { open: dialog === "study", onStudy: studyGame, onClose: () => setDialog(undefined), you: profile.name, accounts: profile.accounts, ai: name, text: text }), served.update === undefined || served.table === undefined
+                    ? null
+                    : (_jsx(UpdateDialog, { open: dialog === "update", version: served.update.version, current: served.version, installing: served.update.installing === true, installed: served.update.installed === true, going: going, chat: served.table.chat ? (served.table.held ? "held" : "byHand") : undefined, name: name, onClose: () => setDialog(undefined), text: text })), offline ? _jsx("p", { class: "offline", role: "alert", children: text.offline(name) }) : null, served.outdated === true
+                    ? _jsx("p", { class: "outdated", role: "status", children: text.outdated(name) })
+                    : served.update !== undefined && served.table === undefined
+                        ? _jsx(UpdateNotice, { version: served.update.version, name: name, text: text })
+                        : null, _jsxs("main", { class: `app${flipped ? " flipped" : ""}${folds.talk === "open" ? "" : ` talk-${folds.talk}`}${folds.game === "folded" ? " folded" : ""}`, inert: offline, children: [header, sides === undefined
                             ? (_jsx(TalkFaces, { name: name, aiPicture: thinker(40), you: profile.name, picture: picture, ...(idle ? {} : { ai, player }), aiMoves: going && !playerToMove, playerMoves: playerToMove, unread: unread || asleep, text: text }))
                             : (_jsx(TalkFaces, { name: sides[ai].name, aiPicture: pictureOf(sides[ai], profile, 40, mood), you: sides[player].name, picture: pictureOf(sides[player], profile, 40, mood), ai: ai, player: player, aiMoves: false, playerMoves: false, unread: asleep, text: text })), _jsx(FoldTab, { column: "talk", folded: folds.talk === "folded", label: thinking === undefined || folds.talk !== "folded" ? text.talk : `${text.talk}: ${text.thinking[thinking]}`, unread: (unread || asleep) && folds.talk === "folded", ...(thinking === undefined || folds.talk !== "folded" ? {} : { mark: _jsx(Thought, { thinking: thinking, words: text.thinking }) }), onFold: fold }), _jsx(FoldTab, { column: "game", folded: folds.game === "folded", label: text.game, onFold: fold }), _jsx("span", { class: "visually-hidden", "aria-live": "polite", children: unread ? text.wrote(name) : "" }), _jsx("div", { class: sides === undefined ? "talk" : "talk studied", id: "talk", children: sides !== undefined && studied !== undefined
-                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(summary === undefined ? { reviewing: true } : {}), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
+                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(reviewing ? { reviewing: true } : {}), ...(completeIt === undefined ? {} : { onComplete: completeIt }), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
                                                             setDraft(words);
                                                             setUnsent(undefined);
                                                         }, onSend: () => sendWords({ game: studied.name, at }), canMove: false, name: name, problem: unsent, about: { ...(at === 0 ? {} : { ply: plies[at - 1] }), onShow: goTo }, text: text }) }), studiedCard(player, "you")] })] }))
-                                : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: table === undefined ? name : _jsx(AiNameButton, { name: name, table: table, onOpen: () => setDialog("chat"), text: text }), signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
+                                : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: table === undefined ? name : _jsx(AiNameButton, { name: name, table: table, onOpen: askChat, text: text }), signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
                                                     // Between games, and before the first, the player writes freely, a line at a time, as the AI does (D-74, D-77).
                                                     spent: going ? playerSpent(plies, ai, talk) : 0, draft: draft, onDraft: (words) => {
                                                         setDraft(words);
                                                         setUnsent(undefined);
-                                                    }, onSend: sendWords, canMove: playerToMove, name: name, problem: unsent, text: text }), _jsx(PlayerCard, { place: "you", picture: _jsx(PictureButton, { profile: profile, onOpen: () => setDialog("profile"), text: text }), name: _jsx(NameButton, { profile: profile, onOpen: () => setDialog("profiles"), text: text }), side: idle ? undefined : player, taken: material.taken[player], ahead: ahead(player), turn: playerToMove, clock: _jsxs(_Fragment, { children: [clockOf(player), startClocks, nextGame] }), text: text })] })] })) }), _jsxs("div", { 
+                                                    }, onSend: sendWords, canMove: playerToMove, name: name, problem: unsent, text: text }), _jsx(PlayerCard, { place: "you", picture: picture, name: _jsx(NameButton, { profile: profile, onOpen: () => setDialog("profiles"), text: text }), side: idle ? undefined : player, taken: material.taken[player], ahead: ahead(player), turn: playerToMove, clock: _jsxs(_Fragment, { children: [clockOf(player), startClocks, nextGame] }), text: text })] })] })) }), _jsxs("div", { 
                             // Between games the board goes off (D-77): a game the page saw end once its effects are over, its final position less off than the table set.
                             class: between && !justEnded ? "board-wrap off" : "board-wrap", onWheel: wheel, 
                             // A press on the board while the player looks back brings the game as it is: the next one plays.
                             onPointerDownCapture: viewing === undefined || studied !== undefined ? undefined : (event) => event.button === 0 && goTo(total), children: [_jsx(Board, { fen: shown.position.fen, bottom: flipped ? ai : player, lastMove: shown.lastMove, pointed: pointed, ...(helps === undefined ? {} : { helps }), ...(mapping && helps !== undefined ? { control: helps.strategy.control } : {}), bare: bare && helps !== undefined, ...(review?.badge === undefined ? {} : { badge: { badge: review.badge, name: text.badges[review.badge] } }), ...(drawn === undefined ? {} : { drawn }), nextMove: next, jumped: jumped, check: shown.position.check, end: boardEnd, player: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing === undefined ? refusal : undefined, promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleepNote !== null || clockWaits)
                                     ? (_jsxs("div", { class: "over-board", children: [asleepNote, startClocks] }))
-                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : { analysis: summary === undefined ? { by: analyst } : { by: analyst, summary } }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null && replayed.record.moves.length > 0 ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text })] })] }) }));
+                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : {
+                                analysis: {
+                                    by: analyst,
+                                    ...(summary === undefined ? {} : { summary }),
+                                    ...(reviewing ? { reviewing: true } : {}),
+                                    ...(completeIt === undefined ? {} : { onComplete: completeIt }),
+                                },
+                            }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null && replayed.record.moves.length > 0 ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text }), _jsx(PageFoot, { version: served.version, text: text })] })] }) }));
 }
 /** The picture of a player of the game in analysis: the player's own, the AI's Torretta with its mood, or the plain face of someone else. */
 function pictureOf({ who }, profile, size, mood) {
-    return who === "ai" ? _jsx(Torretta, { size: size, mood: mood }) : _jsx(PlayerPicture, { profile: who === "player" ? profile : undefined, size: size });
+    return who === "ai" ? _jsx(Torretta, { size: size, mood: mood, bust: true }) : _jsx(PlayerPicture, { profile: who === "player" ? profile : undefined, size: size });
 }
 /**
  * Plays the sound of each move the game gains while the page watches it, the AI's and the player's, of its end without a move and of a draw offered:

package/dist/page/app/served.js

@@ -13,6 +13,8 @@ export function useServed(onNewGame) {
     const reload = useRef(() => { });
     useEffect(() => {
         let latest = 0;
+        // The Chesspal version of the first answer: a server of another, after an update, sends data this page may not read.
+        let pageVersion;
         const load = () => {
             // Two reads in flight may answer out of order: only the last one asked counts.
             const asked = ++latest;
@@ -22,6 +24,11 @@ export function useServed(onNewGame) {
                 if (asked !== latest) {
                     return;
                 }
+                pageVersion ??= body.version;
+                if (body.version !== undefined && body.version !== pageVersion) {
+                    window.location.reload();
+                    return;
+                }
                 setProblem(body.error);
                 if (body.error === undefined) {
                     setData(body);
@@ -49,17 +56,22 @@ export function useServed(onNewGame) {
  * it sends the player, or undefined.
  */
 export async function post(path, body, text, name) {
+    const sent = await ask(path, body, text, name);
+    return "refused" in sent ? sent.refused : undefined;
+}
+/** Sends a request to the server as `post` does: its answer, or the reason it was refused. */
+export async function ask(path, body, text, name) {
     try {
         const response = await fetch(path, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
         if (response.ok) {
-            return undefined;
+            return { answer: await response.json().catch(() => ({})) };
         }
         const refused = (await response.json());
         const known = refused.refusal === undefined ? undefined : text.refused[refused.refusal];
-        return { text: known?.(refused.most ?? 0, name) ?? refused.error ?? response.statusText, words: refused.refusal?.startsWith("words-") === true };
+        return { refused: { text: known?.(refused.most ?? 0, name) ?? refused.error ?? response.statusText, words: refused.refusal?.startsWith("words-") === true } };
     }
     catch (error) {
-        return { text: String(error), words: false };
+        return { refused: { text: String(error), words: false } };
     }
 }
 /** Sends the player's move to the server, which plays it as the chat would, with the words written for the AI: the reason it was refused, or undefined. */

package/dist/page/avatars/torretta.js

@@ -1,12 +1,19 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-runtime";
 // The Torretta (D-45, D-46): the opponent and the logo, a rook that is a robot. Its screen shows the AI's mood (D-14, D-70): only the eyes, the mouth and the light change.
 import { useRef } from "preact/hooks";
-/** The Torretta at a size in pixels, with the face of a mood (neutral by default); with a label it is an image a screen reader names, else a decoration. */
-export function Torretta({ size, label, mood = "neutral" }) {
+/**
+ * The Torretta at a size in pixels, with the face of a mood (neutral by default); with a label it is an image a screen reader names, else a decoration.
+ * As a bust it is its own profile picture, on a player's card: a disc that frames it from the antenna to the screen, so that its face reads (Stefano).
+ */
+export function Torretta({ size, label, mood = "neutral", bust = false }) {
     // The face pops in when the mood changes, never when the Torretta first shows (the logo, a card, a dialog).
     const changed = useChanged(mood);
-    return (_jsxs("svg", { class: `torretta mood-${mood}`, viewBox: "0 0 128 128", width: size, height: size, role: label === undefined ? undefined : "img", "aria-label": label, "aria-hidden": label === undefined ? "true" : undefined, children: [_jsx("path", { class: "antenna", d: "M64 31V19" }), _jsx("circle", { class: "light", cx: "64", cy: "16", r: "5" }), _jsx("rect", { class: "shade", x: "29", y: "64", width: "12", height: "26", rx: "2" }), _jsx("rect", { class: "shade", x: "87", y: "64", width: "12", height: "26", rx: "2" }), _jsx("path", { class: "body", d: "M34 30H47V40H57V30H71V40H81V30H94V54L89 58L92 106H36L39 58L34 54Z" }), _jsx("rect", { class: "shade", x: "30", y: "104", width: "68", height: "12", rx: "4" }), _jsx("rect", { class: "screen", x: "44", y: "63", width: "40", height: "32", rx: "7" }), _jsx("g", { class: changed ? "expression changed" : "expression", children: _jsx(Face, { mood: mood }) }, mood)] }));
+    return (_jsxs("svg", { class: `torretta mood-${mood}${bust ? " bust" : ""}`, viewBox: bust ? bustFrame : fullFrame, width: size, height: size, role: label === undefined ? undefined : "img", "aria-label": label, "aria-hidden": label === undefined ? "true" : undefined, children: [bust ? _jsx("circle", { class: "back", cx: "64", cy: "56", r: "48" }) : null, _jsx("path", { class: "antenna", d: "M64 31V19" }), _jsx("circle", { class: "light", cx: "64", cy: "16", r: "5" }), _jsx("rect", { class: "shade", x: "29", y: "64", width: "12", height: "26", rx: "2" }), _jsx("rect", { class: "shade", x: "87", y: "64", width: "12", height: "26", rx: "2" }), _jsx("path", { class: "body", d: "M34 30H47V40H57V30H71V40H81V30H94V54L89 58L92 106H36L39 58L34 54Z" }), _jsx("rect", { class: "shade", x: "30", y: "104", width: "68", height: "12", rx: "4" }), _jsx("rect", { class: "screen", x: "44", y: "63", width: "40", height: "32", rx: "7" }), _jsx("g", { class: changed ? "expression changed" : "expression", children: _jsx(Face, { mood: mood }) }, mood)] }));
 }
+// The whole figure's frame: the square around it, from the antenna's light (y 11) to the base (y 116), two units clear of each, so that it fills its size.
+const fullFrame = "9.5 9 109 109";
+// The bust's frame, the square around its disc: the antenna's light three units under its top, the base left out below.
+const bustFrame = "16 8 96 96";
 /** Whether the mood has changed since the Torretta first showed: true from its first change on, so a face already shown never starts its entrance again. */
 function useChanged(mood) {
     const first = useRef(mood);

package/dist/page/dialogs/dialogs.css

@@ -291,6 +291,16 @@ h3 + .switch {
     translate: 14px 0;
 }
 
+/* A switch that cannot be used here: faded, and its tooltip says why */
+.switch:has(input:disabled),
+.switch input:disabled {
+    cursor: help;
+}
+
+.switch:has(input:disabled) > * {
+    opacity: 0.5;
+}
+
 @media (prefers-reduced-motion: reduce) {
     .switch input,
     .switch input::after {

package/dist/page/dialogs/profiles.js

@@ -11,11 +11,7 @@ import { Dialog } from "./dialog.js";
 export function Wizard({ text, hasGame, account, dataFolder, onMade }) {
     return (_jsxs("main", { class: "wizard", children: [_jsx(Torretta, { size: 56 }), _jsx("h1", { children: text.profile.welcome }), _jsxs("p", { class: "lead", children: [text.profile.lead, hasGame ? _jsx("span", { children: text.profile.gameMoves }) : null] }), _jsx(ProfileForm, { text: text, submit: text.profile.start, suggestion: account, onMade: onMade }), _jsx(DataFolder, { folders: dataFolder, text: text })] }));
 }
-/** The player's picture on their card: a click opens their profile; a mark on it says so where nothing hovers. */
-export function PictureButton({ profile, onOpen, text }) {
-    return (_jsxs("button", { class: "me", type: "button", title: text.profile.editProfile, "aria-label": text.profile.yourPicture, "aria-haspopup": "dialog", onClick: onOpen, children: [_jsx(PlayerPicture, { profile: profile }), _jsx("span", { class: "me-cover", children: pencilIcon }), _jsx("span", { class: "me-badge", children: pencilIcon })] }));
-}
-/** The player's name on their card: a click opens the menu of the players. */
+/** The player's name on their card: a click opens the menu of the players, as their picture in the header does; from there the pencil opens their profile. */
 export function NameButton({ profile, onOpen, text }) {
     return (_jsxs("button", { class: "profile-name", type: "button", title: text.profile.changePlayer, "aria-label": `${profile.name}: ${text.profile.changePlayer}`, "aria-haspopup": "dialog", onClick: onOpen, children: [_jsx("span", { children: profile.name }), _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M7 10L12 15L17 10" }) })] }));
 }