chesspal 0.2.4 → 0.3.0

package/dist/page/text.js

@@ -108,6 +108,7 @@ const english = {
     talk: "The talk",
     move: "Move",
     draw: "draw",
+    aborted: "Game aborted",
     checkmate: "checkmate",
     ended: {
         checkmate: "checkmate",
@@ -132,6 +133,18 @@ const english = {
     thinking: { move: "Thinking about its move", ponder: "Thinking while you play" },
     asleep: (name) => `${name} is not listening: write a message, such as "hi", in the window where you opened ${name}, not here. Its clock waits until it answers.`,
     asleepInAnalysis: (name) => `${name} is not listening: write to it in the window where you opened it, not here.`,
+    table: {
+        label: "Open a chat",
+        noChat: (name) => `To play with ${name}, open its chat: it starts in a window of its own, to keep open.`,
+        install: (name) => `To play with ${name}, install Claude Code or Codex, then open this page again.`,
+        model: "Model",
+        effort: "Effort",
+        asHost: (host) => `as set in ${host}`,
+        opening: "Opening the chat… In the terminal, if it asks whether you trust the folder, choose Yes with the arrow keys and press Enter.",
+        again: (name) => `${name} starts again with a clean chat for the new game…`,
+        failed: "The terminal did not open: type the command below in a terminal.",
+        typeIt: "Or type in a terminal:",
+    },
     commandHere: (name) => `/clear and the other commands go in the window where you opened ${name}, not here.`,
     refused: {
         "no-game": () => "There is no game going on: press + to start one, or ask for one in the chat.",
@@ -187,14 +200,15 @@ const english = {
             learning: ["I've just learned", "I know the rules, little more"],
             casual: ["I play now and then", "With friends or on my phone"],
             regular: ["I play often", "Online or at a club"],
-            tournament: ["I play tournaments", "I have a FIDE rating"],
+            tournament: ["I play tournaments", "At a club, with a rating"],
         },
-        rating: "Do you have a rating?",
         optional: "optional",
-        ratingPlaceholder: "e.g. 1450",
-        ratingLabel: "Rating",
-        siteLabel: "Where",
-        sites: { "lichess": "on Lichess", "chess.com": "on Chess.com", "fide": "FIDE" },
+        privacy: "We only read your public rating. No password.",
+        speeds: { rapid: "rapid", classical: "classical", blitz: "blitz" },
+        ratingTitle: (speed, played) => (played === undefined ? speed : `${speed} · last game ${played}`),
+        notFound: (site) => `${site} has no player of this name`,
+        unreached: (site) => `${site} isn't answering: we'll try again later`,
+        pending: "Reading your rating…",
         start: "Start playing",
         create: "Done",
         newProfile: "Add a player",
@@ -202,12 +216,17 @@ const english = {
         eachOwn: "Each player has their own games and settings.",
         changePlayer: "Change player",
         back: "Back",
-        changePicture: "Change picture",
-        yourPicture: "Your picture: change it",
+        yourProfile: "Your profile",
+        editProfile: "Edit your profile",
+        yourPicture: "Your picture: edit your profile",
         avatars: { "short-hair": "Short hair", bun: "Bun", glasses: "Glasses", beanie: "Beanie", beard: "Beard", curls: "Curls", moustache: "Moustache", "silver-bob": "Silver bob", cat: "Cat", owl: "Owl" },
         whilePlaying: "Finish the game, or resign, before changing player.",
+        accounts: "Do you play on Lichess, Chess.com or in FIDE tournaments?",
         username: "your username",
         accountTitle: "With your name there, a game you load from there knows which side is yours.",
+        fidePlaceholder: "your rating",
+        fideTitle: "Your FIDE rating, as FIDE lists it: Chesspal cannot read it by itself.",
+        fideRange: (lowest, highest) => `A FIDE rating goes from ${lowest} to ${highest}`,
         badImage: "That picture won't open: try another photo (the ones from a phone usually work).",
     },
     start: {
@@ -343,6 +362,20 @@ const english = {
         control: "How many of White's pieces and of Black's reach the square",
         ends: { crown: "Won", mate: "Checkmated", flag: "Resigned", half: "Draw, half a point each" },
     },
+    guide: {
+        title: "Guide",
+        contents: "Contents",
+        onGitHub: "Chesspal on GitHub",
+        onNpm: "Chesspal on npm",
+        support: "Support Chesspal",
+        credits: "Credits",
+        creditLines: [
+            "The rules: [chess.js](https://github.com/jhlywa/chess.js), under the BSD 2-Clause license.",
+            "The openings' names: Lichess's [chess-openings](https://github.com/lichess-org/chess-openings), under CC0.",
+            "The pieces: Nitida, Torretta and Capablanca are Chesspal's own, the last after the diagrams of Capablanca's *Chess Fundamentals* (1921), under CC BY 4.0: [their credits](https://github.com/stefanocaronia/chesspal/blob/main/src/page/pieces/CREDITS.md).",
+            "The sounds: Chesspal's own.",
+        ],
+    },
 };
 const italian = {
     language: "it",
@@ -447,6 +480,7 @@ const italian = {
     talk: "Conversazione",
     move: "Mossa",
     draw: "patta",
+    aborted: "Partita annullata",
     checkmate: "scacco matto",
     ended: {
         checkmate: "scacco matto",
@@ -471,6 +505,18 @@ const italian = {
     thinking: { move: "Sta pensando alla sua mossa", ponder: "Pensa mentre giochi tu" },
     asleep: (name) => `${name} non ti sta ascoltando: scrivi un messaggio, per esempio "ciao", nella finestra dove hai aperto ${name}, non qui. Il suo orologio aspetta che risponda.`,
     asleepInAnalysis: (name) => `${name} non ti sta ascoltando: scrivigli nella finestra dove l'hai aperto, non qui.`,
+    table: {
+        label: "Apri una chat",
+        noChat: (name) => `Per giocare con ${name}, apri la sua chat: parte in una finestra a parte, da tenere aperta.`,
+        install: (name) => `Per giocare con ${name}, installa Claude Code o Codex, poi apri di nuovo questa pagina.`,
+        model: "Modello",
+        effort: "Ragionamento",
+        asHost: (host) => `come è impostato in ${host}`,
+        opening: "Apro la chat… Nel terminale, se ti chiede se ti fidi della cartella, scegli Yes con le frecce e premi Invio.",
+        again: (name) => `${name} riparte con una chat pulita per la nuova partita…`,
+        failed: "Il terminale non si è aperto: scrivi il comando qui sotto in un terminale.",
+        typeIt: "Oppure scrivi in un terminale:",
+    },
     commandHere: (name) => `/clear e gli altri comandi vanno scritti nella finestra dove hai aperto ${name}, non qui.`,
     refused: {
         "no-game": () => "Nessuna partita in corso: premi + per iniziarne una, o chiedila nella chat.",
@@ -492,7 +538,7 @@ const italian = {
     piece: (letter, side) => `${italianNames[letter]} ${side === "white" ? (letter === "Q" || letter === "R" ? "bianca" : "bianco") : (letter === "Q" || letter === "R" ? "nera" : "nero")}`,
     taken: (pieces, ahead) => `Pezzi presi: ${pieces.length === 0 ? "nessuno" : pieces.join(", ")}${ahead > 0 ? `; avanti di ${ahead}` : ""}`,
     writeTo: (name) => `Scrivi a ${name}…`,
-    askAbout: (name) => `Chiedi a ${name} di questa partita…`,
+    askAbout: (name) => `Chiedi ${name === "AI" ? "all'AI" : `a ${name}`} di questa partita…`,
     goTo: (move) => `Vai a ${move}`,
     readBy: (name) => `Letto da ${name}`,
     wrote: (name) => `${name} ha scritto`,
@@ -527,14 +573,15 @@ const italian = {
             learning: ["Ho appena imparato", "Conosco le regole, poco di più"],
             casual: ["Gioco ogni tanto", "Con amici o sul telefono"],
             regular: ["Gioco spesso", "Online o al circolo"],
-            tournament: ["Gioco a torneo", "Ho un punteggio FIDE"],
+            tournament: ["Gioco a torneo", "Al circolo, con punteggio"],
         },
-        rating: "Hai un punteggio?",
         optional: "facoltativo",
-        ratingPlaceholder: "es. 1450",
-        ratingLabel: "Punteggio",
-        siteLabel: "Dove",
-        sites: { "lichess": "su Lichess", "chess.com": "su Chess.com", "fide": "FIDE" },
+        privacy: "Leggiamo solo il tuo punteggio pubblico. Niente password.",
+        speeds: { rapid: "rapid", classical: "classica", blitz: "blitz" },
+        ratingTitle: (speed, played) => (played === undefined ? speed : `${speed} · ultima partita il ${played.split("-").reverse().join("/")}`),
+        notFound: (site) => `Su ${site} non trovo questo nome`,
+        unreached: (site) => `${site} non risponde: riproviamo più tardi`,
+        pending: "Leggo il tuo punteggio…",
         start: "Inizia a giocare",
         create: "Fatto",
         newProfile: "Aggiungi un giocatore",
@@ -542,12 +589,17 @@ const italian = {
         eachOwn: "Ognuno ha le sue partite e le sue impostazioni.",
         changePlayer: "Cambia giocatore",
         back: "Indietro",
-        changePicture: "Cambia immagine",
-        yourPicture: "La tua immagine: cambiala",
+        yourProfile: "Il tuo profilo",
+        editProfile: "Modifica il profilo",
+        yourPicture: "La tua immagine: modifica il profilo",
         avatars: { "short-hair": "Capelli corti", bun: "Chignon", glasses: "Occhiali", beanie: "Berretto", beard: "Barba", curls: "Ricci", moustache: "Baffi", "silver-bob": "Caschetto grigio", cat: "Gatto", owl: "Gufo" },
         whilePlaying: "Finisci la partita, o abbandona, prima di cambiare giocatore.",
+        accounts: "Giochi su Lichess, Chess.com o nei tornei FIDE?",
         username: "il tuo nome utente",
         accountTitle: "Col tuo nome lì, una partita che carichi da lì sa qual è la tua parte.",
+        fidePlaceholder: "il tuo punteggio",
+        fideTitle: "Il tuo punteggio FIDE, come lo trovi sul sito della FIDE: Chesspal non può leggerlo da sé.",
+        fideRange: (lowest, highest) => `Un punteggio FIDE va da ${lowest} a ${highest}`,
         badImage: "Questa immagine non si apre: prova con un'altra foto (quelle del telefono di solito vanno bene).",
     },
     start: {
@@ -683,6 +735,20 @@ const italian = {
         control: "Quanti pezzi del Bianco e del Nero raggiungono la casa",
         ends: { crown: "Ha vinto", mate: "Scacco matto", flag: "Ha abbandonato", half: "Patta, mezzo punto a testa" },
     },
+    guide: {
+        title: "Guida",
+        contents: "Indice",
+        onGitHub: "Chesspal su GitHub",
+        onNpm: "Chesspal su npm",
+        support: "Sostieni Chesspal",
+        credits: "Crediti",
+        creditLines: [
+            "Le regole: [chess.js](https://github.com/jhlywa/chess.js), con licenza BSD 2-Clause.",
+            "I nomi delle aperture: [chess-openings](https://github.com/lichess-org/chess-openings) di Lichess, con licenza CC0.",
+            "I pezzi: Nitida, Torretta e Capablanca sono di Chesspal, l'ultimo dai diagrammi di *Chess Fundamentals* di Capablanca (1921), con licenza CC BY 4.0: [i loro crediti](https://github.com/stefanocaronia/chesspal/blob/main/src/page/pieces/CREDITS.md).",
+            "I suoni: di Chesspal.",
+        ],
+    },
 };
 // How each piece moves, said when it was taken where it cannot go (Anatolij's words).
 const englishMoves = {

package/dist/page/theme.css

@@ -33,6 +33,10 @@
     --help-on: #fff;
     --help-line: rgba(17, 22, 29, 0.78);
     --help-halo: rgba(255, 255, 255, 0.85);
+    /* The control map's veils (Zoe's variant A): grey over the board, sand where White alone reaches, slate where Black alone does */
+    --map-veil: rgba(160, 166, 176, 0.5);
+    --map-white: rgba(242, 233, 210, 0.78);
+    --map-black: rgba(56, 66, 84, 0.5);
     --torretta-body: #6d9fd1;
     --torretta-shade: #4b7cb0;
     --torretta-screen: #16263a;
@@ -102,6 +106,9 @@
     --badge-blunder: #d93434;
     --shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 8px 22px rgba(0, 0, 0, 0.25);
     --board-shadow: var(--shadow);
+    --map-veil: rgba(112, 120, 132, 0.66);
+    --map-white: rgba(226, 214, 188, 0.64);
+    --map-black: rgba(28, 35, 48, 0.7);
     color-scheme: dark;
 }
 

package/dist/profiles/index.d.ts

@@ -1,3 +1,4 @@
 export { type ImageType, imageTypeOf, imageTypes, ownImage, ownImageStamp, removeOwnImage, saveOwnImage, sentImageLimit } from "./avatar.ts";
-export { type Accounts, 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 { type Accounts, activateProfile, activeProfile, createProfile, type DrawnAvatar, drawnAvatars, ensureProfile, fideHighest, fideLowest, gameFolder, gameFolders, type Level, levels, listProfiles, nameLimit, type PlayerProfile, type ProfileFields, profileFolder, updateProfile, } from "./profiles.ts";
+export { type Rating, type RatingSite, ratingSites, saveReadings, type SiteReading, type SiteReadings, type Speed, speeds } from "./ratings.ts";
 export { helpsIn, languageIn, type PageSettings, profileSettings, saveProfileSettings, settingsOf } from "./settings.ts";

package/dist/profiles/index.js

@@ -1,5 +1,6 @@
 // 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 { activateProfile, activeProfile, createProfile, drawnAvatars, ensureProfile, fideHighest, fideLowest, gameFolder, gameFolders, levels, listProfiles, nameLimit, profileFolder, updateProfile, } from "./profiles.js";
+export { ratingSites, saveReadings, speeds } from "./ratings.js";
 export { helpsIn, languageIn, profileSettings, saveProfileSettings, settingsOf } from "./settings.js";

package/dist/profiles/profiles.d.ts

@@ -1,30 +1,21 @@
+import { type Rating, type SiteReadings } from "./ratings.ts";
 /** 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. */
+/** The FIDE ratings Chesspal takes: whole numbers from FIDE's lowest, 1400 since 2024, to 3000. */
+export declare const fideLowest = 1400;
+export declare const fideHighest = 3000;
+/** What the player tells of themselves: their name, how they play, the avatar they chose, their FIDE rating, typed since FIDE has no API (D-106). */
 export interface ProfileFields {
     readonly name: string;
     readonly level?: Level;
-    readonly rating?: Rating;
     readonly avatar?: DrawnAvatar;
+    readonly fide?: number;
 }
 /** The player's names on the sites they play on. */
 export interface Accounts {
@@ -38,6 +29,10 @@ export interface PlayerProfile extends ProfileFields {
     readonly new?: true;
     /** The player's names on Lichess and chess.com, written in profile.md by hand or from the page, by which the games they load are theirs (D-93). */
     readonly accounts?: Accounts;
+    /** What Lichess and chess.com said of those names, the last time Chesspal asked (D-105). */
+    readonly sites?: SiteReadings;
+    /** The rating that counts, of the names the profile has now: of two, the one the sites are surer of (D-106). */
+    readonly rating?: Rating;
 }
 /** What may change in a profile: what the player tells of themselves, and their names on the sites, each one written whole. */
 export type ProfileChanges = Partial<ProfileFields> & {

package/dist/profiles/profiles.js

@@ -4,16 +4,16 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:f
 import { join } from "node:path";
 import { makeFolder, renameOver, writeAtomically } from "../games/index.js";
 import { readFrontMatter, writeFrontMatter } from "./front-matter.js";
+import { savedReadings } from "./ratings.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 FIDE ratings Chesspal takes: whole numbers from FIDE's lowest, 1400 since 2024, to 3000. */
+export const fideLowest = 1400;
+export const fideHighest = 3000;
 /** The profiles in the data folder, by their folders' names. */
 export function listProfiles(root) {
     return profileIds(root).map((id) => readProfile(root, id));
@@ -47,9 +47,9 @@ export function profileFolder(root, id) {
 export function createProfile(root, fields, use = true) {
     const id = activeId(root);
     if (id !== undefined && readProfile(root, id).new === true) {
-        const { level, rating, avatar } = fields;
+        const { level, avatar, fide } = fields;
         const named = renamed(root, id, fields.name);
-        writeProfile(root, named, { name: fields.name, level, rating, avatar, new: false });
+        writeProfile(root, named, { name: fields.name, level, avatar, fide, new: false });
         return readProfile(root, named);
     }
     let made = freeId(root, slugOf(fields.name));
@@ -172,22 +172,38 @@ function writeActive(root, id) {
 }
 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;
+    const fide = fideIn(fields.fide);
+    const { accounts } = accountsIn(fields);
+    const sites = savedReadings(profileFolder(root, id));
+    const rating = sites === undefined ? undefined : surest([ofAccount(sites.lichess, accounts?.lichess), ofAccount(sites.chesscom, accounts?.chesscom)]);
     // 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 }),
+        ...(fide === undefined ? {} : { fide }),
         ...(fields.new === "true" ? { new: true } : {}),
-        ...accountsIn(fields),
+        ...(accounts === undefined ? {} : { accounts }),
+        ...(sites === undefined ? {} : { sites }),
+        ...(rating === undefined ? {} : { rating }),
     };
 }
+/** A site's rating, when it was read for the name the profile has there now. */
+function ofAccount(reading, account) {
+    return account !== undefined && reading?.account.toLowerCase() === account.toLowerCase() ? reading.rating : undefined;
+}
+/** Of the ratings, the one its site is surest of: the lowest RD (D-106). */
+function surest(ratings) {
+    return ratings.reduce((best, one) => (one !== undefined && (best === undefined || one.deviation < best.deviation) ? one : best), undefined);
+}
+/** The FIDE rating of profile.md's fide line: none when it is not a whole number in FIDE's range, as one written by hand may not be. */
+function fideIn(text) {
+    const fide = Number(text?.trim());
+    return Number.isInteger(fide) && fide >= fideLowest && fide <= fideHighest ? fide : undefined;
+}
 /** The player's names on the sites, from profile.md's lichess and chesscom lines; none without either. */
 function accountsIn(fields) {
     const named = (site) => fields[site]?.trim().slice(0, nameLimit).trim() || undefined;
@@ -208,13 +224,12 @@ function writeProfile(root, id, changes) {
     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 ("fide" in changes) {
+        written.fide = changes.fide;
+    }
     if ("accounts" in changes) {
         written.lichess = changes.accounts?.lichess;
         written.chesscom = changes.accounts?.chesscom;

package/dist/profiles/ratings.d.ts

@@ -0,0 +1,35 @@
+/** The sites a rating is read from, by the player's names there (D-105). */
+export declare const ratingSites: readonly ["lichess", "chess.com"];
+export type RatingSite = (typeof ratingSites)[number];
+/** The speeds whose rating counts, in the order they count: the games with the AI are like a slow rapid (D-106). */
+export declare const speeds: readonly ["rapid", "classical", "blitz"];
+export type Speed = (typeof speeds)[number];
+/** A rating a site gives: the number as it is, never converted, its speed, how sure the site is of it (its rating deviation, RD), and the day of the last game at that speed. */
+export interface Rating {
+    readonly value: number;
+    readonly site: RatingSite;
+    readonly speed: Speed;
+    readonly deviation: number;
+    /** YYYY-MM-DD. */
+    readonly played?: string;
+}
+/** What a site said of the player's name there, the last time Chesspal asked. */
+export interface SiteReading {
+    readonly account: string;
+    /** False when the site has no player of that name; unknown while it has never answered. */
+    readonly found?: boolean;
+    /** The rating that counts there: none when the player has no established rating at a speed that counts. */
+    readonly rating?: Rating;
+    /** The last try did not reach the site: what it said before stays. */
+    readonly unreached?: true;
+}
+/** What the sites said, and when Chesspal last asked them. */
+export interface SiteReadings {
+    readonly read: string;
+    readonly lichess?: SiteReading;
+    readonly chesscom?: SiteReading;
+}
+/** The readings kept in a profile's folder; undefined when it has none, or they cannot be read. */
+export declare function savedReadings(folder: string): SiteReadings | undefined;
+/** Keeps the readings in a profile's folder, over the ones before; none removes them. */
+export declare function saveReadings(folder: string, readings: SiteReadings | undefined): void;

package/dist/profiles/ratings.js

@@ -0,0 +1,61 @@
+// What Lichess and Chess.com said of the player's names there (D-105, D-106): ratings.json in the profile's folder, written by Chesspal each time it reads
+// them, never by hand; the rating that counts is chosen from it as the profile is read.
+import { readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { writeAtomically } from "../games/index.js";
+/** The sites a rating is read from, by the player's names there (D-105). */
+export const ratingSites = ["lichess", "chess.com"];
+/** The speeds whose rating counts, in the order they count: the games with the AI are like a slow rapid (D-106). */
+export const speeds = ["rapid", "classical", "blitz"];
+/** The readings kept in a profile's folder; undefined when it has none, or they cannot be read. */
+export function savedReadings(folder) {
+    try {
+        return readingsOf(JSON.parse(readFileSync(join(folder, fileName), "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Keeps the readings in a profile's folder, over the ones before; none removes them. */
+export function saveReadings(folder, readings) {
+    if (readings === undefined) {
+        rmSync(join(folder, fileName), { force: true });
+    }
+    else {
+        writeAtomically(join(folder, fileName), `${JSON.stringify(readings, null, 2)}\n`);
+    }
+}
+const fileName = "ratings.json";
+// Readings as the file has them, each part checked: a file edited by hand never gives the AI a rating that is not one.
+function readingsOf(value) {
+    const file = value;
+    if (typeof file?.read !== "string" || Number.isNaN(Date.parse(file.read))) {
+        return undefined;
+    }
+    const lichess = readingOf(file.lichess, "lichess");
+    const chesscom = readingOf(file.chesscom, "chess.com");
+    return { read: file.read, ...(lichess === undefined ? {} : { lichess }), ...(chesscom === undefined ? {} : { chesscom }) };
+}
+function readingOf(value, site) {
+    const reading = value;
+    if (typeof reading?.account !== "string" || reading.account === "") {
+        return undefined;
+    }
+    const rating = ratingOf(reading.rating, site);
+    return {
+        account: reading.account,
+        ...(typeof reading.found === "boolean" ? { found: reading.found } : {}),
+        ...(rating === undefined ? {} : { rating }),
+        ...(reading.unreached === true ? { unreached: true } : {}),
+    };
+}
+function ratingOf(value, site) {
+    const rating = value;
+    const speed = speeds.find((one) => one === rating?.speed);
+    const plausible = (number) => typeof number === "number" && Number.isInteger(number) && number > 0 && number < 4000;
+    if (rating?.site !== site || speed === undefined || !plausible(rating.value) || !plausible(rating.deviation)) {
+        return undefined;
+    }
+    const played = typeof rating.played === "string" && /^\d{4}-\d{2}-\d{2}$/.test(rating.played) ? rating.played : undefined;
+    return { value: rating.value, site, speed, deviation: rating.deviation, ...(played === undefined ? {} : { played }) };
+}

package/dist/server/bell.d.ts

@@ -29,16 +29,32 @@ export declare class Bell {
     ring(): void;
     /** A hook waits for the bell, so the chat's turn has ended; the hook before it, of a turn already ended, is let go. */
     listen(request: IncomingMessage, response: ServerResponse): void;
+    /** The chat left the table (D-104): its process ended, and nobody is in a turn or waits for the bell; a ring no hook heard is no longer news for anyone. */
+    chatLeft(): void;
     private tellIf;
 }
-/** Whose page answers at a port, for the hook to find its own: the chat's session, the player's folder, and whether a browser has the page open. */
-export declare function bellProbe(folder: string, open?: boolean): BellProbe;
+/**
+ * Whose page answers at a port, for the hook to find its own: the chat's session, the player's folder, whether a browser has the page open, Chesspal's
+ * version, and whether the table serves it (D-104), with the session and the folder of the chat attached to it, never its own process's.
+ */
+export declare function bellProbe(folder: string, open?: boolean, table?: TableChat): BellProbe;
+/** The chat attached to the table, as its probe says it: its session, null for none or for Codex, and its folder; neither while no chat is attached. */
+export interface TableChat {
+    session: string | null;
+    chat?: string;
+}
 /** What a page says of itself at `/api/bell?probe`. */
 export interface BellProbe {
     session: string | null;
     folder: string;
     open: boolean;
+    version?: string;
+    table?: true;
+    /** The folder of the chat attached to the table. */
+    chat?: string;
 }
+/** What the page at a port of this computer says of itself; undefined when none answers there. */
+export declare function pageAt(port: number): Promise<BellProbe | undefined>;
 /** The ports a folder's page tries first: one in each of a few ranges, by its path, since Windows may reserve a range. The hook looks for it there. */
 export declare function pagePorts(folder: string): number[];
 /** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
@@ -62,7 +78,12 @@ export type BellHeard = {
     rang: false;
     why: string;
 };
-/** Waits at the page of the hook's chat, as waitForBell does, and says what it heard. */
+/**
+ * Waits at the page of the hook's chat, as waitForBell does, and says what it heard. The chat may be attached to the table (D-104), beside another chat
+ * of its folder that serves its own page: the table is one more page to choose from, unless the ports to try are given (Priya).
+ */
 export declare function bellHeard(input: string, ports?: number[]): Promise<BellHeard>;
 /** Adds a line to the log of the hooks that heard no bell, keeping its last lines; a log that cannot be written never stops the hook. */
 export declare function noteSilence(folder: string, why: string, now?: Date): void;
+/** Whether two paths name the same folder: without regard to case on Windows. */
+export declare function samePath(one: string, other: string): boolean;