chesspal 0.2.3 → 0.3.0

package/dist/commands/view.js

@@ -1,23 +1,37 @@
-/** The view after the player's move: the check, the pieces attacked, then what is at risk, the pins, the checks and the moves of each piece. */
-export function compactView(facts, turn) {
+/**
+ * The view after the player's move, in the masters' order (D-100): the check, the checks, the captures, the threats, what the moves would do, the pins,
+ * skewers and loose pieces, the pieces attacked, the moves of each piece.
+ */
+export function compactView(facts, turn, possible) {
     const names = namesOf(facts);
     const attacked = officersOf(facts).filter((piece) => piece.attackers.length > 0);
     const pieces = attacked.length === 0 ? ["Attacked pieces: none"] : ["Attacked pieces (attackers / defenders):", ...attacked.map((piece) => pieceLine(piece, names, true))];
-    return [...checkLines(facts, turn, names), ...pieces, ...tacticLines(facts, turn, names)];
+    return [...checkLines(facts, turn, names), ...tacticLines(facts, turn, names, possible, pieces)];
 }
 /** The view of a level without the tactical facts (D-60): the check and the legal moves by piece, which are the rules (D-17). */
 export function boardView(facts, turn) {
     const names = namesOf(facts);
     return [...checkLines(facts, turn, names), ...legalLines(facts, names)];
 }
-/** The whole view, for look: every piece with its attackers and defenders, then the same lines as the compact view. */
-export function fullView(facts, turn) {
+/** The whole view, for look: the same lines as the compact view, with every piece's attackers and defenders. */
+export function fullView(facts, turn, possible) {
     const names = namesOf(facts);
     const sides = sidesInOrder.flatMap((side) => [
         `${colourName(side)} pieces (attackers / defenders):`,
         ...officersOf(facts).filter((piece) => piece.side === side).map((piece) => pieceLine(piece, names, false)),
     ]);
-    return [...checkLines(facts, turn, names), ...sides, ...tacticLines(facts, turn, names)];
+    return [...checkLines(facts, turn, names), ...tacticLines(facts, turn, names, possible, sides)];
+}
+/** What the moves of the side to move would do, in one line for a move of the analysis: fork Nc7+ (Ke8 Ra8); stalemate Qf7; none when nothing. */
+export function tacticsText(facts, possibilities, withTraps) {
+    const names = namesOf(facts);
+    const traps = withTraps ? possibilities.stalemateTraps.map(({ san, replies }) => `${san} (if ${replies === "all" ? "any reply" : replies.join(" or ")})`) : [];
+    const parts = [
+        ...chanceParts(possibilities, names),
+        kindPart("stalemate", possibilities.stalemates),
+        kindPart("stalemate trap", traps),
+    ].filter((part) => part !== undefined);
+    return parts.length === 0 ? undefined : parts.join("; ");
 }
 /** What is at risk, in one line for a move of the analysis (D-68): undefended Black Nf6; by a cheaper piece White Qd1; outnumbered Black Pe5; none when nothing is. */
 export function riskLine(facts) {
@@ -54,22 +68,65 @@ const sidesInOrder = ["white", "black"];
 function checkLines(facts, turn, names) {
     return facts.checkedBy === undefined ? [] : [`${colourName(turn)} is in check from ${facts.checkedBy.map(names.piece).join(" and ")}.`];
 }
-/** What is at risk, loose and pinned, the checks of both sides, and the legal moves of the side to move by piece. */
-function tacticLines(facts, turn, names) {
+/**
+ * In the masters' order (D-100): the side to move's checks and captures, the threats (what is at risk, the other side's checks and chances), what its
+ * moves would do, the pins, skewers and loose pieces, the pieces in detail, its legal moves by piece.
+ */
+function tacticLines(facts, turn, names, possible, detail) {
     const list = (squares) => bySide(facts, squares, names) || "none";
     const atRisk = facts.undefended.length === 0 && facts.attackedByCheaper.length === 0 && facts.outnumbered.length === 0
         ? "At risk: none"
         : `Attacked and undefended: ${list(facts.undefended)}; defended, but attacked by a cheaper piece: ${list(facts.attackedByCheaper)}; `
             + `attacked more times than defended: ${list(facts.outnumbered)}`;
     const pins = facts.pins.map((pin) => `${names.sided(pin.square)} to ${names.piece(pin.to)} by ${names.piece(pin.by)}`);
+    const skewers = facts.skewers.map((skewer) => `${names.sided(skewer.square)} with ${names.piece(skewer.to)} behind, by ${names.piece(skewer.by)}`);
+    const [ownChecks, ...otherChecks] = checksLines(facts, turn);
+    // A game over has no moves to tell of.
+    const moves = possible !== undefined && facts.pieces.some((piece) => (piece.moves?.length ?? 0) > 0) ? possible : undefined;
     return [
+        ownChecks,
+        ...(moves === undefined ? [] : [captureLine(moves.possibilities)]),
         atRisk,
-        `Loose: ${list(facts.loose)}`,
+        ...otherChecks,
+        ...(moves === undefined ? [] : threatLines(moves, turn, names)),
+        ...(moves === undefined ? [] : [`${colourName(turn)} (to move) tactics: ${tacticsText(facts, moves.possibilities, moves.strong) ?? "none"}`]),
         `Pinned: ${pins.join(", ") || "none"}`,
-        ...checksLines(facts, turn),
+        ...(skewers.length === 0 ? [] : [`Skewered: ${skewers.join(", ")}`]),
+        `Loose: ${list(facts.loose)}`,
+        ...detail,
         ...legalLines(facts, names),
     ];
 }
+/** The captures of the side to move, each with what the piece taken is to the piece taking it. */
+function captureLine({ captures }) {
+    return `Captures: ${captures.map((capture) => (capture.fact === undefined ? capture.san : `${capture.san} (${capture.fact})`)).join(", ") || "none"}`;
+}
+/** What the other side's moves would do if it were to move: its promotions, and as the level sees them its double attacks and discovered checks. */
+function threatLines({ threats, strong }, turn, names) {
+    if (threats === undefined) {
+        return [];
+    }
+    const parts = [
+        kindPart("promote", threats.promotions),
+        ...(strong ? chanceParts({ ...threats, promotions: [] }, names) : []),
+    ].filter((part) => part !== undefined);
+    return parts.length === 0 ? [] : [`${colourName(turn === "white" ? "black" : "white")} threats, if it were to move: ${parts.join("; ")}`];
+}
+/** A side's forks, double attacks, double and discovered checks and promotions, each kind with its moves. */
+function chanceParts(chances, names) {
+    const attack = ({ san, targets }) => `${san} (${targets.map(names.piece).join(" ")})`;
+    return [
+        kindPart("fork", chances.doubleAttacks.filter((each) => each.fork).map(attack)),
+        kindPart("double attack", chances.doubleAttacks.filter((each) => !each.fork).map(attack)),
+        kindPart("double check", chances.doubleChecks),
+        kindPart("discovered check", chances.discoveredChecks),
+        kindPart("promote", chances.promotions),
+    ];
+}
+/** A kind with its moves, comma-separated; none without moves. */
+function kindPart(kind, moves) {
+    return moves.length === 0 ? undefined : `${kind} ${moves.join(", ")}`;
+}
 /** The checks the side to move can give, and those the other side could give if it were to move; one line when neither has any. */
 function checksLines(facts, turn) {
     if (facts.checks.length === 0 && facts.otherChecks?.length === 0) {

package/dist/core/facts.d.ts

@@ -1,4 +1,4 @@
-import { Chess, type Color, type Square } from "chess.js";
+import { Chess, type Color, type PieceSymbol, type Square } from "chess.js";
 import type { Move, Side } from "./game.ts";
 /** A piece's letter, as SAN writes it, with P for a pawn. */
 export type PieceLetter = "K" | "Q" | "R" | "B" | "N" | "P";
@@ -60,8 +60,20 @@ export interface Facts {
 export declare function factsOf(chess: Chess, legal: readonly Move[]): Facts;
 /** Which pieces attack a square: chess.js's direct attacks, a piece pinned to its king only along the pin's line, and the pawns that take en passant. */
 export type Reach = (square: Square, color: Color) => Square[];
+/** What the attacks read of a board: its pieces, where a side's pieces of a type stand, and which pieces of a side attack a square, as chess.js counts them. */
+export interface Board {
+    get(square: Square): {
+        type: PieceSymbol;
+        color: Color;
+    } | undefined;
+    findPiece(piece: {
+        type: PieceSymbol;
+        color: Color;
+    }): Square[];
+    attackers(square: Square, color: Color): Square[];
+}
 /** Which pieces attack a square as the facts count them: a piece pinned to its king only along the pin's line, though it still gives check; no en passant. */
-export declare function attacksOf(chess: Chess): Reach;
+export declare function attacksOf(board: Board): Reach;
 /** The squares strictly between two squares on one line. */
 export declare function squaresBetween(from: Square, to: Square): Square[];
 export declare function fileOf(square: Square): number;

package/dist/core/facts.js

@@ -1,5 +1,6 @@
 // What a position shows, computed without judging it (D-19, D-26): who attacks and defends each piece, what is at risk, the pins and skewers, the checks, the moves of each piece.
 import { Chess } from "chess.js";
+import { mayCastle, Placement, turnPassed } from "./placement.js";
 /** The facts of a chess.js board, whose legal moves are given: computed once for each position, by its key, and frozen. */
 export function factsOf(chess, legal) {
     const key = chess.hash();
@@ -24,8 +25,9 @@ const order = { k: 0, q: 1, r: 2, b: 3, n: 4, p: 5 };
 const lines = [[0, 1, "r"], [0, -1, "r"], [1, 0, "r"], [-1, 0, "r"], [1, 1, "b"], [1, -1, "b"], [-1, 1, "b"], [-1, -1, "b"]];
 const files = "abcdefgh";
 /** Which pieces attack a square as the facts count them: a piece pinned to its king only along the pin's line, though it still gives check; no en passant. */
-export function attacksOf(chess) {
-    return alongPins(chess, piecesOf(chess).filter((piece) => piece.type === "k").flatMap((king) => pinsTo(chess, king)));
+export function attacksOf(board) {
+    const kings = ["w", "b"].flatMap((color) => board.findPiece({ type: "k", color }).map((square) => ({ square, type: "k", color })));
+    return alongPins(board, kings.flatMap((king) => pinsTo(board, king)));
 }
 /** The squares strictly between two squares on one line. */
 export function squaresBetween(from, to) {
@@ -164,17 +166,40 @@ function enPassantVictim(chess) {
 }
 /** The checks of the side not to move, on the same board with the turn passed: no en passant, which belonged to the side to move. */
 function otherChecks(chess) {
-    const fields = chess.fen().split(" ");
-    fields[1] = chess.turn() === "w" ? "b" : "w";
-    fields[3] = "-";
-    return new Chess(fields.join(" ")).moves().filter((san) => /[+#]$/.test(san));
+    const other = chess.turn() === "w" ? "b" : "w";
+    // Castling may check, and the board of pieces alone does not try it: where the other side may castle, chess.js lists all its moves.
+    if (mayCastle(chess, other)) {
+        return turnPassed(chess).moves().filter((san) => /[+#]$/.test(san));
+    }
+    // Else its moves are tried and written on the board of pieces alone, in chess.js's order (D-34); chess.js writes the rare one it cannot.
+    const board = new Placement(chess);
+    const moves = board.movesOf(other);
+    const checks = moves.filter((move) => {
+        board.play(move);
+        const check = board.inCheck(chess.turn());
+        board.undo();
+        return check;
+    }).map((move) => board.sanOf(move, moves));
+    return checks.includes(undefined) ? turnPassed(chess).moves().filter((san) => /[+#]$/.test(san)) : checks;
 }
 /** The pieces on the board, White's first, each side's from the king down (K Q R B N P), then by square. */
 function piecesOf(chess) {
     return chess.board().flat().filter((cell) => cell !== null).map(({ square, type, color }) => ({ square, type, color })).sort((left, right) => compare(right.color, left.color) || order[left.type] - order[right.type] || compare(left.square, right.square));
 }
-/** The squares from a square to the edge of the board, one step at a time. */
+/** The squares from a square to the edge of the board, one step at a time; worked out once for each square and step. */
 function rayFrom(from, fileStep, rankStep) {
+    const step = (fileStep + 1) * 3 + rankStep + 1;
+    let known = rays.get(from);
+    if (known === undefined) {
+        known = [];
+        rays.set(from, known);
+    }
+    known[step] ??= Object.freeze(walked(from, fileStep, rankStep));
+    return known[step];
+}
+// The rays from each square already walked, by their step.
+const rays = new Map();
+function walked(from, fileStep, rankStep) {
     const ray = [];
     let file = fileOf(from) + fileStep;
     let rank = rankOf(from) + rankStep;

package/dist/core/game.d.ts

@@ -1,6 +1,7 @@
 import { type Square } from "chess.js";
 import { type Facts } from "./facts.ts";
 import { type Illegal } from "./illegal.ts";
+import { type Chances, type Possibilities } from "./possibilities.ts";
 import { type Profile } from "./profile.ts";
 import { type Annotation, type GameRecord } from "./record.ts";
 export type { Square } from "chess.js";
@@ -73,6 +74,10 @@ export declare class Game {
     get lastMove(): Move | undefined;
     /** What the position shows (D-26): attackers and defenders, pieces at risk, pins, checks, the moves of each piece; computed once for each position. */
     get facts(): Facts;
+    /** What the moves would do (D-100): captures, double attacks, discovered checks, promotions, stalemates; once for each position. */
+    get possibilities(): Possibilities;
+    /** What the other side's moves would do if it were to move (D-100), none in check; once for each position, only where it is shown. */
+    get threats(): Chances | undefined;
     /** The positional profile (D-19): pawns, files, outposts, space, mobility, development, king safety, control, phase, draws; computed once for each position. */
     get profile(): Profile;
     /** The legal moves, or those of the piece on a square. */

package/dist/core/game.js

@@ -2,6 +2,7 @@
 import { Chess, validateFen } from "chess.js";
 import { factsOf } from "./facts.js";
 import { whyIllegal } from "./illegal.js";
+import { possibilitiesOf, threatsOf } from "./possibilities.js";
 import { profileOf } from "./profile.js";
 import { cleanComment, recordedMove } from "./record.js";
 /**
@@ -65,6 +66,14 @@ export class Game {
     get facts() {
         return factsOf(this.chess, legalMovesOf(this.chess));
     }
+    /** What the moves would do (D-100): captures, double attacks, discovered checks, promotions, stalemates; once for each position. */
+    get possibilities() {
+        return possibilitiesOf(this.chess, legalMovesOf(this.chess));
+    }
+    /** What the other side's moves would do if it were to move (D-100), none in check; once for each position, only where it is shown. */
+    get threats() {
+        return threatsOf(this.chess);
+    }
     /** The positional profile (D-19): pawns, files, outposts, space, mobility, development, king safety, control, phase, draws; computed once for each position. */
     get profile() {
         const key = this.chess.hash();

package/dist/core/index.d.ts

@@ -14,7 +14,8 @@ export { endWithMood, type Mood, moodAt, type MoodNow, moodOf, moods, moodTag, w
 export { bookMoves, indexBook, indexOpenings, inOpenings, openingOf, outOfBookMove } from "./openings.ts";
 export type { Opening, OpeningBook, OpeningIndex } from "./openings.ts";
 export { pgnDate, readPgn, writePgn } from "./pgn.ts";
+export type { Capture, Chances, DoubleAttack, Possibilities, StalemateTrap } from "./possibilities.ts";
 export type { BishopFacts, CentreSquare, KingFacts, Outpost, PawnFacts, PawnSquare, Phase, Profile, SideProfile } from "./profile.ts";
 export { movesOnly } from "./record.ts";
 export type { Annotation, GameRecord, RecordedMove } from "./record.ts";
-export { aiHostIn, type AiModel, aiModelIn, aiNameOf, annotatorOf, arrowOf, type Badge, badges, closingOf, type DrawColour, drawingsIn, drawingsText, type DrawnArrow, type DrawnSquare, gameReviewOf, isReviewed, type MoveReview, reviewed, reviewOf, squareOf, unreviewed, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.ts";
+export { aiHostIn, type AiModel, aiModelIn, aiNameOf, annotatorOf, arrowOf, type Badge, badges, closingOf, type DrawColour, drawingsIn, drawingsText, type DrawnArrow, type DrawnSquare, gameReviewOf, isReviewed, type MoveReview, reviewed, reviewOf, squareOf, unreviewed, unsigned, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.ts";

package/dist/core/index.js

@@ -9,4 +9,4 @@ export { endWithMood, moodAt, moodOf, moods, moodTag, withoutMoods } from "./moo
 export { bookMoves, indexBook, indexOpenings, inOpenings, openingOf, outOfBookMove } from "./openings.js";
 export { pgnDate, readPgn, writePgn } from "./pgn.js";
 export { movesOnly } from "./record.js";
-export { aiHostIn, aiModelIn, aiNameOf, annotatorOf, arrowOf, badges, closingOf, drawingsIn, drawingsText, gameReviewOf, isReviewed, reviewed, reviewOf, squareOf, unreviewed, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.js";
+export { aiHostIn, aiModelIn, aiNameOf, annotatorOf, arrowOf, badges, closingOf, drawingsIn, drawingsText, gameReviewOf, isReviewed, reviewed, reviewOf, squareOf, unreviewed, unsigned, withAiHost, withAiModel, withAnnotator, withGameReview, } from "./review.js";

package/dist/core/placement.d.ts

@@ -0,0 +1,63 @@
+import { Chess, type Color, type PieceSymbol, type Square } from "chess.js";
+/** A piece, by its type and side. */
+export interface Piece {
+    readonly type: PieceSymbol;
+    readonly color: Color;
+}
+/** A piece on its square. */
+export interface Placed extends Piece {
+    readonly square: Square;
+}
+/** A move to try: its squares, and the piece a pawn becomes. */
+export interface Tried {
+    readonly from: Square;
+    readonly to: Square;
+    readonly promotion?: PieceSymbol;
+}
+/** The pieces of a position, moved without the rules' checks and taken back in the reverse order. */
+export declare class Placement {
+    #private;
+    constructor(chess: Chess);
+    get(square: Square): Piece | undefined;
+    /** The squares of a side's pieces of one type. */
+    findPiece({ type, color }: Piece): Square[];
+    /** A side's pieces. */
+    piecesOf(color: Color): Placed[];
+    /** 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: Square, color: Color): Square[];
+    /** The squares the piece on a square attacks: by its steps, or along its lines up to the first piece. */
+    attackedFrom(square: Square): Square[];
+    /** 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: Square, color: Color): boolean;
+    /** 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: Color): boolean;
+    /** 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: Tried): Piece | undefined;
+    /** Takes back the last move played. */
+    undo(): void;
+    /**
+     * 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: Color): Tried[];
+    /** Whether a side has a move of those, stopping at the first. */
+    hasMove(color: Color): boolean;
+    /**
+     * 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: Tried, moves: readonly Tried[]): string | undefined;
+    /** Whether a side's king is attacked. */
+    inCheck(color: Color): boolean;
+}
+/** A move's SAN, and where chess.js lists it among the side's moves: the lists keep that order. */
+export interface Named {
+    readonly san: string;
+    readonly order: number;
+}
+/** 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 declare function namesOn(boardOf: () => Chess): (move: Tried) => Named | undefined;
+/** 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 declare function mayCastle(chess: Chess, color: Color): boolean;
+/** The same board with the other side to move, without en passant, which belonged to the side to move. */
+export declare function turnPassed(chess: Chess): Chess;

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;