chesspal 0.2.3 → 0.3.0

package/dist/core/possibilities.js

@@ -0,0 +1,254 @@
+// What the moves of a position would do (D-100): the captures and what they take, the forks and double attacks, the discovered and double checks, the
+// promotions, the stalemates and the stalemate traps; for the side to move, and as threats for the other side. Facts on each move, never a judgment or a
+// search beyond the move and, for a stalemate, the reply to it (D-6, D-19). The definitions are Anatolij's.
+import { Chess } from "chess.js";
+import { attacksOf, factsOf } from "./facts.js";
+import { mayCastle, namesOn, Placement, turnPassed } from "./placement.js";
+/** The possibilities of a chess.js board, whose legal moves are given: computed once for each position, by its key, and frozen. */
+export function possibilitiesOf(chess, legal) {
+    return kept(possibilitiesByPosition, chess, () => computed(chess, legal));
+}
+/**
+ * What the other side's moves would do if it were to move, as threats: none when the side to move is in check, since the other side could not be to move.
+ * Computed apart from the possibilities, only where they are shown: once for each position, by its key, and frozen.
+ */
+export function threatsOf(chess) {
+    return chess.inCheck() ? undefined : kept(threatsByPosition, chess, () => threatsComputed(chess));
+}
+// The possibilities and the threats of the positions seen last, by their key.
+const possibilitiesByPosition = new Map();
+const threatsByPosition = new Map();
+const positionsKept = 256;
+function kept(byPosition, chess, compute) {
+    const key = chess.hash();
+    let found = byPosition.get(key);
+    if (found === undefined) {
+        found = Object.freeze(compute());
+        if (byPosition.size >= positionsKept) {
+            byPosition.delete(byPosition.keys().next().value);
+        }
+        byPosition.set(key, found);
+    }
+    return found;
+}
+// The usual values, only to compare two pieces, never summed (D-19), as the facts have them.
+const values = { p: 1, n: 3, b: 3, r: 5, q: 9, k: 100 };
+// A stalemate is looked for only when the side it would stalemate has at most this many pieces besides its king and pawns (Anatolij).
+const fewPieces = 1;
+function computed(chess, legal) {
+    const side = chess.turn();
+    const stalemates = stalematesOf(chess, legal);
+    const strikes = strikesOf(chess, side, legal.filter((move) => !move.san.startsWith("O-O")));
+    return {
+        captures: capturesOf(chess, legal),
+        ...chancesOf(strikes, (move) => ({ san: move.san, order: 0 }), promotionsOf(legal, stalemates)),
+        stalemates,
+        stalemateTraps: stalemateTrapsOf(chess, legal),
+    };
+}
+/** Each capture with the fact of the piece taken: undefended, worth more than the taker, worth the same, or attacked more times than defended. */
+function capturesOf(chess, legal) {
+    const pieces = new Map(factsOf(chess, legal).pieces.map((piece) => [piece.square, piece]));
+    return legal.filter((move) => move.san.includes("x")).map((move) => {
+        const taken = chess.get(move.to) === undefined ? `${move.to[0]}${move.from[1]}` : move.to;
+        const victim = pieces.get(taken);
+        const valueTaken = values[chess.get(taken).type];
+        const valueTaker = values[chess.get(move.from).type];
+        if (victim === undefined || victim.defenders.length === 0) {
+            return { san: move.san, fact: "undefended" };
+        }
+        if (valueTaken !== valueTaker) {
+            return valueTaken > valueTaker ? { san: move.san, fact: "worth more" } : victim.attackers.length > victim.defenders.length ? { san: move.san, fact: "outnumbered" } : { san: move.san };
+        }
+        return { san: move.san, fact: "same value" };
+    });
+}
+/** The other side's moves tried on the same board without SAN, given only to the moves that do something. */
+function threatsComputed(chess) {
+    const other = chess.turn() === "w" ? "b" : "w";
+    const board = new Placement(chess);
+    const moves = board.movesOf(other);
+    // Written on the board of pieces alone, in chess.js's order; chess.js writes the rare move it cannot.
+    const fallback = namesWithTurnPassed(chess);
+    const nameOf = (move) => {
+        const san = board.sanOf(move, moves) ?? fallback(move)?.san;
+        return san === undefined ? undefined : { san, order: moves.indexOf(move) };
+    };
+    const promoting = moves.filter((move) => move.promotion !== undefined).flatMap((move) => {
+        const name = nameOf(move);
+        return name === undefined ? [] : [{ ...move, ...name }];
+    });
+    return chancesOf(strikesOf(chess, other, moves), nameOf, promotionsOf(promoting));
+}
+/** A side's double attacks, discovered and double checks, by the SAN of their moves; a move without one is left out. */
+function chancesOf(strikes, nameOf, promotions) {
+    const named = strikes.flatMap((strike) => {
+        const name = nameOf(strike.move);
+        return name === undefined ? [] : [{ ...strike, ...name }];
+    }).sort((one, two) => one.order - two.order);
+    return {
+        doubleAttacks: named.flatMap(({ san, attack }) => (attack === undefined ? [] : [{ san, ...attack }])),
+        discoveredChecks: named.filter((strike) => !strike.double && strike.discovered).map((strike) => strike.san),
+        doubleChecks: named.filter((strike) => strike.double).map((strike) => strike.san),
+        promotions,
+    };
+}
+/** The moves of a side that check twice, check by uncovering a piece, or attack two targets, each tried on a board of pieces alone. */
+function strikesOf(chess, side, moves) {
+    const board = new Placement(chess);
+    // On a board of its own, which no move changes: the reach reads the board at each call.
+    const before = remembered(attacksOf(new Placement(chess)));
+    // A piece pinned to its king may attack more once the pin is gone: every move is looked at whole.
+    const pinned = board.isPinned(side);
+    return moves.flatMap((move) => {
+        const passant = board.get(move.to) === undefined && move.from[0] !== move.to[0] && board.get(move.from).type === "p";
+        const taken = board.play(move);
+        const strike = pinned || passant || mayStrike(board, side, move) ? afterMove(board, side, move, taken, before) : undefined;
+        board.undo();
+        return strike !== undefined && (strike.double || strike.discovered || strike.attack !== undefined) ? [strike] : [];
+    });
+}
+/**
+ * A first look at a move just played, cheaper than the whole: the piece moved attacks the enemy king or two enemy pieces besides pawns, or it left a line
+ * between a rook, bishop or queen of its side and an enemy piece besides a pawn. A move that does neither checks, forks and uncovers nothing.
+ */
+function mayStrike(board, side, move) {
+    const hit = board.attackedFrom(move.to).map((square) => board.get(square)).filter((piece) => piece !== undefined && piece.color !== side && piece.type !== "p");
+    return hit.length >= 2 || hit.some((piece) => piece.type === "k") || board.isBetween(move.from, side);
+}
+/** What a move just played on the board did: a double check, a discovered check, a fork or a double attack. */
+function afterMove(board, side, move, taken, before) {
+    const reach = remembered(attacksOf(board));
+    const other = side === "w" ? "b" : "w";
+    const enemies = board.piecesOf(other);
+    const king = enemies.find((piece) => piece.type === "k");
+    const checkers = king === undefined ? [] : reach(king.square, side);
+    const double = checkers.length >= 2;
+    const discovered = checkers.some((square) => square !== move.to);
+    const moved = board.get(move.to);
+    // A piece of its side attacks an enemy piece it did not attack before the move: the piece moved, or one its move uncovered.
+    const targetsOf = (attacker) => enemies.filter((enemy) => enemy.type !== "p" && reach(enemy.square, side).includes(attacker) && isTarget(enemy, attacker));
+    const isTarget = (enemy, attacker) => enemy.type === "k" || values[enemy.type] > values[board.get(attacker).type]
+        || (reach(enemy.square, other).length === 0 && !reach(attacker, other).includes(enemy.square));
+    const own = targetsOf(move.to);
+    const fresh = own.filter((enemy) => !before(enemy.square, side).includes(move.from));
+    const uncovered = board.piecesOf(side).filter((piece) => piece.square !== move.to && "rbq".includes(piece.type)).flatMap((line) => targetsOf(line.square).filter((enemy) => enemy.type !== "k" && !before(enemy.square, side).includes(line.square)));
+    const attackers = reach(move.to, other);
+    const atRisk = attackers.length > 0 && (reach(move.to, side).length === 0 || Math.min(...attackers.map((square) => values[board.get(square).type])) < values[moved.type]);
+    const fork = own.length >= 2 && fresh.length >= 1 && (!atRisk || double);
+    const targets = [...new Set([...own, ...uncovered].map((enemy) => enemy.square))].sort();
+    // A piece uncovered counts when the piece moved does something too: it attacks another target, takes, checks or promotes.
+    const strikes = taken !== undefined || move.promotion !== undefined || checkers.length > 0;
+    const withUncovered = uncovered.length > 0 && (targets.length >= 2 || strikes);
+    return !fork && !withUncovered ? { move, double, discovered } : { move, double, discovered, attack: { targets, fork: uncovered.length === 0 } };
+}
+/** A reach that reads each square once for each side. */
+function remembered(reach) {
+    const known = new Map();
+    return (square, color) => {
+        const key = `${square}${color}`;
+        let found = known.get(key);
+        if (found === undefined) {
+            found = reach(square, color);
+            known.set(key, found);
+        }
+        return found;
+    };
+}
+/** The promotions, a queen's for each pawn and square, and another piece's only when it checks or mates where the queen does not, or the queen stalemates and it does not. */
+function promotionsOf(legal, stalemates = []) {
+    const queens = legal.filter((move) => move.promotion === "q");
+    const suffix = (san) => /[+#]$/.exec(san)?.[0] ?? "";
+    const others = legal.filter((move) => {
+        const queen = queens.find((each) => each.from === move.from && each.to === move.to)?.san ?? "";
+        const checksAlone = suffix(move.san) !== "" && suffix(move.san) !== suffix(queen);
+        return move.promotion !== undefined && move.promotion !== "q" && (checksAlone || (stalemates.includes(queen) && !stalemates.includes(move.san)));
+    });
+    return [...queens, ...others].map((move) => move.san);
+}
+/** The moves after which the other side, with few pieces, is not in check and has no legal move. */
+function stalematesOf(chess, legal) {
+    const other = chess.turn() === "w" ? "b" : "w";
+    if (officersOf(chess, other) > fewPieces + 1) {
+        return [];
+    }
+    const board = new Chess(chess.fen());
+    const placement = new Placement(chess);
+    return legal.filter((move) => {
+        // Castling moves a rook the board of pieces alone does not.
+        if (move.san.startsWith("O-O")) {
+            return stalemateAfter(board, [move]);
+        }
+        // A side with a move on the board of pieces alone is not stalemated; one without may still castle or take en passant, which chess.js tells.
+        placement.play(move);
+        const maybe = placement.piecesOf(other).filter((piece) => piece.type !== "k" && piece.type !== "p").length <= fewPieces && !placement.inCheck(other) && !placement.hasMove(other);
+        placement.undo();
+        return maybe && stalemateAfter(board, [move]);
+    }).map((move) => move.san);
+}
+/** The moves of a side with few pieces after which a reply of the other side stalemates it, with those replies. */
+function stalemateTrapsOf(chess, legal) {
+    const side = chess.turn();
+    if (officersOf(chess, side) > fewPieces) {
+        return [];
+    }
+    const board = new Chess(chess.fen());
+    const placement = new Placement(chess);
+    // The board of pieces alone lists every reply but castling and en passant: where the other side may castle, or take a pawn just pushed two squares, chess.js does.
+    const otherCastles = mayCastle(chess, side === "w" ? "b" : "w");
+    return legal.flatMap((move) => {
+        const pushedTwo = board.get(move.from)?.type === "p" && Math.abs(Number(move.to[1]) - Number(move.from[1])) === 2;
+        const trap = otherCastles || pushedTwo || move.san.startsWith("O-O") ? trapByChess(board, move) : trapOnPlacement(placement, board, side, move);
+        return trap === undefined ? [] : [trap];
+    });
+}
+/** The replies to a move that stalemate the side that moved, tried on chess.js. */
+function trapByChess(board, move) {
+    board.move(chessMove(move));
+    const replies = board.moves({ verbose: true });
+    const stalemating = replies.filter((reply) => stalemateAfter(board, [reply]));
+    board.undo();
+    return stalemating.length === 0 ? undefined : { san: move.san, replies: stalemating.length === replies.length ? "all" : stalemating.map((reply) => reply.san) };
+}
+/** The same, the replies tried on the board of pieces alone; chess.js names those that stalemate there, and tells whether castling or en passant saves the side. */
+function trapOnPlacement(placement, board, side, move) {
+    placement.play(move);
+    const replies = placement.movesOf(side === "w" ? "b" : "w");
+    const stalemating = replies.filter((reply) => {
+        placement.play(reply);
+        const maybe = !placement.inCheck(side) && !placement.hasMove(side);
+        placement.undo();
+        return maybe;
+    });
+    placement.undo();
+    if (stalemating.length === 0) {
+        return undefined;
+    }
+    board.move(chessMove(move));
+    const nameOf = namesOn(() => board);
+    const named = stalemating.flatMap((reply) => {
+        const name = nameOf(reply);
+        return name !== undefined && stalemateAfter(board, [reply]) ? [name] : [];
+    }).sort((one, two) => one.order - two.order);
+    board.undo();
+    return named.length === 0 ? undefined : { san: move.san, replies: named.length === replies.length ? "all" : named.map((name) => name.san) };
+}
+/** Whether moves played on a chess.js board stalemate the side to move then; the board is left as it was. */
+function stalemateAfter(board, moves) {
+    moves.forEach((move) => board.move(chessMove(move)));
+    const stalemate = board.isStalemate();
+    moves.forEach(() => board.undo());
+    return stalemate;
+}
+function chessMove({ from, to, promotion }) {
+    return promotion === undefined ? { from, to } : { from, to, promotion };
+}
+/** A side's pieces besides its king and pawns. */
+function officersOf(chess, color) {
+    return chess.board().flat().filter((cell) => cell !== null && cell.color === color && cell.type !== "k" && cell.type !== "p").length;
+}
+/** The SAN of the other side's moves and their order, read on the board with the turn passed, which is set up only when a move needs it. */
+function namesWithTurnPassed(chess) {
+    let passed;
+    return namesOn(() => (passed ??= turnPassed(chess)));
+}

package/dist/core/review.d.ts

@@ -51,6 +51,8 @@ export declare function reviewed(move: RecordedMove, review: MoveReview): Record
  * the game and who signed it. What the comments held besides stays, as do the NAGs of moves without a badge and the Annotator of a game it never reviewed.
  */
 export declare function unreviewed(record: GameRecord): GameRecord;
+/** The tags without who signed a review, the Annotator and its effort: the same game whoever reviewed it. */
+export declare function unsigned(tags: Readonly<Record<string, string>>): Record<string, string>;
 /** The arrows and squares as PGN's [%cal] and [%csl] write them, for a comment; empty without any. */
 export declare function drawingsText({ arrows, squares }: Pick<MoveReview, "arrows" | "squares">): string;
 /** The record with who reviewed it (D-81): the model, else the host, as PGN's Annotator, and the effort only when known; an effort no longer known goes. */
@@ -65,7 +67,10 @@ export interface AiModel {
 }
 /** The record with the model the AI played it with (D-82), and the effort only when known; with none known, as it is. */
 export declare function withAiModel(record: GameRecord, played: AiModel | undefined): GameRecord;
-/** Who reviewed the game, as its tags say: the Annotator, and the effort when known; undefined without an Annotator. */
+/**
+ * Who reviewed the game, as its tags say: the Annotator, and the effort when known; undefined without an Annotator, or on a game the AI has not reviewed,
+ * whose Annotator is someone else's, such as Lichess's.
+ */
 export declare function annotatorOf(record: GameRecord): {
     annotator: string;
     effort?: string;

package/dist/core/review.js

@@ -63,11 +63,14 @@ export function unreviewed(record) {
         return recordedMove(move.san, nags, withoutReview(move.comment).replace(/\s*\[%lead [^\]]*\]/g, "").trim());
     });
     const comment = withoutReview(record.comment);
-    // The signature is the AI's only on a game it reviewed: a game from elsewhere keeps its own Annotator.
-    const signedByAi = isReviewed(record) || record.moves.some((move) => reviewMark.test(move.comment ?? ""));
-    const tags = signedByAi ? Object.fromEntries(Object.entries(record.tags).filter(([name]) => name !== "Annotator" && name !== effortTag)) : record.tags;
+    // A game from elsewhere keeps its own Annotator.
+    const tags = carriesReview(record) ? unsigned(record.tags) : record.tags;
     return comment === "" ? { tags, moves } : { tags, comment, moves };
 }
+/** The tags without who signed a review, the Annotator and its effort: the same game whoever reviewed it. */
+export function unsigned(tags) {
+    return Object.fromEntries(Object.entries(tags).filter(([name]) => name !== "Annotator" && name !== effortTag));
+}
 /** The arrows and squares as PGN's [%cal] and [%csl] write them, for a comment; empty without any. */
 export function drawingsText({ arrows = [], squares = [] }) {
     const arrowList = arrows.map(({ colour, from, to }) => `${letterOf(colour)}${from}${to}`).join(",");
@@ -82,9 +85,12 @@ export function withAnnotator(record, { annotator, effort }) {
 export function withAiModel(record, played) {
     return played === undefined ? record : { ...record, tags: signed(record.tags, ["AIModel", "AIEffort"], played.model, played.effort) };
 }
-/** Who reviewed the game, as its tags say: the Annotator, and the effort when known; undefined without an Annotator. */
+/**
+ * Who reviewed the game, as its tags say: the Annotator, and the effort when known; undefined without an Annotator, or on a game the AI has not reviewed,
+ * whose Annotator is someone else's, such as Lichess's.
+ */
 export function annotatorOf(record) {
-    const found = signerOf(record.tags, ["Annotator", effortTag]);
+    const found = carriesReview(record) ? signerOf(record.tags, ["Annotator", effortTag]) : undefined;
     return found === undefined ? undefined : { annotator: found.model, ...(found.effort === undefined ? {} : { effort: found.effort }) };
 }
 /** The model the AI played the game with, as its tags say (D-82), and the effort when known; undefined without one. */
@@ -123,6 +129,16 @@ export function withGameReview(record, { summary, closing }) {
 }
 // The effort has no tag of its own in PGN: Chesspal's sits beside the Annotator.
 const effortTag = "AnnotatorEffort";
+/**
+ * The game holds the AI's review: its word on the game, or a note or badge on a move, the book's badge apart, which Chesspal puts there when the analysis
+ * starts. Only then is the Annotator the AI's.
+ */
+function carriesReview(record) {
+    return isReviewed(record) || record.moves.some((move) => {
+        const review = reviewOf(move.comment);
+        return review?.note !== undefined || (review?.badge !== undefined && review.badge !== "book");
+    });
+}
 /** A model and its effort as the tags say, each only when not blank; undefined without the model. */
 function signerOf(tags, [modelTag, modelEffortTag]) {
     const model = tags[modelTag]?.trim();
@@ -146,7 +162,6 @@ const judgmentNags = new Set([1, 2, 3, 4, 5, 6]);
 // The badges PGN has a NAG for: !! ! ?! ? ??.
 const nagOfBadge = { brilliant: 3, great: 1, inaccuracy: 6, mistake: 2, blunder: 4 };
 const badgePattern = /\[%badge (\w+)\]/;
-const reviewMark = /\[%(badge|review) /;
 const notePattern = /\[%review ([^\]]*)\]/;
 const closingPattern = /\[%closing ([^\]]*)\]/;
 const arrowPattern = /\[%cal ([^\]]*)\]/;

package/dist/games/ai-model.d.ts

@@ -3,7 +3,9 @@ import type { AiModel } from "../core/index.ts";
 export declare function noteAiModel(folder: string, noted: AiModel): boolean;
 /** The AI's model last noted for the games of a folder in this process; none on the command line, or before the AI's first move. */
 export declare function aiModelOf(folder: string): AiModel | undefined;
-/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. */
-export declare function noteAiHost(folder: string, host: string): void;
+/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. Whether it changed. */
+export declare function noteAiHost(folder: string, host: string): boolean;
+/** Forgets who played as the AI for the games of a folder: the chat that did has left the table (D-104), and the next may be another. */
+export declare function forgetTheAi(folder: string): void;
 /** The host the AI played its last move in, for the games of a folder in this process; none on the command line, or before the AI's first move. */
 export declare function aiHostOf(folder: string): string | undefined;

package/dist/games/ai-model.js

@@ -11,9 +11,18 @@ export function noteAiModel(folder, noted) {
 export function aiModelOf(folder) {
     return models.get(folder);
 }
-/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. */
+/** Notes the host the AI plays in for the games of a folder, after its move (D-97), as the model. Whether it changed. */
 export function noteAiHost(folder, host) {
+    if (hosts.get(folder) === host) {
+        return false;
+    }
     hosts.set(folder, host);
+    return true;
+}
+/** Forgets who played as the AI for the games of a folder: the chat that did has left the table (D-104), and the next may be another. */
+export function forgetTheAi(folder) {
+    models.delete(folder);
+    hosts.delete(folder);
 }
 /** The host the AI played its last move in, for the games of a folder in this process; none on the command line, or before the AI's first move. */
 export function aiHostOf(folder) {

package/dist/games/analysis.d.ts

@@ -1,12 +1,39 @@
-/** The game in analysis: its name as the lists write it, when the analysis last changed it, and whether the player brought it on the page and the AI has not gone over it yet. */
+/**
+ * The game in analysis: its name as the lists write it, when the analysis last changed it, whether the player brought it on the page and the AI has not
+ * gone over it yet, the moves whose note the chat corrected with the player, which the analyst leaves (D-101), and the run of the analyst that took it.
+ */
 export interface Analysis {
     readonly game: string;
     readonly at: string;
     readonly brought?: true;
+    readonly corrected?: readonly string[];
+    readonly analyst?: AnalystRun;
 }
-/** Names the game in analysis, over the one before; written again each time its review changes, so the page hears of it. */
-export declare function startAnalysis(folder: string, game: string, now: Date, brought?: boolean): void;
+/** The run of the analyst agent that took a game, as the host names it, the game it took and when. */
+export interface AnalystRun {
+    readonly game: string;
+    readonly run: string;
+    readonly since: string;
+}
+/**
+ * How a game is named in analysis: brought to the page by the player, with the moves the chat just corrected, taken by a run of the analyst, or afresh,
+ * without the corrections and the analyst it had.
+ */
+export interface AnalysisStart {
+    readonly brought?: boolean;
+    readonly corrected?: readonly string[];
+    readonly analyst?: AnalystRun;
+    readonly afresh?: boolean;
+}
+/**
+ * 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
+ * unless it starts afresh, in one write, so that the page never sees it leave the analysis; the analyst stays with the game it took, whichever the page
+ * opens meanwhile (Federico), and goes when that game starts afresh.
+ */
+export declare function startAnalysis(folder: string, game: string, now: Date, { brought, corrected, analyst, afresh }?: AnalysisStart): void;
+/** Lets the analyst go from the game it took, when that game's review is deleted while the page shows another. */
+export declare function forgetAnalyst(folder: string): void;
 /** The game in analysis, or none when there is none, or analysis.json cannot be read. */
 export declare function gameInAnalysis(folder: string): Analysis | undefined;
-/** Ends the analysis, when a new game starts. */
+/** Ends the analysis, when a new game starts or its review is deleted. */
 export declare function endAnalysis(folder: string): void;

package/dist/games/analysis.js

@@ -3,24 +3,63 @@
 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
+ * unless it starts afresh, in one write, so that the page never sees it leave the analysis; the analyst stays with the game it took, whichever the page
+ * opens meanwhile (Federico), and goes when that game starts afresh.
+ */
+export function startAnalysis(folder, game, now, { brought = false, corrected = [], analyst, afresh = false } = {}) {
+    const before = gameInAnalysis(folder);
+    const same = !afresh && before?.game === game;
+    const kept = [...new Set([...(same ? before.corrected ?? [] : []), ...corrected])];
+    const held = afresh && before?.analyst?.game === game ? undefined : before?.analyst;
+    writeAnalysis(folder, {
+        game,
+        at: now.toISOString(),
+        ...(brought ? { brought: true } : {}),
+        ...(kept.length === 0 ? {} : { corrected: kept }),
+        ...withAnalyst(analyst ?? held),
+    });
+}
+/** Lets the analyst go from the game it took, when that game's review is deleted while the page shows another. */
+export function forgetAnalyst(folder) {
+    const analysis = gameInAnalysis(folder);
+    if (analysis?.analyst !== undefined) {
+        const { game, at, brought, corrected } = analysis;
+        writeAnalysis(folder, { game, at, ...(brought === undefined ? {} : { brought }), ...(corrected === undefined ? {} : { corrected }) });
+    }
 }
 /** 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 }),
+                ...withAnalyst(isAnalystRun(analysis.analyst) ? analysis.analyst : undefined),
+            }
             : 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 });
 }
 const fileName = "analysis.json";
+function writeAnalysis(folder, analysis) {
+    writeAtomically(join(folder, fileName), `${JSON.stringify(analysis, null, 2)}\n`);
+}
+function withAnalyst(analyst) {
+    return analyst === undefined ? {} : { analyst: { game: analyst.game, run: analyst.run, since: analyst.since } };
+}
+function isAnalystRun(value) {
+    const run = value;
+    return typeof run?.game === "string" && typeof run.run === "string" && typeof run.since === "string";
+}

package/dist/games/archive.d.ts

@@ -11,10 +11,13 @@ export declare function isOverOnTable(folder: string, name: string): boolean;
 export declare function startOfNewGame(folder: string, now: Date, before?: CurrentGame): Date;
 /**
  * Writes the game to the archive, with the plans, how it ended and the AI's model and host last noted (D-82, D-97), and gives its name; the same game again rewrites the
- * same file.
+ * same file. A game closed before any move is not kept, as Lichess aborts it: none.
+ */
+export declare function archiveGame(folder: string, current: CurrentGame): string | undefined;
+/**
+ * Archives a game that has ended: its name in the archive, none for a game closed before any move, or, when that fails, a warning, since the game is saved in
+ * game.json all the same.
  */
-export declare function archiveGame(folder: string, current: CurrentGame): string;
-/** Archives a game that has ended: its name in the archive or, when that fails, a warning, since the game is saved in game.json all the same. */
 export declare function archiveEnded(folder: string, current: CurrentGame): {
     archive?: string;
     warning?: string;

package/dist/games/archive.js

@@ -1,7 +1,7 @@
 // The finished games, as PGN in games/ (D-9, D-41), with the AI's plans for the analyst (D-21); and the games played elsewhere, kept to study in study/ (D-68).
 import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { movesOnly, pgnDate, readPgn, withAiHost, withAiModel, writePgn } from "../core/index.js";
+import { movesOnly, pgnDate, readPgn, unsigned, withAiHost, withAiModel, writePgn } from "../core/index.js";
 import { aiHostOf, aiModelOf } from "./ai-model.js";
 import { coachWords, withCoach } from "./coach.js";
 import { endOf, loadGame } from "./current-game.js";
@@ -35,9 +35,12 @@ export function startOfNewGame(folder, now, before) {
 }
 /**
  * Writes the game to the archive, with the plans, how it ended and the AI's model and host last noted (D-82, D-97), and gives its name; the same game again rewrites the
- * same file.
+ * same file. A game closed before any move is not kept, as Lichess aborts it: none.
  */
 export function archiveGame(folder, current) {
+    if (current.game.record.moves.length === 0) {
+        return undefined;
+    }
     const name = archiveName(current);
     const path = join(folder, name);
     try {
@@ -49,10 +52,14 @@ export function archiveGame(folder, current) {
     }
     return name;
 }
-/** Archives a game that has ended: its name in the archive or, when that fails, a warning, since the game is saved in game.json all the same. */
+/**
+ * Archives a game that has ended: its name in the archive, none for a game closed before any move, or, when that fails, a warning, since the game is saved in
+ * game.json all the same.
+ */
 export function archiveEnded(folder, current) {
     try {
-        return { archive: archiveGame(folder, current) };
+        const archive = archiveGame(folder, current);
+        return archive === undefined ? {} : { archive };
     }
     catch (error) {
         return { warning: `${error.message} The game is saved in game.json: it goes to the archive when a new game starts.` };
@@ -225,7 +232,8 @@ function gameNamed(folder, shelf, name) {
 }
 /** Whether two records are the same game: the same tags and the same moves, whatever their comments say. */
 function sameGame(one, other) {
-    const shape = (record) => JSON.stringify([record?.tags, record?.moves.map((move) => move.san)]);
+    // Who signed a review is not the game: one the AI reviewed, or brought again with Lichess's Annotator, is the one kept.
+    const shape = (record) => JSON.stringify([record === undefined ? undefined : unsigned(record.tags), record?.moves.map((move) => move.san)]);
     return one !== undefined && shape(one) === shape(other);
 }
 function nameAt(date, shelf = "games") {

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 {
@@ -31,8 +41,17 @@ export interface GameEnd {
 }
 /** 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 declare function loadGame(folder: string): CurrentGame | undefined;
-/** Writes the current game to game.json, whole or not at all; from then on it is the one kept in memory. */
+/**
+ * Writes the current game to game.json, whole or not at all; from then on it is the one kept in memory. Refused with GameChanged when another process wrote
+ * the file since this one read it: the change made on the game read before would lose theirs.
+ */
 export declare function saveGame(folder: string, current: CurrentGame): void;
+/** The refusal of a save on a game another process changed since this one read it: what wrote it reads it again and starts over, once (rerunIfChanged). */
+export declare class GameChanged extends Error {
+    constructor();
+}
+/** Runs a change of the game, and once more from the start when another process changed the game under it: a second refusal stands. */
+export declare function rerunIfChanged<T>(run: () => T): T;
 /** How the game ended, or undefined while it goes on: by the board, or by what the record says, such as a resignation. */
 export declare function endOf(game: Game): GameEnd | undefined;
 /** The draw offer that stands: none once the game is over (D-65). */
@@ -53,4 +72,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>;