chesspal 0.2.2 → 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

@@ -3,12 +3,13 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-ru
 // with two clicks or by dragging a piece, which lifts off the board, in Zoe's design.
 import { useMemo, useRef } from "preact/hooks";
 import { BadgeIcon } from "../game/badges.js";
-import { riskOn } from "../helps/view.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, Pins, PromotionChoice } 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
@@ -104,12 +105,17 @@ export function Board({ fen, bottom, lastMove, pointed, helps, control, bare, ba
                             "--dy": ranks.indexOf(Number(from[1])) - row,
                         };
                         const risk = signsOfHelps === undefined ? undefined : riskOn(signsOfHelps, square);
+                        // A pinned piece's pushpin and a skewered one's skewer go with their lines, so not over the control map.
+                        const pin = signsOfHelps === undefined || control !== undefined ? undefined : pinOn(signsOfHelps, square);
+                        const skewer = signsOfHelps === undefined || control !== undefined ? undefined : skewerOn(signsOfHelps, square);
                         return (_jsxs("div", { class: classes, role: "button", "aria-label": label, "aria-pressed": own(square) ? selected === square : undefined, tabIndex: square === focused ? 0 : -1, "data-square": square, onKeyDown: (event) => key(event, square), onFocus: () => setCursor(square), 
                             // A click with no pointer behind it, as a screen reader's in browse mode, presses the square as Enter does.
                             onClick: (event) => event.detail === 0 && pressKey(square), style: away, children: [column === 0 ? _jsx("span", { class: "coordinate rank", children: rank }) : null, row === 7 ? _jsx("span", { class: "coordinate file", children: file }) : null, _jsx("span", { class: "square-name", "aria-hidden": "true", children: square }), motion.taken?.square === square
                                     ? (_jsx("span", { class: "taken-piece", children: _jsx(Piece, { letter: motion.taken.letter }) }, `taken ${fen}`))
-                                    : null, motion.gone?.filter((gone) => gone.square === square).map((gone) => (_jsx("span", { class: "gone-piece", children: _jsx(Piece, { letter: gone.letter }) }, `gone ${fen}`))), control === undefined ? null : _jsx("span", { class: `control-ground ${controlOf(control[square])}`, "aria-hidden": "true" }), piece === undefined ? null : _jsx(Piece, { letter: piece }, moving ? fen : "still"), sign === undefined ? null : _jsx(Badge, { kind: sign.badge }), risk === undefined ? null : _jsx(Notch, { tone: risk }), control === undefined ? null : _jsx(ControlCount, { counts: control[square] }), badge === undefined || lastMove?.to !== square ? null : _jsx(BadgeIcon, { badge: badge.badge, title: badge.name })] }, square));
-                    })), signsOfHelps === undefined || signsOfHelps.pins.length === 0 || control !== undefined ? null : _jsx(Pins, { pins: signsOfHelps.pins, at: centreOf })] }), _jsx(Arrows, { arrows: aiArrows, at: centreOf, occupied: (square) => pieces.has(square) }), _jsx(Arrows, { arrows: ownArrows, at: centreOf }), notice?.explanation?.arrow === undefined ? null : _jsx(Arrows, { arrows: [notice.explanation.arrow], at: centreOf, explain: { occupied: pieces.has(notice.explanation.arrow.to) } }), drag === undefined || !pieces.has(drag.from) ? null : _jsx(Lifted, { drag: drag, letter: pieces.get(drag.from) }), promotion === undefined
+                                    : null, motion.gone?.filter((gone) => gone.square === square).map((gone) => (_jsx("span", { class: "gone-piece", children: _jsx(Piece, { letter: gone.letter }) }, `gone ${fen}`))), control === undefined ? null : _jsx("span", { class: `control-ground ${controlOf(control[square])}`, "aria-hidden": "true" }), piece === undefined ? null : _jsx(Piece, { letter: piece }, moving ? fen : "still"), sign === undefined ? null : _jsx(Badge, { kind: sign.badge }), risk === undefined ? null : _jsx(Notch, { tone: risk }), pin === undefined ? null : _jsx(Pushpin, { tone: pin }), skewer === undefined ? null : _jsx(Skewer, { tone: skewer }), control === undefined ? null : _jsx(ControlCount, { counts: control[square] }), badge === undefined || lastMove?.to !== square ? null : _jsx(BadgeIcon, { badge: badge.badge, title: badge.name })] }, square));
+                    })), signsOfHelps === undefined || signsOfHelps.pins.length + signsOfHelps.skewers.length === 0 || control !== undefined
+                        ? null
+                        : _jsx(PinsAndSkewers, { pins: signsOfHelps.pins, skewers: signsOfHelps.skewers, at: centreOf })] }), _jsx(Arrows, { arrows: aiArrows, at: centreOf, occupied: (square) => pieces.has(square) }), _jsx(Arrows, { arrows: ownArrows, at: centreOf }), notice?.explanation?.arrow === undefined ? null : _jsx(Arrows, { arrows: [notice.explanation.arrow], at: centreOf, explain: { occupied: pieces.has(notice.explanation.arrow.to) } }), drag === undefined || !pieces.has(drag.from) ? null : _jsx(Lifted, { drag: drag, letter: pieces.get(drag.from) }), promotion === undefined
                 ? null
                 : _jsx(PromotionChoice, { side: promotion.side, column: columns.indexOf(promotion.to[0]), down: ranks[0] === Number(promotion.to[1]), onPick: promote, text: text }), notice === undefined ? null : (_jsx(Bubble, { notice: notice, place: notice.square === undefined ? undefined : seen(notice.square), where: notice.square === undefined
                     ? "above"