chesspal 0.2.4 → 0.3.1

package/dist/page/talk/voice.js

@@ -1,10 +1,9 @@
-// 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) {
+/** Reads the words aloud in the voice's language, the moves in words, cutting short what was being read. */
+export function speak(words, voice) {
     if (typeof speechSynthesis === "undefined") {
         return;
     }
-    const said = words.replace(/\*\*/g, "").trim();
+    const said = spokenMoves(words.replace(/\*\*/g, ""), voice.saidMove).trim();
     speechSynthesis.cancel();
     clearTimeout(pending);
     if (said === "") {
@@ -13,10 +12,10 @@ export function speak(words, language) {
     // 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;
+        const reader = readerFor(voice.language);
+        utterance.lang = reader?.lang ?? voice.language;
+        if (reader !== undefined) {
+            utterance.voice = reader;
         }
         speechSynthesis.resume();
         speechSynthesis.speak(utterance);
@@ -29,9 +28,36 @@ export function hush() {
         speechSynthesis.cancel();
     }
 }
+/**
+ * The words with each move the AI wrote said in words, since a voice reads ♟g4 as "chess pawn g4": ♞xf6+, Nxf6+, exd5, O-O, e8=♛. A square alone, e4,
+ * stays as it is; a pawn's move becomes words only with its figurine, a capture, a promotion or a check, and without the file it takes from.
+ */
+export function spokenMoves(words, say) {
+    return words.replace(movePattern, (move, ...found) => {
+        const { castles, figurine, letter, from, takes, square, promotion, check } = found.at(-1);
+        const checked = check === undefined ? {} : { check: check === "+" ? "check" : "mate" };
+        if (castles !== undefined) {
+            return say({ castles: castles.length > 3 ? "long" : "short", ...checked });
+        }
+        if (square === undefined || (figurine === undefined && letter === undefined && takes === undefined && promotion === undefined && check === undefined)) {
+            return move;
+        }
+        const piece = figurine === undefined ? (letter ?? "P") : pieceOf(figurine);
+        const promoted = promotion === undefined ? {} : { promotion: pieceOf(promotion) };
+        // A pawn's file, exd5, goes unsaid: "pawn takes d5".
+        const said = from === undefined || from === "" || piece === "P" ? {} : { from };
+        return say({ piece, ...said, takes: takes !== undefined, square, ...promoted, ...checked });
+    });
+}
 let pending;
+// A move in SAN, with the pieces' letters or figurines, as the AI writes it; the parts named, castling apart.
+const movePattern = /(?<![\w♔-♟])(?:(?<castles>O-O(?:-O)?|0-0(?:-0)?)|(?:(?<figurine>[♔-♟])[\uFE0E\uFE0F]?|(?<letter>[KQRBN]))?(?<from>[a-h]?[1-8]?)(?<takes>[x×])?(?<square>[a-h][1-8])(?:=?(?<promotion>[QRBN]|[♔-♟]))?[\uFE0E\uFE0F]?)(?<check>\+\+|[+#])?(?![\w♔-♟])/gu;
+// A piece's letter, or its figurine: White's run ♔♕♖♗♘♙ and Black's ♚♛♜♝♞♟, in SAN's order.
+function pieceOf(sign) {
+    return ("KQRBN".includes(sign) ? sign : "KQRBNP".charAt(((sign.codePointAt(0) ?? 0) - 0x2654) % 6));
+}
 /** A voice for the language: a local one first, the browser's default among them first. */
-function voiceFor(language) {
+function readerFor(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/page/text.js

@@ -5,12 +5,31 @@ export function textFor(languages) {
 }
 const englishNames = { K: "king", Q: "queen", R: "rook", B: "bishop", N: "knight", P: "pawn" };
 const italianNames = { K: "re", Q: "donna", R: "torre", B: "alfiere", N: "cavallo", P: "pedone" };
+const englishMoveWords = {
+    names: englishNames,
+    castles: { short: "castles short", long: "castles long" },
+    from: "from",
+    to: "to",
+    takes: "takes",
+    promotes: "promotes to",
+    check: { check: "check", mate: "checkmate" },
+};
+const italianMoveWords = {
+    names: italianNames,
+    castles: { short: "arrocco corto", long: "arrocco lungo" },
+    from: "da",
+    to: "in",
+    takes: "prende",
+    promotes: "promuove a",
+    check: { check: "scacco", mate: "scacco matto" },
+};
 const english = {
     language: "en",
     flip: "Flip",
     theme: "Light or dark theme",
     sounds: "Sounds",
     voice: "Read the AI's words aloud",
+    saidMove: (move) => moveInWords(englishMoveWords, move),
     newGame: "New game",
     offerDraw: "Offer a draw",
     offerDrawWhen: "Offer a draw: on your turn, once each side has moved",
@@ -108,6 +127,7 @@ const english = {
     talk: "The talk",
     move: "Move",
     draw: "draw",
+    aborted: "Game aborted",
     checkmate: "checkmate",
     ended: {
         checkmate: "checkmate",
@@ -132,6 +152,28 @@ 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: {
+        title: "Who are you playing?",
+        choose: "Choose the chat to play with: it opens in a window of its own, to keep open.",
+        restartHint: "Choose the model and effort, then press Claude Code or Codex: the chat starts again, clean, in the same window, once it has ended its answer. The game stays as it is.",
+        byHand: (name) => `You opened this chat yourself: change ${name}'s model with /model in its window, or close it and open one from here, with the choices below.`,
+        noChat: "No chat at the table: choose one",
+        change: "Change the chat or its model",
+        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…`,
+        restart: "The chat starts again, clean…",
+        waiting: (name) => `${name} starts again once it has ended its answer…`,
+        restartChanged: "Starts again, clean, with the new choices",
+        restartNow: "Start again now: it cuts the answer it is giving",
+        cancel: "Do not start again",
+        failed: "The terminal did not open: type the command below in a terminal.",
+        notRestarted: "The chat did not start again: close its window, then open another from here.",
+        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 +229,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 +245,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 +391,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",
@@ -350,6 +412,7 @@ const italian = {
     theme: "Tema chiaro o scuro",
     sounds: "Suoni",
     voice: "Leggi ad alta voce le parole dell'AI",
+    saidMove: (move) => moveInWords(italianMoveWords, move),
     newGame: "Nuova partita",
     offerDraw: "Proponi patta",
     offerDrawWhen: "Proponi patta: nel tuo turno, dopo una mossa a testa",
@@ -447,6 +510,7 @@ const italian = {
     talk: "Conversazione",
     move: "Mossa",
     draw: "patta",
+    aborted: "Partita annullata",
     checkmate: "scacco matto",
     ended: {
         checkmate: "scacco matto",
@@ -471,6 +535,28 @@ 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: {
+        title: "Contro chi giochi?",
+        choose: "Scegli la chat con cui giocare: parte in una finestra a parte, da tenere aperta.",
+        restartHint: "Scegli modello e ragionamento, poi premi Claude Code o Codex: la chat riparte pulita nella stessa finestra, appena ha finito di rispondere. La partita resta com'è.",
+        byHand: (name) => `Questa chat l'hai aperta tu: cambia il modello di ${name} con /model nella sua finestra, oppure chiudila e aprine una da qui, con le scelte qui sotto.`,
+        noChat: "Nessuna chat al tavolo: scegline una",
+        change: "Cambia la chat o il modello",
+        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…`,
+        restart: "La chat riparte pulita…",
+        waiting: (name) => `${name} riparte appena ha finito di rispondere…`,
+        restartChanged: "Riparte pulita con le nuove scelte",
+        restartNow: "Riparti adesso: interrompe la risposta in corso",
+        cancel: "Non ripartire",
+        failed: "Il terminale non si è aperto: scrivi il comando qui sotto in un terminale.",
+        notRestarted: "La chat non è ripartita: chiudi la sua finestra, poi aprine un'altra da qui.",
+        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 +578,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 +613,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 +629,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 +775,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 = {
@@ -745,6 +851,14 @@ function italianCulprit(by) {
 function italianWith(preposition, letter) {
     return italianThe[letter].replace(/^il /, `${preposition}l `).replace(/^la /, `${preposition}lla `).replace(/^l'/, `${preposition}ll'`);
 }
+/** A move in words: "knight from b takes d7, check", "cavallo in f3", "arrocco corto". */
+function moveInWords(words, move) {
+    const promotion = "castles" in move || move.promotion === undefined ? undefined : `${words.promotes} ${words.names[move.promotion]}`;
+    const played = "castles" in move
+        ? words.castles[move.castles]
+        : [words.names[move.piece], ...(move.from === undefined ? [] : [words.from, move.from]), move.takes ? words.takes : words.to, move.square].join(" ");
+    return [played, promotion, move.check === undefined ? undefined : words.check[move.check]].filter((part) => part !== undefined).join(", ");
+}
 /** The words with their first letter capital, to open a sentence. */
 function capital(words) {
     return words.charAt(0).toUpperCase() + words.slice(1);

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 }) };
+}