chesspal 0.0.1 → 0.1.0

package/dist/page/voice.js

@@ -0,0 +1,38 @@
+// The AI's words read aloud (Stefano's idea, IDEE.md): the browser's own voices, a local one first, so the words stay on the computer where it can.
+/** Reads the words aloud in the language given, cutting short what was being read. */
+export function speak(words, language) {
+    if (typeof speechSynthesis === "undefined") {
+        return;
+    }
+    const said = words.replace(/\*\*/g, "").trim();
+    speechSynthesis.cancel();
+    clearTimeout(pending);
+    if (said === "") {
+        return;
+    }
+    // Chrome drops words spoken right after a cancel, and lists its voices late the first time: the words wait a moment.
+    pending = setTimeout(() => {
+        const utterance = new SpeechSynthesisUtterance(said);
+        const voice = voiceFor(language);
+        utterance.lang = voice?.lang ?? language;
+        if (voice !== undefined) {
+            utterance.voice = voice;
+        }
+        speechSynthesis.resume();
+        speechSynthesis.speak(utterance);
+    }, 150);
+}
+/** Stops reading. */
+export function hush() {
+    if (typeof speechSynthesis !== "undefined") {
+        clearTimeout(pending);
+        speechSynthesis.cancel();
+    }
+}
+let pending;
+/** A voice for the language: a local one first, the browser's default among them first. */
+function voiceFor(language) {
+    const voices = speechSynthesis.getVoices().filter((voice) => voice.lang.toLowerCase().startsWith(language.toLowerCase()));
+    const local = voices.filter((voice) => voice.localService);
+    return local.find((voice) => voice.default) ?? local[0] ?? voices[0];
+}

package/dist/profiles/avatar.d.ts

@@ -0,0 +1,23 @@
+/** The types of image a profile takes, by the file names they have there. */
+export declare const imageTypes: {
+    readonly png: "image/png";
+    readonly jpg: "image/jpeg";
+    readonly webp: "image/webp";
+};
+export type ImageType = keyof typeof imageTypes;
+/** The largest image the page may send: it sends a small one, made from the player's photo. */
+export declare const sentImageLimit: number;
+/** The player's own image: its bytes, its type as its first bytes tell it, and a stamp that changes with it; undefined when there is none, or it is no image. */
+export declare function ownImage(root: string, id: string): {
+    bytes: Buffer;
+    type: ImageType;
+    stamp: string;
+} | undefined;
+/** The stamp of the player's own image, which the page adds to its address; undefined when there is none. Only its first bytes are read. */
+export declare function ownImageStamp(root: string, id: string): string | undefined;
+/** Saves an image the page sent as the player's own, in place of any other: a PNG, JPEG or WebP, as its first bytes tell, within the limit. */
+export declare function saveOwnImage(root: string, id: string, bytes: Uint8Array): void;
+/** Removes the player's own images, but the one kept: a drawn avatar chosen on the page shows in their place. */
+export declare function removeOwnImage(root: string, id: string, kept?: string): void;
+/** An image's type by its first bytes: never by its name, which anything may have. */
+export declare function imageTypeOf(bytes: Uint8Array): ImageType | undefined;

package/dist/profiles/avatar.js

@@ -0,0 +1,84 @@
+// The player's own picture (D-45): an image in the profile's folder, put there by hand or sent from the page, which shows instead of a drawn avatar.
+import { closeSync, openSync, readFileSync, readSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { writeAtomically } from "../games/index.js";
+import { profileFolder } from "./profiles.js";
+/** The types of image a profile takes, by the file names they have there. */
+export const imageTypes = { png: "image/png", jpg: "image/jpeg", webp: "image/webp" };
+/** The largest image the page may send: it sends a small one, made from the player's photo. */
+export const sentImageLimit = 1024 * 1024;
+/** The player's own image: its bytes, its type as its first bytes tell it, and a stamp that changes with it; undefined when there is none, or it is no image. */
+export function ownImage(root, id) {
+    const found = ownImageFile(root, id);
+    try {
+        return found === undefined ? undefined : { bytes: readFileSync(found.path), type: found.type, stamp: found.stamp };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The stamp of the player's own image, which the page adds to its address; undefined when there is none. Only its first bytes are read. */
+export function ownImageStamp(root, id) {
+    return ownImageFile(root, id)?.stamp;
+}
+/** Saves an image the page sent as the player's own, in place of any other: a PNG, JPEG or WebP, as its first bytes tell, within the limit. */
+export function saveOwnImage(root, id, bytes) {
+    const type = imageTypeOf(bytes);
+    if (type === undefined) {
+        throw new Error("The picture must be a PNG, JPEG or WebP image.");
+    }
+    if (bytes.length > sentImageLimit) {
+        throw new Error(`The picture is ${Math.ceil(bytes.length / 1024)} KB: send one of ${sentImageLimit / 1024} KB at most.`);
+    }
+    const name = `avatar.${type}`;
+    writeAtomically(join(profileFolder(root, id), name), bytes);
+    removeOwnImage(root, id, name);
+}
+/** Removes the player's own images, but the one kept: a drawn avatar chosen on the page shows in their place. */
+export function removeOwnImage(root, id, kept) {
+    for (const name of fileNames.filter((one) => one !== kept)) {
+        rmSync(join(profileFolder(root, id), name), { force: true });
+    }
+}
+/** An image's type by its first bytes: never by its name, which anything may have. */
+export function imageTypeOf(bytes) {
+    const starts = (signature, at = 0) => signature.every((byte, index) => bytes[at + index] === byte);
+    if (starts([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) {
+        return "png";
+    }
+    if (starts([0xff, 0xd8, 0xff])) {
+        return "jpg";
+    }
+    return starts([0x52, 0x49, 0x46, 0x46]) && starts([0x57, 0x45, 0x42, 0x50], 8) ? "webp" : undefined;
+}
+function ownImageFile(root, id) {
+    for (const name of fileNames) {
+        const path = join(profileFolder(root, id), name);
+        try {
+            const { size, mtimeMs } = statSync(path);
+            const type = size > keptImageLimit ? undefined : imageTypeOf(firstBytes(path));
+            if (type !== undefined) {
+                return { path, type, stamp: `${Math.trunc(mtimeMs)}-${size}` };
+            }
+        }
+        catch {
+            // No such file, or one that cannot be read: the next name.
+        }
+    }
+    return undefined;
+}
+function firstBytes(path) {
+    const bytes = new Uint8Array(12);
+    const file = openSync(path, "r");
+    try {
+        readSync(file, bytes, 0, bytes.length, 0);
+    }
+    finally {
+        closeSync(file);
+    }
+    return bytes;
+}
+// The names the player's image may have in the profile's folder, the first found winning.
+const fileNames = ["avatar.png", "avatar.jpg", "avatar.jpeg", "avatar.webp"];
+// An image the player put in the folder by hand may be a photo as the camera took it, but not a huge file.
+const keptImageLimit = 10 * 1024 * 1024;

package/dist/profiles/front-matter.d.ts

@@ -0,0 +1,9 @@
+/** The fields of a markdown file's front matter, as text, and the text below it. */
+export interface FrontMatter {
+    readonly fields: Readonly<Record<string, string>>;
+    readonly body: string;
+}
+/** Reads a flat front matter: a value in double quotes as JSON writes it, any other as it stands; lines that are not key: value are left out. */
+export declare function readFrontMatter(text: string): FrontMatter;
+/** Writes a flat front matter, its text values in double quotes so that any name reads back as it was, and the text below it. */
+export declare function writeFrontMatter(fields: Readonly<Record<string, string | number | undefined>>, body?: string): string;

package/dist/profiles/front-matter.js

@@ -0,0 +1,33 @@
+// A flat YAML front matter (D-9): one field a line, key: value, between two lines of ---, then the text below it, which stays as it was.
+/** Reads a flat front matter: a value in double quotes as JSON writes it, any other as it stands; lines that are not key: value are left out. */
+export function readFrontMatter(text) {
+    // An editor may begin the file with a byte-order mark.
+    const match = /^?---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
+    if (match === null) {
+        return { fields: {}, body: text };
+    }
+    const fields = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const field = /^([A-Za-z][\w-]*):\s*(.*?)\s*$/.exec(line);
+        if (field !== null && field[2] !== "") {
+            fields[field[1]] = valueOf(field[2]);
+        }
+    }
+    return { fields, body: text.slice(match[0].length) };
+}
+/** Writes a flat front matter, its text values in double quotes so that any name reads back as it was, and the text below it. */
+export function writeFrontMatter(fields, body = "") {
+    const lines = Object.entries(fields).flatMap(([key, value]) => (value === undefined ? [] : [`${key}: ${typeof value === "number" ? value : JSON.stringify(value)}`]));
+    return `---\n${lines.join("\n")}\n---\n${body}`;
+}
+function valueOf(written) {
+    if (written.startsWith('"')) {
+        try {
+            return String(JSON.parse(written));
+        }
+        catch {
+            return written;
+        }
+    }
+    return written.startsWith("'") && written.endsWith("'") && written.length > 1 ? written.slice(1, -1).replaceAll("''", "'") : written;
+}

package/dist/profiles/index.d.ts

@@ -0,0 +1,3 @@
+export { type ImageType, imageTypeOf, imageTypes, ownImage, ownImageStamp, removeOwnImage, saveOwnImage, sentImageLimit } from "./avatar.ts";
+export { activateProfile, activeProfile, createProfile, type DrawnAvatar, drawnAvatars, ensureProfile, gameFolder, gameFolders, type Level, levels, listProfiles, nameLimit, type PlayerProfile, type ProfileFields, profileFolder, type Rating, ratingLimits, type RatingSite, ratingSites, updateProfile, } from "./profiles.ts";
+export { helpsIn, languageIn, type PageSettings, profileSettings, saveProfileSettings, settingsOf } from "./settings.ts";

package/dist/profiles/index.js

@@ -0,0 +1,5 @@
+// The player's profiles (D-23): who plays, their games, their picture and their page settings, each in profiles/<id>/ of the data folder (D-71). Below the
+// commands, beside the games.
+export { imageTypeOf, imageTypes, ownImage, ownImageStamp, removeOwnImage, saveOwnImage, sentImageLimit } from "./avatar.js";
+export { activateProfile, activeProfile, createProfile, drawnAvatars, ensureProfile, gameFolder, gameFolders, levels, listProfiles, nameLimit, profileFolder, ratingLimits, ratingSites, updateProfile, } from "./profiles.js";
+export { helpsIn, languageIn, profileSettings, saveProfileSettings, settingsOf } from "./settings.js";

package/dist/profiles/profiles.d.ts

@@ -0,0 +1,58 @@
+/** How the player says they play, from who has just learned to who plays tournaments. */
+export declare const levels: readonly ["learning", "casual", "regular", "tournament"];
+export type Level = (typeof levels)[number];
+/** Where a rating comes from. */
+export declare const ratingSites: readonly ["lichess", "chess.com", "fide"];
+export type RatingSite = (typeof ratingSites)[number];
+/** The lowest and highest rating a profile takes. */
+export declare const ratingLimits: {
+    readonly lowest: 100;
+    readonly highest: 3500;
+};
+/** The longest name a profile keeps. */
+export declare const nameLimit = 40;
+/** The avatars Zoe drew, for a player without an image of their own (D-45). */
+export declare const drawnAvatars: readonly ["short-hair", "bun", "glasses", "beanie", "beard", "curls", "moustache", "silver-bob", "cat", "owl"];
+export type DrawnAvatar = (typeof drawnAvatars)[number];
+/** A rating and where it comes from. */
+export interface Rating {
+    readonly value: number;
+    readonly site: RatingSite;
+}
+/** What the player tells of themselves: their name, how they play, their rating, the avatar they chose. */
+export interface ProfileFields {
+    readonly name: string;
+    readonly level?: Level;
+    readonly rating?: Rating;
+    readonly avatar?: DrawnAvatar;
+}
+/** A profile: its folder's name, and what profile.md says; a folder without one is named by the folder. */
+export interface PlayerProfile extends ProfileFields {
+    readonly id: string;
+    /** Made by Chesspal at the first start, until the player completes it: the board page's wizard does (D-71). */
+    readonly new?: true;
+}
+/** The profiles in the data folder, by their folders' names. */
+export declare function listProfiles(root: string): PlayerProfile[];
+/**
+ * Makes the first profile when there is none, named after the system's account and new until the player completes it (D-71). Two processes starting
+ * together make one: the second finds its folder taken.
+ */
+export declare function ensureProfile(root: string, account: string): void;
+/** The profile in use: the one active.json names, else the first. */
+export declare function activeProfile(root: string): PlayerProfile;
+/** Where the games are: the folder of the profile in use. */
+export declare function gameFolder(root: string): string;
+/** A profile's folder. */
+export declare function profileFolder(root: string, id: string): string;
+/**
+ * Makes a profile, its folder named from the player's name, and puts it in use; the one Chesspal made, while new, becomes it instead, with its games, and
+ * its folder takes the player's name too (D-71).
+ */
+export declare function createProfile(root: string, fields: ProfileFields): PlayerProfile;
+/** Every profile's folder, where games may be. */
+export declare function gameFolders(root: string): string[];
+/** Puts a profile in use. */
+export declare function activateProfile(root: string, id: string): PlayerProfile;
+/** Changes what a profile says of the player, keeping the rest of profile.md as it was written: its other fields and the text below them. */
+export declare function updateProfile(root: string, id: string, changes: Partial<ProfileFields>): PlayerProfile;

package/dist/profiles/profiles.js

@@ -0,0 +1,237 @@
+// The player's profiles (D-23): profiles/<id>/ in the data folder (D-71), each with its profile.md, its games and its page settings, and the one in use;
+// there is always one, the first made by Chesspal.
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { makeFolder, renameOver, writeAtomically } from "../games/index.js";
+import { readFrontMatter, writeFrontMatter } from "./front-matter.js";
+/** How the player says they play, from who has just learned to who plays tournaments. */
+export const levels = ["learning", "casual", "regular", "tournament"];
+/** Where a rating comes from. */
+export const ratingSites = ["lichess", "chess.com", "fide"];
+/** The lowest and highest rating a profile takes. */
+export const ratingLimits = { lowest: 100, highest: 3500 };
+/** The longest name a profile keeps. */
+export const nameLimit = 40;
+/** The avatars Zoe drew, for a player without an image of their own (D-45). */
+export const drawnAvatars = ["short-hair", "bun", "glasses", "beanie", "beard", "curls", "moustache", "silver-bob", "cat", "owl"];
+/** The profiles in the data folder, by their folders' names. */
+export function listProfiles(root) {
+    return profileIds(root).map((id) => readProfile(root, id));
+}
+/**
+ * Makes the first profile when there is none, named after the system's account and new until the player completes it (D-71). Two processes starting
+ * together make one: the second finds its folder taken.
+ */
+export function ensureProfile(root, account) {
+    const id = freeId(root, slugOf(account));
+    if (profileIds(root).length === 0 && claimed(root, id)) {
+        fillProfile(root, id, { name: account }, true);
+    }
+}
+/** The profile in use: the one active.json names, else the first. */
+export function activeProfile(root) {
+    return readProfile(root, activeIdOf(root));
+}
+/** Where the games are: the folder of the profile in use. */
+export function gameFolder(root) {
+    return profileFolder(root, activeIdOf(root));
+}
+/** A profile's folder. */
+export function profileFolder(root, id) {
+    return join(root, folderName, id);
+}
+/**
+ * Makes a profile, its folder named from the player's name, and puts it in use; the one Chesspal made, while new, becomes it instead, with its games, and
+ * its folder takes the player's name too (D-71).
+ */
+export function createProfile(root, fields) {
+    const id = activeId(root);
+    if (id !== undefined && readProfile(root, id).new === true) {
+        const { level, rating, avatar } = fields;
+        const named = renamed(root, id, fields.name);
+        writeProfile(root, named, { name: fields.name, level, rating, avatar, new: false });
+        return readProfile(root, named);
+    }
+    let made = freeId(root, slugOf(fields.name));
+    // Another process may take the same id between the look and the folder: the next free one, then.
+    while (!claimed(root, made)) {
+        made = freeId(root, slugOf(fields.name));
+    }
+    return fillProfile(root, made, fields, false);
+}
+/** Every profile's folder, where games may be. */
+export function gameFolders(root) {
+    return profileIds(root).map((id) => profileFolder(root, id));
+}
+/** Puts a profile in use. */
+export function activateProfile(root, id) {
+    const ids = profileIds(root);
+    if (!ids.includes(id)) {
+        throw new Error(ids.length === 0 ? "There is no profile yet: make one first." : `There is no profile ${id}: the profiles are ${ids.join(", ")}.`);
+    }
+    writeActive(root, id);
+    return readProfile(root, id);
+}
+/** Changes what a profile says of the player, keeping the rest of profile.md as it was written: its other fields and the text below them. */
+export function updateProfile(root, id, changes) {
+    writeProfile(root, id, changes);
+    return readProfile(root, id);
+}
+const folderName = "profiles";
+const profileFile = "profile.md";
+const activeFile = "active.json";
+// Names Windows keeps for devices: no folder may take them.
+const reserved = /^(con|prn|aux|nul|com\d|lpt\d)$/;
+function profileIds(root) {
+    try {
+        return readdirSync(join(root, folderName), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    }
+    catch {
+        return [];
+    }
+}
+function activeId(root) {
+    const named = activeNamed(root);
+    const ids = profileIds(root);
+    return named !== undefined && ids.includes(named) ? named : ids[0];
+}
+function activeIdOf(root) {
+    const id = activeId(root);
+    if (id === undefined) {
+        throw new Error(`There is no profile in ${join(root, folderName)}: run any Chesspal command, and it makes one.`);
+    }
+    return id;
+}
+/** Takes a profile's folder for this call alone: false when another process has made it already. */
+function claimed(root, id) {
+    makeFolder(join(root, folderName));
+    const folder = profileFolder(root, id);
+    try {
+        mkdirSync(folder);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            return false;
+        }
+        throw new Error(`${folder} could not be made (${error.message}): check that it is a folder, and can be written.`, { cause: error });
+    }
+}
+/** Writes a profile in the folder this call claimed and puts it in use; on a failure the folder goes, which holds nothing of another's. */
+function fillProfile(root, id, fields, made) {
+    try {
+        writeProfile(root, id, made ? { ...fields, new: true } : fields);
+        writeActive(root, id);
+    }
+    catch (error) {
+        rmSync(profileFolder(root, id), { recursive: true, force: true });
+        throw error;
+    }
+    return readProfile(root, id);
+}
+/**
+ * The folder of the profile Chesspal made, named after the account, moved to the player's name and put in use; it keeps the account's for a name without
+ * letters or digits, and where it cannot move, as with a file held open in it.
+ */
+function renamed(root, id, name) {
+    const plain = plainName(name);
+    if (plain === "" || id === plain || (id.startsWith(`${plain}-`) && /^\d+$/.test(id.slice(plain.length + 1)))) {
+        return id;
+    }
+    const target = freeId(root, plain);
+    // On Linux and macOS a folder another process made between the look and the move would be replaced: two profiles made in the same instant.
+    try {
+        renameOver(profileFolder(root, id), profileFolder(root, target));
+    }
+    catch {
+        return id;
+    }
+    try {
+        writeActive(root, target);
+    }
+    catch (error) {
+        // Moved back, or the first folder would be put in use in its place.
+        renameOver(profileFolder(root, target), profileFolder(root, id));
+        throw error;
+    }
+    return target;
+}
+function activeNamed(root) {
+    try {
+        const { profile } = JSON.parse(readFileSync(join(root, folderName, activeFile), "utf8"));
+        return typeof profile === "string" && /^[^/\\.][^/\\]*$/.test(profile) ? profile : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeActive(root, id) {
+    writeAtomically(join(root, folderName, activeFile), `${JSON.stringify({ profile: id }, null, 2)}\n`);
+}
+function readProfile(root, id) {
+    const { fields } = readFrontMatter(profileText(root, id));
+    const value = Number(fields.rating);
+    const site = oneOf(ratingSites, fields.site);
+    const level = oneOf(levels, fields.level);
+    const avatar = oneOf(drawnAvatars, fields.avatar);
+    const rated = Number.isInteger(value) && value >= ratingLimits.lowest && value <= ratingLimits.highest && site !== undefined;
+    // A name written by hand is cut as the page and the CLI cut it: the AI reads it.
+    return {
+        id,
+        name: fields.name?.trim().slice(0, nameLimit).trim() || id,
+        ...(level === undefined ? {} : { level }),
+        ...(rated ? { rating: { value, site } } : {}),
+        ...(avatar === undefined ? {} : { avatar }),
+        ...(fields.new === "true" ? { new: true } : {}),
+    };
+}
+// Writes the fields that change, and keeps the others as the file has them, even those this version does not read.
+function writeProfile(root, id, changes) {
+    const { fields, body } = readFrontMatter(profileText(root, id));
+    const written = { ...fields };
+    if (changes.name !== undefined) {
+        written.name = changes.name;
+    }
+    if ("level" in changes) {
+        written.level = changes.level;
+    }
+    if ("rating" in changes) {
+        written.rating = changes.rating?.value;
+        written.site = changes.rating?.site;
+    }
+    if ("avatar" in changes) {
+        written.avatar = changes.avatar;
+    }
+    if ("new" in changes) {
+        written.new = changes.new === true ? "true" : undefined;
+    }
+    writeAtomically(join(profileFolder(root, id), profileFile), writeFrontMatter(written, body));
+}
+function profileText(root, id) {
+    try {
+        return readFileSync(join(profileFolder(root, id), profileFile), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/** A folder's name from the player's name: its plain letters and digits, or player for a name without any. */
+function slugOf(name) {
+    return plainName(name) || "player";
+}
+/** A name in plain letters and digits, lower case, words joined by hyphens; empty for a name without any. */
+function plainName(name) {
+    return name.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").slice(0, 32).replace(/-+$/, "");
+}
+function freeId(root, slug) {
+    const taken = (id) => reserved.test(id) || existsSync(profileFolder(root, id));
+    let id = slug;
+    for (let number = 2; taken(id); number++) {
+        id = `${slug}-${number}`;
+    }
+    return id;
+}
+// A value of a list, as a hand may write it: in capitals too.
+function oneOf(values, value) {
+    return values.find((one) => one === value?.toLowerCase());
+}

package/dist/profiles/settings.d.ts

@@ -0,0 +1,12 @@
+/** The page's settings, by name: text, numbers and flags. */
+export type PageSettings = Readonly<Record<string, string | number | boolean>>;
+/** A profile's settings, or undefined when it has none yet, or they cannot be read. */
+export declare function profileSettings(root: string, id: string): PageSettings | undefined;
+/** Whether the player has turned the helps on (D-78), in the settings of the profile whose games are in `folder`: off without them. */
+export declare function helpsIn(folder: string): boolean;
+/** The language of the player of the profile whose games are in `folder`: the page's, or the system's when the page follows the browser. */
+export declare function languageIn(folder: string, systemLanguage: string | undefined): string | undefined;
+/** Saves a profile's settings, over the ones before. */
+export declare function saveProfileSettings(root: string, id: string, settings: PageSettings): void;
+/** Settings from what JSON gave: an object of text, numbers and flags, at most a few dozen; undefined for anything else. */
+export declare function settingsOf(value: unknown): PageSettings | undefined;

package/dist/profiles/settings.js

@@ -0,0 +1,46 @@
+// The page's settings of a profile (D-56): settings.json in its folder, kept as the page sends them; the page checks each one as it reads them.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeAtomically } from "../games/index.js";
+import { profileFolder } from "./profiles.js";
+/** A profile's settings, or undefined when it has none yet, or they cannot be read. */
+export function profileSettings(root, id) {
+    try {
+        return settingsOf(JSON.parse(readFileSync(join(profileFolder(root, id), fileName), "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether the player has turned the helps on (D-78), in the settings of the profile whose games are in `folder`: off without them. */
+export function helpsIn(folder) {
+    return settingsIn(folder)?.helps === true;
+}
+/** The language of the player of the profile whose games are in `folder`: the page's, or the system's when the page follows the browser. */
+export function languageIn(folder, systemLanguage) {
+    const language = settingsIn(folder)?.language;
+    return typeof language === "string" && language !== "auto" ? language : systemLanguage;
+}
+/** Saves a profile's settings, over the ones before. */
+export function saveProfileSettings(root, id, settings) {
+    writeAtomically(join(profileFolder(root, id), fileName), `${JSON.stringify(settings, null, 2)}\n`);
+}
+/** Settings from what JSON gave: an object of text, numbers and flags, at most a few dozen; undefined for anything else. */
+export function settingsOf(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value);
+    const plain = entries.every(([, one]) => ["string", "number", "boolean"].includes(typeof one) && (typeof one !== "string" || one.length <= 64));
+    return plain && entries.length <= 40 ? Object.fromEntries(entries) : undefined;
+}
+const fileName = "settings.json";
+/** The settings of the profile whose games are in `folder`; undefined without them. */
+function settingsIn(folder) {
+    try {
+        return settingsOf(JSON.parse(readFileSync(join(folder, fileName), "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/server/analyses.d.ts

@@ -0,0 +1,17 @@
+import { type AiModel, type GameRecord } from "../core/index.ts";
+/** An analysis as the page lists it: who played, with the AI's model (D-82), when, how it ended, its opening, how long, and whether the AI has reviewed it. */
+export interface AnalysisItem {
+    readonly name: string;
+    readonly white: string;
+    readonly black: string;
+    readonly aiModel?: AiModel;
+    readonly date?: string;
+    readonly result: string;
+    readonly opening?: string;
+    readonly moves: number;
+    readonly reviewed: boolean;
+}
+/** The games to analyse in the profile in use, the latest 20: those kept to study and those played, reviewed or not. */
+export declare function analysesOf(home: string): AnalysisItem[];
+/** Whether the analyst has reviewed a game: its word on the whole game or on how it ended. The opponent's badges, given during the game with the helps on, are not a review (D-78). */
+export declare function isReviewed(record: GameRecord): boolean;

package/dist/server/analyses.js

@@ -0,0 +1,46 @@
+// The analyses the page lists (T-106): the games brought to study and those played here, to analyse or open again on the board page.
+import { bookOpening } from "../commands/opening-book.js";
+import { aiModelIn, closingOf, gameReviewOf } from "../core/index.js";
+import { archivedGame, archivedGames, keptGame, keptGames } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+/** The games to analyse in the profile in use, the latest 20: those kept to study and those played, reviewed or not. */
+export function analysesOf(home) {
+    const folder = gameFolder(home);
+    const names = [...keptGames(folder), ...archivedGames(folder)].sort((one, other) => stampOf(other).localeCompare(stampOf(one))).slice(0, shown);
+    return names.flatMap((name) => itemOf(name, () => name.startsWith("study/") ? keptGame(folder, name) : archivedGame(folder, name)));
+}
+// Enough for now; a longer list would load more as it scrolls.
+const shown = 20;
+/** Whether the analyst has reviewed a game: its word on the whole game or on how it ended. The opponent's badges, given during the game with the helps on, are not a review (D-78). */
+export function isReviewed(record) {
+    return gameReviewOf(record) !== undefined || closingOf(record) !== undefined;
+}
+function itemOf(name, read) {
+    let record;
+    try {
+        record = read();
+    }
+    catch {
+        // A game that cannot be read stays out of the list.
+        return [];
+    }
+    const { tags } = record;
+    const date = tags.Date === undefined || tags.Date.includes("?") ? undefined : tags.Date;
+    const opening = bookOpening(record)?.name;
+    const aiModel = aiModelIn(record);
+    return [{
+            name,
+            white: tags.White ?? "?",
+            black: tags.Black ?? "?",
+            ...(aiModel === undefined ? {} : { aiModel }),
+            ...(date === undefined ? {} : { date }),
+            result: tags.Result ?? "*",
+            ...(opening === undefined ? {} : { opening }),
+            moves: Math.ceil(record.moves.length / 2),
+            reviewed: isReviewed(record),
+        }];
+}
+/** The time in a game's name, which orders kept and played games together: 2026-11-04-153012. */
+function stampOf(name) {
+    return /(\d{4}-\d{2}-\d{2}-\d{6})/.exec(name)?.[1] ?? "";
+}