chesspal 0.0.1 → 0.2.0

package/dist/games/coach.d.ts

@@ -0,0 +1,57 @@
+import { type Badge, type DrawnArrow, type DrawnSquare, type GameRecord, type Lead } from "../core/index.ts";
+import type { CurrentGame } from "./current-game.ts";
+/** The coach's word on a move of the player's: the move by the plies up to it, its badge and note, and the moves of theirs its note names. */
+export interface CoachJudgment {
+    readonly ply: number;
+    readonly badge?: Badge;
+    readonly note?: string;
+    /** The moves in SAN its note names that the player could play: the page shows it only once none is legal on their turn (Anatolij). */
+    readonly held?: string[];
+    /** Only as shown, never kept: a held note the player's last move let go, which the card shows now (Zoe). */
+    readonly released?: true;
+}
+/** The coach's hint for the player's turn, for the position it was given in, with what it draws on the board to show it. */
+export interface CoachHint {
+    readonly position: number;
+    readonly text: string;
+    readonly arrows?: DrawnArrow[];
+    readonly squares?: DrawnSquare[];
+}
+/** Who the coach sees ahead in a position the player was to move in (D-90), by the plies up to it. */
+export interface CoachLead {
+    readonly position: number;
+    readonly lead: Lead;
+}
+/** What the coach wrote in a game. */
+export interface CoachWords {
+    readonly judgments: readonly CoachJudgment[];
+    readonly hint?: CoachHint;
+    readonly leads?: readonly CoachLead[];
+}
+/** What the coach wrote in the game going on: nothing when the file is another game's, or missing. */
+export declare function coachWords(folder: string, current: CurrentGame): CoachWords;
+/** Keeps the coach's word on a move of the player's, in place of one it wrote on the same move. */
+export declare function keepJudgment(folder: string, current: CurrentGame, judgment: CoachJudgment): void;
+/** Keeps the coach's hint for the player's turn, in place of the one before. */
+export declare function keepHint(folder: string, current: CurrentGame, hint: CoachHint): void;
+/** Keeps who the coach sees ahead in a position, in place of what it said there before. */
+export declare function keepLead(folder: string, current: CurrentGame, { position, lead }: CoachLead): void;
+/** Since when the coach has waited for the player's move in a position: the first time it asked, `now` then. */
+export declare function coachWaitingSince(folder: string, current: CurrentGame, position: number, now: Date): Date;
+/** Whether a coach has started on the game as it is now: until one has, the chat is told again to start it (Priya). */
+export declare function coachStarted(folder: string, current: CurrentGame): boolean;
+/** Notes that a coach starts on the game as it is now: true for the first, false for another the chat started on it too, which stops. */
+export declare function startCoach(folder: string, current: CurrentGame): boolean;
+/** Forgets the coach's words on the game over, when its review is deleted (D-92): they would go back into its PGN. */
+export declare function forgetCoach(folder: string): void;
+/**
+ * What the player may see of it in the game as it is: the judgments but those that name a move the player may play, held while the opponent is to move
+ * too (Anatolij), and the hint only in its own position. A held one that the last pair of moves let go is marked, for the card to show it
+ * now, however far back its move (Zoe).
+ */
+export declare function coachShown({ judgments, hint, leads }: CoachWords, { game, ai }: CurrentGame): CoachWords;
+/**
+ * The record with the coach's judgments in the comments of the moves they judge, as the analyst writes its own: for the game over. A move the analyst has
+ * reviewed already keeps its review (Federico); the book's badge alone is no review, and stays under a note alone, as annotate_game keeps it.
+ */
+export declare function withCoach(record: GameRecord, { judgments, leads }: CoachWords): GameRecord;

package/dist/games/coach.js

@@ -0,0 +1,144 @@
+// What the coach writes during a game with the helps on (D-88): its judgments of the player's moves, its hint for their turn and who it sees ahead (D-90),
+// in coach.json beside game.json, where no command of the opponent's reads them; the judgments and the leads go into the game's PGN once it is over.
+import { readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { badges, Game, leadOf, leadText, readLead, reviewed, reviewOf, withLead } from "../core/index.js";
+import { writeAtomically } from "./files.js";
+/** What the coach wrote in the game going on: nothing when the file is another game's, or missing. */
+export function coachWords(folder, current) {
+    const { judgments, hint, leads = [] } = keptFor(folder, current);
+    const read = leads.flatMap(({ position, lead }) => {
+        const known = readLead(lead);
+        return known === undefined ? [] : [{ position, lead: known }];
+    });
+    return { judgments, ...(hint === undefined ? {} : { hint }), ...(read.length === 0 ? {} : { leads: read }) };
+}
+/** Keeps the coach's word on a move of the player's, in place of one it wrote on the same move. */
+export function keepJudgment(folder, current, judgment) {
+    const kept = keptFor(folder, current);
+    const judgments = [...kept.judgments.filter((one) => one.ply !== judgment.ply), judgment].sort((one, other) => one.ply - other.ply);
+    write(folder, { ...kept, judgments });
+}
+/** Keeps the coach's hint for the player's turn, in place of the one before. */
+export function keepHint(folder, current, hint) {
+    write(folder, { ...keptFor(folder, current), hint });
+}
+/** Keeps who the coach sees ahead in a position, in place of what it said there before. */
+export function keepLead(folder, current, { position, lead }) {
+    const kept = keptFor(folder, current);
+    const leads = [...(kept.leads ?? []).filter((one) => one.position !== position), { position, lead: leadText(lead) }].sort((one, other) => one.position - other.position);
+    write(folder, { ...kept, leads });
+}
+/** Since when the coach has waited for the player's move in a position: the first time it asked, `now` then. */
+export function coachWaitingSince(folder, current, position, now) {
+    const kept = keptFor(folder, current);
+    if (kept.waiting?.position === position) {
+        return new Date(kept.waiting.since);
+    }
+    write(folder, { ...kept, waiting: { position, since: now.toISOString() } });
+    return now;
+}
+/** Whether a coach has started on the game as it is now: until one has, the chat is told again to start it (Priya). */
+export function coachStarted(folder, current) {
+    return keptFor(folder, current).begun === current.game.record.moves.length;
+}
+/** Notes that a coach starts on the game as it is now: true for the first, false for another the chat started on it too, which stops. */
+export function startCoach(folder, current) {
+    const kept = keptFor(folder, current);
+    const plies = current.game.record.moves.length;
+    if (kept.begun === plies) {
+        return false;
+    }
+    write(folder, { ...kept, begun: plies });
+    return true;
+}
+/** Forgets the coach's words on the game over, when its review is deleted (D-92): they would go back into its PGN. */
+export function forgetCoach(folder) {
+    rmSync(join(folder, fileName), { force: true });
+}
+/**
+ * What the player may see of it in the game as it is: the judgments but those that name a move the player may play, held while the opponent is to move
+ * too (Anatolij), and the hint only in its own position. A held one that the last pair of moves let go is marked, for the card to show it
+ * now, however far back its move (Zoe).
+ */
+export function coachShown({ judgments, hint, leads = [] }, { game, ai }) {
+    const plies = game.record.moves.length;
+    const legal = game.position.turn === ai ? undefined : legalMoves(game);
+    const shown = judgments.filter(({ held }) => held === undefined || (legal !== undefined && !names(held, legal)));
+    const before = legal === undefined || plies < 2 || shown.every(({ held }) => held === undefined)
+        ? undefined
+        : legalMoves(new Game({ tags: game.record.tags, moves: game.record.moves.slice(0, plies - 2) }));
+    const marked = before === undefined ? shown : shown.map((judgment) => judgment.held !== undefined && names(judgment.held, before) ? { ...judgment, released: true } : judgment);
+    return { judgments: marked, ...(hint === undefined || hint.position !== plies ? {} : { hint }), ...(leads.length === 0 ? {} : { leads }) };
+}
+/**
+ * The record with the coach's judgments in the comments of the moves they judge, as the analyst writes its own: for the game over. A move the analyst has
+ * reviewed already keeps its review (Federico); the book's badge alone is no review, and stays under a note alone, as annotate_game keeps it.
+ */
+export function withCoach(record, { judgments, leads = [] }) {
+    if (judgments.length === 0 && leads.length === 0) {
+        return record;
+    }
+    const moves = record.moves.map((move, index) => {
+        const judgment = judgments.find((one) => one.ply === index + 1);
+        const review = reviewOf(move.comment);
+        if (judgment === undefined || (review !== undefined && (review.badge !== "book" || review.note !== undefined))) {
+            return move;
+        }
+        const badge = judgment.badge ?? review?.badge;
+        return reviewed(move, { ...(badge === undefined ? {} : { badge }), ...(judgment.note === undefined ? {} : { note: judgment.note }) });
+    });
+    return { ...record, moves: withLeads(moves, leads) };
+}
+/** The moves with who the coach saw ahead after each (D-90), where nobody has said it there since: on the move that led to the position it was given in. */
+function withLeads(moves, leads) {
+    return moves.map((move, index) => {
+        const lead = leads.find((one) => one.position === index + 1)?.lead;
+        return lead === undefined || leadOf(move.comment) !== undefined ? move : withLead(move, lead);
+    });
+}
+/** The legal moves in a position, without their checks. */
+function legalMoves(game) {
+    return new Set(game.legalMoves().map((move) => withoutCheck(move.san)));
+}
+/** Whether a note's moves name one of the legal moves. */
+function names(held, legal) {
+    return held.some((san) => legal.has(withoutCheck(san)));
+}
+/** A move in SAN without its check or mate, which the position it is played in decides: Qxf7# then is Qxf7+ now. */
+function withoutCheck(san) {
+    return san.replace(/[+#]$/, "");
+}
+const fileName = "coach.json";
+const colours = ["green", "red", "yellow", "blue"];
+const coachFile = z.object({
+    started: z.string(),
+    judgments: z.array(z.object({ ply: z.int().min(1), badge: z.enum(badges).optional(), note: z.string().optional(), held: z.array(z.string()).optional() })),
+    leads: z.array(z.object({ position: z.int().min(0), lead: z.string() })).optional(),
+    hint: z.object({
+        position: z.int().min(0),
+        text: z.string(),
+        arrows: z.array(z.object({ colour: z.enum(colours), from: z.string(), to: z.string() })).optional(),
+        squares: z.array(z.object({ colour: z.enum(colours), square: z.string() })).optional(),
+    }).optional(),
+    waiting: z.object({ position: z.int().min(0), since: z.iso.datetime() }).optional(),
+    begun: z.int().min(0).optional(),
+});
+/** What is kept for a game, by when it started: nothing yet when the file is another game's, or missing. */
+function keptFor(folder, current) {
+    const kept = read(folder);
+    return kept?.started === current.started ? kept : { started: current.started, judgments: [] };
+}
+function read(folder) {
+    try {
+        return coachFile.parse(JSON.parse(readFileSync(join(folder, fileName), "utf8")));
+    }
+    catch {
+        // None yet, or one Chesspal cannot read: the coach's words are only a help, and the next one written replaces it.
+        return undefined;
+    }
+}
+function write(folder, kept) {
+    writeAtomically(join(folder, fileName), `${JSON.stringify(kept, null, 2)}\n`);
+}

package/dist/games/current-game.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { type Clock, Game, type Side } from "../core/index.ts";
+/** The player's current game, going on or over: the live game, and what game.json keeps beside its PGN. */
+export interface CurrentGame {
+    readonly game: Game;
+    /** The side the AI plays. */
+    readonly ai: Side;
+    /** When the game started, as an ISO date: it names the game in the archive. */
+    readonly started: string;
+    /** What the player and the AI said on the board page, beside the PGN and never in the archive (D-51). */
+    readonly talk: TalkLine[];
+    /** The clock, in a game with a time control (D-13). */
+    readonly clock?: Clock;
+    /** Who offered a draw, while the offer stands: until the other side accepts it, declines it or moves (D-65). */
+    readonly drawOffer?: Speaker;
+}
+/** Who speaks on the board page. */
+export type Speaker = "player" | "ai";
+/** A line said on the board page: who said it, its words, how many moves the game had then, and when, as an ISO date; the AI's agent on the player's time (D-72). */
+export interface TalkLine {
+    readonly who: Speaker;
+    readonly text: string;
+    readonly ply: number;
+    readonly at: string;
+    readonly agent?: true;
+}
+/** How a game ended: its result, and why when the record says it or the board decided it. */
+export interface GameEnd {
+    readonly result: string;
+    readonly termination?: string;
+}
+/** The current game of a folder, as it is on disk, or undefined when there is none. A game.json Chesspal cannot read throws: nothing overwrites it. */
+export declare function loadGame(folder: string): CurrentGame | undefined;
+/** Writes the current game to game.json, whole or not at all; from then on it is the one kept in memory. */
+export declare function saveGame(folder: string, current: CurrentGame): void;
+/** How the game ended, or undefined while it goes on: by the board, or by what the record says, such as a resignation. */
+export declare function endOf(game: Game): GameEnd | undefined;
+/** The draw offer that stands: none once the game is over (D-65). */
+export declare function drawOfferOf(current: CurrentGame): Speaker | undefined;
+/** Whether each side has made a move in the game, before which no draw is agreed (FIDE 5.2.3, D-65). */
+export declare function bothSidesMoved(game: Game): boolean;
+/** A stamp of the folder's game.json that changes whenever it is written, whoever writes it; undefined when there is none. */
+export declare function gameStamp(folder: string): string | undefined;
+/** Removes game.json, when the game over it holds is deleted from the archive (D-92): a new game would archive it again. */
+export declare function removeGame(folder: string): void;
+/** A line of the talk as game.json and talk.json keep it. */
+export declare const savedLine: z.ZodObject<{
+    who: z.ZodEnum<{
+        player: "player";
+        ai: "ai";
+    }>;
+    text: z.ZodString;
+    ply: z.ZodInt;
+    at: z.ZodISODateTime;
+    agent: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>;

package/dist/games/current-game.js

@@ -0,0 +1,134 @@
+// The player's current game on disk (D-27, D-41): game.json, its PGN and the talk on the board page inside, written whole at every change, and kept in
+// memory while nobody else changes it.
+import { readFileSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { Game, readPgn, writePgn } from "../core/index.js";
+import { writeAtomically } from "./files.js";
+/** The current game of a folder, as it is on disk, or undefined when there is none. A game.json Chesspal cannot read throws: nothing overwrites it. */
+export function loadGame(folder) {
+    const path = join(folder, fileName);
+    const stamp = stampOf(path);
+    if (stamp === undefined) {
+        kept.delete(path);
+        return undefined;
+    }
+    const known = kept.get(path);
+    if (known?.stamp === stamp) {
+        return known.current;
+    }
+    const current = parsed(readFileSync(path, "utf8"), path);
+    kept.set(path, { stamp, current });
+    return current;
+}
+/** Writes the current game to game.json, whole or not at all; from then on it is the one kept in memory. */
+export function saveGame(folder, current) {
+    const path = join(folder, fileName);
+    const file = {
+        format: 1,
+        ai: current.ai,
+        started: current.started,
+        pgn: writePgn(current.game.record),
+        ...(current.talk.length === 0 ? {} : { talk: current.talk }),
+        ...(current.clock === undefined ? {} : { clock: savedClockOf(current.clock) }),
+        ...(drawOfferOf(current) === undefined ? {} : { drawOffer: current.drawOffer }),
+    };
+    try {
+        writeAtomically(path, `${JSON.stringify(file, null, 2)}\n`);
+    }
+    catch (error) {
+        // The live game may hold a move the file does not: the next call reads the file again.
+        kept.delete(path);
+        throw new Error(`Chesspal could not save the game: ${error.message} Nothing changed.`, { cause: error });
+    }
+    kept.set(path, { stamp: stampOf(path) ?? "", current });
+}
+/** How the game ended, or undefined while it goes on: by the board, or by what the record says, such as a resignation. */
+export function endOf(game) {
+    const { tags } = game.record;
+    const { outcome } = game;
+    if (tags.Result === undefined || tags.Result === "*") {
+        return undefined;
+    }
+    const termination = tags.Termination ?? (outcome.over ? outcome.ending : undefined);
+    return termination === undefined ? { result: tags.Result } : { result: tags.Result, termination };
+}
+/** The draw offer that stands: none once the game is over (D-65). */
+export function drawOfferOf(current) {
+    return endOf(current.game) === undefined ? current.drawOffer : undefined;
+}
+/** Whether each side has made a move in the game, before which no draw is agreed (FIDE 5.2.3, D-65). */
+export function bothSidesMoved(game) {
+    return game.record.moves.length >= 2;
+}
+/** A stamp of the folder's game.json that changes whenever it is written, whoever writes it; undefined when there is none. */
+export function gameStamp(folder) {
+    return stampOf(join(folder, fileName));
+}
+/** Removes game.json, when the game over it holds is deleted from the archive (D-92): a new game would archive it again. */
+export function removeGame(folder) {
+    const path = join(folder, fileName);
+    kept.delete(path);
+    rmSync(path, { force: true });
+}
+const fileName = "game.json";
+/** A line of the talk as game.json and talk.json keep it. */
+export const savedLine = z.object({ who: z.enum(["player", "ai"]), text: z.string(), ply: z.int().min(0), at: z.iso.datetime(), agent: z.literal(true).optional() });
+const savedClock = z.object({
+    base: z.int().positive(),
+    increment: z.int().min(0),
+    white: z.number().min(0),
+    black: z.number().min(0),
+    since: z.iso.datetime(),
+    waiting: z.literal(true).optional(),
+});
+const gameFile = z.object({
+    format: z.literal(1),
+    ai: z.enum(["white", "black"]),
+    started: z.iso.datetime(),
+    pgn: z.string(),
+    talk: z.array(savedLine).optional(),
+    clock: savedClock.optional(),
+    drawOffer: z.enum(["player", "ai"]).optional(),
+});
+// The games read or written in this process, by their file, with the file's stamp then: a call reads a file again only when another process changed it.
+const kept = new Map();
+function stampOf(path) {
+    // The file's id changes at every rename: a write within the same tick of the clock, and of the same size, is seen too.
+    const stats = statSync(path, { bigint: true, throwIfNoEntry: false });
+    return stats === undefined ? undefined : `${stats.ino}:${stats.mtimeNs}:${stats.size}`;
+}
+function parsed(text, path) {
+    try {
+        const file = gameFile.parse(JSON.parse(text));
+        const records = readPgn(file.pgn);
+        const [record] = records;
+        if (record === undefined || records.length > 1) {
+            throw new Error(`its PGN holds ${records.length} games`);
+        }
+        return {
+            game: new Game(record),
+            ai: file.ai,
+            started: file.started,
+            talk: file.talk ?? [],
+            ...(file.clock === undefined ? {} : { clock: clockOf(file.clock) }),
+            ...(file.drawOffer === undefined ? {} : { drawOffer: file.drawOffer }),
+        };
+    }
+    catch (error) {
+        throw new Error(`${path} is not a game Chesspal can read (${problemOf(error)}): ask the player to fix it or move it away, since Chesspal never overwrites it.`);
+    }
+}
+/** The clock as game.json keeps it, flat, in milliseconds. */
+function savedClockOf({ control, left, since, waiting }) {
+    return { base: control.base, increment: control.increment, white: left.white, black: left.black, since, ...(waiting === true ? { waiting } : {}) };
+}
+function clockOf({ base, increment, white, black, since, waiting }) {
+    return { control: { base, increment }, left: { white, black }, since, ...(waiting === true ? { waiting } : {}) };
+}
+function problemOf(error) {
+    if (error instanceof z.ZodError) {
+        return error.issues.map((issue) => `${issue.path.join(".") || "the file"}: ${issue.message}`).join("; ");
+    }
+    return error.message;
+}

package/dist/games/files.d.ts

@@ -0,0 +1,9 @@
+/** Writes a file whole or not at all: a temporary file beside it, then renamed over it (D-27). A failure says what to do about it. */
+export declare function writeAtomically(path: string, text: string | Uint8Array): void;
+/** Makes a folder, and those above it, when missing. A failure says what to do about it. */
+export declare function makeFolder(path: string): void;
+/**
+ * Renames a file or a folder. Windows refuses while another program holds a file in it open (an editor, an antivirus, a sync client): Chesspal waits a
+ * little and tries again, half a second at most.
+ */
+export declare function renameOver(from: string, to: string): void;

package/dist/games/files.js

@@ -0,0 +1,53 @@
+// Writing the player's files safely: whole or not at all, with failures that say what to do (D-27).
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+/** Writes a file whole or not at all: a temporary file beside it, then renamed over it (D-27). A failure says what to do about it. */
+export function writeAtomically(path, text) {
+    const temporary = `${path}.${process.pid}.tmp`;
+    try {
+        writeFileSync(temporary, text);
+        renameOver(temporary, path);
+    }
+    catch (error) {
+        throw new Error(problemOf(error, path), { cause: error });
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+/** Makes a folder, and those above it, when missing. A failure says what to do about it. */
+export function makeFolder(path) {
+    try {
+        mkdirSync(path, { recursive: true });
+    }
+    catch (error) {
+        throw new Error(`${path} could not be made (${error.message}): check that it is a folder, and can be written.`, { cause: error });
+    }
+}
+const attempts = 10;
+/**
+ * Renames a file or a folder. Windows refuses while another program holds a file in it open (an editor, an antivirus, a sync client): Chesspal waits a
+ * little and tries again, half a second at most.
+ */
+export function renameOver(from, to) {
+    for (let attempt = 1;; attempt++) {
+        try {
+            renameSync(from, to);
+            return;
+        }
+        catch (error) {
+            if (attempt === attempts || !isHeld(error)) {
+                throw error;
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10 * attempt);
+        }
+    }
+}
+function isHeld(error) {
+    return error.syscall === "rename" && (error.code === "EPERM" || error.code === "EACCES" || error.code === "EBUSY");
+}
+function problemOf(error, path) {
+    if (isHeld(error)) {
+        return `${path} is held open by another program, or is read-only (${error.code}, ${attempts} tries): close that program, or make the file writable.`;
+    }
+    return `${path} could not be written (${error.message}): check that its folder can be written.`;
+}

package/dist/games/index.d.ts

@@ -0,0 +1,11 @@
+export { aiModelOf, noteAiModel } from "./ai-model.ts";
+export { type Analysis, endAnalysis, gameInAnalysis, startAnalysis } from "./analysis.ts";
+export { archiveCoached, archivedGame, archivedGames, archivedName, archivedWhen, archiveEnded, archiveGame, archiveName, deleteGame, gameStemOf, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, playerPgn, rewriteGame, startOfNewGame, } from "./archive.ts";
+export { type ChatStart, cleanSince, lastChatStart, saveChatStart } from "./chat-start.ts";
+export { type CoachHint, type CoachJudgment, type CoachLead, coachShown, coachStarted, coachWaitingSince, type CoachWords, coachWords, forgetCoach, keepHint, keepJudgment, keepLead, startCoach, withCoach } from "./coach.ts";
+export { bothSidesMoved, type CurrentGame, drawOfferOf, endOf, type GameEnd, gameStamp, loadGame, removeGame, saveGame, type Speaker, type TalkLine } from "./current-game.ts";
+export { makeFolder, renameOver, writeAtomically } from "./files.ts";
+export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.ts";
+export { endTableTalk, loadTableTalk, saveTableTalk, type TableTalk } from "./table-talk.ts";
+export { type Heard, heardLines, type Sayer, type Talk, talkLimits, talkLine, unheardWords, wakesTheChat, type Words, WordsRefused } from "./talk.ts";
+export { keepThought, type Thought, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.ts";

package/dist/games/index.js

@@ -0,0 +1,12 @@
+// The player's games on disk: the current one in game.json, the finished ones in games/ (D-27, D-41), the games kept to study in study/ (D-68). Below the commands, above the core.
+export { aiModelOf, noteAiModel } from "./ai-model.js";
+export { endAnalysis, gameInAnalysis, startAnalysis } from "./analysis.js";
+export { archiveCoached, archivedGame, archivedGames, archivedName, archivedWhen, archiveEnded, archiveGame, archiveName, deleteGame, gameStemOf, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, playerPgn, rewriteGame, startOfNewGame, } from "./archive.js";
+export { cleanSince, lastChatStart, saveChatStart } from "./chat-start.js";
+export { coachShown, coachStarted, coachWaitingSince, coachWords, forgetCoach, keepHint, keepJudgment, keepLead, startCoach, withCoach } from "./coach.js";
+export { bothSidesMoved, drawOfferOf, endOf, gameStamp, loadGame, removeGame, saveGame } from "./current-game.js";
+export { makeFolder, renameOver, writeAtomically } from "./files.js";
+export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.js";
+export { endTableTalk, loadTableTalk, saveTableTalk } from "./table-talk.js";
+export { heardLines, talkLimits, talkLine, unheardWords, wakesTheChat, WordsRefused } from "./talk.js";
+export { keepThought, thoughtForLastMove, thoughtKey, waitingSince } from "./thoughts.js";

package/dist/games/plans.d.ts

@@ -0,0 +1,9 @@
+import type { GameRecord } from "../core/index.ts";
+/** The comment of the AI's move, when it has one, with its plan. */
+export declare function commentWithPlan(comment: string | undefined, plan: string): string;
+/** The plan a move's comment carries, if it carries one. */
+export declare function planOf(comment: string | undefined): string | undefined;
+/** The plan the AI wrote last, if it wrote one. */
+export declare function currentPlan(record: GameRecord): string | undefined;
+/** The record without the AI's plans: what the player may see while the game goes on. */
+export declare function withoutPlans(record: GameRecord): GameRecord;

package/dist/games/plans.js

@@ -0,0 +1,23 @@
+/** The comment of the AI's move, when it has one, with its plan. */
+export function commentWithPlan(comment, plan) {
+    return comment === undefined ? `[%plan ${plan}]` : `${comment} [%plan ${plan}]`;
+}
+/** The plan a move's comment carries, if it carries one. */
+export function planOf(comment) {
+    return planPattern.exec(comment ?? "")?.[1];
+}
+/** The plan the AI wrote last, if it wrote one. */
+export function currentPlan(record) {
+    for (let index = record.moves.length - 1; index >= 0; index--) {
+        const plan = planOf(record.moves[index]?.comment);
+        if (plan !== undefined) {
+            return plan;
+        }
+    }
+    return undefined;
+}
+/** The record without the AI's plans: what the player may see while the game goes on. */
+export function withoutPlans(record) {
+    return { ...record, moves: record.moves.map((move) => ({ ...move, comment: move.comment?.replace(planPattern, "") })) };
+}
+const planPattern = /\s*\[%plan ([^\]]*)\]/;

package/dist/games/table-talk.d.ts

@@ -0,0 +1,12 @@
+import { type TalkLine } from "./current-game.ts";
+/** What the player and the AI said with no game on the page, and since when: it keys the player's lines apart from any game's. */
+export interface TableTalk {
+    readonly started: string;
+    readonly talk: readonly TalkLine[];
+}
+/** The talk with no game: empty when there is none, or talk.json cannot be read, since it is only words. */
+export declare function loadTableTalk(folder: string): TableTalk;
+/** Writes the talk with no game, whole or not at all. */
+export declare function saveTableTalk(folder: string, table: TableTalk): void;
+/** Forgets the talk with no game, when a game starts. */
+export declare function endTableTalk(folder: string): void;

package/dist/games/table-talk.js

@@ -0,0 +1,25 @@
+// The talk on the board page before the first game (D-77): talk.json, in the folder of the profile's games, until a game starts and its talk goes in game.json.
+import { readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { savedLine } from "./current-game.js";
+import { writeAtomically } from "./files.js";
+/** The talk with no game: empty when there is none, or talk.json cannot be read, since it is only words. */
+export function loadTableTalk(folder) {
+    try {
+        return tableFile.parse(JSON.parse(readFileSync(join(folder, fileName), "utf8")));
+    }
+    catch {
+        return { started: "", talk: [] };
+    }
+}
+/** Writes the talk with no game, whole or not at all. */
+export function saveTableTalk(folder, table) {
+    writeAtomically(join(folder, fileName), `${JSON.stringify(table, null, 2)}\n`);
+}
+/** Forgets the talk with no game, when a game starts. */
+export function endTableTalk(folder) {
+    rmSync(join(folder, fileName), { force: true });
+}
+const fileName = "talk.json";
+const tableFile = z.object({ started: z.iso.datetime(), talk: z.array(savedLine) });

package/dist/games/talk.d.ts

@@ -0,0 +1,36 @@
+import { type CurrentGame, type Speaker, type TalkLine } from "./current-game.ts";
+import type { TableTalk } from "./table-talk.ts";
+/** The most the player may write in a move, in all their lines, and the most a line of the AI's may hold (D-54); with the helps on, as an analyst's note (D-78). */
+export declare const talkLimits: {
+    readonly player: 200;
+    readonly ai: 300;
+    readonly aiHelps: 700;
+};
+/** Who says a line: the player, the AI in the chat, or the AI's agent thinking on the player's time (D-72), whose lines are the AI's on the page. */
+export type Sayer = Speaker | "agent";
+/** A talk: a game's, going on or over, or the one with no game, where both talk freely as between games (D-74, D-77). */
+export type Talk = CurrentGame | TableTalk;
+/**
+ * A new line of the talk, said when the game has `ply` moves: refused when it is empty or too long. The player writes 200 characters a move in all, the
+ * words sent with the move included; the AI speaks once a move of theirs, on their time, and its agent's word leaves it an answer to what they write after (D-54, D-72).
+ */
+export declare function talkLine(current: Talk, sayer: Sayer, text: string, at: Date, ply?: number, aiMost?: number): TalkLine;
+/** Words refused, and why, for the page to say it in the player's language: none, the move's characters spent, more than a line or what is left holds. */
+export declare class WordsRefused extends Error {
+    readonly reason: "empty" | "spent" | "long" | "longer-than-left";
+    readonly most: number;
+    constructor(message: string, reason: WordsRefused["reason"], most?: number);
+}
+/** Whether the player's last line wakes the chat: the first of a move, and between games the first since the AI last spoke (D-54, D-74). */
+export declare function wakesTheChat(current: Talk): boolean;
+/** Words of the player's, with the key that tells them apart across games. */
+export interface Words {
+    readonly key: string;
+    readonly text: string;
+}
+/** What the player said that the AI has not answered, but for the words whose keys are in `given`. */
+export declare function unheardWords(current: Talk, given: ReadonlySet<string>): Words[];
+/** How far a line of the player's got: written, read by the AI in this chat, or answered by its words or its move. */
+export type Heard = "sent" | "read" | "answered";
+/** How far each line of the talk got: the player's by `Heard`, the AI's undefined (D-53). */
+export declare function heardLines(current: Talk, given: ReadonlySet<string>): (Heard | undefined)[];