chesspal 0.5.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

@@ -17,9 +17,10 @@ import { BadgeCounts } from "../game/badges.js";
 import { stepped } from "../game/browse.js";
 import { GameColumn } from "../game/column.js";
 import { howEnded, useDeclined, useJustEnded, useSawEnd } from "../game/ending.js";
-import { Steps } from "../game/move-list.js";
+import { Steps, stepsLine } from "../game/move-list.js";
 import { useOpeningBook } from "../game/opening-book.js";
 import { aiSpoke, aiWords, analysisTalk, judgmentsOf, playerSpent, playerWords, pliesOf, reviewCount, withBook, withJudgments, withoutReviews } from "../game/plies.js";
+import { afterMove, isJump, leaveLine, linePlies, lineRecord, onLine, stepLine } from "../game/variation.js";
 import { GuideDialog } from "../guide/guide.js";
 import { BareButton, HelpsCard, HintLine, MapButton } from "../helps/helps.js";
 import { helpsOf } from "../helps/view.js";
@@ -42,7 +43,7 @@ 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 { useBrowseKeys, useEscapeKey, useFoldKeys, useLegendKey, useMapKey, useWheelSteps } from "./keys.js";
 import { helpsShown, phaseOf, verdictOf } from "./phase.js";
 import { ask, post, refusedText, sendMessage, sendMove, useServed } from "./served.js";
 import { tabTitle, useTabTitle } from "./title.js";
@@ -72,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 = () => {
@@ -92,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.
@@ -169,7 +174,7 @@ export function App({ start }) {
     const playedAs = studied === undefined ? name : aiNameOf(aiHostIn(live.record), aiModelIn(live.record)?.model) ?? text.ai;
     const analyst = annotator === undefined ? name : aiNameOf(annotator.annotator, annotator.annotator) ?? text.ai;
     const material = useMemo(() => materialOf(live.position.fen), [live]);
-    const pieces = useMemo(() => piecesOf(live.position.fen), [live]);
+    const piecesOnBoard = useMemo(() => piecesOf(live.position.fen), [live]);
     // How many of the game's first plies a line of the book reaches, as the server counts them (D-68).
     const bookPlies = studied !== undefined ? studied.book : game?.book ?? 0;
     // While the game goes on, the book's first moves carry its badge, when the player wants it, as the AI's review gives it after (D-69).
@@ -203,13 +208,27 @@ export function App({ start }) {
     // The legend of the marks on the board, open until the player closes it (D-99).
     const [legendOpen, setLegendOpen] = useState(false);
     useLegendKey(() => setLegendOpen((open) => !open));
+    // In analysis the player plays a variation from the move shown, White's moves and Black's (D-116): one line, kept by the page alone, faded once the board
+    // is back on the game.
+    const [line, setLine] = useState(undefined);
+    const analysing = studied !== undefined;
+    const onTheLine = analysing && onLine(line);
     const past = useMemo(() => viewing === undefined ? undefined : new Game({ tags: live.record.tags, moves: live.record.moves.slice(0, viewing) }), [live, viewing]);
-    const next = useMemo(() => viewing === undefined ? undefined : new Game({ tags: live.record.tags, moves: live.record.moves.slice(0, viewing + 1) }).lastMove, [live, viewing]);
-    const shown = useMemo(() => past ?? (pending === undefined ? live : withMove(live, pending)), [live, pending, past]);
-    // A square lit from the AI's words goes off with the position: a touch keeps it lit until then, a mouse until it leaves the word.
-    useEffect(() => setPointed(noSquares), [shown]);
+    const lineGame = useMemo(() => onTheLine ? new Game(lineRecord(live.record, line)) : undefined, [live, onTheLine ? line : undefined]);
+    const shown = useMemo(() => lineGame ?? past ?? (pending === undefined ? live : withMove(live, pending)), [live, pending, past, lineGame]);
+    // The move after the position shown, which a step back slides home: the line's own on the line.
+    const next = useMemo(() => onTheLine ? shown.legalMoves().find((move) => move.san === line.moves[line.cursor]) : viewing === undefined ? undefined : new Game({ tags: live.record.tags, moves: live.record.moves.slice(0, viewing + 1) }).lastMove, [live, viewing, shown]);
+    // Where the line starts its numbers when it leaves from the game's first position.
+    const firstPosition = useMemo(() => new Game({ tags: live.record.tags, moves: [] }).position, [live]);
+    // A square lit from the AI's words goes off with the position: a touch keeps it lit until then, a mouse until it leaves the word; in analysis a refusal
+    // goes off with it too.
+    useEffect(() => {
+        setPointed(noSquares);
+        if (analysing) {
+            setRefusal(undefined);
+        }
+    }, [shown]);
     // The player sees all of Chesspal's facts, whatever the AI's level (D-79): in a game with the helps on, always in analysis (D-114).
-    const analysing = studied !== undefined;
     const helped = helpsShown(phase, settings.helps);
     // Seen from the player's side (D-91): theirs in a game, in analysis the side the game names theirs, none when it names neither.
     const you = analysing ? playerIn(studiedSides(live.record.tags, served?.profile.name ?? "", playedAs, text.sides, served?.profile.accounts)) : game?.ai === undefined ? undefined : game.ai === "white" ? "black" : "white";
@@ -225,6 +244,7 @@ export function App({ start }) {
         setPending(undefined);
         setViewing(undefined);
         setPromoting(undefined);
+        setLine(undefined);
     }, [gameKey]);
     const played = studied === undefined ? game : null;
     useGameSounds(played, replayed, sound);
@@ -252,16 +272,49 @@ export function App({ start }) {
     const shownOpening = useMemo(() => bookAt === undefined || book === undefined ? undefined : openingOf(bookAt, book), [live, book, bookAt === undefined ? 0 : at]);
     // Whether the move shown is still the book's, whatever the badges show: the card says the move the game left it at, once it is past it.
     const leftBook = outOfBookMove(at, bookPlies);
-    // A jump of more than one move shows the position at once: only a step slides its pieces.
-    const shownBefore = useRef(at);
-    const jumped = Math.abs(shownBefore.current - at) > 1;
-    shownBefore.current = at;
+    // A jump of more than one move shows the position at once: only a step slides its pieces, on the game or on a variation.
+    const place = { at, cursor: onTheLine ? line.cursor : 0 };
+    const shownBefore = useRef(place);
+    const jumped = isJump(shownBefore.current, place);
+    shownBefore.current = place;
+    // A move of the game shown takes the board off a variation, which stays faded.
     const goTo = (count) => {
         setSelected(undefined);
+        setLine(leaveLine);
         setViewing(count >= total ? undefined : Math.max(0, count));
     };
-    const step = (to) => goTo(stepped(to, at, total));
+    // On a variation the arrows back and forward step through it; to either end of the game they leave it.
+    const step = (to) => {
+        if (onTheLine && (to === "back" || to === "forward")) {
+            setSelected(undefined);
+            setLine(stepLine(line, to));
+        }
+        else {
+            goTo(stepped(to, at, total));
+        }
+    };
     useBrowseKeys(step, () => setFlipped(!flipped));
+    // A move of the variation shown: the board goes back on it, at the game's move it leaves from.
+    const showLine = (cursor) => {
+        if (line !== undefined) {
+            setSelected(undefined);
+            setLine({ ...line, cursor });
+            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);
+        setLine(undefined);
+    };
+    // Esc first lets go of a piece picked, and leaves the legend, a promotion's choice, the settings and the dialogs to close themselves.
+    useEscapeKey(line === undefined || legendOpen || promoting !== undefined || setting || dialog !== undefined ? undefined : () => selected === undefined ? closeLine() : setSelected(undefined));
     const wheel = useWheelSteps(step);
     // The move shown stays in the page's address, for a reload and a link to it; after the reset on a new game, which would undo the move it goes to. A
     // game a link opens is there to look at: the analyst starts on the player's yes alone (D-89; Zoe and Federico).
@@ -269,7 +322,8 @@ export function App({ start }) {
     useAnchor({ ready: served !== undefined, shown: studied !== undefined ? anchorName(studied.name) : idle ? undefined : playedName, played: playedName, going }, viewing, (plies) => goTo(plies ?? total), async (wanted) => await post("/api/study", { game: wanted, look: true }, text, name) === undefined, setLinkIgnored);
     // The tab names the game and the move shown, as the cards name its players; between games, Chesspal alone.
     const titled = idle || served === undefined ? undefined : studiedSides(live.record.tags, served.profile.name, playedAs, text.sides, served.profile.accounts, othersOf(served.profiles, served.profile.id));
-    useTabTitle(titled === undefined ? undefined : tabTitle(titled.white.name, titled.black.name, at === 0 ? undefined : plies[at - 1]));
+    const lineNumbered = line === undefined ? undefined : linePlies(line, lineStartOf(plies, line.at, firstPosition));
+    useTabTitle(titled === undefined ? undefined : onTheLine ? tabTitle(titled.white.name, titled.black.name, lineNumbered?.[line.cursor - 1], true) : tabTitle(titled.white.name, titled.black.name, at === 0 ? undefined : plies[at - 1]));
     // The header's theme switch picks the other of the two the page shows, leaving the system's.
     const switchTheme = () => change({ ...settings, theme: document.documentElement.dataset.theme === "dark" ? "light" : "dark" });
     // An action of the player's on the game: the game the server sends next shows it; a refusal shows on the board.
@@ -322,7 +376,8 @@ export function App({ start }) {
     const mood = moodAt(live.record, sides?.white.who === "ai" ? "white" : sides?.black.who === "ai" ? "black" : ai, at).mood;
     const playerToMove = going && live.position.turn === player;
     const ahead = (side) => side === "white" ? material.balance : -material.balance;
-    const reviewed = judged || at <= inBook ? plies[at - 1] : undefined;
+    // On a variation the AI's badges, notes and drawings say nothing: they are of the game's moves (D-116).
+    const reviewed = onTheLine ? undefined : judged || at <= inBook ? plies[at - 1] : undefined;
     // With the helps on, the coach's judgments of the player's last move, once the AI has answered it, and of one a held note let go only now (D-78, D-88).
     const judgments = going && settings.helps ? judgmentsOf(plies, player, coached ?? noCoach) : [];
     const review = reviewed?.review;
@@ -330,7 +385,7 @@ export function App({ start }) {
     const drawn = hintOpen && hint !== undefined && viewing === undefined && (hint.arrows !== undefined || hint.squares !== undefined) ? hint : review;
     const drawnByCoach = hint !== undefined && drawn === hint;
     // The game over, when this is its last position: the kings' signs, on the board and in the legend.
-    const boardEnd = ended && !aborted && viewing === undefined && pending === undefined ? { how, winner, player, fresh: justEnded } : undefined;
+    const boardEnd = ended && !aborted && viewing === undefined && pending === undefined && !onTheLine ? { how, winner, player, fresh: justEnded } : undefined;
     // The legend has the marks the board shows: none of the helps' or the drawings while the board is bare (D-99).
     const shownBare = bare && helps !== undefined;
     const legendRows = legendOf({
@@ -349,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;
@@ -397,7 +454,7 @@ export function App({ start }) {
     const play = (from, to, piece) => {
         setSelected(undefined);
         setRefusal(undefined);
-        if (piece === undefined && promotes(pieces.get(from), to)) {
+        if (piece === undefined && promotes(piecesOnBoard.get(from), to)) {
             setPromoting({ from, to });
             return;
         }
@@ -416,9 +473,35 @@ export function App({ start }) {
             }
         });
     };
-    // A move the board refuses says why, without the AI (D-18), unless the player turned it off: the piece goes back, the reason over it.
+    // In analysis the player moves from the position shown, White's pieces and Black's, and a variation grows (D-116); the game's own next move only steps
+    // forward through it. The move sounds as the board stands after it.
+    const explore = (from, to, piece) => {
+        setSelected(undefined);
+        setRefusal(undefined);
+        if (piece === undefined && promotes(piecesOf(shown.position.fen).get(from), to)) {
+            setPromoting({ from, to });
+            return;
+        }
+        setPromoting(undefined);
+        const move = shown.legalMoves(from).find((legal) => legal.to === to && legal.promotion === piece);
+        if (move === undefined) {
+            return;
+        }
+        const after = afterMove(line, live.record.moves.map(({ san }) => san), at, move.san);
+        setLine(after.line);
+        setViewing(after.shown >= total ? undefined : after.shown);
+        const played = new Game(shown.record);
+        const moveSound = played.play(move.san).played && sound ? soundOf(played) : undefined;
+        if (moveSound !== undefined) {
+            playSound(moveSound);
+        }
+    };
+    // A move the board refuses says why, without the AI (D-18), unless the player turned it off: the piece goes back, the reason over it. In analysis, from
+    // the position shown.
     const refuse = (from, to) => {
-        const illegal = settings.explain ? live.whyNot(from, to) : undefined;
+        const board = analysing ? shown : live;
+        const pieces = analysing ? piecesOf(shown.position.fen) : piecesOnBoard;
+        const illegal = settings.explain ? board.whyNot(from, to) : undefined;
         if (illegal !== undefined) {
             const letterOn = (square) => pieces.get(square).toUpperCase();
             const sideOn = (square) => pieces.get(square) === letterOn(square) ? "white" : "black";
@@ -428,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).
@@ -453,6 +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),
+            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) => {
@@ -465,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) })
@@ -474,10 +580,10 @@ export function App({ start }) {
                         : 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, served.profiles, 40, mood), you: sides[player].name, picture: pictureOf(sides[player], profile, served.profiles, 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 } : {}), ...(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) => {
+                                ? (_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) => {
@@ -485,19 +591,27 @@ export function App({ start }) {
                                                         setUnsent(undefined);
                                                     }, 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 variation rings the board in the accent (D-116).
+                            class: between && !justEnded ? "board-wrap off" : onTheLine ? "board-wrap variation" : "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 ? undefined : refusal ?? (linkIgnored === undefined ? undefined : { text: text.link[linkIgnored] }), 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)
+                            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: analysing ? (shown.outcome.over ? undefined : shown.position.turn) : playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined ? [] : analysing ? shown.legalMoves(selected) : viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing !== undefined && !analysing ? undefined : refusal ?? (linkIgnored === undefined ? undefined : { text: text.link[linkIgnored] }), promotion: promoting === undefined
+                                        ? undefined
+                                        : analysing
+                                            ? { ...promoting, side: shown.position.turn }
+                                            : viewing !== undefined || !playerToMove
+                                                ? undefined
+                                                : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : (analysing ? explore : play)(promoting.from, promoting.to, piece), onSelect: select, onMove: analysing ? explore : play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleepNote !== null || clockWaits)
                                     ? (_jsxs("div", { class: "over-board", children: [asleepNote, startClocks] }))
-                                    : null] }), studied === undefined ? null : (_jsxs("div", { class: "board-steps", children: [_jsx(Steps, { shown: at, total: total, onStep: step, text: text }), standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: at, onShow: goTo, 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, ...(leftBook === undefined ? {} : { outOfBook: leftBook }), 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 ? {} : {
+                                    : null] }), studied === undefined ? null : (_jsxs("div", { class: "board-steps", children: [_jsx(Steps, { shown: at, total: total, ...stepsLine(lineView, plies), onStep: step, text: text }), standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: at, onShow: goTo, 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, ...(leftBook === undefined ? {} : { outOfBook: leftBook }), 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 } : {}),
                                     ...(count === undefined ? {} : { count }),
+                                    ...(stopIt === undefined ? {} : { onStop: stopIt }),
                                     ...(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 })] })] }) }));
+                            }), 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 })] })] }) }));
 }
 /** The picture of a player of the game in analysis: the player's own, the AI's Torretta with its mood, another profile's, or the plain face of someone else. */
 function pictureOf({ who, profile: other }, profile, profiles, size, mood) {
@@ -580,6 +694,11 @@ function withMove(game, move) {
     const copy = new Game(game.record);
     return copy.play(move).played ? copy : game;
 }
+/** Where a variation that leaves the game after `at` moves starts its numbers: after the game's move there, or from the game's first position. */
+function lineStartOf(plies, at, first) {
+    const fork = plies[at - 1];
+    return fork === undefined ? first : fork.side === "white" ? { moveNumber: fork.number, turn: "black" } : { moveNumber: fork.number + 1, turn: "white" };
+}
 /** Whether a pawn's move takes it to the last rank, where the player chooses what it becomes. */
 function promotes(piece, to) {
     return (piece === "P" && to.endsWith("8")) || (piece === "p" && to.endsWith("1"));

package/dist/page/app/keys.js

@@ -1,5 +1,5 @@
 // The page's keys and wheel: [ and ] fold the side columns, M holds the helps' map (D-78), ? opens the legend (D-99), the arrows, Home and End step
-// through the moves and f and x turn the board, and the wheel over the board steps too.
+// through the moves and f and x turn the board, Esc closes a variation, and the wheel over the board steps too.
 import { useEffect, useRef } from "preact/hooks";
 import { flipKeys, stepKeys } from "../game/browse.js";
 import { foldKeys, gameUnderBoard, oneColumn } from "../layout/folds.js";
@@ -87,6 +87,21 @@ export function useBrowseKeys(step, flip) {
         return () => window.removeEventListener("keydown", press);
     });
 }
+/** Esc closes what `close` closes, a variation in analysis (D-116), when nothing else on the page takes it: none while it is undefined. */
+export function useEscapeKey(close) {
+    useEffect(() => {
+        if (close === undefined) {
+            return;
+        }
+        const press = (event) => {
+            if (event.key === "Escape" && forThePage(event)) {
+                close();
+            }
+        };
+        window.addEventListener("keydown", press);
+        return () => window.removeEventListener("keydown", press);
+    });
+}
 /** The mouse wheel over the board steps through the moves, as on Lichess: down forward, a step a notch, however finely a touchpad turns it. */
 export function useWheelSteps(step) {
     const turned = useRef(0);

package/dist/page/app/title.js

@@ -1,10 +1,13 @@
 // The tab's title names the game and the move shown, Stefano – Claude, 16. ♞f3, so that the player's bookmarks and tabs tell its games apart.
 import { useEffect } from "preact/hooks";
 import { figurinesOf } from "../../core/index.js";
-/** The title of a game: its players by their first names, White first, so that the move fits in a tab (Zoe), and the move shown with its number, none before the first. */
-export function tabTitle(white, black, shown) {
+/**
+ * The title of a game: its players by their first names, White first, so that the move fits in a tab (Zoe), and the move shown with its number, none before
+ * the first; a move of a variation in analysis after its fork, ⑂ (D-116).
+ */
+export function tabTitle(white, black, shown, line = false) {
     const players = `${firstName(white)} – ${firstName(black)}`;
-    return shown === undefined ? players : `${players}, ${shown.number}${shown.side === "white" ? "." : "..."} ${figurinesOf(shown.san)}`;
+    return shown === undefined ? players : `${players}, ${line ? "⑂ " : ""}${shown.number}${shown.side === "white" ? "." : "..."} ${figurinesOf(shown.san)}`;
 }
 /** Keeps the tab's title, Chesspal's name while no game shows. */
 export function useTabTitle(title) {

package/dist/page/board/board.css

@@ -960,3 +960,9 @@
         transition: opacity 400ms ease, --kept 400ms ease;
     }
 }
+
+/* A variation in analysis rings the board in the accent, just outside its edge, on the page, where every skin leaves it in sight: nothing else changes (D-116) */
+.board-wrap.variation > .board {
+    outline: 3px solid var(--accent);
+    outline-offset: 2px;
+}