chesspal 0.3.3 → 0.3.5

package/dist/server/page/game.js

@@ -245,7 +245,7 @@ async function studyFromPage(request, response, served) {
     let brought;
     try {
         // Without what the chat was told: the analyst's instructions stay for the AI's own analyse_game.
-        const opened = last ? lastPlayed(served.context) : game === undefined ? kept(served, pgn) : namedGame(served.context, game);
+        const opened = last ? lastPlayed(served.context) : game === undefined ? await kept(served, pgn) : namedGame(served.context, game);
         reviewed = isReviewed(opened.record);
         brought = !reviewed && !look;
         // A game not yet reviewed is marked as brought, for status to ask the AI to go over it; one reviewed is ready, and the chat sleeps on.
@@ -377,8 +377,8 @@ function lastPlayed(context) {
     return { name, record };
 }
 /** A game brought as a PGN, kept to study as analyse_game keeps it: the one already kept when it is the same game, with its review. */
-function kept(served, pgn) {
-    analyseGame.run({ pgn }, served.context);
+async function kept(served, pgn) {
+    await analyseGame.run({ pgn }, served.context);
     return namedGame(served.context, gameInAnalysis(gameFolder(served.context.home())).game);
 }
 /** The longest PGN the page brings: a long game with its clocks, and the comments a site adds, which go. */

package/dist/server/page/page.js

@@ -9,7 +9,7 @@ import { forgetAnalyst, gameStamp, tableTalkStamp } from "../../games/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { Bell, bellProbe, pagePorts } from "../bell/index.js";
-import { analysesOf, answerAnalyses } from "./analyses.js";
+import { analysesOf, answerAnalyses, sendSiteGames } from "./analyses.js";
 import { answerChat } from "./attach.js";
 import { attachedSeen, chatSeenOf, pageContext } from "./chat.js";
 import { askNewGame, keepPosted, tellWatchers } from "./events.js";
@@ -131,6 +131,9 @@ function answer(request, response, served) {
     else if (path === "/api/analyses") {
         send(response, 200, json, JSON.stringify(analysesOf(served.context.home())));
     }
+    else if (path === "/api/site-games") {
+        sendSiteGames(response, served);
+    }
     else if (path === "/api/events") {
         keepPosted(request, response, served.watchers);
         // A page that opens reads the player's ratings again after a day (D-106).

package/dist/sites/chesscom.d.ts

@@ -1,4 +1,4 @@
 import type { SiteReading } from "../profiles/index.ts";
-import { type Fetch } from "./request.ts";
+import { type Fetch } from "./request/index.ts";
 /** What Chess.com says of a name: undefined when it could not be reached. */
 export declare function chesscomReading(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteReading | undefined>;

package/dist/sites/chesscom.js

@@ -1,5 +1,5 @@
 import { counted } from "./choice.js";
-import { askSite } from "./request.js";
+import { askSite } from "./request/index.js";
 /** What Chess.com says of a name: undefined when it could not be reached. */
 export async function chesscomReading(account, fetch, signal) {
     const statistics = await askSite(`https://api.chess.com/pub/player/${encodeURIComponent(account.toLowerCase())}/stats`, fetch, signal);

package/dist/sites/games/chesscom.d.ts

@@ -0,0 +1,4 @@
+import { type Fetch } from "../request/index.ts";
+import { type SiteGamesAnswer } from "./game.ts";
+/** What Chess.com gives of a name's latest games, the latest first. */
+export declare function chesscomGames(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteGamesAnswer>;

package/dist/sites/games/chesscom.js

@@ -0,0 +1,54 @@
+// The player's latest games on Chess.com (D-110): its archives by month, the last one, and the one before when the last holds too few.
+import { askSite } from "../request/index.js";
+import { gamesASite, latestFirst, siteGameOf } from "./game.js";
+/** What Chess.com gives of a name's latest games, the latest first. */
+export async function chesscomGames(account, fetch, signal) {
+    const archives = await askSite(`${address}${encodeURIComponent(account.toLowerCase())}/games/archives`, fetch, signal);
+    if (archives === undefined || (archives.status !== 200 && archives.status !== 404)) {
+        return "unreached";
+    }
+    if (archives.status === 404) {
+        return "unknown";
+    }
+    // The months' addresses, the oldest first: the last two are read, the latest first.
+    const listed = archives.body?.archives;
+    // A 200 without its list of months, as a page of HTML, is no answer.
+    if (!Array.isArray(listed)) {
+        return "unreached";
+    }
+    const months = listed.filter((month) => typeof month === "string" && month.startsWith(address));
+    const games = [];
+    for (const monthAddress of months.slice(-2).reverse()) {
+        const month = await monthGames(monthAddress, fetch, signal);
+        // A month that cannot be read fails the site only when it gave no game yet.
+        if (month === undefined) {
+            if (games.length === 0) {
+                return "unreached";
+            }
+            break;
+        }
+        games.push(...month);
+        if (games.length >= gamesASite) {
+            break;
+        }
+    }
+    return games.sort(latestFirst).slice(0, gamesASite);
+}
+// Where Chess.com keeps a player's games: the months it lists are asked only there.
+const address = "https://api.chess.com/pub/player/";
+/** The games of standard chess of a month; undefined when it could not be read. */
+async function monthGames(monthAddress, fetch, signal) {
+    const month = await askSite(monthAddress, fetch, signal);
+    const listed = month?.body?.games;
+    if (month?.status !== 200 || !Array.isArray(listed)) {
+        return undefined;
+    }
+    return listed.flatMap((game) => {
+        const { url, pgn, time_class: speed, rules, end_time: ended } = (game ?? {});
+        if (rules !== "chess" || typeof url !== "string" || typeof pgn !== "string" || typeof speed !== "string" || typeof ended !== "number") {
+            return [];
+        }
+        const read = siteGameOf("chess.com", `chess.com/${url.split("/").slice(-2).join("/")}`, speed, new Date(ended * 1000), pgn);
+        return read === undefined ? [] : [read];
+    });
+}

package/dist/sites/games/game.d.ts

@@ -0,0 +1,34 @@
+import type { RatingSite } from "../../profiles/index.ts";
+/** A finished game of the player's on a site, as the list gives it, with its PGN to study. */
+export interface SiteGame {
+    readonly site: RatingSite;
+    /** What the list calls it: lichess/HqjDTU4A, chess.com/live/186466981288. */
+    readonly name: string;
+    readonly white: string;
+    readonly black: string;
+    readonly whiteRating?: number;
+    readonly blackRating?: number;
+    /** As the Result tag writes it: 1-0, 0-1, 1/2-1/2. */
+    readonly result: string;
+    /** As the site names it: blitz, rapid, daily… */
+    readonly speed: string;
+    /** When the game ended, as an ISO time. */
+    readonly played: string;
+    /** How long it was, in full moves. */
+    readonly moves: number;
+    readonly pgn: string;
+}
+/** What a site said of a name: its latest games, or that it could not be reached, or has no player of that name. */
+export type SiteGamesAnswer = readonly SiteGame[] | "unreached" | "unknown";
+/** The most games a site gives. */
+export declare const gamesASite = 20;
+/** A site's game from what its JSON gives and its PGN's tags; none for a name the list cannot write, or a game without a result, as one aborted. */
+export declare function siteGameOf(site: RatingSite, name: string, speed: string, played: Date, pgn: string): SiteGame | undefined;
+/** Whether a text is a game's name exactly as the list writes it: lichess/HqjDTU4A, chess.com/live/186466981288. */
+export declare function isSiteGameName(text: string): boolean;
+/** A game's name as the list writes it, from one given with spaces around or the site in other capitals (Lichess/HqjDTU4A); none for another text. */
+export declare function siteGameName(text: string): string | undefined;
+/** Whether a text points at a site's game without being a name the list writes: a link to Lichess or Chess.com, or a name gone wrong. */
+export declare function pointsAtSite(text: string): boolean;
+/** The latest games first. */
+export declare function latestFirst(one: SiteGame, other: SiteGame): number;

package/dist/sites/games/game.js

@@ -0,0 +1,64 @@
+/** The most games a site gives. */
+export const gamesASite = 20;
+/** A site's game from what its JSON gives and its PGN's tags; none for a name the list cannot write, or a game without a result, as one aborted. */
+export function siteGameOf(site, name, speed, played, pgn) {
+    const tags = tagsOf(pgn);
+    const result = tags.Result;
+    if (!isSiteGameName(name) || result === undefined || !results.has(result) || Number.isNaN(played.getTime())) {
+        return undefined;
+    }
+    const whiteRating = ratingOf(tags.WhiteElo);
+    const blackRating = ratingOf(tags.BlackElo);
+    return {
+        site,
+        name,
+        white: tags.White ?? "?",
+        black: tags.Black ?? "?",
+        ...(whiteRating === undefined ? {} : { whiteRating }),
+        ...(blackRating === undefined ? {} : { blackRating }),
+        result,
+        speed,
+        played: played.toISOString(),
+        moves: fullMovesOf(pgn),
+        pgn,
+    };
+}
+/** Whether a text is a game's name exactly as the list writes it: lichess/HqjDTU4A, chess.com/live/186466981288. */
+export function isSiteGameName(text) {
+    return siteGameName(text) === text;
+}
+/** A game's name as the list writes it, from one given with spaces around or the site in other capitals (Lichess/HqjDTU4A); none for another text. */
+export function siteGameName(text) {
+    const [, site, rest = ""] = /^(lichess|chess\.com)\/(\S+)$/i.exec(text.trim()) ?? [];
+    if (site?.toLowerCase() === "lichess" && /^[A-Za-z0-9]+$/.test(rest)) {
+        return `lichess/${rest}`;
+    }
+    return site?.toLowerCase() === "chess.com" && /^[a-z]+\/\d+$/i.test(rest) ? `chess.com/${rest.toLowerCase()}` : undefined;
+}
+/** Whether a text points at a site's game without being a name the list writes: a link to Lichess or Chess.com, or a name gone wrong. */
+export function pointsAtSite(text) {
+    const trimmed = text.trim();
+    return siteGameName(trimmed) === undefined && /^(?:https?:\/\/)?(?:www\.)?(?:lichess\.org|lichess\/|chess\.?com\b)/i.test(trimmed);
+}
+/** The latest games first. */
+export function latestFirst(one, other) {
+    return other.played.localeCompare(one.played);
+}
+const results = new Set(["1-0", "0-1", "1/2-1/2"]);
+// The tags of a PGN, [White "Anna"]: the sites do not depend on the chess core, and need only these.
+function tagsOf(pgn) {
+    const tags = {};
+    for (const [, key, value] of pgn.matchAll(/^\s*\[(\w+)\s+"((?:[^"\\]|\\.)*)"\]\s*$/gm)) {
+        tags[key] = value.replace(/\\(.)/g, "$1");
+    }
+    return tags;
+}
+/** The full moves of a PGN's movetext: its moves counted without the tags, comments, move numbers, annotations and result. */
+function fullMovesOf(pgn) {
+    const movetext = pgn.replace(/^\s*\[.*\]\s*$/gm, " ").replace(/\{[^}]*\}|;[^\n]*/g, " ");
+    const plies = movetext.split(/\s+/).filter((token) => token !== "" && !/^(?:\d+\.+|\$\d+|1-0|0-1|1\/2-1\/2|\*)$/.test(token)).map((token) => token.replace(/^\d+\.+/, ""));
+    return Math.ceil(plies.filter((token) => token !== "").length / 2);
+}
+function ratingOf(tag) {
+    return tag !== undefined && /^\d+$/.test(tag) ? Number(tag) : undefined;
+}

package/dist/sites/games/games.d.ts

@@ -0,0 +1,14 @@
+import type { Accounts, RatingSite } from "../../profiles/index.ts";
+import type { Fetch } from "../request/index.ts";
+import { type SiteGame } from "./game.ts";
+/** The latest games of the sites asked, the latest first; the sites that gave their list, those that could not be reached, and those with no player of that name. */
+export interface SiteGames {
+    readonly games: readonly SiteGame[];
+    readonly answered: readonly RatingSite[];
+    readonly unreached: readonly RatingSite[];
+    readonly unknown: readonly RatingSite[];
+}
+/** What Lichess and Chess.com give now of the player's latest games there, each asked only for a name it has: a site that fails never fails the other. */
+export declare function readSiteGames(accounts: Accounts, fetch: Fetch): Promise<SiteGames>;
+/** The site of a game's name as the list writes it. */
+export declare function siteOfGameName(name: string): RatingSite;

package/dist/sites/games/games.js

@@ -0,0 +1,22 @@
+import { chesscomGames } from "./chesscom.js";
+import { latestFirst } from "./game.js";
+import { lichessGames } from "./lichess.js";
+/** What Lichess and Chess.com give now of the player's latest games there, each asked only for a name it has: a site that fails never fails the other. */
+export async function readSiteGames(accounts, fetch) {
+    const signal = AbortSignal.timeout(siteGamesTime);
+    const ask = async (site, account, games) => account === undefined ? [] : [[site, await games(account, fetch, signal)]];
+    const answers = (await Promise.all([ask("lichess", accounts.lichess, lichessGames), ask("chess.com", accounts.chesscom, chesscomGames)])).flat();
+    const sitesThat = (said) => answers.filter(([, answer]) => said(answer)).map(([site]) => site);
+    return {
+        games: answers.flatMap(([, answer]) => typeof answer === "string" ? [] : answer).sort(latestFirst),
+        answered: sitesThat((answer) => typeof answer !== "string"),
+        unreached: sitesThat((answer) => answer === "unreached"),
+        unknown: sitesThat((answer) => answer === "unknown"),
+    };
+}
+/** The site of a game's name as the list writes it. */
+export function siteOfGameName(name) {
+    return name.startsWith("lichess/") ? "lichess" : "chess.com";
+}
+// The longest the sites may take to give the games, together, in milliseconds: a month of Chess.com's can be long.
+const siteGamesTime = 10_000;

package/dist/sites/games/index.d.ts

@@ -0,0 +1,2 @@
+export { isSiteGameName, pointsAtSite, type SiteGame, siteGameName } from "./game.ts";
+export { readSiteGames, type SiteGames, siteOfGameName } from "./games.ts";

package/dist/sites/games/index.js

@@ -0,0 +1,3 @@
+// The player's latest games on Lichess and Chess.com (D-110), asked from the names in their profile to study one of them: never kept on disk.
+export { isSiteGameName, pointsAtSite, siteGameName } from "./game.js";
+export { readSiteGames, siteOfGameName } from "./games.js";

package/dist/sites/games/lichess.d.ts

@@ -0,0 +1,4 @@
+import { type Fetch } from "../request/index.ts";
+import { type SiteGamesAnswer } from "./game.ts";
+/** What Lichess gives of a name's latest games, the latest first. */
+export declare function lichessGames(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteGamesAnswer>;

package/dist/sites/games/lichess.js

@@ -0,0 +1,45 @@
+// The player's latest games on Lichess (D-110): finished, of standard chess, with their clocks and without the site's evaluations.
+import { askSiteText } from "../request/index.js";
+import { gamesASite, siteGameOf } from "./game.js";
+/** What Lichess gives of a name's latest games, the latest first. */
+export async function lichessGames(account, fetch, signal) {
+    // The speeds of standard chess alone, so that a player of variants still gets their last twenty standard games.
+    const query = `max=${gamesASite}&perfType=ultraBullet,bullet,blitz,rapid,classical,correspondence&pgnInJson=true&clocks=true&evals=false&opening=false`;
+    const answer = await askSiteText(`https://lichess.org/api/games/user/${encodeURIComponent(account)}?${query}`, "application/x-ndjson", fetch, signal);
+    if (answer === undefined || (answer.status !== 200 && answer.status !== 404)) {
+        return "unreached";
+    }
+    if (answer.status === 404) {
+        return "unknown";
+    }
+    const lines = answer.text.split("\n").filter((line) => line.trim() !== "").map(objectOf);
+    // An answer with text but no game in it, as a page of HTML, is no answer.
+    if (lines.length > 0 && lines.every((line) => line === undefined)) {
+        return "unreached";
+    }
+    return lines.flatMap(gameOf);
+}
+// Games not yet begun, or still going on.
+const unfinished = new Set(["created", "started"]);
+/** The JSON object of a line; none for a line that is not one. */
+function objectOf(line) {
+    try {
+        const read = JSON.parse(line);
+        return typeof read === "object" && read !== null && !Array.isArray(read) ? read : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The game of one line of Lichess's answer: none for a variant, a game not finished, or a line that is no game. */
+function gameOf(game) {
+    const { id, variant, speed, status, lastMoveAt, pgn } = game ?? {};
+    if (typeof id !== "string" || variant !== "standard" || typeof status !== "string" || unfinished.has(status)) {
+        return [];
+    }
+    if (typeof speed !== "string" || typeof lastMoveAt !== "number" || typeof pgn !== "string") {
+        return [];
+    }
+    const read = siteGameOf("lichess", `lichess/${id}`, speed, new Date(lastMoveAt), pgn);
+    return read === undefined ? [] : [read];
+}

package/dist/sites/index.d.ts

@@ -1,2 +1,3 @@
-export { answerTime, askSite, type Fetch } from "./request.ts";
+export { isSiteGameName, pointsAtSite, readSiteGames, type SiteGame, siteGameName, type SiteGames, siteOfGameName } from "./games/index.ts";
+export { answerTime, askSite, type Fetch } from "./request/index.ts";
 export { readingsStale, readSites } from "./sites.ts";

package/dist/sites/index.js

@@ -1,4 +1,6 @@
-// The sites the player plays on (D-24, D-105): their public ratings on Lichess and chess.com, read from the names in their profile, without a key. Below
-// the commands, beside the profiles, whose types it fills; never asked by a tool of the AI's (D-106). Its request asks npm too, for a newer Chesspal (D-108).
-export { answerTime, askSite } from "./request.js";
+// The sites the player plays on (D-24, D-105): their public ratings on Lichess and chess.com, read from the names in their profile, without a key, never
+// asked by a tool of the AI's (D-106); and their latest games there, which a tool lists too, to study one (D-110). Below the commands, beside the profiles,
+// whose types it fills. Its request asks npm too, for a newer Chesspal (D-108).
+export { isSiteGameName, pointsAtSite, readSiteGames, siteGameName, siteOfGameName } from "./games/index.js";
+export { answerTime, askSite } from "./request/index.js";
 export { readingsStale, readSites } from "./sites.js";

package/dist/sites/lichess.d.ts

@@ -1,4 +1,4 @@
 import type { SiteReading } from "../profiles/index.ts";
-import { type Fetch } from "./request.ts";
+import { type Fetch } from "./request/index.ts";
 /** What Lichess says of a name: undefined when it could not be reached. */
 export declare function lichessReading(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteReading | undefined>;

package/dist/sites/lichess.js

@@ -1,5 +1,5 @@
 import { counted } from "./choice.js";
-import { askSite } from "./request.js";
+import { askSite } from "./request/index.js";
 /** What Lichess says of a name: undefined when it could not be reached. */
 export async function lichessReading(account, fetch, signal) {
     const user = await askSite(`${address}/${encodeURIComponent(account)}`, fetch, signal);

package/dist/sites/request/index.d.ts

@@ -0,0 +1 @@
+export { answerTime, askSite, askSiteText, type Fetch, type SiteAnswer, type SiteText } from "./request.ts";

package/dist/sites/request/index.js

@@ -0,0 +1,2 @@
+// A question to a site's public API (D-24): JSON or text, named as Chesspal, within the signal it is given.
+export { answerTime, askSite, askSiteText } from "./request.js";

package/dist/sites/{request.d.ts → request/request.d.ts}

@@ -5,7 +5,14 @@ export interface SiteAnswer {
     readonly status: number;
     readonly body?: unknown;
 }
+/** What a site answered in text: its status and its text, as Lichess's games, one JSON object a line. */
+export interface SiteText {
+    readonly status: number;
+    readonly text: string;
+}
 /** The longest the sites may take to answer, together, in milliseconds: the page waits for them. */
 export declare const answerTime = 5000;
 /** Asks a site for JSON: what it answered, or undefined when it could not be reached before `signal` gave up. */
 export declare function askSite(url: string, fetch: Fetch, signal: AbortSignal): Promise<SiteAnswer | undefined>;
+/** Asks a site for text of the type `accept` names: what it answered, or undefined when it could not be reached, or stopped, before `signal` gave up. */
+export declare function askSiteText(url: string, accept: string, fetch: Fetch, signal: AbortSignal): Promise<SiteText | undefined>;

package/dist/sites/request/request.js

@@ -0,0 +1,37 @@
+// A question to a site's public API (D-24): JSON or text over HTTPS, without a key, named as Chesspal and nothing of the player's besides the name asked.
+import { version } from "../../version.js";
+/** The longest the sites may take to answer, together, in milliseconds: the page waits for them. */
+export const answerTime = 5000;
+/** Asks a site for JSON: what it answered, or undefined when it could not be reached before `signal` gave up. */
+export async function askSite(url, fetch, signal) {
+    try {
+        const response = await fetch(url, { headers: headersFor("application/json"), signal });
+        // The whole body read here: one the signal cuts short is a site not reached, not an answer without JSON.
+        const body = jsonOf(await response.text());
+        return body === undefined ? { status: response.status } : { status: response.status, body };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Asks a site for text of the type `accept` names: what it answered, or undefined when it could not be reached, or stopped, before `signal` gave up. */
+export async function askSiteText(url, accept, fetch, signal) {
+    try {
+        const response = await fetch(url, { headers: headersFor(accept), signal });
+        return { status: response.status, text: await response.text() };
+    }
+    catch {
+        return undefined;
+    }
+}
+function jsonOf(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function headersFor(accept) {
+    return { "Accept": accept, "User-Agent": `Chesspal/${version}` };
+}

package/dist/sites/sites.d.ts

@@ -1,5 +1,5 @@
 import type { Accounts, SiteReadings } from "../profiles/index.ts";
-import { type Fetch } from "./request.ts";
+import { type Fetch } from "./request/index.ts";
 /** What Lichess and Chess.com say now of the player's names there, at `now`; a site that cannot be reached keeps what it said before of the same name. */
 export declare function readSites(accounts: Accounts, fetch: Fetch, before: SiteReadings | undefined, now: Date): Promise<SiteReadings>;
 /** Whether the readings are of other names than the profile's now, or a site did not answer a while ago: they are read again then, whatever their age. */

package/dist/sites/sites.js

@@ -1,6 +1,6 @@
 import { chesscomReading } from "./chesscom.js";
 import { lichessReading } from "./lichess.js";
-import { answerTime } from "./request.js";
+import { answerTime } from "./request/index.js";
 /** What Lichess and Chess.com say now of the player's names there, at `now`; a site that cannot be reached keeps what it said before of the same name. */
 export async function readSites(accounts, fetch, before, now) {
     const signal = AbortSignal.timeout(answerTime);

package/instructions/opponent.md

@@ -10,6 +10,6 @@ You choose your moves, explain them briefly and talk with the player.
 - You have a face on the board page, and it shows how you feel. Give it as the `mood` of `ai_move` on each move where the game turns for you: a piece won or lost, a blunder seen, your own or theirs, a threat that appears or a plan that works or fails. Let it colour your words while it lasts. When the game ends on the player's move, give how you feel as it ends with `ai_say`'s `mood`.
 - Draws and resignations: `offer_draw` on `ai_move` offers a draw, on `player_move` records the player's, made with their move; an offer stands until the other side moves; `end_game` `draw_agreed` accepts a standing offer, `player_resigns` records the player's resignation in the chat, `ai_resigns` resigns yours. On the board page the player offers, answers and resigns there.
 - When they ask for a game, call `new_game` without choices: the board page's New game window asks the sides, the clock and the level; ask them in the chat only when `new_game` says there is no board page.
-- To go over a game with the player once no game goes on, the one just over or one they bring as a PGN, give it to `analyse_game`: it reads the PGN for you; where Chesspal's answers say to start the analyst agent for it, start that instead, each time those answers say so and never on your own, not even when the player asks for the analysis again. While it works, and after, talk the game over whenever the player asks: `look` and `position` with game and move show you any of its positions. When they show you something the review missed, first correct that move's note with `annotate_game` {game, notes: [{move, badge, note}]}, that move only, then answer. Words from the board page you answer with `ai_say`; words in the chat, in the chat. While a game goes on, go over no game, not even in your head or from a PGN they paste: tell them it waits until this one ends.
+- To go over a game with the player once no game goes on, the one just over or one they bring as a PGN, or one of their latest on Lichess or Chess.com, which `site_games` lists, give it to `analyse_game`: it reads the PGN for you; where Chesspal's answers say to start the analyst agent for it, start that instead, each time those answers say so and never on your own, not even when the player asks for the analysis again. While it works, and after, talk the game over whenever the player asks: `look` and `position` with game and move show you any of its positions. When they show you something the review missed, first correct that move's note with `annotate_game` {game, notes: [{move, badge, note}]}, that move only, then answer. Words from the board page you answer with `ai_say`; words in the chat, in the chat. While a game goes on, go over no game, not even in your head or from a PGN they paste: tell them it waits until this one ends.
 - How to read the facts: attackers and defenders count only the pieces that reach the square directly, and a piece in brackets stands behind them; "Loose" means neither attacked nor defended, not attacked now; "At risk" lists the pieces attacked and undefended, attacked by a cheaper piece, or attacked more times than defended.
 - Talk with the player in their language, in a few words. The facts and the tools are for you: tell the player what a chess player would say, never the lists or the tools' names. Name pieces and moves in words, as people talk at the board ("your bishop took on f7"); when you write a move, yours or the player's, write it with the pieces' figurines, as the tools show it (♞f6 for Nf6, ♝xf7+ for Bxf7+), for both sides and in every language: never with letters, neither N B R Q K nor the player's own (Cf6), even when they write them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chesspal",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Play chess against an AI with a character, and learn with an AI coach: Chesspal keeps the rules, the board, the games and the memory; the AI plays, reasons and talks.",
   "type": "module",
   "bin": {

package/dist/sites/request.js

@@ -1,15 +0,0 @@
-// A question to a site's public API (D-24): JSON over HTTPS, without a key, named as Chesspal and nothing of the player's besides the name asked.
-import { version } from "../version.js";
-/** The longest the sites may take to answer, together, in milliseconds: the page waits for them. */
-export const answerTime = 5000;
-/** Asks a site for JSON: what it answered, or undefined when it could not be reached before `signal` gave up. */
-export async function askSite(url, fetch, signal) {
-    try {
-        const response = await fetch(url, { headers: { "Accept": "application/json", "User-Agent": `Chesspal/${version}` }, signal });
-        const body = await response.json().catch(() => undefined);
-        return body === undefined ? { status: response.status } : { status: response.status, body };
-    }
-    catch {
-        return undefined;
-    }
-}