chesspal 0.2.3 → 0.2.4

package/dist/core/placement.js

@@ -0,0 +1,259 @@
+// A board of pieces alone, to try many moves in a row fast (D-34): no turn, castling rights or history, which the possibilities do not read. Which pieces
+// attack a square is read along the board's lines and steps, as chess.js counts it.
+import { Chess } from "chess.js";
+/** The pieces of a position, moved without the rules' checks and taken back in the reverse order. */
+export class Placement {
+    #pieces = new Map();
+    #played = [];
+    constructor(chess) {
+        for (const cell of chess.board().flat()) {
+            if (cell !== null) {
+                this.#pieces.set(cell.square, { type: cell.type, color: cell.color });
+            }
+        }
+    }
+    get(square) {
+        return this.#pieces.get(square);
+    }
+    /** The squares of a side's pieces of one type. */
+    findPiece({ type, color }) {
+        const found = [];
+        for (const [square, piece] of this.#pieces) {
+            if (piece.type === type && piece.color === color) {
+                found.push(square);
+            }
+        }
+        return found;
+    }
+    /** A side's pieces. */
+    piecesOf(color) {
+        const found = [];
+        for (const [square, piece] of this.#pieces) {
+            if (piece.color === color) {
+                found.push({ square, type: piece.type, color });
+            }
+        }
+        return found;
+    }
+    /** The pieces of a side that attack a square, pinned or not: pawns, knights and kings by their steps, the others along their lines. */
+    attackers(square, color) {
+        const of = (from, types) => {
+            const piece = this.#pieces.get(from);
+            return piece !== undefined && piece.color === color && types.includes(piece.type);
+        };
+        const found = [
+            ...pawnsTaking[color].get(square).filter((from) => of(from, "p")),
+            ...knightSteps.get(square).filter((from) => of(from, "n")),
+            ...kingSteps.get(square).filter((from) => of(from, "k")),
+        ];
+        for (const { squares, sliders } of linesFrom.get(square)) {
+            const first = squares.find((each) => this.#pieces.has(each));
+            if (first !== undefined && of(first, sliders)) {
+                found.push(first);
+            }
+        }
+        return found;
+    }
+    /** The squares the piece on a square attacks: by its steps, or along its lines up to the first piece. */
+    attackedFrom(square) {
+        const { type, color } = this.#pieces.get(square);
+        if (type === "p" || type === "n" || type === "k") {
+            return (type === "p" ? pawnCaptures[color] : type === "n" ? knightSteps : kingSteps).get(square);
+        }
+        return linesFrom.get(square).filter((line) => line.sliders.includes(type)).flatMap(({ squares }) => {
+            const stop = squares.findIndex((each) => this.#pieces.has(each));
+            return stop === -1 ? squares : squares.slice(0, stop + 1);
+        });
+    }
+    /** Whether a square lies between a rook, bishop or queen of a side and a piece of the other side besides a pawn, on their line with nothing else between. */
+    isBetween(square, color) {
+        const lines = linesFrom.get(square);
+        const first = lines.map(({ squares }) => squares.find((each) => this.#pieces.has(each)));
+        const slider = (index) => {
+            const piece = first[index] === undefined ? undefined : this.#pieces.get(first[index]);
+            return piece !== undefined && piece.color === color && lines[index].sliders.includes(piece.type);
+        };
+        const target = (index) => {
+            const piece = first[index] === undefined ? undefined : this.#pieces.get(first[index]);
+            return piece !== undefined && piece.color !== color && piece.type !== "p";
+        };
+        return opposite.some(([one, two]) => (slider(one) && target(two)) || (slider(two) && target(one)));
+    }
+    /** Whether a piece of a side stands between its king and a rook, bishop or queen of the other side on their line. */
+    isPinned(color) {
+        const king = this.findPiece({ type: "k", color })[0];
+        return king !== undefined && linesFrom.get(king).some(({ squares, sliders }) => {
+            const [first, second] = squares.filter((each) => this.#pieces.has(each)).map((each) => this.#pieces.get(each));
+            return first?.color === color && second !== undefined && second.color !== color && sliders.includes(second.type);
+        });
+    }
+    /** Plays a move: the piece taken goes, en passant too, and a pawn becomes the piece it promotes to. It returns the piece taken. */
+    play(move) {
+        const piece = this.#pieces.get(move.from);
+        const passant = piece.type === "p" && move.from[0] !== move.to[0] && !this.#pieces.has(move.to);
+        const takenOn = passant ? `${move.to[0]}${move.from[1]}` : move.to;
+        const taken = this.#pieces.get(takenOn);
+        this.#played.push({ move, piece, taken, takenOn });
+        this.#pieces.delete(move.from);
+        this.#pieces.delete(takenOn);
+        this.#pieces.set(move.to, move.promotion === undefined ? piece : { type: move.promotion, color: piece.color });
+        return taken;
+    }
+    /** Takes back the last move played. */
+    undo() {
+        const { move, piece, taken, takenOn } = this.#played.pop();
+        this.#pieces.delete(move.to);
+        this.#pieces.set(move.from, piece);
+        if (taken !== undefined) {
+            this.#pieces.set(takenOn, taken);
+        }
+    }
+    /**
+     * A side's moves that leave its king safe, in the order chess.js lists them: the pawns' pushes, captures and promotions, the pieces' steps and lines;
+     * never castling or en passant.
+     */
+    movesOf(color) {
+        return this.#placedOf(color).flatMap((piece) => this.#reachable(piece)).filter((move) => this.#leavesKingSafe(move, color));
+    }
+    /** Whether a side has a move of those, stopping at the first. */
+    hasMove(color) {
+        return this.#placedOf(color).some((piece) => this.#reachable(piece).some((move) => this.#leavesKingSafe(move, color)));
+    }
+    /**
+     * A move of those in SAN, as chess.js writes it, with the side's moves for the disambiguation; undefined for a pawn pushed two squares that would
+     * mate, which an en passant capture may answer: chess.js tells.
+     */
+    sanOf(move, moves) {
+        const { type, color } = this.#pieces.get(move.from);
+        const other = color === "w" ? "b" : "w";
+        const takes = this.#pieces.has(move.to) || (type === "p" && move.from[0] !== move.to[0]);
+        const head = type === "p" ? (takes ? `${move.from[0]}x` : "") : `${type.toUpperCase()}${this.#disambiguation(move, type, moves)}${takes ? "x" : ""}`;
+        this.play(move);
+        const check = this.inCheck(other);
+        const mate = check && !this.hasMove(other);
+        this.undo();
+        if (mate && type === "p" && Math.abs(Number(move.to[1]) - Number(move.from[1])) === 2) {
+            return undefined;
+        }
+        return `${head}${move.to}${move.promotion === undefined ? "" : `=${move.promotion.toUpperCase()}`}${mate ? "#" : check ? "+" : ""}`;
+    }
+    /** Whether a side's king is attacked. */
+    inCheck(color) {
+        const king = this.findPiece({ type: "k", color })[0];
+        return king !== undefined && this.attackers(king, color === "w" ? "b" : "w").length > 0;
+    }
+    #leavesKingSafe(move, color) {
+        this.play(move);
+        const safe = !this.inCheck(color);
+        this.undo();
+        return safe;
+    }
+    // A side's pieces square by square from a8 to h1, as chess.js goes over them.
+    #placedOf(color) {
+        return boardOrder.flatMap((square) => {
+            const piece = this.#pieces.get(square);
+            return piece?.color === color ? [{ square, type: piece.type, color }] : [];
+        });
+    }
+    // The squares a move's piece starts from, when another of its type reaches the same square: its file, else its rank, else both (chess.js).
+    #disambiguation(move, type, moves) {
+        const rivals = moves.filter((each) => each.to === move.to && each.from !== move.from && this.#pieces.get(each.from)?.type === type);
+        if (rivals.length === 0) {
+            return "";
+        }
+        const sameRank = rivals.some((each) => each.from[1] === move.from[1]);
+        const sameFile = rivals.some((each) => each.from[0] === move.from[0]);
+        return sameRank && sameFile ? move.from : sameFile ? move.from[1] : move.from[0];
+    }
+    // A piece's moves before its king's safety is looked at, in chess.js's order.
+    #reachable({ square, type, color }) {
+        const free = (to) => !this.#pieces.has(to);
+        const takes = (to) => this.#pieces.get(to)?.color === (color === "w" ? "b" : "w");
+        const open = (to) => free(to) || takes(to);
+        if (type === "p") {
+            const forward = pawnPushes[color].get(square);
+            const pushes = free(forward[0]) ? (forward.length === 2 && free(forward[1]) ? forward : forward.slice(0, 1)) : [];
+            const captures = pawnCaptures[color].get(square).filter(takes);
+            return [...pushes, ...captures].flatMap((to) => (to[1] === "8" || to[1] === "1" ? promotions.map((promotion) => ({ from: square, to, promotion })) : [{ from: square, to }]));
+        }
+        if (type === "n" || type === "k") {
+            return (type === "n" ? knightSteps : kingSteps).get(square).filter(open).map((to) => ({ from: square, to }));
+        }
+        return sliderRays[type].get(square).flatMap((ray) => {
+            const stop = ray.findIndex((each) => !free(each));
+            const reached = stop === -1 ? ray : ray.slice(0, takes(ray[stop]) ? stop + 1 : stop);
+            return reached.map((to) => ({ from: square, to }));
+        });
+    }
+}
+/** The SAN of moves of the side to move of a chess.js board, and their order as chess.js lists them; read square by square, as moves need them. */
+export function namesOn(boardOf) {
+    const bySquare = new Map();
+    return (move) => {
+        let moves = bySquare.get(move.from);
+        if (moves === undefined) {
+            moves = boardOf().moves({ square: move.from, verbose: true });
+            bySquare.set(move.from, moves);
+        }
+        const index = moves.findIndex((each) => each.to === move.to && each.promotion === move.promotion);
+        // chess.js lists the moves square by square from a8 to h1.
+        const square = (8 - Number(move.from[1])) * 8 + files.indexOf(move.from[0]);
+        return index === -1 ? undefined : { san: moves[index].san, order: square * 256 + index };
+    };
+}
+/** Whether a side may castle on a chess.js board, as far as the board of pieces alone would miss it: a right it keeps, with the squares to its rook empty. */
+export function mayCastle(chess, color) {
+    const rank = color === "w" ? "1" : "8";
+    const rights = chess.getCastlingRights(color);
+    const empty = (between) => [...between].every((file) => chess.get(`${file}${rank}`) === undefined);
+    return (rights.k && empty("fg")) || (rights.q && empty("bcd"));
+}
+/** The same board with the other side to move, without en passant, which belonged to the side to move. */
+export function turnPassed(chess) {
+    const fields = chess.fen().split(" ");
+    fields[1] = chess.turn() === "w" ? "b" : "w";
+    fields[3] = "-";
+    return new Chess(fields.join(" "));
+}
+const files = "abcdefgh";
+const promotions = ["n", "b", "r", "q"];
+const squares = [...files].flatMap((file) => [1, 2, 3, 4, 5, 6, 7, 8].map((rank) => `${file}${rank}`));
+const boardOrder = [8, 7, 6, 5, 4, 3, 2, 1].flatMap((rank) => [...files].map((file) => `${file}${rank}`));
+// The steps and lines from each square, worked out once, in the order chess.js tries them.
+const knightSteps = stepsFrom([[-2, 1], [-1, 2], [1, 2], [2, 1], [2, -1], [1, -2], [-1, -2], [-2, -1]]);
+const kingSteps = stepsFrom([[-1, 1], [0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0]]);
+// The squares a pawn of a side takes a square from, those it takes on, and those it pushes to: one, or two from its first rank.
+const pawnsTaking = { w: stepsFrom([[-1, -1], [1, -1]]), b: stepsFrom([[-1, 1], [1, 1]]) };
+const pawnCaptures = { w: stepsFrom([[-1, 1], [1, 1]]), b: stepsFrom([[1, -1], [-1, -1]]) };
+const pawnPushes = { w: pushesFrom(1, "2"), b: pushesFrom(-1, "7") };
+const sliderRays = {
+    b: raysFrom([[-1, 1], [1, 1], [1, -1], [-1, -1]]),
+    r: raysFrom([[0, 1], [1, 0], [0, -1], [-1, 0]]),
+    q: raysFrom([[-1, 1], [0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0]]),
+};
+// Each line from each square, with the pieces that move along it.
+const lineSteps = [[0, 1, "rq"], [0, -1, "rq"], [1, 0, "rq"], [-1, 0, "rq"], [1, 1, "bq"], [1, -1, "bq"], [-1, 1, "bq"], [-1, -1, "bq"]];
+const linesFrom = new Map(squares.map((square) => [square, lineSteps.map(([file, rank, sliders]) => ({ squares: rayFrom(square, file, rank), sliders }))]));
+// The lines of lineSteps that run opposite ways from a square.
+const opposite = [[0, 1], [2, 3], [4, 7], [5, 6]];
+function stepsFrom(steps) {
+    return new Map(squares.map((square) => [square, steps.map(([file, rank]) => squareAt(square, file, rank)).filter((each) => each !== undefined)]));
+}
+function raysFrom(steps) {
+    return new Map(squares.map((square) => [square, steps.map(([file, rank]) => rayFrom(square, file, rank))]));
+}
+function pushesFrom(step, firstRank) {
+    return new Map(squares.map((square) => [square, (square[1] === firstRank ? [step, 2 * step] : [step]).map((rank) => squareAt(square, 0, rank)).filter((each) => each !== undefined)]));
+}
+function rayFrom(from, fileStep, rankStep) {
+    const ray = [];
+    for (let next = squareAt(from, fileStep, rankStep); next !== undefined; next = squareAt(next, fileStep, rankStep)) {
+        ray.push(next);
+    }
+    return ray;
+}
+function squareAt(from, fileStep, rankStep) {
+    const file = files.indexOf(from[0]) + fileStep;
+    const rank = Number(from[1]) + rankStep;
+    return file >= 0 && file < 8 && rank >= 1 && rank <= 8 ? `${files[file]}${rank}` : undefined;
+}

package/dist/core/possibilities.d.ts

@@ -0,0 +1,38 @@
+import { Chess, type Square } from "chess.js";
+import type { Move } from "./game.ts";
+/** A capture of the side to move, with what the piece taken is to the piece taking it: none when it is defended and worth less. */
+export interface Capture {
+    readonly san: string;
+    readonly fact?: "undefended" | "worth more" | "same value" | "outnumbered";
+}
+/** A move that attacks two targets or more: a fork when the piece moved attacks them all, else a double attack with a piece it uncovers. */
+export interface DoubleAttack {
+    readonly san: string;
+    readonly targets: readonly Square[];
+    readonly fork: boolean;
+}
+/** A move after which a reply of the other side stalemates the side that moved: those replies, or all when every one does. */
+export interface StalemateTrap {
+    readonly san: string;
+    readonly replies: readonly string[] | "all";
+}
+/** What a side's moves would do to the other side. */
+export interface Chances {
+    readonly doubleAttacks: readonly DoubleAttack[];
+    readonly discoveredChecks: readonly string[];
+    readonly doubleChecks: readonly string[];
+    readonly promotions: readonly string[];
+}
+/** What the moves of the side to move would do. */
+export interface Possibilities extends Chances {
+    readonly captures: readonly Capture[];
+    readonly stalemates: readonly string[];
+    readonly stalemateTraps: readonly StalemateTrap[];
+}
+/** The possibilities of a chess.js board, whose legal moves are given: computed once for each position, by its key, and frozen. */
+export declare function possibilitiesOf(chess: Chess, legal: readonly Move[]): Possibilities;
+/**
+ * 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 declare function threatsOf(chess: Chess): Chances | undefined;

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

@@ -65,7 +65,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,9 +63,8 @@ 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) ? Object.fromEntries(Object.entries(record.tags).filter(([name]) => name !== "Annotator" && name !== effortTag)) : record.tags;
     return comment === "" ? { tags, moves } : { tags, comment, moves };
 }
 /** The arrows and squares as PGN's [%cal] and [%csl] write them, for a comment; empty without any. */
@@ -82,9 +81,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 +125,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 +158,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/analysis.d.ts

@@ -1,12 +1,16 @@
-/** 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, and the moves whose note the chat corrected with the player, which the analyst leaves (D-101).
+ */
 export interface Analysis {
     readonly game: string;
     readonly at: string;
     readonly brought?: true;
+    readonly corrected?: readonly string[];
 }
-/** 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;
+/** 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 declare function startAnalysis(folder: string, game: string, now: Date, brought?: boolean, corrected?: readonly 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;