chesspal 0.6.0 → 0.7.0

package/dist/games/analysis.d.ts

@@ -38,5 +38,16 @@ export declare function startAnalysis(folder: string, game: string, now: Date, {
 export declare function forgetAnalyst(folder: string): void;
 /** The game in analysis, or none when there is none, or analysis.json cannot be read. */
 export declare function gameInAnalysis(folder: string): Analysis | undefined;
+/**
+ * Stops the analysis of the game in analysis at the player's word on the board page: the page goes back to the game over, status no longer names it, and
+ * the review written so far stays on the game. analysis.json keeps the game stopped, with the analyst that held it, until the next analysis starts: their
+ * later writes are refused. False when another game, or none, is in analysis.
+ */
+export declare function stopAnalysis(folder: string, game: string): boolean;
+/** The game whose analysis the player stopped on the board page, with the analyst that held it then; none once another analysis starts. */
+export declare function stoppedAnalysis(folder: string): {
+    game: string;
+    analyst?: AnalystRun;
+} | undefined;
 /** Ends the analysis, when a new game starts or its review is deleted. */
 export declare function endAnalysis(folder: string): void;

package/dist/games/analysis.js

@@ -50,6 +50,29 @@ export function gameInAnalysis(folder) {
         return undefined;
     }
 }
+/**
+ * Stops the analysis of the game in analysis at the player's word on the board page: the page goes back to the game over, status no longer names it, and
+ * the review written so far stays on the game. analysis.json keeps the game stopped, with the analyst that held it, until the next analysis starts: their
+ * later writes are refused. False when another game, or none, is in analysis.
+ */
+export function stopAnalysis(folder, game) {
+    const analysis = gameInAnalysis(folder);
+    if (analysis?.game !== game) {
+        return false;
+    }
+    writeAtomically(join(folder, fileName), `${JSON.stringify({ stopped: game, ...withAnalyst(analysis.analyst) }, null, 2)}\n`);
+    return true;
+}
+/** The game whose analysis the player stopped on the board page, with the analyst that held it then; none once another analysis starts. */
+export function stoppedAnalysis(folder) {
+    try {
+        const stopped = JSON.parse(readFileSync(join(folder, fileName), "utf8"));
+        return typeof stopped.stopped === "string" ? { game: stopped.stopped, ...withAnalyst(isAnalystRun(stopped.analyst) ? stopped.analyst : undefined) } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Ends the analysis, when a new game starts or its review is deleted. */
 export function endAnalysis(folder) {
     rmSync(join(folder, fileName), { force: true });

package/dist/games/archive.d.ts

@@ -1,4 +1,4 @@
-import { type GameRecord } from "../core/index.ts";
+import { type GameRecord, type Mood } from "../core/index.ts";
 import { type CurrentGame } from "./current-game.ts";
 /** Where the game goes in the archive, in the player's folder: named by when it started, in the player's time, games/2026-11-02-153012.pgn. */
 export declare function archiveName(current: CurrentGame): string;
@@ -22,6 +22,14 @@ export declare function archiveEnded(folder: string, current: CurrentGame, openi
     archive?: string;
     warning?: string;
 };
+/**
+ * Gives the mood the AI ends with to a game over already in the archive, on its last move, beside the review the analyst and Chesspal may have written there
+ * since; archives the game when it is not there.
+ */
+export declare function archiveMood(folder: string, current: CurrentGame, mood: Mood, opening: OpeningTags): {
+    archive?: string;
+    warning?: string;
+};
 /**
  * Writes the coach's judgments into a game over already in the archive, beside what the analyst may have written there since (Federico);
  * archives the game when it is not there.

package/dist/games/archive.js

@@ -1,7 +1,7 @@
 // The finished games, as PGN in games/ (D-9, D-41), with the AI's plans for the analyst (D-21); and the games played elsewhere, kept to study in study/ (D-68).
 import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { movesOnly, pgnDate, readPgn, readPgnTags, readPgnUnplayed, unsigned, withAiHost, withAiModel, writePgn } from "../core/index.js";
+import { movesOnly, pgnDate, readPgn, readPgnTags, readPgnUnplayed, recordWithMood, unsigned, withAiHost, withAiModel, writePgn } from "../core/index.js";
 import { aiHostOf, aiModelOf } from "./ai-model.js";
 import { coachWords, withCoach } from "./coach.js";
 import { endOf, loadGame } from "./current-game.js";
@@ -65,6 +65,23 @@ export function archiveEnded(folder, current, opening) {
         return { warning: `${error.message} The game is saved in game.json: it goes to the archive when a new game starts.` };
     }
 }
+/**
+ * Gives the mood the AI ends with to a game over already in the archive, on its last move, beside the review the analyst and Chesspal may have written there
+ * since; archives the game when it is not there.
+ */
+export function archiveMood(folder, current, mood, opening) {
+    const name = archivedName(folder, current);
+    if (name === undefined) {
+        return archiveEnded(folder, current, opening);
+    }
+    try {
+        writeAtomically(join(folder, name), writePgn(recordWithMood(archivedGame(folder, name), mood)));
+        return { archive: name };
+    }
+    catch (error) {
+        return { warning: `Chesspal could not write the mood into ${name}: ${error.message}` };
+    }
+}
 /**
  * Writes the coach's judgments into a game over already in the archive, beside what the analyst may have written there since (Federico);
  * archives the game when it is not there.

package/dist/games/current-game.d.ts

@@ -28,11 +28,26 @@ export interface TalkLine {
     readonly agent?: true;
     readonly shown?: Shown;
 }
-/** A position of a game in analysis: the game's name, how many of its moves the page showed, and the last of them numbered, 52...Kf6; none at the start. */
+/**
+ * A position of a game in analysis: the game's name, how many of its moves the page showed, and the last of them numbered, 52...Kf6; none at the start. With
+ * the variation the player played there (D-116), on the board or set aside.
+ */
 export interface Shown {
     readonly game: string;
     readonly at: number;
     readonly move?: string;
+    readonly variation?: ShownVariation;
+}
+/**
+ * A variation of the page's (D-116): how many of the game's moves come before it, its moves in SAN, how many of them the board showed (0 with the board back
+ * on the game), the line as PGN writes it, 12...Kf8 13.Nxe5 Bxe2, and the move shown numbered, 13.Nxe5.
+ */
+export interface ShownVariation {
+    readonly at: number;
+    readonly moves: readonly string[];
+    readonly cursor: number;
+    readonly text: string;
+    readonly move?: string;
 }
 /** How a game ended: its result, and why when the record says it or the board decided it. */
 export interface GameEnd {
@@ -76,5 +91,12 @@ export declare const savedLine: z.ZodObject<{
         game: z.ZodString;
         at: z.ZodInt;
         move: z.ZodOptional<z.ZodString>;
+        variation: z.ZodOptional<z.ZodObject<{
+            at: z.ZodInt;
+            moves: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            cursor: z.ZodInt;
+            text: z.ZodString;
+            move: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/games/current-game.js

@@ -94,7 +94,12 @@ export const savedLine = z.object({
     ply: z.int().min(0),
     at: z.iso.datetime(),
     agent: z.literal(true).optional(),
-    shown: z.object({ game: z.string(), at: z.int().min(0), move: z.string().optional() }).optional(),
+    shown: z.object({
+        game: z.string(),
+        at: z.int().min(0),
+        move: z.string().optional(),
+        variation: z.object({ at: z.int().min(0), moves: z.array(z.string()).min(1).readonly(), cursor: z.int().min(0), text: z.string(), move: z.string().optional() }).optional(),
+    }).optional(),
 });
 const savedClock = z.object({
     base: z.int().positive(),

package/dist/games/index.d.ts

@@ -1,9 +1,9 @@
 export { aiHostOf, aiModelOf, forgetTheAi, noteAiHost, noteAiModel } from "./ai-model.ts";
-export { type Analysis, type AnalysisStart, endAnalysis, forgetAnalyst, gameInAnalysis, startAnalysis } from "./analysis.ts";
-export { archiveCoached, archivedGame, archivedGames, archivedGameUnplayed, archivedName, archivedTags, archivedWhen, archiveEnded, archiveGame, archiveName, deleteGame, GameMissing, gameStemOf, hasListTags, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, type OpeningTags, playerPgn, rewriteGame, startOfNewGame, } from "./archive.ts";
+export { type Analysis, type AnalysisStart, endAnalysis, forgetAnalyst, gameInAnalysis, startAnalysis, stopAnalysis, stoppedAnalysis } from "./analysis.ts";
+export { archiveCoached, archivedGame, archivedGames, archivedGameUnplayed, archivedName, archivedTags, archivedWhen, archiveEnded, archiveGame, archiveMood, archiveName, deleteGame, GameMissing, gameStemOf, hasListTags, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, type OpeningTags, playerPgn, rewriteGame, startOfNewGame, } from "./archive.ts";
 export { type ChatStart, cleanSince, lastChatStart, saveChatStart } from "./chat-start.ts";
 export { type CoachHint, type CoachJudgment, type CoachLead, coachShown, coachStarted, coachWaitingSince, type CoachWords, coachWords, forgetCoach, keepHint, keepJudgment, keepLead, startCoach, withCoach } from "./coach.ts";
-export { bothSidesMoved, type CurrentGame, drawOfferOf, endOf, GameChanged, type GameEnd, gameStamp, loadGame, removeGame, rerunIfChanged, saveGame, type Shown, type Speaker, type TalkLine } from "./current-game.ts";
+export { bothSidesMoved, type CurrentGame, drawOfferOf, endOf, GameChanged, type GameEnd, gameStamp, loadGame, removeGame, rerunIfChanged, saveGame, type Shown, type ShownVariation, type Speaker, type TalkLine } from "./current-game.ts";
 export { makeFolder, renameOver, writeAtomically } from "./files.ts";
 export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.ts";
 export { forgetPositionShown, hostProcess, notePositionShown, type PositionShown, positionShownNote } from "./position-shown.ts";

package/dist/games/index.js

@@ -1,7 +1,7 @@
 // The player's games on disk: the current one in game.json, the finished ones in games/ (D-27, D-41), the games kept to study in study/ (D-68). Below the commands, above the core.
 export { aiHostOf, aiModelOf, forgetTheAi, noteAiHost, noteAiModel } from "./ai-model.js";
-export { endAnalysis, forgetAnalyst, gameInAnalysis, startAnalysis } from "./analysis.js";
-export { archiveCoached, archivedGame, archivedGames, archivedGameUnplayed, archivedName, archivedTags, archivedWhen, archiveEnded, archiveGame, archiveName, deleteGame, GameMissing, gameStemOf, hasListTags, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, playerPgn, rewriteGame, startOfNewGame, } from "./archive.js";
+export { endAnalysis, forgetAnalyst, gameInAnalysis, startAnalysis, stopAnalysis, stoppedAnalysis } from "./analysis.js";
+export { archiveCoached, archivedGame, archivedGames, archivedGameUnplayed, archivedName, archivedTags, archivedWhen, archiveEnded, archiveGame, archiveMood, archiveName, deleteGame, GameMissing, gameStemOf, hasListTags, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, playerPgn, rewriteGame, startOfNewGame, } from "./archive.js";
 export { cleanSince, lastChatStart, saveChatStart } from "./chat-start.js";
 export { coachShown, coachStarted, coachWaitingSince, coachWords, forgetCoach, keepHint, keepJudgment, keepLead, startCoach, withCoach } from "./coach.js";
 export { bothSidesMoved, drawOfferOf, endOf, GameChanged, gameStamp, loadGame, removeGame, rerunIfChanged, saveGame } from "./current-game.js";

package/dist/page/app/app.js

@@ -73,7 +73,7 @@ export function App({ start }) {
     };
     const [dialog, setDialog] = useState(undefined);
     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.
+    // Nuova partita with no chat at the table asks for one first (D-107): the chat's window, then the new game's once a chat starts; closed without, neither.
     const [chatFirst, setChatFirst] = useState(false);
     // 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 = () => {
@@ -93,10 +93,14 @@ export function App({ start }) {
         setChatToReview(served?.analysis !== undefined);
         setDialog("chat");
     };
-    const closeChat = () => {
+    const chatStarted = () => {
         setDialog(chatFirst ? "new-game" : undefined);
         setChatFirst(false);
     };
+    const closeChat = () => {
+        setDialog(undefined);
+        setChatFirst(false);
+    };
     const [selected, setSelected] = useState(undefined);
     const [refusal, setRefusal] = useState(undefined);
     // A link the page did not follow says why on the board, in the language of the settings the page has by then, until the player's next click or key.
@@ -298,6 +302,12 @@ export function App({ start }) {
             setViewing(line.at >= total ? undefined : line.at);
         }
     };
+    // A variation a line of the talk was written on goes back on the board, at the move it showed, or at its end when it was set aside (D-116).
+    const putLineBack = (sent) => {
+        setSelected(undefined);
+        setLine({ at: sent.at, moves: sent.moves, cursor: sent.cursor > 0 ? sent.cursor : sent.moves.length });
+        setViewing(sent.at >= total ? undefined : sent.at);
+    };
     // The cross and Esc close the variation: the board shows the game where it left it.
     const closeLine = () => {
         setSelected(undefined);
@@ -394,6 +404,8 @@ export function App({ start }) {
     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;
+    // While it waits, the player may cancel the analysis asked, one click: what is written of the review stays, and the page goes back to the game.
+    const stopIt = reviewing ? () => act("/api/stop-analysis", { game: studied.name }) : undefined;
     const closing = studied === undefined ? undefined : closingOf(live.record);
     // How far the review has got, counted as status counts it for the AI: who is ahead after how many of the game's moves.
     const count = reviewing || completeIt !== undefined ? reviewCount(plies) : undefined;
@@ -499,7 +511,7 @@ export function App({ start }) {
             setRefusal({ text: words, square: from, piece: pieces.get(from), explanation: explain(illegal, to, king) });
         }
     };
-    // In analysis the words go with the game and the move shown (D-101).
+    // In analysis the words go with the game and the move shown (D-101), and the variation played there, on the board or set aside (D-116).
     const sendWords = (position) => {
         const words = draft;
         // /clear and the other commands are for Claude's app: written here they would reach the AI as words (Sebastiano's playtest).
@@ -524,10 +536,29 @@ export function App({ start }) {
     };
     // 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, picture: pictureOf(sides[side], profile, served.profiles, 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 }));
+    // Where the words go in analysis: the game, the move shown, and the variation, on the board or set aside (D-116).
+    const shownIn = (game) => line === undefined ? { game, at } : { game, at, variation: line };
+    // «Analyse» on the variation sends the player's request, as their words would (D-116).
+    const analyseLine = () => {
+        if (studied !== undefined) {
+            setUnsent(undefined);
+            void sendMessage(text.variation.analyseWords, text, name, shownIn(studied.name)).then((refused) => setUnsent(refused?.text));
+        }
+    };
     // The variation as the column and the steps show it.
     const lineView = !analysing || line === undefined || lineNumbered === undefined
         ? undefined
-        : { plies: lineNumbered, at: line.at, cursor: line.cursor, onShow: showLine, onClose: closeLine, onBack: () => goTo(line.at) };
+        : {
+            plies: lineNumbered,
+            at: line.at,
+            cursor: line.cursor,
+            onShow: showLine,
+            onClose: closeLine,
+            onBack: () => goTo(line.at),
+            onAnalyse: analyseLine,
+            canAnalyse: !asleep && !offline,
+            analyst: name,
+        };
     // 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) => {
@@ -540,7 +571,7 @@ export function App({ start }) {
         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", 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), onProfile: () => setDialog("profile"), you: profile.name, accounts: profile.accounts, others: othersOf(served.profiles, profile.id), ai: name, text: text }), served.update === undefined || served.table === 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, onStarted: chatStarted, 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), onProfile: () => setDialog("profile"), you: profile.name, accounts: profile.accounts, others: othersOf(served.profiles, profile.id), 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) })
@@ -552,7 +583,7 @@ export function App({ start }) {
                                 ? (_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 || onTheLine ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined && !onTheLine ? { closing } : {}), ...(at === 0 && summary !== undefined && !onTheLine ? { summary } : {}), ...(reviewing ? { reviewing: true } : {}), ...(count === undefined ? {} : { count }), ...(completeIt === undefined ? {} : { onComplete: completeIt }), name: analyst, by: annotator, mood: mood, ...(voiced ? { 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 }, ...(chatName === undefined ? {} : { to: chatName }), text: text }) }), studiedCard(player, "you")] })] }))
+                                                        }, onSend: () => sendWords(shownIn(studied.name)), canMove: false, name: name, problem: unsent, about: { ...(at === 0 ? {} : { ply: plies[at - 1] }), onShow: goTo, onLine: putLineBack }, ...(chatName === undefined ? {} : { to: chatName }), 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: 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, ...(voiced ? { 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) => {
@@ -577,6 +608,7 @@ export function App({ start }) {
                                     ...(summary === undefined ? {} : { summary }),
                                     ...(reviewing ? { reviewing: true } : {}),
                                     ...(count === undefined ? {} : { count }),
+                                    ...(stopIt === undefined ? {} : { onStop: stopIt }),
                                     ...(completeIt === undefined ? {} : { onComplete: completeIt }),
                                 },
                             }), shownPlies: at, ...(lineView === undefined ? {} : { line: lineView }), 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 })] })] }) }));

package/dist/page/game/column.js

@@ -12,10 +12,11 @@ import { ReviewProgress } from "./review-progress.js";
  * (D-69) says above the moves that the AI is going over it, until its word on the whole game comes, which the talk shows.
  */
 export function GameColumn({ plies, result, how, lit, started, move, toMove, opening, outOfBook, helps, legend, standings, analysis, shownPlies, line, onShow, onStep, onDownload, onSaveMoves, onAnalyse, text }) {
-    const bar = standings === undefined ? undefined : _jsx(LeadBar, { standing: standingAt(standings, shownPlies), shown: shownPlies, text: text });
+    // In a game the bar waits for the coach's first estimate: a host that runs no coach gives none (Stefano).
+    const bar = standings === undefined || (analysis === undefined && standings.length === 0) ? undefined : _jsx(LeadBar, { standing: standingAt(standings, shownPlies), shown: shownPlies, text: text });
     return (_jsx("aside", { class: "side", id: "game", "aria-label": text.game, children: started === undefined && analysis === undefined
             ? (_jsxs(_Fragment, { children: [_jsx("p", { class: "card empty", children: text.noGame }), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseLast, onAnalyse: onAnalyse })] }))
-            : (_jsxs(_Fragment, { children: [_jsxs("div", { class: "side-cards", children: [_jsx(GameCard, { plies: plies, result: result, how: how, lit: lit, started: started, move: move, toMove: toMove, bar: bar, text: text }), analysis?.reviewing !== true ? null : (_jsxs("div", { class: "card review waiting", children: [_jsx("p", { role: "status", children: text.reviewing(analysis.by) }), analysis.count === undefined ? null : _jsx(ReviewProgress, { count: analysis.count, label: text.reviewing(analysis.by) })] })), analysis?.onComplete === undefined ? null : (_jsxs("div", { class: "card review incomplete", children: [_jsxs("p", { children: [_jsx("span", { role: "status", children: text.incomplete }), _jsx("button", { type: "button", title: text.completeHint, "aria-label": text.completeHint, onClick: analysis.onComplete, children: text.complete })] }), analysis.count === undefined || analysis.count.done === 0 ? null : _jsx(ReviewProgress, { count: analysis.count, label: text.incomplete, stopped: true })] })), analysis === undefined || standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: shownPlies, onShow: onShow, text: text }), opening === undefined ? null : _jsx(OpeningCard, { opening: opening, ...(outOfBook === undefined ? {} : { outOfBook }), text: text }), helps] }), _jsxs("div", { class: "side-foot", children: [result !== undefined && plies.length === 0 ? null : _jsx(MoveList, { plies: plies, result: result, shown: shownPlies, ...(line === undefined ? {} : { line }), onShow: onShow, tools: legend, text: text }), onDownload === undefined && onSaveMoves === undefined ? null : (_jsxs("div", { class: "card analysis-actions", children: [onDownload === undefined ? null : _jsx(SaveButton, { label: text.study.download, hint: text.study.downloadHint, onSave: onDownload }), onSaveMoves === undefined ? null : _jsx(SaveButton, { label: text.saveMoves, hint: text.saveMovesHint, onSave: onSaveMoves })] })), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseIt, onAnalyse: onAnalyse }), _jsx(Steps, { shown: shownPlies, total: plies.length, ...stepsLine(line, plies), onStep: onStep, text: text })] })] })) }));
+            : (_jsxs(_Fragment, { children: [_jsxs("div", { class: "side-cards", children: [_jsx(GameCard, { plies: plies, result: result, how: how, lit: lit, started: started, move: move, toMove: toMove, bar: bar, text: text }), analysis?.reviewing !== true ? null : (_jsxs("div", { class: "card review waiting", children: [_jsxs("p", { children: [_jsx("span", { role: "status", children: text.reviewing(analysis.by) }), analysis.onStop === undefined ? null : (_jsx("button", { type: "button", class: "stop-review", title: text.stopReview, "aria-label": text.stopReview, onClick: analysis.onStop, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M7 7L17 17M17 7L7 17" }) }) }))] }), analysis.count === undefined ? null : _jsx(ReviewProgress, { count: analysis.count, label: text.reviewing(analysis.by) })] })), analysis?.onComplete === undefined ? null : (_jsxs("div", { class: "card review incomplete", children: [_jsxs("p", { children: [_jsx("span", { role: "status", children: text.incomplete }), _jsx("button", { type: "button", title: text.completeHint, "aria-label": text.completeHint, onClick: analysis.onComplete, children: text.complete })] }), analysis.count === undefined || analysis.count.done === 0 ? null : _jsx(ReviewProgress, { count: analysis.count, label: text.incomplete, stopped: true })] })), analysis === undefined || standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: shownPlies, onShow: onShow, text: text }), opening === undefined ? null : _jsx(OpeningCard, { opening: opening, ...(outOfBook === undefined ? {} : { outOfBook }), text: text }), helps] }), _jsxs("div", { class: "side-foot", children: [result !== undefined && plies.length === 0 ? null : _jsx(MoveList, { plies: plies, result: result, shown: shownPlies, ...(line === undefined ? {} : { line }), onShow: onShow, tools: legend, text: text }), onDownload === undefined && onSaveMoves === undefined ? null : (_jsxs("div", { class: "card analysis-actions", children: [onDownload === undefined ? null : _jsx(SaveButton, { label: text.study.download, hint: text.study.downloadHint, onSave: onDownload }), onSaveMoves === undefined ? null : _jsx(SaveButton, { label: text.saveMoves, hint: text.saveMovesHint, onSave: onSaveMoves })] })), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseIt, onAnalyse: onAnalyse }), _jsx(Steps, { shown: shownPlies, total: plies.length, ...stepsLine(line, plies), onStep: onStep, text: text })] })] })) }));
 }
 /** A button that saves the game as a file in the player's downloads, its tooltip saying what the file holds. */
 function SaveButton({ label, hint, onSave }) {

package/dist/page/game/game.css

@@ -338,6 +338,7 @@
     color: var(--soft);
 }
 
+.review.waiting > p,
 .review.incomplete > p,
 .say.incomplete > p {
     display: flex;
@@ -605,8 +606,33 @@
     opacity: 0.85;
 }
 
-/* The cross that closes it, at the row's end; a finger's 32 pixels on a touch screen */
-.close-line {
+/* The button that asks the AI to analyse it, small in the accent beside the cross; off while no chat hears the player */
+.analyse-line {
+    flex: none;
+    min-height: 24px;
+    padding: 1px 8px;
+    border: 1px solid var(--accent);
+    border-radius: 6px;
+    background: none;
+    color: var(--accent);
+    font: inherit;
+    font-size: 12px;
+    font-weight: 600;
+    cursor: pointer;
+}
+
+.analyse-line:hover:not(:disabled) {
+    background: color-mix(in oklab, var(--accent) 14%, transparent);
+}
+
+.analyse-line:disabled {
+    opacity: 0.45;
+    cursor: default;
+}
+
+/* The cross that closes it, at the row's end, as the one that stops the analysis asked; a finger's 32 pixels on a touch screen */
+.close-line,
+.stop-review {
     display: grid;
     place-items: center;
     width: 24px;
@@ -620,19 +646,22 @@
     cursor: pointer;
 }
 
-.close-line:hover {
+.close-line:hover,
+.stop-review:hover {
     background: color-mix(in oklab, var(--ink) 9%, transparent);
     color: var(--ink);
 }
 
-.close-line .icon {
+.close-line .icon,
+.stop-review .icon {
     width: 14px;
     height: 14px;
     stroke-width: 2.2;
 }
 
 @media (pointer: coarse) {
-    .close-line {
+    .close-line,
+    .stop-review {
         width: 32px;
         height: 32px;
         margin-block: -4px;

package/dist/page/game/move-list.js

@@ -67,15 +67,15 @@ function Move({ ply, current, fork, onShow, text }) {
     return (_jsxs("button", { type: "button", class: current ? "ply current" : fork ? "ply fork" : "ply", "aria-current": current ? "step" : undefined, onClick: onShow, children: [_jsx("span", { class: "visually-hidden", children: ply.review?.badge === undefined ? ply.san : `${ply.san}, ${text.badges[ply.review.badge]}` }), _jsx("span", { "aria-hidden": "true", children: _jsx(Figurines, { san: ply.san, side: ply.side }) }), ply.review?.badge !== undefined ? _jsx(BadgeIcon, { badge: ply.review.badge }) : ply.review?.note !== undefined ? _jsx(NoteIcon, {}) : null] }));
 }
 /**
- * The variation's row: its moves numbered as a PGN writes them, the one shown in the gold of the moves, and a cross that closes it; faded while the board
- * shows the game, its moves still a click away.
+ * The variation's row: its moves numbered as a PGN writes them, the one shown in the gold of the moves, the button that asks the AI to analyse it, and a
+ * cross that closes it; faded while the board shows the game, its moves still a click away.
  */
 function LineRow({ line, text }) {
     return (_jsxs("li", { class: line.cursor > 0 ? "line" : "line faded", "aria-label": `${text.variation.line}: ${lineText(line.plies)}`, children: [_jsx("span", { class: "line-moves", children: line.plies.map((ply, index) => {
                     const current = index + 1 === line.cursor;
                     const number = moveNumberOf(ply, index === 0);
                     return (_jsxs("button", { type: "button", class: current ? "ply current" : "ply", "aria-current": current ? "step" : undefined, onClick: () => line.onShow(index + 1), children: [_jsxs("span", { class: "visually-hidden", children: [number, ply.san] }), _jsxs("span", { "aria-hidden": "true", children: [number === "" ? null : _jsx("span", { class: "line-number", children: number.replace("...", "…") }), _jsx(Figurines, { san: ply.san, side: ply.side })] })] }, index));
-                }) }), _jsx("button", { type: "button", class: "close-line", title: text.variation.close, "aria-label": text.variation.close, onClick: line.onClose, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M7 7L17 17M17 7L7 17" }) }) })] }));
+                }) }), _jsx("button", { type: "button", class: "analyse-line", title: line.canAnalyse ? text.variation.analyseHint(line.analyst) : text.asleepInAnalysis(line.analyst), disabled: !line.canAnalyse, onClick: line.onAnalyse, children: text.variation.analyse }), _jsx("button", { type: "button", class: "close-line", title: text.variation.close, "aria-label": text.variation.close, onClick: line.onClose, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M7 7L17 17M17 7L7 17" }) }) })] }));
 }
 /** The fork with the game's move the variation leaves from: it takes the board back to the game there. */
 function ForkButton({ fork, onBack, text }) {

package/dist/page/table/window.js

@@ -3,9 +3,12 @@ import { useEffect, useState } from "preact/hooks";
 import { Dialog } from "../dialogs/dialog.js";
 import { checkIcon } from "../dialogs/profiles.js";
 import { canAct, chatAction, choiceKeys, chosen, effortsOf, firstHost, offeredHosts, startedWith } from "./action.js";
-/** 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 }) {
-    return (_jsx(Dialog, { open: open, title: review ? text.table.reviewTitle : text.table.title, onClose: onClose, text: text, children: _jsx(ChatForm, { review: review, table: table, settings: settings, onChange: onChange, name: name, onClose: onClose, text: text }) }));
+/**
+ * The chat's window: `onStarted` once a chat opens or starts again, the page then saying where it stands; `onClose` when the player closes it without;
+ * `review` when it opened to have a game analysed.
+ */
+export function ChatDialog({ open, review = false, table, settings, onChange, name, onStarted, onClose, text }) {
+    return (_jsx(Dialog, { open: open, title: review ? text.table.reviewTitle : text.table.title, onClose: onClose, text: text, children: _jsx(ChatForm, { review: review, table: table, settings: settings, onChange: onChange, name: name, onStarted: onStarted, text: text }) }));
 }
 /** The AI's name on its card, which opens the chat's window: with no chat at the table, a hollow ring before it says so. */
 export function AiNameButton({ name, table, onOpen, text }) {
@@ -45,7 +48,7 @@ const hostTitles = { claude: "Claude Code", codex: "Codex", antigravity: "Antigr
 /** The ↻ of a chat that starts again. */
 const restartIcon = (_jsx("svg", { class: "icon in-use", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M19.5 12a7.5 7.5 0 1 1-2.2-5.3M19.5 4.5v4h-4" }) }));
 /** The window's form, made again at each opening with the host at the table selected, else the last the button used, else the first. */
-function ChatForm({ review, table, settings, onChange, name, onClose, text }) {
+function ChatForm({ review, table, settings, onChange, name, onStarted, text }) {
     const words = text.table;
     const installed = offeredHosts(table);
     const [selected, setSelected] = useState(() => firstHost(table, settings));
@@ -73,7 +76,7 @@ function ChatForm({ review, table, settings, onChange, name, onClose, text }) {
         setSending(false);
         if (done) {
             onChange({ ...settings, chatHost: host.name });
-            onClose();
+            onStarted();
         }
         else {
             setFailed(true);

package/dist/page/talk/chat.css

@@ -106,3 +106,11 @@
     opacity: 1;
     background: color-mix(in oklab, currentColor 15%, transparent);
 }
+
+/* On a variation, the fork's sign under the moves before the move the board showed, in the bubble's colour (D-116) */
+.shown-line .fork-icon {
+    width: 14px;
+    height: 14px;
+    margin-right: 3px;
+    stroke-width: 2.2;
+}

package/dist/page/talk/talk.js

@@ -4,7 +4,7 @@ import { createContext } from "preact";
 import { useContext, useEffect, useLayoutEffect, useRef, useState } from "preact/hooks";
 import { Torretta } from "../avatars/torretta.js";
 import { BadgeIcon, NoteIcon } from "../game/badges.js";
-import { Figurines } from "../game/move-list.js";
+import { Figurines, ForkIcon } from "../game/move-list.js";
 import { talkLimits } from "../game/plies.js";
 import { ReviewProgress } from "../game/review-progress.js";
 import { signature } from "../players/model-name.js";
@@ -87,7 +87,7 @@ export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, can
     };
     return (_jsxs(_Fragment, { children: [_jsx("ol", { ref: list, class: "sent", "aria-live": "polite", children: inOrder(lines.map((line, index) => (_jsxs("li", { class: line.who === "ai" ? "from-ai" : undefined, style: about === undefined ? aged(lines.length - 1 - index) : reread(index, lastAnswer), children: [line.who === "ai"
                             ? (_jsxs(_Fragment, { children: [_jsx(Torretta, { size: 24 }), _jsx("p", { class: "say", children: _jsx(Marked, { text: line.text }) })] }))
-                            : (_jsxs("p", { class: "said", children: [about === undefined || line.shown?.move === undefined ? null : _jsx(ShownMove, { move: line.shown.move, onShow: () => about.onShow(line.shown.at), text: text }), line.text] })), index === lastWritten ? _jsx(Status, { heard: line.heard, name: name, text: text }) : null] }, index))), newestFirst) }), to, left <= 0 ? null : (_jsxs("form", { class: about === undefined ? "compose" : "compose asking", onSubmit: (event) => {
+                            : (_jsxs("p", { class: "said", children: [about === undefined ? null : _jsx(ShownPlace, { shown: line.shown, about: about, text: text }), line.text] })), index === lastWritten ? _jsx(Status, { heard: line.heard, name: name, text: text }) : null] }, index))), newestFirst) }), to, left <= 0 ? null : (_jsxs("form", { class: about === undefined ? "compose" : "compose asking", onSubmit: (event) => {
                     event.preventDefault();
                     submit();
                 }, children: [_jsx("p", { class: "limit", role: "status", children: problem ?? "" }), _jsx("textarea", { rows: 2, maxLength: left, placeholder: prompt, "aria-label": prompt, value: draft, onInput: (event) => onDraft(event.currentTarget.value), onKeyDown: (event) => {
@@ -106,6 +106,24 @@ export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, can
 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, 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 })] }));
 }
+/** Where a line of the player's was written: on a variation the board showed, its mark; else the game's move, none at the start. */
+function ShownPlace({ shown, about, text }) {
+    const variation = shown?.variation;
+    if (variation?.move !== undefined) {
+        return _jsx(ShownLine, { variation: variation, onShow: () => about.onLine(variation), text: text });
+    }
+    return (_jsxs(_Fragment, { children: [shown?.move === undefined ? null : _jsx(ShownMove, { move: shown.move, onShow: () => about.onShow(shown.at), text: text }), variation === undefined ? null : _jsx(ShownLine, { variation: variation, onShow: () => about.onLine(variation), text: text })] }));
+}
+/**
+ * The variation a line of the player's was written on, small at the line's head: the fork's sign in the accent and the move the board showed, none when
+ * it was set aside; a press puts the variation back on the board (D-116).
+ */
+function ShownLine({ variation, onShow, text }) {
+    const { move } = variation;
+    const label = text.variation.show(variation.text);
+    const [, number = "", san = ""] = /^(\d+\.+)(.+)$/.exec(move ?? "") ?? [];
+    return (_jsxs("button", { type: "button", class: "shown-move shown-line", title: label, "aria-label": label, onClick: onShow, children: [_jsx(ForkIcon, {}), move === undefined ? null : (_jsxs(_Fragment, { children: [_jsx("span", { class: "move-number", children: number }), _jsx(Figurines, { san: san, side: number.endsWith("...") ? "black" : "white" })] }))] }));
+}
 /** 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 }) {
     const [, number = "", san = move] = /^(\d+\.+)(.+)$/.exec(move) ?? [];

package/dist/page/text.js

@@ -84,7 +84,15 @@ const english = {
     game: "The game",
     moves: "Moves",
     steps: { first: "Start", back: "Previous move", forward: "Next move", last: "Back to the game" },
-    variation: { line: "Variation", close: "Close the variation (Esc)", back: (move) => move === undefined ? "Back to the start of the game" : `Back to the game, at ${move}` },
+    variation: {
+        line: "Variation",
+        close: "Close the variation (Esc)",
+        back: (move) => move === undefined ? "Back to the start of the game" : `Back to the game, at ${move}`,
+        analyse: "Analyse",
+        analyseHint: (name) => `Ask ${name} to analyse this variation`,
+        analyseWords: "Analyse this variation",
+        show: (line) => `Show the variation ${line} on the board`,
+    },
     noGame: "No game yet: press + to start one, or ask for one in the chat.",
     foldCard: "Fold the card",
     openCard: "Open the card",
@@ -119,6 +127,7 @@ const english = {
         mated: (side) => `${side === "white" ? "White" : "Black"} is mated`,
     },
     reviewing: (name) => `${name} is going over the game…`,
+    stopReview: "Cancel the analysis",
     incomplete: "Analysis not complete",
     complete: "Complete it",
     completeHint: "Complete the analysis",
@@ -524,7 +533,15 @@ const italian = {
     game: "La partita",
     moves: "Mosse",
     steps: { first: "Inizio", back: "Mossa precedente", forward: "Mossa successiva", last: "Torna alla partita" },
-    variation: { line: "Variante", close: "Chiudi la variante (Esc)", back: (move) => move === undefined ? "Torna all'inizio della partita" : `Torna alla partita, a ${move}` },
+    variation: {
+        line: "Variante",
+        close: "Chiudi la variante (Esc)",
+        back: (move) => move === undefined ? "Torna all'inizio della partita" : `Torna alla partita, a ${move}`,
+        analyse: "Analizza",
+        analyseHint: (name) => `Chiedi a ${name} di analizzare questa variante`,
+        analyseWords: "Analizza questa variante",
+        show: (line) => `Rimetti sulla scacchiera la variante ${line}`,
+    },
     noGame: "Nessuna partita: premi + per iniziarne una, o chiedila nella chat.",
     foldCard: "Chiudi la scheda",
     openCard: "Apri la scheda",
@@ -559,6 +576,7 @@ const italian = {
         mated: (side) => `Matto al ${side === "white" ? "Bianco" : "Nero"}`,
     },
     reviewing: (name) => `${name} sta analizzando la partita…`,
+    stopReview: "Annulla l'analisi",
     incomplete: "Analisi non completa",
     complete: "Completa",
     completeHint: "Completa l'analisi",

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

@@ -11,6 +11,7 @@ export declare class Bell {
     private busy;
     private woken;
     private hooked;
+    private unheard;
     private stopWatch;
     private readonly news;
     private readonly changed;
@@ -25,6 +26,8 @@ export declare class Bell {
     get inTurn(): boolean;
     /** Whether the doorbell woke the chat in the turn it is in. */
     get woke(): boolean;
+    /** Whether the chat is out of its turn and hears nobody: its hook went without the bell, or it was stopped; until it calls a tool or a hook waits again. */
+    get deaf(): boolean;
     /** Whether the chat hears the player: in a turn, or waiting for the bell with a hook. */
     get listening(): boolean;
     /** The chat calls a tool, so it is in a turn: true when nobody was listening before. */
@@ -97,5 +100,5 @@ export type BellHeard = {
  * of its folder that serves its own page: the table is one more page to choose from, unless the ports to try are given (Priya).
  */
 export declare function bellHeard(input: string, ports?: number[]): Promise<BellHeard>;
-/** Adds a line to the log of the hooks that heard no bell, keeping its last lines; a log that cannot be written never stops the hook. */
-export declare function noteSilence(folder: string, why: string, now?: Date): void;
+/** Adds a line to the log of the doorbell's hooks, keeping its last lines; a log that cannot be written never stops the hook. */
+export declare function noteHook(folder: string, why: string, now?: Date): void;