chesspal 0.2.3 → 0.2.4

package/dist/games/analysis.js

@@ -3,23 +3,27 @@
 import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { writeAtomically } from "./files.js";
-/** Names the game in analysis, over the one before; written again each time its review changes, so the page hears of it. */
-export function startAnalysis(folder, game, now, brought = false) {
-    writeAtomically(join(folder, fileName), `${JSON.stringify({ game, at: now.toISOString(), ...(brought ? { brought } : {}) }, null, 2)}\n`);
+/** Names the game in analysis, over the one before; written again each time its review changes, so the page hears of it. The same game keeps its corrections. */
+export function startAnalysis(folder, game, now, brought = false, corrected = []) {
+    const before = gameInAnalysis(folder);
+    const kept = [...new Set([...(before?.game === game ? before.corrected ?? [] : []), ...corrected])];
+    const analysis = { game, at: now.toISOString(), ...(brought ? { brought } : {}), ...(kept.length === 0 ? {} : { corrected: kept }) };
+    writeAtomically(join(folder, fileName), `${JSON.stringify(analysis, null, 2)}\n`);
 }
 /** The game in analysis, or none when there is none, or analysis.json cannot be read. */
 export function gameInAnalysis(folder) {
     try {
         const analysis = JSON.parse(readFileSync(join(folder, fileName), "utf8"));
+        const corrected = Array.isArray(analysis.corrected) ? analysis.corrected.filter((move) => typeof move === "string") : [];
         return typeof analysis.game === "string" && typeof analysis.at === "string"
-            ? { game: analysis.game, at: analysis.at, ...(analysis.brought === true ? { brought: true } : {}) }
+            ? { game: analysis.game, at: analysis.at, ...(analysis.brought === true ? { brought: true } : {}), ...(corrected.length === 0 ? {} : { corrected }) }
             : undefined;
     }
     catch {
         return undefined;
     }
 }
-/** Ends the analysis, when a new game starts. */
+/** 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/current-game.d.ts

@@ -16,13 +16,23 @@ export interface CurrentGame {
 }
 /** Who speaks on the board page. */
 export type Speaker = "player" | "ai";
-/** A line said on the board page: who said it, its words, how many moves the game had then, and when, as an ISO date; the AI's agent on the player's time (D-72). */
+/**
+ * A line said on the board page: who said it, its words, how many moves the game had then, and when, as an ISO date; the AI's agent on the player's time
+ * (D-72); in analysis, the position the page showed as the player wrote (D-101).
+ */
 export interface TalkLine {
     readonly who: Speaker;
     readonly text: string;
     readonly ply: number;
     readonly at: string;
     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. */
+export interface Shown {
+    readonly game: string;
+    readonly at: number;
+    readonly move?: string;
 }
 /** How a game ended: its result, and why when the record says it or the board decided it. */
 export interface GameEnd {
@@ -53,4 +63,9 @@ export declare const savedLine: z.ZodObject<{
     ply: z.ZodInt;
     at: z.ZodISODateTime;
     agent: z.ZodOptional<z.ZodLiteral<true>>;
+    shown: z.ZodOptional<z.ZodObject<{
+        game: z.ZodString;
+        at: z.ZodInt;
+        move: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/games/current-game.js

@@ -1,10 +1,10 @@
 // The player's current game on disk (D-27, D-41): game.json, its PGN and the talk on the board page inside, written whole at every change, and kept in
 // memory while nobody else changes it.
-import { readFileSync, rmSync, statSync } from "node:fs";
+import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { Game, readPgn, writePgn } from "../core/index.js";
-import { writeAtomically } from "./files.js";
+import { stampOf, writeAtomically } from "./files.js";
 /** The current game of a folder, as it is on disk, or undefined when there is none. A game.json Chesspal cannot read throws: nothing overwrites it. */
 export function loadGame(folder) {
     const path = join(folder, fileName);
@@ -73,7 +73,14 @@ export function removeGame(folder) {
 }
 const fileName = "game.json";
 /** A line of the talk as game.json and talk.json keep it. */
-export const savedLine = z.object({ who: z.enum(["player", "ai"]), text: z.string(), ply: z.int().min(0), at: z.iso.datetime(), agent: z.literal(true).optional() });
+export const savedLine = z.object({
+    who: z.enum(["player", "ai"]),
+    text: z.string(),
+    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(),
+});
 const savedClock = z.object({
     base: z.int().positive(),
     increment: z.int().min(0),
@@ -93,11 +100,6 @@ const gameFile = z.object({
 });
 // The games read or written in this process, by their file, with the file's stamp then: a call reads a file again only when another process changed it.
 const kept = new Map();
-function stampOf(path) {
-    // The file's id changes at every rename: a write within the same tick of the clock, and of the same size, is seen too.
-    const stats = statSync(path, { bigint: true, throwIfNoEntry: false });
-    return stats === undefined ? undefined : `${stats.ino}:${stats.mtimeNs}:${stats.size}`;
-}
 function parsed(text, path) {
     try {
         const file = gameFile.parse(JSON.parse(text));

package/dist/games/files.d.ts

@@ -2,6 +2,8 @@
 export declare function writeAtomically(path: string, text: string | Uint8Array): void;
 /** Makes a folder, and those above it, when missing. A failure says what to do about it. */
 export declare function makeFolder(path: string): void;
+/** A stamp of a file that changes whenever it is written, whoever writes it; undefined when there is none. */
+export declare function stampOf(path: string): string | undefined;
 /**
  * Renames a file or a folder. Windows refuses while another program holds a file in it open (an editor, an antivirus, a sync client): Chesspal waits a
  * little and tries again, half a second at most.

package/dist/games/files.js

@@ -1,5 +1,5 @@
 // Writing the player's files safely: whole or not at all, with failures that say what to do (D-27).
-import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 /** Writes a file whole or not at all: a temporary file beside it, then renamed over it (D-27). A failure says what to do about it. */
 export function writeAtomically(path, text) {
     const temporary = `${path}.${process.pid}.tmp`;
@@ -23,6 +23,12 @@ export function makeFolder(path) {
         throw new Error(`${path} could not be made (${error.message}): check that it is a folder, and can be written.`, { cause: error });
     }
 }
+/** A stamp of a file that changes whenever it is written, whoever writes it; undefined when there is none. */
+export function stampOf(path) {
+    // The file's id changes at every rename: a write within the same tick of the clock, and of the same size, is seen too.
+    const stats = statSync(path, { bigint: true, throwIfNoEntry: false });
+    return stats === undefined ? undefined : `${stats.ino}:${stats.mtimeNs}:${stats.size}`;
+}
 const attempts = 10;
 /**
  * Renames a file or a folder. Windows refuses while another program holds a file in it open (an editor, an antivirus, a sync client): Chesspal waits a

package/dist/games/index.d.ts

@@ -3,9 +3,9 @@ export { type Analysis, endAnalysis, gameInAnalysis, startAnalysis } from "./ana
 export { archiveCoached, archivedGame, archivedGames, archivedName, archivedWhen, archiveEnded, archiveGame, archiveName, deleteGame, gameStemOf, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, 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, type GameEnd, gameStamp, loadGame, removeGame, saveGame, type Speaker, type TalkLine } from "./current-game.ts";
+export { bothSidesMoved, type CurrentGame, drawOfferOf, endOf, type GameEnd, gameStamp, loadGame, removeGame, saveGame, type Shown, type Speaker, type TalkLine } from "./current-game.ts";
 export { makeFolder, renameOver, writeAtomically } from "./files.ts";
 export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.ts";
-export { endTableTalk, loadTableTalk, saveTableTalk, type TableTalk } from "./table-talk.ts";
+export { endTableTalk, loadTableTalk, saveTableTalk, type TableTalk, tableTalkStamp } from "./table-talk.ts";
 export { type Heard, heardLines, type Sayer, type Talk, talkLimits, talkLine, unheardWords, wakesTheChat, type Words, WordsRefused } from "./talk.ts";
 export { keepThought, notePondering, ponderingOn, type Thought, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.ts";

package/dist/games/index.js

@@ -7,6 +7,6 @@ export { coachShown, coachStarted, coachWaitingSince, coachWords, forgetCoach, k
 export { bothSidesMoved, drawOfferOf, endOf, gameStamp, loadGame, removeGame, saveGame } from "./current-game.js";
 export { makeFolder, renameOver, writeAtomically } from "./files.js";
 export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.js";
-export { endTableTalk, loadTableTalk, saveTableTalk } from "./table-talk.js";
+export { endTableTalk, loadTableTalk, saveTableTalk, tableTalkStamp } from "./table-talk.js";
 export { heardLines, talkLimits, talkLine, unheardWords, wakesTheChat, WordsRefused } from "./talk.js";
 export { keepThought, notePondering, ponderingOn, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.js";

package/dist/games/table-talk.d.ts

@@ -8,5 +8,7 @@ export interface TableTalk {
 export declare function loadTableTalk(folder: string): TableTalk;
 /** Writes the talk with no game, whole or not at all. */
 export declare function saveTableTalk(folder: string, table: TableTalk): void;
+/** A stamp of talk.json that changes whenever it is written; undefined when there is none. */
+export declare function tableTalkStamp(folder: string): string | undefined;
 /** Forgets the talk with no game, when a game starts. */
 export declare function endTableTalk(folder: string): void;

package/dist/games/table-talk.js

@@ -3,7 +3,7 @@ import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { savedLine } from "./current-game.js";
-import { writeAtomically } from "./files.js";
+import { stampOf, writeAtomically } from "./files.js";
 /** The talk with no game: empty when there is none, or talk.json cannot be read, since it is only words. */
 export function loadTableTalk(folder) {
     try {
@@ -17,6 +17,10 @@ export function loadTableTalk(folder) {
 export function saveTableTalk(folder, table) {
     writeAtomically(join(folder, fileName), `${JSON.stringify(table, null, 2)}\n`);
 }
+/** A stamp of talk.json that changes whenever it is written; undefined when there is none. */
+export function tableTalkStamp(folder) {
+    return stampOf(join(folder, fileName));
+}
 /** Forgets the talk with no game, when a game starts. */
 export function endTableTalk(folder) {
     rmSync(join(folder, fileName), { force: true });

package/dist/games/talk.d.ts

@@ -1,4 +1,4 @@
-import { type CurrentGame, type Speaker, type TalkLine } from "./current-game.ts";
+import { type CurrentGame, type Shown, type Speaker, type TalkLine } from "./current-game.ts";
 import type { TableTalk } from "./table-talk.ts";
 /** The most the player may write in a move, in all their lines, and the most a line of the AI's may hold (D-54); with the helps on, as an analyst's note (D-78). */
 export declare const talkLimits: {
@@ -14,7 +14,7 @@ export type Talk = CurrentGame | TableTalk;
  * A new line of the talk, said when the game has `ply` moves: refused when it is empty or too long. The player writes 200 characters a move in all, the
  * words sent with the move included; the AI speaks once a move of theirs, on their time, and its agent's word leaves it an answer to what they write after (D-54, D-72).
  */
-export declare function talkLine(current: Talk, sayer: Sayer, text: string, at: Date, ply?: number, aiMost?: number): TalkLine;
+export declare function talkLine(current: Talk, sayer: Sayer, text: string, at: Date, ply?: number, aiMost?: number, shown?: Shown): TalkLine;
 /** Words refused, and why, for the page to say it in the player's language: none, the move's characters spent, more than a line or what is left holds. */
 export declare class WordsRefused extends Error {
     readonly reason: "empty" | "spent" | "long" | "longer-than-left";
@@ -23,10 +23,11 @@ export declare class WordsRefused extends Error {
 }
 /** Whether the player's last line wakes the chat: the first of a move, and between games the first since the AI last spoke (D-54, D-74). */
 export declare function wakesTheChat(current: Talk): boolean;
-/** Words of the player's, with the key that tells them apart across games. */
+/** Words of the player's, with the key that tells them apart across games, and in analysis the position the page showed (D-101). */
 export interface Words {
     readonly key: string;
     readonly text: string;
+    readonly shown?: Shown;
 }
 /** What the player said that the AI has not answered, but for the words whose keys are in `given`. */
 export declare function unheardWords(current: Talk, given: ReadonlySet<string>): Words[];

package/dist/games/talk.js

@@ -6,7 +6,7 @@ export const talkLimits = { player: 200, ai: 300, aiHelps: 700 };
  * A new line of the talk, said when the game has `ply` moves: refused when it is empty or too long. The player writes 200 characters a move in all, the
  * words sent with the move included; the AI speaks once a move of theirs, on their time, and its agent's word leaves it an answer to what they write after (D-54, D-72).
  */
-export function talkLine(current, sayer, text, at, ply = isGame(current) ? current.game.record.moves.length : 0, aiMost = talkLimits.ai) {
+export function talkLine(current, sayer, text, at, ply = isGame(current) ? current.game.record.moves.length : 0, aiMost = talkLimits.ai, shown) {
     const who = sayer === "agent" ? "ai" : sayer;
     const words = text.trim();
     const most = who === "player" ? wordsLeft(current) : aiMost;
@@ -23,7 +23,7 @@ export function talkLine(current, sayer, text, at, ply = isGame(current) ? curre
     if (who === "ai" && isGame(current)) {
         refuseAiWords(current, sayer === "agent");
     }
-    return { who, text: words, ply, at: at.toISOString(), ...(sayer === "agent" ? { agent: true } : {}) };
+    return { who, text: words, ply, at: at.toISOString(), ...(sayer === "agent" ? { agent: true } : {}), ...(shown === undefined ? {} : { shown }) };
 }
 /** Words refused, and why, for the page to say it in the player's language: none, the move's characters spent, more than a line or what is left holds. */
 export class WordsRefused extends Error {
@@ -41,7 +41,7 @@ export function wakesTheChat(current) {
 }
 /** What the player said that the AI has not answered, but for the words whose keys are in `given`. */
 export function unheardWords(current, given) {
-    return unanswered(current).filter(({ key }) => !given.has(key)).map(({ key, line }) => ({ key, text: line.text }));
+    return unanswered(current).filter(({ key }) => !given.has(key)).map(({ key, line }) => ({ key, text: line.text, ...(line.shown === undefined ? {} : { shown: line.shown }) }));
 }
 /** How far each line of the talk got: the player's by `Heard`, the AI's undefined (D-53). */
 export function heardLines(current, given) {

package/dist/page/app/app.js

@@ -6,6 +6,7 @@ import { Thinker, Thought } from "../avatars/thought.js";
 import { Torretta } from "../avatars/torretta.js";
 import { Board } from "../board/board.js";
 import { explain } from "../board/explain.js";
+import { kingSigns } from "../board/signs.js";
 import { piecesOf } from "../board/squares.js";
 import { NewGameDialog } from "../dialogs/new-game.js";
 import { NameButton, PictureButton, PictureDialog, ProfilesDialog, Wizard } from "../dialogs/profiles.js";
@@ -18,13 +19,15 @@ import { GameColumn } from "../game/column.js";
 import { howEnded, useDeclined, useJustEnded, useSawEnd } from "../game/ending.js";
 import { Steps } from "../game/move-list.js";
 import { useOpeningBook } from "../game/opening-book.js";
-import { aiSpoke, aiWords, judgmentsOf, playerSpent, playerWords, pliesOf, withBook, withJudgments, withoutReviews } from "../game/plies.js";
+import { aiSpoke, aiWords, analysisTalk, judgmentsOf, playerSpent, playerWords, pliesOf, withBook, withJudgments, withoutReviews } from "../game/plies.js";
 import { BareButton, HelpsCard, HintLine, MapButton } from "../helps/helps.js";
 import { helpsOf } from "../helps/view.js";
 import { FoldTab } from "../layout/fold-tab.js";
 import { nextFold, rememberFold, startFolds } from "../layout/folds.js";
 import { Header } from "../layout/header.js";
 import { standingsOf } from "../lead/view.js";
+import { MarksLegend } from "../legend/legend.js";
+import { legendOf } from "../legend/view.js";
 import { ChosenSet } from "../pieces/pieces.js";
 import { ClockFace, PlayerCard } from "../players/card.js";
 import { signature } from "../players/model-name.js";
@@ -34,7 +37,7 @@ import { endSoundOf, playSound, soundOf, wakeSounds } from "../sounds/sounds.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, useMapKey, useWheelSteps } from "./keys.js";
+import { useBrowseKeys, useFoldKeys, useLegendKey, useMapKey, useWheelSteps } from "./keys.js";
 import { phaseOf, verdictOf } from "./phase.js";
 import { post, sendMessage, sendMove, useServed } from "./served.js";
 /**
@@ -135,6 +138,9 @@ export function App({ start }) {
     const [mapping, setMapping] = useState(false);
     // The board without its drawings while their button is held (Stefano).
     const [bare, setBare] = useState(false);
+    // 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));
     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]);
@@ -253,6 +259,22 @@ export function App({ start }) {
     const review = reviewed?.review;
     // An open hint draws on the board as it is, in place of the last move's drawings.
     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 && viewing === undefined && pending === undefined ? { 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({
+        ...(review?.badge === undefined || shown.lastMove === undefined ? {} : { badge: { badge: review.badge, square: shown.lastMove.to } }),
+        ...(helps === undefined || shownBare ? {} : { helps }),
+        ...(drawn === undefined || shownBare ? {} : { drawn }),
+        control: mapping && helps !== undefined,
+        ...(boardEnd === undefined ? {} : { ends: kingSigns(piecesOf(shown.position.fen), shown.position.turn, boardEnd) }),
+    });
+    // In a game the coach draws on the player's moves, the AI on its own.
+    const drawer = drawnByCoach || (going && reviewed?.side === player) ? text.legend.drawnByCoach : text.legend.drawnBy(analyst);
+    const legendAt = (under) => (_jsx(MarksLegend, { rows: legendRows, open: legendOpen, onOpen: setLegendOpen, drawn: { words: drawnByCoach ? text.helpsCard.drawn : text.drawn, by: drawer }, onPoint: setPointed, under: under, text: text }));
+    const legend = legendAt(false);
     const summary = studied === undefined ? undefined : gameReviewOf(live.record);
     const closing = studied === undefined ? undefined : closingOf(live.record);
     // In analysis the AI's card says who played that game, as its PGN keeps it (D-82), not who plays now.
@@ -270,7 +292,7 @@ export function App({ start }) {
     const clockWaits = clock?.waiting === true && !ended && studied === undefined && viewing === undefined && live.position.turn === ai;
     const clockOf = (side) => clock === undefined ? undefined : (_jsx(ClockFace, { clock: clock, side: side, toMove: !ended && live.position.turn === side, held: pending !== undefined || (asleep && side === ai), onFlag: reload, text: text }));
     // Where to wake the chat, under the AI's card (over the board when the talk is folded); the button that starts the clocks, under the player's (Zoe).
-    const asleepNote = asleep ? _jsx("p", { class: "asleep", role: "status", children: text.asleep(name) }) : null;
+    const asleepNote = asleep ? _jsx("p", { class: "asleep", role: "status", children: sides === undefined ? text.asleep(name) : text.asleepInAnalysis(name) }) : null;
     const startClocks = clockWaits
         ? (_jsxs("button", { type: "button", class: "command primary start-clocks", onClick: () => act("/api/start", {}), children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M8 5.5v13l10.5-6.5z" }) }), text.startClocks] }))
         : null;
@@ -322,7 +344,8 @@ export function App({ start }) {
             setRefusal({ text: words, square: from, piece: pieces.get(from), explanation: explain(illegal, to, king) });
         }
     };
-    const sendWords = () => {
+    // In analysis the words go with the game and the move shown (D-101).
+    const sendWords = (shown) => {
         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).
         if (isCommand(words)) {
@@ -330,7 +353,7 @@ export function App({ start }) {
             return;
         }
         setUnsent(undefined);
-        void sendMessage(words, text, name).then((refused) => {
+        void sendMessage(words, text, name, shown).then((refused) => {
             setUnsent(refused?.text);
             clearSent(refused?.text, words);
         });
@@ -344,9 +367,7 @@ export function App({ start }) {
         setDialog(undefined);
         act("/api/new", { ai_colour: colour === "random" ? "random" : colour === "white" ? "black" : "white", level: chosen, ...(control === undefined ? {} : { clock: control }) });
     };
-    // In analysis the AI's note stays under the card on top and its word on the game over the one below, however the board is turned (D-69).
-    const top = flipped ? player : ai;
-    const bottom = flipped ? ai : player;
+    // In analysis the AI's note goes with the other side's card and the talk with the player's, turned round with the board as in a game (D-101, Zoe).
     const studiedCard = (side, place) => sides === undefined ? null : (_jsx(PlayerCard, { place: place, 
         // The player changes their picture in analysis too, from their own side's card.
         picture: sides[side].who === "player" ? _jsx(PictureButton, { profile: profile, onOpen: () => setDialog("picture"), text: text }) : pictureOf(sides[side], profile, 48, mood), name: sides[side].name, signed: sides[side].who === "ai" && playedBy !== undefined ? signature(playedBy.model, playedBy.effort) : undefined, side: side, taken: material.taken[side], ahead: ahead(side), badges: _jsx(BadgeCounts, { plies: plies, side: side, names: text.badges }), text: text }));
@@ -360,8 +381,11 @@ export function App({ start }) {
     };
     return (_jsx(ChosenSet.Provider, { value: settings.set, children: _jsxs(PointSquare.Provider, { value: pointSquare, children: [panel, _jsx(PictureDialog, { open: dialog === "picture", 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, onClose: () => setDialog(undefined), text: text }), _jsx(NewGameDialog, { open: dialog === "new-game", choice: choice, going: going, onStart: startNewGame, onClose: () => setDialog(undefined), text: text }), _jsx(StudyDialog, { open: dialog === "study", onStudy: studyGame, onClose: () => setDialog(undefined), you: profile.name, accounts: profile.accounts, ai: name, text: text }), offline ? _jsx("p", { class: "offline", role: "alert", children: text.offline(name) }) : null, served.outdated === true ? _jsx("p", { class: "outdated", role: "status", children: text.outdated(name) }) : null, _jsxs("main", { class: `app${flipped ? " flipped" : ""}${folds.talk === "open" ? "" : ` talk-${folds.talk}`}${folds.game === "folded" ? " folded" : ""}`, inert: offline, children: [header, sides === undefined
                             ? (_jsx(TalkFaces, { name: name, aiPicture: thinker(40), you: profile.name, picture: picture, ...(idle ? {} : { ai, player }), aiMoves: going && !playerToMove, playerMoves: playerToMove, unread: unread || asleep, text: text }))
-                            : (_jsx(TalkFaces, { name: sides[ai].name, aiPicture: pictureOf(sides[ai], profile, 40, mood), you: sides[player].name, picture: pictureOf(sides[player], profile, 40, mood), ai: ai, player: player, aiMoves: false, playerMoves: false, unread: asleep, text: text })), _jsx(FoldTab, { column: "talk", folded: folds.talk === "folded", label: thinking === undefined || folds.talk !== "folded" ? text.talk : `${text.talk}: ${text.thinking[thinking]}`, unread: (unread || asleep) && folds.talk === "folded", ...(thinking === undefined || folds.talk !== "folded" ? {} : { mark: _jsx(Thought, { thinking: thinking, words: text.thinking }) }), onFold: fold }), _jsx(FoldTab, { column: "game", folded: folds.game === "folded", label: text.game, onFold: fold }), _jsx("span", { class: "visually-hidden", "aria-live": "polite", children: unread ? text.wrote(name) : "" }), _jsx("div", { class: sides === undefined ? "talk" : "talk studied", id: "talk", children: sides !== undefined
-                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[top].name, children: [studiedCard(top, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(summary === undefined ? { reviewing: true } : {}), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text.language } : {}), text: text })] }), _jsx("section", { class: "you-block", "aria-label": sides[bottom].name, children: studiedCard(bottom, "you") })] }))
+                            : (_jsx(TalkFaces, { name: sides[ai].name, aiPicture: pictureOf(sides[ai], profile, 40, mood), you: sides[player].name, picture: pictureOf(sides[player], profile, 40, mood), ai: ai, player: player, aiMoves: false, playerMoves: false, unread: asleep, text: text })), _jsx(FoldTab, { column: "talk", folded: folds.talk === "folded", label: thinking === undefined || folds.talk !== "folded" ? text.talk : `${text.talk}: ${text.thinking[thinking]}`, unread: (unread || asleep) && folds.talk === "folded", ...(thinking === undefined || folds.talk !== "folded" ? {} : { mark: _jsx(Thought, { thinking: thinking, words: text.thinking }) }), onFold: fold }), _jsx(FoldTab, { column: "game", folded: folds.game === "folded", label: text.game, onFold: fold }), _jsx("span", { class: "visually-hidden", "aria-live": "polite", children: unread ? text.wrote(name) : "" }), _jsx("div", { class: sides === undefined ? "talk" : "talk studied", id: "talk", children: sides !== undefined && studied !== undefined
+                                ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(summary === undefined ? { reviewing: true } : {}), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text.language } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
+                                                            setDraft(words);
+                                                            setUnsent(undefined);
+                                                        }, onSend: () => sendWords({ game: studied.name, at }), canMove: false, name: name, problem: unsent, about: { ...(at === 0 ? {} : { ply: plies[at - 1] }), onShow: goTo }, text: text }) }), studiedCard(player, "you")] })] }))
                                 : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: name, signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text.language } : {}) })] }), _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) => {
@@ -371,9 +395,9 @@ export function App({ start }) {
                             // Between games the board goes off (D-77): a game the page saw end once its effects are over, its final position less off than the table set.
                             class: between && !justEnded ? "board-wrap off" : "board-wrap", onWheel: wheel, 
                             // A press on the board while the player looks back brings the game as it is: the next one plays.
-                            onPointerDownCapture: viewing === undefined || studied !== undefined ? undefined : (event) => event.button === 0 && goTo(total), children: [_jsx(Board, { fen: shown.position.fen, bottom: flipped ? ai : player, lastMove: shown.lastMove, pointed: pointed, ...(helps === undefined ? {} : { helps }), ...(mapping && helps !== undefined ? { control: helps.strategy.control } : {}), bare: bare && helps !== undefined, ...(review?.badge === undefined ? {} : { badge: { badge: review.badge, name: text.badges[review.badge] } }), ...(drawn === undefined ? {} : { drawn }), nextMove: next, jumped: jumped, check: shown.position.check, end: ended && viewing === undefined && pending === undefined ? { how, winner, player, fresh: justEnded } : undefined, player: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing === undefined ? refusal : undefined, promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleep || 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: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing === undefined ? refusal : undefined, promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleep || clockWaits)
                                     ? (_jsxs("div", { class: "over-board", children: [asleep ? _jsx("p", { class: "asleep", role: "status", children: text.asleep(name) }) : null, startClocks] }))
-                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [_jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, text: text })), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : { analysis: summary === undefined ? { by: analyst } : { by: analyst, summary } }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text })] })] }) }));
+                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : { analysis: summary === undefined ? { by: analyst } : { by: analyst, summary } }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text })] })] }) }));
 }
 /** The picture of a player of the game in analysis: the player's own, the AI's Torretta with its mood, or the plain face of someone else. */
 function pictureOf({ who }, profile, size, mood) {

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), the arrows, Home and End step through the moves and f
-// and x turn the board, and the wheel over the board steps too.
+// 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.
 import { useEffect, useRef } from "preact/hooks";
 import { flipKeys, stepKeys } from "../game/browse.js";
 import { foldKeys, gameUnderBoard, oneColumn } from "../layout/folds.js";
@@ -52,6 +52,20 @@ export function useMapKey(helping, map) {
         };
     }, [helping]);
 }
+/** ? opens the legend of the marks on the board and closes it, while the page shows its ? (D-99). */
+export function useLegendKey(toggle) {
+    useEffect(() => {
+        const press = (event) => {
+            const shown = [...document.querySelectorAll(".legend-button")].some((button) => button.getClientRects().length > 0);
+            if (shown && forThePage(event) && event.key === "?") {
+                event.preventDefault();
+                toggle();
+            }
+        };
+        window.addEventListener("keydown", press);
+        return () => window.removeEventListener("keydown", press);
+    });
+}
 /** The keys of Lichess and chess.com: the arrows, Home and End step through the moves, f and x turn the board round. */
 export function useBrowseKeys(step, flip) {
     useEffect(() => {

package/dist/page/app/served.js

@@ -68,6 +68,6 @@ export function sendMove(move, words, text, name) {
     return post("/api/move", message === "" ? { move } : { move, message }, text, name);
 }
 /** Sends the player's words alone: the reason they were refused, or undefined. */
-export function sendMessage(words, text, name) {
-    return post("/api/message", { text: words.trim() }, text, name);
+export function sendMessage(words, text, name, shown) {
+    return post("/api/message", { text: words.trim(), ...shown }, text, name);
 }

package/dist/page/board/board.js

@@ -6,9 +6,10 @@ import { BadgeIcon } from "../game/badges.js";
 import { pinOn, riskOn, skewerOn } from "../helps/view.js";
 import { Piece } from "../pieces/pieces.js";
 import { bubblePlace, keptSquares } from "./explain.js";
-import { Arrows, Badge, Bubble, ControlCount, controlOf, kingSigns, Lifted, noSigns, Notch, PinsAndSkewers, PromotionChoice, Pushpin, Skewer } from "./marks.js";
+import { Arrows, Badge, Bubble, ControlCount, controlOf, Lifted, Notch, PinsAndSkewers, PromotionChoice, Pushpin, Skewer } from "./marks.js";
 import { backOf, motionOf, noMotion, playedOn, rearranged } from "./motion.js";
 import { useBoardPointer } from "./pointer.js";
+import { kingSigns, noSigns } from "./signs.js";
 import { files, kingToMove, piecesOf } from "./squares.js";
 /**
  * The board of a position, seen from one side, with the last move's squares marked. While the player may move, their pieces answer the pointer: a press

package/dist/page/board/marks.js

@@ -5,7 +5,10 @@ import { Piece } from "../pieces/pieces.js";
 export function Notch({ tone }) {
     return (_jsx("span", { class: tone === undefined ? "help-notch" : `help-notch ${tone}`, "aria-hidden": "true", children: _jsxs("svg", { viewBox: "0 0 10 10", children: [_jsx("path", { d: "M0.5 0.5V9.5H9.5Z" }), tone === undefined ? null : _jsx("path", { class: "edge", d: "M0.5 0.5V9.5H9.5Z" }), _jsx("circle", { cx: "2.9", cy: "7.1", r: "1.1" })] }) }));
 }
-/** The pushpin stuck in a pinned piece from the top left corner, its needle toward the piece, in the tone of its corner at risk (D-91); in ink in no side's. */
+/**
+ * The pushpin stuck in a pinned piece from the top left corner, its needle toward the piece, in the tone of its corner at risk (D-91); in ink in no side's;
+ * in the card's line, in its colour.
+ */
 export function Pushpin({ tone }) {
     return _jsx(Stuck, { kind: "help-pin", shape: pushpin, tone: tone });
 }
@@ -122,29 +125,6 @@ export function Lifted({ drag, letter }) {
     const classes = ["lifted", up && !drag.back ? "up" : "", drag.touch ? "touch" : "", drag.back ? "back" : ""].filter((name) => name !== "").join(" ");
     return (_jsx("div", { class: classes, style: { "--x": `${drag.at[0]}px`, "--y": `${drag.at[1]}px` }, children: _jsx(Piece, { letter: letter }) }));
 }
-/** The kings' signs at the end, by their squares: the loser's king lies down when mated or resigning; both kings of a draw stand, the stalemated one stuck. */
-export function kingSigns(pieces, toMove, end) {
-    const kingOf = (side) => [...pieces].find(([, letter]) => letter === (side === "white" ? "K" : "k"))?.[0];
-    const signs = new Map();
-    const sign = (side, badge, classes) => {
-        const square = kingOf(side);
-        if (square !== undefined) {
-            signs.set(square, { badge, classes });
-        }
-    };
-    if (end.winner === undefined) {
-        sign("white", "half", end.how === "stalemate" && toMove === "white" ? "drawn stalled" : "drawn");
-        sign("black", "half", end.how === "stalemate" && toMove === "black" ? "drawn stalled" : "drawn");
-        return signs;
-    }
-    const loser = end.winner === "white" ? "black" : "white";
-    sign(end.winner, "crown", "winner");
-    if (end.how === "checkmate" || end.how === "resignation") {
-        sign(loser, end.how === "checkmate" ? "mate" : "flag", "fallen");
-    }
-    return signs;
-}
-export const noSigns = new Map();
 /** Arrows off one square, the AI's on a white edge (D-78): every edge under every arrow, so one edge goes round them all where they meet. */
 function ArrowGroup({ shapes, edged }) {
     return (_jsxs("g", { children: [edged

package/dist/page/board/signs.js

@@ -0,0 +1,23 @@
+/** The kings' signs at the end, by their squares: the loser's king lies down when mated or resigning; both kings of a draw stand, the stalemated one stuck. */
+export function kingSigns(pieces, toMove, end) {
+    const kingOf = (side) => [...pieces].find(([, letter]) => letter === (side === "white" ? "K" : "k"))?.[0];
+    const signs = new Map();
+    const sign = (side, badge, classes) => {
+        const square = kingOf(side);
+        if (square !== undefined) {
+            signs.set(square, { badge, classes });
+        }
+    };
+    if (end.winner === undefined) {
+        sign("white", "half", end.how === "stalemate" && toMove === "white" ? "drawn stalled" : "drawn");
+        sign("black", "half", end.how === "stalemate" && toMove === "black" ? "drawn stalled" : "drawn");
+        return signs;
+    }
+    const loser = end.winner === "white" ? "black" : "white";
+    sign(end.winner, "crown", "winner");
+    if (end.how === "checkmate" || end.how === "resignation") {
+        sign(loser, end.how === "checkmate" ? "mate" : "flag", "fallen");
+    }
+    return signs;
+}
+export const noSigns = new Map();

package/dist/page/game/column.js

@@ -10,11 +10,11 @@ import { ResultTile } from "./result-tile.js";
  * The column, which the player folds with its tab; under the board, where three columns would leave the board small, always open. A game in analysis
  * (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, helps, standings, analysis, shownPlies, onShow, onStep, onDownload, onSaveMoves, onAnalyse, text }) {
+export function GameColumn({ plies, result, how, lit, started, move, toMove, opening, helps, legend, standings, analysis, shownPlies, onShow, onStep, onDownload, onSaveMoves, onAnalyse, text }) {
     const bar = standings === undefined ? 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: [_jsx(GameCard, { plies: plies, result: result, how: how, lit: lit, started: started, move: move, toMove: toMove, bar: bar, text: text }), analysis === undefined || standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: shownPlies, onShow: onShow, text: text }), opening === undefined ? null : _jsx(OpeningCard, { opening: opening, text: text }), helps, analysis === undefined || analysis.summary !== undefined ? null : (_jsxs("p", { class: "card review waiting", role: "status", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(analysis.by)] })), _jsx(MoveList, { plies: plies, result: result, shown: shownPlies, onShow: onShow, 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, onStep: onStep, text: text })] })) }));
+            : (_jsxs(_Fragment, { children: [_jsx(GameCard, { plies: plies, result: result, how: how, lit: lit, started: started, move: move, toMove: toMove, bar: bar, text: text }), analysis === undefined || standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: shownPlies, onShow: onShow, text: text }), opening === undefined ? null : _jsx(OpeningCard, { opening: opening, text: text }), helps, analysis === undefined || analysis.summary !== undefined ? null : (_jsxs("p", { class: "card review waiting", role: "status", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(analysis.by)] })), _jsx(MoveList, { plies: plies, result: result, shown: shownPlies, 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, 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

@@ -352,6 +352,18 @@
     padding: 2px 4px 0;
 }
 
+/* The title, and on its right the legend of the marks when no helps' card holds it (D-99) */
+.moves-head {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+}
+
+.moves-head .hold-button {
+    padding: 3px 6px;
+}
+
 /* Positioned, so that the moves' hidden names scroll with the list instead of stretching the page */
 .moves {
     position: relative;

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

@@ -7,7 +7,7 @@ import { FoldButton, useCardFold } from "./card-fold.js";
  * The moves numbered in pairs, the one the board shows marked (`shown`, how many moves it shows), and the result once the game is over; a click on a move
  * shows it. The list keeps its last move in sight, and the one shown while the player looks back.
  */
-export function MoveList({ plies, result, shown, onShow, text }) {
+export function MoveList({ plies, result, shown, onShow, tools, text }) {
     const list = useRef(null);
     const [folded, toggleFold] = useCardFold("moves");
     const rows = rowsOf(plies);
@@ -30,7 +30,7 @@ export function MoveList({ plies, result, shown, onShow, text }) {
     const move = (ply) => _jsx(Move, { ply: ply, current: ply !== undefined && ply === current, onShow: () => onShow(plies.indexOf(ply) + 1), text: text });
     // The card's title with its icon, a score sheet, as the other cards of the column, which folds the card to it (Stefano); only the list under it
     // scrolls, and it stays in the page while folded, so that it keeps its move in sight.
-    return (_jsxs("section", { class: `card moves-card${folded ? " folded" : ""}`, "aria-label": text.moves, children: [_jsx("h3", { class: "card-title", children: _jsxs(FoldButton, { folded: folded, onFold: toggleFold, text: text, children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M6 3H15L19 7V21H6ZM15 3V7H19M9 11H16M9 14.5H16M9 18H13" }) }), text.moves] }) }), _jsxs("div", { ref: list, class: "moves", hidden: folded, children: [_jsx("ol", { children: rows.map(({ number, white, black }) => (_jsxs("li", { children: [_jsxs("span", { class: "number", children: [number, "."] }), move(white), move(black)] }, number))) }), result === undefined ? null : _jsx("p", { class: "result", children: result })] })] }));
+    return (_jsxs("section", { class: `card moves-card${folded ? " folded" : ""}`, "aria-label": text.moves, children: [_jsxs("div", { class: "moves-head", children: [_jsx("h3", { class: "card-title", children: _jsxs(FoldButton, { folded: folded, onFold: toggleFold, text: text, children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M6 3H15L19 7V21H6ZM15 3V7H19M9 11H16M9 14.5H16M9 18H13" }) }), text.moves] }) }), tools] }), _jsxs("div", { ref: list, class: "moves", hidden: folded, children: [_jsx("ol", { children: rows.map(({ number, white, black }) => (_jsxs("li", { children: [_jsxs("span", { class: "number", children: [number, "."] }), move(white), move(black)] }, number))) }), result === undefined ? null : _jsx("p", { class: "result", children: result })] })] }));
 }
 /** The buttons that step through the moves: to the start, back, forward, and to the game as it is; each one off where it could not go. */
 export function Steps({ shown, total, onStep, text }) {

package/dist/page/game/plies.js

@@ -58,6 +58,14 @@ export function judgmentsOf(plies, player, { judgments }) {
 }
 /** How long a line of the player's may be: the server's limit (D-54), which a test keeps equal. */
 export const talkLimits = { line: 200 };
+/**
+ * The talk over a game in analysis (D-101): from the player's first line on it, the lines said since, but for the player's on another game; the last ten,
+ * which is all half the column holds (Zoe).
+ */
+export function analysisTalk(talk, game) {
+    const first = talk.findIndex((line) => line.shown?.game === game);
+    return first === -1 ? [] : talk.slice(first).filter((line) => line.shown === undefined || line.shown.game === game).slice(-10);
+}
 /** How many times the AI has spoken in the game, its comments on its moves and its lines on the page: the page sees it speak when the count grows. */
 export function aiSpoke(plies, ai, talk) {
     return plies.filter((ply) => ply.side === ai && ply.comment !== undefined).length + talk.filter((line) => line.who === "ai").length;