chesspal 0.0.1 → 0.1.0

package/dist/commands/play-move.js

@@ -0,0 +1,102 @@
+// A move of the AI or of the player on the current game: played, timed by the clock, saved, and archived when it ends the game.
+import { clockAfterMove, clockTag, reviewed } from "../core/index.js";
+import { archiveEnded, endOf, loadGame, saveGame, talkLine } from "../games/index.js";
+import { gameGoingOn, summaryOf, withThought } from "./game-summary.js";
+import { colourName } from "./view.js";
+/**
+ * Plays a move for one side `now` and saves the game, with the time it took and the clock after it in its comment ([%clk]). A refused move, or words refused
+ * with it, change nothing: it throws the message `refused` writes from the core's.
+ */
+export function playMove(folder, now, mover, text, refused, { comment, said, offerDraw = false, allowance = 0, judged } = {}) {
+    // A flag falls only past the allowance.
+    const before = gameToMove(folder, mover, new Date(now.getTime() - allowance));
+    const { game } = before;
+    const position = game.position;
+    // The words are checked before the move, which changes the live game; they count as said after it.
+    const line = said === undefined ? undefined : talkLine(before, mover, said.text, said.at, game.record.moves.length + 1);
+    if (mover === "ai" && before.clock?.waiting === true) {
+        throw new Error("The clocks wait for the player to start the game with Start on the board page: don't move yet, the doorbell wakes you then. Nothing changed.");
+    }
+    if (offerDraw && game.record.moves.length === 0) {
+        throw new Error("A draw can be offered once each side has made a move: play the move without offer_draw. Nothing changed.");
+    }
+    if (judged !== undefined && game.record.moves.length === 0) {
+        throw new Error("The player has made no move yet: play without badge and note. Nothing changed.");
+    }
+    const played = game.play(text);
+    if (!played.played) {
+        throw new Error(refused(played.message, played.legal));
+    }
+    if (judged !== undefined) {
+        // The player's move is the one before the move just played: its badge and note sit in its comment, beside its clock.
+        const judging = game.record.moves.length - 1;
+        const { nags, comment: judgedComment } = reviewed(game.record.moves[judging - 1], judged);
+        game.annotate(judging, { nags, comment: judgedComment ?? "" });
+    }
+    const clock = before.clock === undefined ? undefined : clockAfterMove(before.clock, position.turn, now, allowance, mover === "player");
+    // A move declines the other side's draw offer; the mover's own stands, and the move carries it in the record as FIDE writes it, (=) (D-65). A move that
+    // ends the game leaves no offer.
+    const offers = (offerDraw || before.drawOffer === mover) && endOf(game) === undefined;
+    const current = { ...before, drawOffer: offers ? mover : undefined, ...(clock === undefined ? {} : { clock }) };
+    const words = [offers ? "(=)" : undefined, comment, clock === undefined ? undefined : clockTag(clock.left[position.turn])].filter((part) => part !== undefined);
+    if (words.length > 0) {
+        game.annotate(game.record.moves.length, { comment: words.join(" ") });
+    }
+    if (line !== undefined) {
+        current.talk.push(line);
+    }
+    saveGame(folder, current);
+    const { archive, warning } = endOf(game) === undefined ? {} : archiveEnded(folder, current);
+    const result = { move: `${position.moveNumber}${position.turn === "white" ? "." : "..."}${played.move.san}`, game: withThought(summaryOf(current, now, archive), folder, current) };
+    if (played.note !== undefined) {
+        result.note = played.note;
+    }
+    if (warning !== undefined) {
+        result.warning = warning;
+    }
+    return result;
+}
+/** A chat's move, resignation or game replaced on a position it has not seen (D-71): it was decided on another. */
+export class PositionChanged extends Error {
+    constructor() {
+        super("The game may have changed since you last saw it, in another chat or on the board page: call status to see it, then decide. Nothing changed.");
+    }
+}
+/** The position of the profile's game now. */
+export function positionIn(folder) {
+    const current = loadGame(folder);
+    return current === undefined ? { plies: 0 } : { started: current.started, plies: current.game.record.moves.length };
+}
+/**
+ * Refuses a chat's move or ending on a position it has not seen, changed by another chat or on the board page, or before any tool showed it the game
+ * (D-71). Words and the clock change no position; the command line and the page, which have no chat, are never refused.
+ */
+export function refuseUnseenPosition(context, folder) {
+    const seen = context.positionSeen;
+    if (seen === null || (seen !== undefined && !samePosition(seen, positionIn(folder)))) {
+        throw new PositionChanged();
+    }
+}
+/** Refuses a chat's words on a game it has not seen, which another chat or the page started: words on a later move of the same game do no harm. */
+export function refuseOtherGame(context, folder) {
+    const seen = context.positionSeen;
+    const now = positionIn(folder);
+    if (now.started !== undefined && (seen === null || (seen !== undefined && seen.started !== now.started))) {
+        throw new PositionChanged();
+    }
+}
+function samePosition(one, other) {
+    return one.started === other.started && one.plies === other.plies;
+}
+function gameToMove(folder, mover, now) {
+    const current = gameGoingOn(folder, now);
+    const { turn } = current.game.position;
+    const aiToMove = turn === current.ai;
+    if (mover === "player" && aiToMove) {
+        throw new Error(`It is your move (${colourName(turn)}): call ai_move. Nothing changed.`);
+    }
+    if (mover === "ai" && !aiToMove) {
+        throw new Error(`It is the player's move (${colourName(turn)}): wait for it, then call player_move. Nothing changed.`);
+    }
+    return current;
+}

package/dist/commands/player-move.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { type MovePlayed } from "./game-summary.ts";
+/** The player's move, written in the chat and given by the AI: it answers with the position the AI decides on (D-34). */
+export declare const playerMove: import("./registry.ts").Command<z.ZodObject<{
+    move: z.ZodString;
+    offer_draw: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, PlayerMove>;
+/** The player's move, with the board page's address once a game while no browser has it open (D-85). */
+interface PlayerMove extends MovePlayed {
+    invite?: string;
+}
+/**
+ * The time a move in the chat leaves off the player's clock (D-36): the AI writing after its move and reading the player's, about 10 s as Priya measured.
+ * Claude Code's hooks will time it exactly (T-53); the board page's moves need none.
+ */
+export declare const chatAllowance = 10000;
+export {};

package/dist/commands/player-move.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { gameFolder } from "../profiles/index.js";
+import { closingLines, lastMoveText, moveLines, shownMove } from "./game-summary.js";
+import { inviteLine, pageInvite } from "./page-link.js";
+import { playMove, positionIn, refuseUnseenPosition } from "./play-move.js";
+import { defineCommand } from "./registry.js";
+import { newWords } from "./say.js";
+/** The player's move, written in the chat and given by the AI: it answers with the position the AI decides on (D-34). */
+export const playerMove = defineCommand({
+    name: "player_move",
+    description: "Plays the move the player wrote in the chat, and answers with the position for your reply: the FEN, your legal moves by piece and, from "
+        + "the club level up, the pieces attacked with their defenders, the pins and the checks; look gives the rest. Give the move in SAN or as squares, and never choose for "
+        + 'them: if their words fit two moves, or it is refused, ask them again. Example: player_move {move: "Nf3"}.',
+    input: z.object({
+        move: z.string().min(1).describe("the player's move, in SAN (Nf3, exd5, O-O, e8=Q) or as squares (g1f3, e7e8q)"),
+        offer_draw: z.boolean().optional().describe("true when the player offers a draw with this move: it stands until your move"),
+    }),
+    alwaysLoad: true,
+    showsGame: true,
+    positionals: ["move"],
+    run: ({ move, offer_draw: offerDraw = false }, context) => {
+        const folder = gameFolder(context.home());
+        // A chat that has seen no game yet, new or resumed, plays the player's own move: its answer shows the game the AI decides on (D-71, T-129).
+        if (context.positionSeen !== null) {
+            refuseUnseenPosition(context, folder);
+        }
+        const started = context.positionSeen === null ? positionIn(folder).started : context.positionSeen?.started;
+        const played = playMove(folder, context.now(), "player", move, (message) => `${message} Ask the player again. Nothing changed.`, { allowance: chatAllowance, offerDraw });
+        // A game over by this move has no more moves to play there: the next game's window gives the address (Federico, round of D-85).
+        const invite = played.game.end === undefined ? pageInvite(context, started) : undefined;
+        return { ...played, words: newWords(context), ...(invite === undefined ? {} : { invite }) };
+    },
+    format: (result) => [
+        `Player: ${result.game.lastMove === undefined ? shownMove(result.move) : lastMoveText(result.game.lastMove)}.`,
+        ...moveLines(result),
+        ...(result.invite === undefined ? [] : [inviteLine(result.invite)]),
+        ...closingLines(result.game, result.words),
+    ].join("\n"),
+});
+/**
+ * The time a move in the chat leaves off the player's clock (D-36): the AI writing after its move and reading the player's, about 10 s as Priya measured.
+ * Claude Code's hooks will time it exactly (T-53); the board page's moves need none.
+ */
+export const chatAllowance = 10_000;

package/dist/commands/player-say.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+/** The player's words to the AI, as the board page sends them (T-65): on the command line only, since the AI never writes for the player. */
+export declare const playerSay: import("./registry.ts").Command<z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>, string>;

package/dist/commands/player-say.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { talkLimits } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { defineCommand } from "./registry.js";
+import { say } from "./say.js";
+/** The player's words to the AI, as the board page sends them (T-65): on the command line only, since the AI never writes for the player. */
+export const playerSay = defineCommand({
+    name: "player_say",
+    description: "Writes the player's words to the AI, as the board page does: the AI reads them at its next call. "
+        + 'Example: chesspal player_say "Play faster, please."',
+    input: z.object({ text: z.string().trim().min(1, "write what you say").max(talkLimits.player, `write ${talkLimits.player} characters at most`).describe("what the player says to the AI") }),
+    cliOnly: true,
+    positionals: ["text"],
+    run: ({ text }, context) => say(gameFolder(context.home()), "player", text, context.now()).talk.at(-1).text,
+    format: (text) => `Written for the AI: «${text}». It reads it at its next call.`,
+});

package/dist/commands/ponder.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { type Thought } from "../games/index.ts";
+import { type GameSummary } from "./game-summary.ts";
+/** What ponder answers: stop, the position to think on, the position after a reply, the thoughts kept, its words said, or still the player's move. */
+type Pondered = {
+    stop: "moved" | "waited";
+} | {
+    start: Start;
+} | {
+    after: GameSummary;
+    position: number;
+    reply: string;
+} | {
+    kept: readonly Thought[];
+    position: number;
+} | {
+    waiting: number;
+} | {
+    said: number;
+};
+/** The position the player is to move in, as the AI thinks on it. */
+interface Start {
+    position: number;
+    line: string;
+    plan?: string;
+    mood?: string;
+    comment?: string;
+    talk: string[];
+}
+/**
+ * The AI's thinking on the player's time (D-72), for the agent that does it: the position, the view after a reply, its answer kept for its move, and its
+ * words on the board page. Its calls are not the chat's: the doorbell still wakes the chat for the player's move. Offered to Claude Code alone, which runs the agent.
+ */
+export declare const ponder: import("./registry.ts").Command<z.ZodObject<{
+    position: z.ZodOptional<z.ZodInt>;
+    reply: z.ZodOptional<z.ZodString>;
+    move: z.ZodOptional<z.ZodString>;
+    why: z.ZodOptional<z.ZodString>;
+    say: z.ZodOptional<z.ZodString>;
+    done: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, Pondered>;
+export {};

package/dist/commands/ponder.js

@@ -0,0 +1,167 @@
+import { z } from "zod";
+import { Game, levelOf, moodAt, sees, timeLeft } from "../core/index.js";
+import { currentPlan, endOf, keepThought, loadGame, talkLimits, thoughtKey, waitingSince } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { positionLines, summaryOf } from "./game-summary.js";
+import { levelText } from "./levels.js";
+import { defineCommand, sentence } from "./registry.js";
+import { say as sayWords } from "./say.js";
+import { boardView, colourName, compactView } from "./view.js";
+/**
+ * The AI's thinking on the player's time (D-72), for the agent that does it: the position, the view after a reply, its answer kept for its move, and its
+ * words on the board page. Its calls are not the chat's: the doorbell still wakes the chat for the player's move. Offered to Claude Code alone, which runs the agent.
+ */
+export const ponder = defineCommand({
+    name: "ponder",
+    description: "For the chesspal-ponder agents only, never from the chat: ai_move says when to start one. While the player is to move: ponder {} gives the "
+        + "position to think on; ponder {position, reply} the position after a likely reply, as you will see it; ponder {position, reply, move, why} keeps your "
+        + "answer to it, which you are given when they play it; ponder {position, say} says a word on the board page; ponder {position, done: true} waits for their "
+        + 'move. Whenever it says stop, stop. Example: ponder {position: 24, reply: "Nxe5", move: "d6", why: "The knight has to go back."}.',
+    input: z.object({
+        position: z.int().min(0).optional().describe("the position's number, as ponder {} gives it"),
+        reply: z.string().min(1).optional().describe("a move the player may play, in SAN (Nxe5) or as squares (f3e5)"),
+        move: z.string().min(1).optional().describe("your answer to that reply, in SAN or as squares"),
+        why: sentence(200).optional().describe("why, in one sentence: kept for you, hidden from the player"),
+        say: z.string().trim().min(1).max(talkLimits.ai).optional().describe("your words for the player on the board page, once, in one short sentence, of what has happened: pieces and moves in words, never in notation"),
+        done: z.boolean().optional().describe("true when you have no more replies to think on: it waits for the player's move"),
+    }),
+    byAgent: true,
+    host: "claude-code",
+    run: async ({ position, reply, move, why, say, done = false }, context) => {
+        const folder = gameFolder(context.home());
+        const current = toPonder(folder, context.now(), position);
+        if (current === undefined) {
+            return { stop: "moved" };
+        }
+        if (position === undefined) {
+            if (reply !== undefined || move !== undefined || why !== undefined || say !== undefined || done) {
+                throw new Error("Give the position's number with it: call ponder {} first, which gives it. Nothing changed.");
+            }
+            return { start: startOf(current) };
+        }
+        if ((say !== undefined || done) && (reply !== undefined || move !== undefined || why !== undefined || (say !== undefined && done))) {
+            throw new Error("One thing a call: say, done, or a reply with its answer. Nothing changed.");
+        }
+        if (say !== undefined) {
+            sayWords(folder, "agent", say, context.now());
+            return { said: position };
+        }
+        if (done) {
+            return await waitForMove(folder, context, current);
+        }
+        if (reply === undefined) {
+            throw new Error(`Name a reply of the player's: ponder {position: ${position}, reply}, or ponder {position: ${position}, done: true} when you have no more. Nothing changed.`);
+        }
+        if (move === undefined && why !== undefined) {
+            throw new Error(`Give your move with its why: ponder {position: ${position}, reply, move, why}. Nothing changed.`);
+        }
+        const after = new Game(current.game.record);
+        const played = after.play(reply);
+        if (!played.played) {
+            throw new Error(`${played.message} The player's legal moves: ${played.legal.join(" ")}. Nothing changed.`);
+        }
+        if (move === undefined) {
+            return { after: summaryOf({ game: after, ai: current.ai, started: current.started, talk: [] }, context.now()), position, reply: played.move.san };
+        }
+        if (why === undefined) {
+            throw new Error(`Say why in one sentence: ponder {position: ${position}, reply, move, why}. Nothing changed.`);
+        }
+        const answer = after.play(move);
+        if (!answer.played) {
+            throw new Error(`${answer.message} Your legal moves after ${played.move.san}: ${answer.legal.join(" ")}. Nothing changed.`);
+        }
+        return { kept: keepThought(folder, thoughtKey(current), { reply: played.move.san, move: answer.move.san, why }), position };
+    },
+    format: (pondered) => {
+        if ("stop" in pondered) {
+            return pondered.stop === "moved"
+                ? "Stop now: the player has moved, or the game is over. End with one word."
+                : "Stop now: you have waited long enough, and your answers are kept. End with one word.";
+        }
+        if ("start" in pondered) {
+            return startLines(pondered.start).join("\n");
+        }
+        if ("after" in pondered) {
+            const { after, position, reply } = pondered;
+            return [`If the player plays ${reply}:`, ...positionLines(after), `Keep your answer: ponder {position: ${position}, reply: "${reply}", move, why}.`].join("\n");
+        }
+        if ("kept" in pondered) {
+            const replies = pondered.kept.map((thought) => thought.reply).join(", ");
+            return `Kept: your answers to ${replies}. Think on another likely reply, or call ponder {position: ${pondered.position}, done: true} when you have no more.`;
+        }
+        if ("said" in pondered) {
+            return "Said on the board page, where the player reads it.";
+        }
+        return `Still the player's move: call ponder {position: ${pondered.waiting}, done: true} again.`;
+    },
+});
+/**
+ * How long one call waits for the player's move at most, under the minute a host may give a tool (Priya, T-109), how often it looks, and how long the agent
+ * waits in all before it stops: a player who leaves the game open must not keep it asking (Priya, round of T-109).
+ */
+const ponderWait = { most: 50_000, every: 500, inAll: 10 * 60_000 };
+/** The game whose position the AI thinks on, read and never written: none once the player has moved, the game is over or their flag has fallen, or the position given is another. */
+function toPonder(folder, now, position) {
+    const current = loadGame(folder);
+    if (current === undefined || endOf(current.game) !== undefined || current.game.position.turn === current.ai) {
+        return undefined;
+    }
+    // A flag fallen is the page's or the chat's to write, so that the doorbell rings it (Federico, round of T-109).
+    const { turn } = current.game.position;
+    if (current.clock !== undefined && timeLeft(current.clock, turn, now)[turn] <= 0) {
+        return undefined;
+    }
+    return position === undefined || position === current.game.record.moves.length ? current : undefined;
+}
+/** Waits for the player's move: stop once they have moved or the agent has waited long enough in all, else still their move after a while. */
+async function waitForMove(folder, context, current) {
+    const pause = context.pause ?? ((milliseconds) => new Promise((done) => setTimeout(done, milliseconds)));
+    const position = current.game.record.moves.length;
+    const start = context.now().getTime();
+    const end = Math.min(start + ponderWait.most, waitingSince(folder, thoughtKey(current), context.now()).getTime() + ponderWait.inAll);
+    while (context.now().getTime() < end) {
+        await pause(ponderWait.every);
+        if (toPonder(folder, context.now(), position) === undefined) {
+            return { stop: "moved" };
+        }
+    }
+    return end < start + ponderWait.most ? { stop: "waited" } : { waiting: position };
+}
+function startOf(current) {
+    const { game, ai, talk } = current;
+    const level = levelOf(game.record);
+    const plan = currentPlan(game.record);
+    const player = game.position.turn;
+    const { mood } = moodAt(game.record, ai);
+    const comment = wordsOf(game.record.moves.at(-1)?.comment);
+    const line = [
+        `Position ${game.record.moves.length}: the player (${colourName(player)}) to move, move ${game.position.moveNumber}; you play ${colourName(ai)} ${levelText(level)}.`,
+        `FEN: ${game.position.fen}`,
+        ...(sees(level, "tactics") ? compactView : boardView)(game.facts, player),
+    ].join("\n");
+    const said = talk.slice(-3).map((spoken) => `${spoken.who === "ai" ? "You" : "Player"}: «${spoken.text.replace(/\s+/g, " ")}»`);
+    return {
+        position: game.record.moves.length,
+        line,
+        ...(plan === undefined ? {} : { plan }),
+        ...(mood === "neutral" ? {} : { mood }),
+        ...(comment === undefined ? {} : { comment }),
+        talk: said,
+    };
+}
+function startLines({ position, line, plan, mood, comment, talk }) {
+    return [
+        line,
+        ...(plan === undefined ? [] : [`Your plan: ${plan}`]),
+        ...(mood === undefined ? [] : [`Your mood: ${mood}.`]),
+        comment === undefined ? "You said nothing with your move." : `You said with your move: «${comment}»`,
+        ...(talk.length === 0 ? [] : ["Last words on the board page:", ...talk]),
+        `For each reply you think likely, ponder {position: ${position}, reply} shows the position after it, then ponder {position: ${position}, reply, move, why} keeps `
+            + `your answer; ponder {position: ${position}, done: true} when you have no more.`,
+    ];
+}
+/** The words of the AI's move for the player: its comment without the plan, the mood, the clock and the draw offer it carries. */
+function wordsOf(comment) {
+    const words = comment?.replace(/\[%[^\]]*\]/g, "").replace("(=)", "").replace(/\s+/g, " ").trim();
+    return words === undefined || words === "" ? undefined : words;
+}

package/dist/commands/position.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { type Profile } from "../core/index.ts";
+/** The positional profile of a position: of a game studied, with where it stands. */
+type Described = Profile & {
+    where?: string;
+};
+/** The positional profile of the game in progress (D-19, T-12), or of any position of a game over (D-68): separate facts, never a score. */
+export declare const position: import("./registry.ts").Command<z.ZodObject<{
+    game: z.ZodOptional<z.ZodString>;
+    move: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, Described>;
+/** The profile as lines for the AI, White's facts before Black's; a line with nothing to say is left out. */
+export declare function profileLines(profile: Profile): string[];
+export {};

package/dist/commands/position.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import {} from "../core/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { gameAt } from "./clock.js";
+import { refuseUnseen } from "./levels.js";
+import { defineCommand } from "./registry.js";
+import { gameToStudy, positionAfter, positionLine, studyInput } from "./study.js";
+import { colourName, materialText } from "./view.js";
+/** The positional profile of the game in progress (D-19, T-12), or of any position of a game over (D-68): separate facts, never a score. */
+export const position = defineCommand({
+    name: "position",
+    description: "Shows the positional facts of the position, from the strong level up and at every level once the game is over: material, pawns (isolated, doubled, backward, passed, islands), open files, rooks and queens on the seventh, bishops, "
+        + "outposts, centre, space, control, mobility, development and castling, king safety, the phase, the draw rules and, with only kings and pawns, "
+        + "the rule of the square and the opposition. Facts only, never a score: weigh them yourself. Call it when you set or change your plan: out of "
+        + "the opening, after a big exchange, in the endgame; not at every move. With move, and game for a game of the archive, the facts of any position of a "
+        + 'game over, to analyse it. Example: position {}, position {move: "24."}.',
+    input: z.object(studyInput),
+    readOnly: true,
+    idempotent: true,
+    run: ({ game, move }, context) => {
+        if (game !== undefined || move !== undefined) {
+            const studied = gameToStudy(context, game);
+            const at = positionAfter(studied.record, move);
+            return { ...at.game.profile, where: positionLine(at, studied.name) };
+        }
+        const current = gameAt(gameFolder(context.home()), context.now());
+        if (current === undefined) {
+            throw new Error("There is no game to describe: start one with new_game.");
+        }
+        refuseUnseen(current, "strategy", "position");
+        return current.game.profile;
+    },
+    format: (described) => [...(described.where === undefined ? [] : [described.where]), ...profileLines(described)].join("\n"),
+});
+/** The profile as lines for the AI, White's facts before Black's; a line with nothing to say is left out. */
+export function profileLines(profile) {
+    const sides = [["white", profile.white], ["black", profile.black]];
+    const perSide = (line) => sides.map(([side, facts]) => {
+        const text = line(facts);
+        return text === undefined ? undefined : `${colourName(side)} ${text}`;
+    }).filter((text) => text !== undefined).join("; ");
+    const lines = [
+        `Phase: ${profile.phase}`,
+        `Material: ${materialText(profile.material)}`,
+        ...sides.map(([side, facts]) => pawnLine(side, facts)),
+        filesLine(profile),
+        seventhLine(perSide((side) => joined(side.onSeventh))),
+        bishopsLine(profile),
+        `Outposts: ${perSide((side) => joined(side.outposts.map((outpost) => (outpost.piece === undefined ? outpost.square : `${outpost.piece}${outpost.square}`)))) || "none"}`,
+        `Centre (White/Black pieces reaching it): ${profile.centre.map(centreText).join(", ")}`,
+        `Space (squares of the other half attacked): White ${profile.white.space}, Black ${profile.black.space}`,
+        `Control: only White ${profile.controlled.white}, only Black ${profile.controlled.black}, both ${profile.controlled.contested}`,
+        `Mobility: ${perSide((side) => (side.mobility === undefined ? undefined : mobilityText(side.mobility)))}`,
+        `Development: ${perSide(developmentText)}`,
+        ...sides.flatMap(([side, facts]) => (facts.king === undefined ? [] : [kingLine(side, facts.king)])),
+        drawLine(profile),
+        ...endingLines(profile),
+    ];
+    return lines.filter((line) => line !== "");
+}
+const pieceOrder = ["K", "Q", "R", "B", "N", "P"];
+function pawnLine(side, { pawns }) {
+    const kinds = [["isolated", pawns.isolated], ["doubled", pawns.doubled], ["backward", pawns.backward], ["passed", pawns.passed]];
+    const named = kinds.filter(([, squares]) => squares.length > 0).map(([kind, squares]) => `${kind} ${squares.join(" ")}`);
+    return `${colourName(side)} pawns: ${[...named, `islands ${pawns.islands.join(", ") || "none"}`].join("; ")}`;
+}
+function filesLine(profile) {
+    const parts = [
+        profile.openFiles.length === 0 ? "" : `open ${profile.openFiles.join(" ")}`,
+        ...["white", "black"].map((side) => {
+            const files = profile[side].halfOpenFiles;
+            return files.length === 0 ? "" : `half-open for ${colourName(side)} ${files.join(" ")}`;
+        }),
+        ...["white", "black"].map((side) => {
+            const heavy = profile[side].heavyOnFiles;
+            return heavy.length === 0 ? "" : `${colourName(side)} heavy pieces on them ${heavy.join(" ")}`;
+        }),
+    ].filter((part) => part !== "");
+    return `Files: ${parts.join("; ") || "no open or half-open file"}`;
+}
+function seventhLine(pieces) {
+    return pieces === "" ? "" : `Rooks and queens on the seventh rank (the second for Black): ${pieces}`;
+}
+function bishopsLine(profile) {
+    const parts = ["white", "black"].flatMap((side) => {
+        const facts = profile[side];
+        const each = facts.bishops.map((bishop) => `B${bishop.square} ${bishop.pawnsOnColour}/${bishop.pawns}`);
+        return each.length === 0 ? [] : [`${colourName(side)}${facts.bishopPair ? " (pair)" : ""} ${each.join(", ")}`];
+    });
+    return parts.length === 0 ? "" : `Bishops (own pawns on its colour/all): ${parts.join("; ")}${profile.oppositeBishops ? "; opposite-coloured" : ""}`;
+}
+function centreText({ square, piece, white, black }) {
+    const on = piece === undefined ? "" : ` ${colourName(piece.side)} ${piece.letter}`;
+    return `${square}${on} ${white}/${black}`;
+}
+function mobilityText(mobility) {
+    const total = Object.values(mobility).reduce((sum, count) => sum + count, 0);
+    return total === 0 ? "0" : `${total} (${pieceOrder.filter((letter) => mobility[letter] !== undefined).map((letter) => `${letter}${mobility[letter]}`).join(" ")})`;
+}
+function developmentText(side) {
+    const castled = side.castled === undefined ? "" : side.castled === "no" ? "not castled" : `castled ${side.castled}`;
+    const rights = side.castlingRights.length === 0 ? "" : `may castle ${side.castlingRights.join(" ")}`;
+    const home = side.undeveloped.length === 0 ? "" : `at home ${side.undeveloped.join(" ")}`;
+    return [castled, rights, home].filter((part) => part !== "").join(", ") || "nothing to say";
+}
+function kingLine(side, king) {
+    const files = king.openFiles.length === 0 ? "" : `, no own pawn on ${king.openFiles.join(" ")}`;
+    return `${colourName(side)} K${king.square}: shield ${king.shield.join(" ") || "none"}${files}, enemy attacks around it ${king.attacksNear}`;
+}
+function drawLine({ draw }) {
+    const parts = [
+        draw.repetitions > 1 ? `position seen ${draw.repetitions} times` : "",
+        draw.fiftyMovesLeft <= 20 ? `${draw.fiftyMovesLeft} half-moves left before the fifty-move draw` : "",
+        draw.insufficient ? "material insufficient to mate" : "",
+    ].filter((part) => part !== "");
+    return parts.length === 0 ? "" : `Draw rules: ${parts.join("; ")}`;
+}
+function endingLines({ pawnEnding }) {
+    if (pawnEnding === undefined) {
+        return [];
+    }
+    const squares = pawnEnding.squares.map((square) => `${square.pawn} ${square.caught ? "inside" : "outside"} the enemy king's square`);
+    const opposition = pawnEnding.opposition === undefined ? "nobody" : colourName(pawnEnding.opposition);
+    return [`Pawn ending: ${[...squares, `opposition: ${opposition}`].join("; ")}`];
+}
+function joined(items) {
+    return items.length === 0 ? undefined : items.join(" ");
+}

package/dist/commands/profiles.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { type DrawnAvatar, type PlayerProfile } from "../profiles/index.ts";
+import type { Context } from "./context.ts";
+/** A change of profile refused while a game goes on: the page says it in the player's language. */
+export declare class GameGoingOn extends Error {
+    constructor();
+}
+/** The profiles, the one in use first. */
+export declare const profiles: import("./registry.ts").Command<z.ZodObject<{}, z.core.$strip>, {
+    profiles: PlayerProfile[];
+    active: string;
+}>;
+/** A new profile, put in use once the game going on has ended; the one Chesspal made at the first start, while new, becomes it, game and all (D-71). */
+export declare const newProfile: import("./registry.ts").Command<z.ZodObject<{
+    name: z.ZodString;
+    level: z.ZodOptional<z.ZodEnum<{
+        learning: "learning";
+        casual: "casual";
+        regular: "regular";
+        tournament: "tournament";
+    }>>;
+    rating: z.ZodOptional<z.ZodInt>;
+    site: z.ZodOptional<z.ZodEnum<{
+        lichess: "lichess";
+        "chess.com": "chess.com";
+        fide: "fide";
+    }>>;
+    avatar: z.ZodOptional<z.ZodEnum<{
+        "short-hair": "short-hair";
+        bun: "bun";
+        glasses: "glasses";
+        beanie: "beanie";
+        beard: "beard";
+        curls: "curls";
+        moustache: "moustache";
+        "silver-bob": "silver-bob";
+        cat: "cat";
+        owl: "owl";
+    }>>;
+}, z.core.$strip>, PlayerProfile>;
+/** Another profile put in use, once the game going on has ended. */
+export declare const useProfile: import("./registry.ts").Command<z.ZodObject<{
+    profile: z.ZodString;
+}, z.core.$strip>, PlayerProfile>;
+/** The picture of the profile in use: a drawn avatar, or an image of the player's, which replaces any before. */
+export declare const setAvatar: import("./registry.ts").Command<z.ZodObject<{
+    avatar: z.ZodString;
+}, z.core.$strip>, {
+    profile: string;
+    avatar: string;
+}>;
+/** A drawn avatar chosen for a profile: the player's own image goes, or it would still show. */
+export declare function chooseDrawnAvatar(context: Context, id: string, avatar: DrawnAvatar): void;
+/**
+ * Who plays, as the AI reads it in status and new_game: their name, how they play and their rating; nothing while the profile is new, named after the
+ * system's account until the player completes it (D-71).
+ */
+export declare function playerLine(context: Context): string | undefined;
+/** Throws while a game goes on in the profile in use. */
+export declare function refuseWhilePlaying(context: Context): void;