chesspal 0.2.3 → 0.2.4

package/dist/commands/status.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { type GameSummary } from "./game-summary.ts";
+import { type Written } from "./say.ts";
 import { type Speech } from "./speech.ts";
 interface Status {
     version: string;
@@ -16,12 +17,13 @@ interface Status {
     /** Why the game on disk cannot be read, when it cannot. */
     problem?: string;
     /** What the player wrote on the board page that the AI has not answered yet, all of it. */
-    words?: string[];
+    words?: Written[];
     /** The game in analysis on the board page once none goes on (D-69), which the player may have brought there. */
     analysis?: {
         game: string;
         brought?: true;
         analyst?: true;
+        review?: string;
     };
     /** A game going on from before this chat, told once a chat: the player says whether to go on with it. */
     fromBefore?: true;

package/dist/commands/status.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { gameReviewOf, leadOf, reviewOf } from "../core/index.js";
 import { archivedName, cleanSince, endOf, gameInAnalysis, lastChatStart } from "../games/index.js";
 import { coachAgent, outdatedHostFiles } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
@@ -13,6 +14,7 @@ import { playerLine } from "./profiles.js";
 import { defineCommand } from "./registry.js";
 import { unansweredWords } from "./say.js";
 import { speechLine, speechOf } from "./speech.js";
+import { namedGame } from "./study.js";
 /** What Chesspal sees now, the first call of a chat: a dashboard under 150 tokens while the player is to move, with the next step. */
 export const status = defineCommand({
     name: "status",
@@ -60,7 +62,13 @@ export const status = defineCommand({
             const analysis = current === undefined || status.game?.end !== undefined ? gameInAnalysis(folder) : undefined;
             if (analysis !== undefined) {
                 // The analyst agent goes over a game the player brought, where it runs, and the chat over what it reviewed (D-89).
-                status.analysis = { game: analysis.game, ...(analysis.brought === true ? { brought: true } : {}), ...(analystRuns(context) ? { analyst: true } : {}) };
+                const review = analysis.brought === true ? undefined : reviewProgress(context, analysis.game);
+                status.analysis = {
+                    game: analysis.game,
+                    ...(analysis.brought === true ? { brought: true } : {}),
+                    ...(analystRuns(context) ? { analyst: true } : {}),
+                    ...(review === undefined ? {} : { review }),
+                };
             }
         }
         catch (error) {
@@ -103,16 +111,33 @@ function fromBeforeChat(context, started) {
     const start = lastChatStart(context.folder);
     return start === undefined || cleanSince(start, started);
 }
-/** The game in analysis; the next step when the player has just brought it on the board page. */
-function analysisLine({ game, brought, analyst }) {
+/** The game in analysis, with how far its review has got; the next step when the player has just brought it on the board page. */
+function analysisLine({ game, brought, analyst, review }) {
     if (brought === true) {
         return analyst === true
             ? `The player brought ${game} on the board page to analyse it. Next: ${analystLine(game)}`
             : `The player brought ${game} on the board page to analyse it. Next: call analyse_game {"game": "${game}"}, then keep your review on that page with annotate_game, and go over it with them.`;
     }
-    return analyst === true
-        ? `In analysis on the board page: ${game}. ${reviewedLine(game)}`
-        : `In analysis on the board page: ${game}; analyse_game {"game": "${game}"} goes over it with the player.`;
+    const shown = `In analysis on the board page: ${game}${review === undefined ? "" : ` (${review})`}`;
+    return analyst === true ? `${shown}. ${reviewedLine(game)}` : `${shown}; analyse_game {"game": "${game}"} goes over it with the player.`;
+}
+/** How far the review of a game has got, as the board page shows it (Priya): done once it holds the word on the whole game. */
+function reviewProgress(context, game) {
+    try {
+        const { record } = namedGame(context, game);
+        if (gameReviewOf(record) !== undefined) {
+            return "its review is done";
+        }
+        const noted = record.moves.filter(({ comment }) => {
+            const review = reviewOf(comment);
+            return review !== undefined && (review.badge !== "book" || review.note !== undefined);
+        }).length;
+        const estimated = record.moves.filter(({ comment }) => leadOf(comment) !== undefined).length;
+        return noted === 0 && estimated === 0 ? "no review yet" : `its review so far: notes on ${noted} moves, who is ahead after ${estimated} of ${record.moves.length}`;
+    }
+    catch {
+        return undefined;
+    }
 }
 /**
  * The game's lines; a game the player brought to analyse takes the place of the next step. The coach to start goes just before the next step, where

package/dist/commands/study.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { Game, type GameRecord } from "../core/index.ts";
-import { type CurrentGame } from "../games/index.ts";
+import { type CurrentGame, type Shown } from "../games/index.ts";
 import type { Context } from "./context.ts";
 /** What look and position take to show any position of a game that is over. */
 export declare const studyInput: {
@@ -21,10 +21,20 @@ export interface StudiedPosition {
 export declare function noGameGoingOn(context: Context): CurrentGame | undefined;
 /** The game played or kept to study by that name; without one, the current game over, or else the latest of the archive; refused while a game goes on. */
 export declare function gameToStudy(context: Context, name?: string): Studied;
+/**
+ * The game look and position show: without a name, for the chat, the one in analysis on the board page, which the player's words there name by their move
+ * alone (D-101, Priya); else as gameToStudy. An agent names its game, since the page may turn to another meanwhile.
+ */
+export declare function gameShown(context: Context, name?: string): Studied;
 /** A game played or kept to study by its name as the lists write it, or without its folder or its .pgn; refused when it is not there. */
 export declare function namedGame(context: Context, name: string): Required<Studied>;
 /** The index of a move in the game's record, given as analyse_game numbers it: 12. for White's, 12... for Black's, 12...Kf8 too. */
 export declare function moveIndex(record: GameRecord, move: string): number;
+/**
+ * A position of a game over as the board page shows it in analysis (D-101): the game's name, how many of its moves it shows, and the last of them numbered;
+ * none for a game or a position there is not, or while a game goes on.
+ */
+export declare function shownPosition(context: Context, game: string, at: number): Shown | undefined;
 /** The number of each move of a game as the analysis writes it: 1. for White's first move, 1... for Black's. */
 export declare function moveNumbers(record: GameRecord): string[];
 /**

package/dist/commands/study.js

@@ -2,13 +2,13 @@
 // goes on, nothing is studied: the analysis would help the game being played (D-60, D-62).
 import { z } from "zod";
 import { Game } from "../core/index.js";
-import { archivedGame, archivedGames, archivedName, endOf, keptGame, listedName } from "../games/index.js";
+import { archivedGame, archivedGames, archivedName, endOf, gameInAnalysis, keptGame, listedName } from "../games/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { gameAt } from "./clock.js";
 import { colourName } from "./view.js";
 /** What look and position take to show any position of a game that is over. */
 export const studyInput = {
-    game: z.string().optional().describe("a game's name, as past_games, study_games or analyse_game writes it: one of its positions"),
+    game: z.string().optional().describe("a game's name, as past_games, study_games or analyse_game writes it: one of its positions; without it, the game on the board page"),
     move: z.string().optional().describe("the position after this move of a game over, as analyse_game numbers it: 12. for White's, 12... for Black's"),
 };
 /** The current game when it is over, or none; refused while it goes on, for every game: games are analysed once the one being played is over. */
@@ -38,6 +38,18 @@ export function gameToStudy(context, name) {
     }
     return { record: archivedGame(folder, latest), name: latest };
 }
+/**
+ * The game look and position show: without a name, for the chat, the one in analysis on the board page, which the player's words there name by their move
+ * alone (D-101, Priya); else as gameToStudy. An agent names its game, since the page may turn to another meanwhile.
+ */
+export function gameShown(context, name) {
+    const analysis = name === undefined && context.agent === undefined ? gameInAnalysis(gameFolder(context.home())) : undefined;
+    if (analysis === undefined) {
+        return gameToStudy(context, name);
+    }
+    noGameGoingOn(context);
+    return namedGame(context, analysis.game);
+}
 /** A game played or kept to study by its name as the lists write it, or without its folder or its .pgn; refused when it is not there. */
 export function namedGame(context, name) {
     const folder = gameFolder(context.home());
@@ -48,6 +60,23 @@ export function namedGame(context, name) {
 export function moveIndex(record, move) {
     return plyOf(record, moveNumbers(record), move);
 }
+/**
+ * A position of a game over as the board page shows it in analysis (D-101): the game's name, how many of its moves it shows, and the last of them numbered;
+ * none for a game or a position there is not, or while a game goes on.
+ */
+export function shownPosition(context, game, at) {
+    try {
+        noGameGoingOn(context);
+        const { name, record } = namedGame(context, game);
+        if (!Number.isInteger(at) || at < 0 || at > record.moves.length) {
+            return undefined;
+        }
+        return at === 0 ? { game: name, at } : { game: name, at, move: `${moveNumbers(record)[at - 1]}${record.moves[at - 1].san}` };
+    }
+    catch {
+        return undefined;
+    }
+}
 /** The number of each move of a game as the analysis writes it: 1. for White's first move, 1... for Black's. */
 export function moveNumbers(record) {
     const start = new Game({ tags: record.tags, moves: [] }).position;

package/dist/commands/view.d.ts

@@ -1,10 +1,22 @@
-import type { Facts, Material, Side } from "../core/index.ts";
-/** 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 declare function compactView(facts: Facts, turn: Side): string[];
+import type { Chances, Facts, Material, Possibilities, Side } from "../core/index.ts";
+/** What the moves would do (D-100), and the other side's threats, none in check. */
+export interface Possible {
+    readonly possibilities: Possibilities;
+    readonly threats: Chances | undefined;
+    /** The level sees the threats' double attacks and discovered checks, and the stalemate traps: from the strong level up. */
+    readonly strong: boolean;
+}
+/**
+ * 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 declare function compactView(facts: Facts, turn: Side, possible?: Possible): string[];
 /** 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 declare function boardView(facts: Facts, turn: Side): string[];
-/** The whole view, for look: every piece with its attackers and defenders, then the same lines as the compact view. */
-export declare function fullView(facts: Facts, turn: Side): string[];
+/** The whole view, for look: the same lines as the compact view, with every piece's attackers and defenders. */
+export declare function fullView(facts: Facts, turn: Side, possible?: Possible): string[];
+/** 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 declare function tacticsText(facts: Facts, possibilities: Possibilities, withTraps: boolean): string | undefined;
 /** 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 declare function riskLine(facts: Facts): string | undefined;
 export declare function colourName(side: Side): string;

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,6 +14,7 @@ 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";

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;