chesspal 0.3.5 → 0.4.0

package/dist/page/talk/voice.js

@@ -1,33 +1,38 @@
-/** Reads the words aloud in the voice's language, the moves in words, cutting short what was being read. */
-export function speak(words, voice) {
+/** Reads the bubbles aloud one after the other in the voice's language, the moves in words, cutting short what was being read. */
+export function speak(readings, voice) {
     if (typeof speechSynthesis === "undefined") {
         return;
     }
-    const said = spokenMoves(words.replace(/\*\*/g, ""), voice.saidMove).trim();
-    speechSynthesis.cancel();
-    clearTimeout(pending);
-    if (said === "") {
-        return;
+    stop();
+    queue = readings.map((reading) => ({ key: reading.key, said: spokenMoves(reading.words.replace(/\*\*/g, ""), voice.saidMove).trim() })).filter((reading) => reading.said !== "");
+    language = voice.language;
+    readNextSoon();
+}
+/** Stops reading the bubble the key names, when it is the one read, and goes on with the next. */
+export function skip(key) {
+    if (current?.key === key) {
+        stop();
+        readNextSoon();
     }
-    // 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 reader = readerFor(voice.language);
-        utterance.lang = reader?.lang ?? voice.language;
-        if (reader !== undefined) {
-            utterance.voice = reader;
-        }
-        speechSynthesis.resume();
-        speechSynthesis.speak(utterance);
-    }, 150);
 }
-/** Stops reading. */
+/** Stops reading, and forgets what was waiting. */
 export function hush() {
     if (typeof speechSynthesis !== "undefined") {
-        clearTimeout(pending);
-        speechSynthesis.cancel();
+        queue = [];
+        stop();
     }
 }
+/** The key of the bubble being read, from the moment the voice starts it to its end; none while nothing is read. */
+export function reading() {
+    return current?.started === true ? current.key : undefined;
+}
+/** Calls the listener whenever the bubble being read changes: what it returns stops it. */
+export function onReading(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
 /** Whether the browser has a voice for the language: without one the words cannot be read. */
 export function hasVoice(language) {
     return typeof speechSynthesis !== "undefined" && readerFor(language) !== undefined;
@@ -61,7 +66,73 @@ export function spokenMoves(words, say) {
         return say({ piece, ...said, takes: takes !== undefined, square, ...promoted, ...checked });
     });
 }
+// What waits to be read, what is read and in which language, and who wants to know which bubble is read.
+let queue = [];
+let current;
+let language = "";
 let pending;
+const listeners = new Set();
+// Chrome drops words spoken right after a cancel, and lists its voices late the first time: the words wait a moment.
+function readNextSoon() {
+    pending = setTimeout(readNext, 150);
+}
+function readNext() {
+    const next = queue.shift();
+    if (next === undefined) {
+        return;
+    }
+    const utterance = new SpeechSynthesisUtterance(next.said);
+    const reader = readerFor(language);
+    utterance.lang = reader?.lang ?? language;
+    if (reader !== undefined) {
+        utterance.voice = reader;
+    }
+    const reading = { key: next.key, utterance, started: false };
+    current = reading;
+    // A cancel fires end or error in some browsers and nothing in others: only the events of the utterance read now count, and the page drops its own at once.
+    utterance.onstart = () => {
+        if (current === reading) {
+            reading.started = true;
+            // The voice may stop with no event at all: a look each second at whether it still speaks, so no mark stays on a bubble nobody reads.
+            reading.watch = setInterval(() => {
+                if (current === reading && !speechSynthesis.speaking) {
+                    finished(reading);
+                }
+            }, 1000);
+            tell();
+        }
+    };
+    utterance.onend = () => finished(reading);
+    utterance.onerror = () => finished(reading);
+    speechSynthesis.resume();
+    speechSynthesis.speak(utterance);
+}
+function finished(reading) {
+    if (current === reading) {
+        drop();
+        readNext();
+    }
+}
+// Cuts short what is read, keeping what waits.
+function stop() {
+    clearTimeout(pending);
+    drop();
+    speechSynthesis.cancel();
+}
+function drop() {
+    const was = current;
+    clearInterval(was?.watch);
+    current = undefined;
+    if (was?.started === true) {
+        tell();
+    }
+}
+function tell() {
+    const key = reading();
+    for (const listener of listeners) {
+        listener(key);
+    }
+}
 // 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.

package/dist/page/text.js

@@ -30,6 +30,7 @@ const english = {
     sounds: "Sounds",
     voice: "Read the AI's words aloud",
     noVoice: "This browser has no voice for this language: add one in your system's settings",
+    skipReading: "Stop reading this aloud",
     saidMove: (move) => moveInWords(englishMoveWords, move),
     newGame: "New game",
     offerDraw: "Offer a draw",
@@ -40,6 +41,7 @@ const english = {
     declineDrawTitle: "Decline: moving declines it too",
     resign: "Resign",
     resignGame: "Resign this game?",
+    keepPlaying: "Play on",
     settings: "Settings",
     close: "Close",
     look: "Look",
@@ -175,31 +177,40 @@ const english = {
         choose: "Choose the chat to play with: it opens in a window of its own, to keep open.",
         reviewTitle: "Who reviews the game?",
         reviewChoose: "Choose the chat that reviews the game: 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.",
+        restartHint: "The chat starts again, clean, in the same window, once it has ended its answer, with the chat, model and effort chosen here. 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.`,
+        chat: "Chat",
         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.",
+        atTable: "At the table",
+        act: { open: (host) => `Start ${host}`, review: (host) => `Review with ${host}`, restart: (host) => `Restart ${host}`, switch: (host) => `Switch to ${host}` },
+        opening: "Opening the chat… In the terminal, if it asks whether you trust the folder, say yes (in Claude Code, go down to Yes with the arrow keys) and press Enter; with Codex, on the hooks, choose Trust all and continue.",
         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",
+        newGameWaiting: (name) => `The new game starts once ${name} has ended its answer…`,
         restartNow: "Start again now: it cuts the answer it is giving",
         cancel: "Do not start again",
+        newGameNow: "Start the new game now: it cuts the answer it is giving",
+        newGameCancel: "Do not start the new game",
         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.`,
+    link: {
+        going: "A game is going on: finish it, then open the link again.",
+        gone: "The game of this link is not here: it was deleted, or it is another profile's.",
+    },
     refused: {
         "no-game": () => "There is no game going on: press + to start one, or ask for one in the chat.",
         "ai-to-move": () => "Wait for the AI's move.",
         illegal: () => "That move is not legal here.",
         "clear-chat": (most, name) => english.clearChat(name),
+        "new-game-profile": () => "The new game did not start: you changed profile while it waited. Start it again from this one.",
         "words-empty": () => "Write something first.",
         "words-spent": () => "You have used up your words for this move: write again after the AI's move.",
         "words-long": (most) => `Write at most ${most} characters.`,
@@ -210,6 +221,8 @@ const english = {
         "profile-game": () => english.profile.whilePlaying,
         "game-going": () => "A game is going on: finish it before you bring another to analyse.",
         "pgn-unreadable": () => "Chesspal cannot read this PGN: check you copied the whole game, its tags and its moves.",
+        "game-missing": () => "This game is no longer there: pick another.",
+        "game-not-archived": () => "The game just over is not saved yet: try again in a moment.",
         "update-game": () => english.update.whilePlaying,
         "update-chat": (most, name) => `${name} is answering: update once it has done.`,
     },
@@ -455,6 +468,7 @@ const italian = {
     sounds: "Suoni",
     voice: "Leggi ad alta voce le parole dell'AI",
     noVoice: "Questo browser non ha una voce per questa lingua: aggiungila nelle impostazioni del sistema",
+    skipReading: "Smetti di leggere questo a voce",
     saidMove: (move) => moveInWords(italianMoveWords, move),
     newGame: "Nuova partita",
     offerDraw: "Proponi patta",
@@ -465,6 +479,7 @@ const italian = {
     declineDrawTitle: "Rifiuta: anche muovere rifiuta",
     resign: "Abbandona",
     resignGame: "Abbandonare la partita?",
+    keepPlaying: "Continua",
     settings: "Impostazioni",
     close: "Chiudi",
     look: "Aspetto",
@@ -600,31 +615,40 @@ const italian = {
         choose: "Scegli la chat con cui giocare: parte in una finestra a parte, da tenere aperta.",
         reviewTitle: "Chi analizza la partita?",
         reviewChoose: "Scegli la chat che analizza la partita: 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'è.",
+        restartHint: "La chat riparte pulita nella stessa finestra, appena ha finito di rispondere, con la chat, il modello e il ragionamento scelti qui. 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.`,
+        chat: "Chat",
         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.",
+        atTable: "Al tavolo",
+        act: { open: (host) => `Avvia ${host}`, review: (host) => `Analizza con ${host}`, restart: (host) => `Riavvia ${host}`, switch: (host) => `Passa a ${host}` },
+        opening: "Apro la chat… Nel terminale, se ti chiede se ti fidi della cartella, rispondi sì (in Claude Code scendi su Yes con le frecce) e premi Invio; con Codex, sugli «hook», scegli Trust all and continue.",
         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",
+        newGameWaiting: (name) => `La nuova partita comincia appena ${name} ha finito di rispondere…`,
         restartNow: "Riparti adesso: interrompe la risposta in corso",
         cancel: "Non ripartire",
+        newGameNow: "Comincia adesso la nuova partita: interrompe la risposta in corso",
+        newGameCancel: "Non cominciare la nuova partita",
         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.`,
+    link: {
+        going: "C'è una partita in corso: finiscila, poi riapri il link.",
+        gone: "La partita di questo link non c'è: è stata cancellata, o è di un altro profilo.",
+    },
     refused: {
         "no-game": () => "Nessuna partita in corso: premi + per iniziarne una, o chiedila nella chat.",
         "ai-to-move": () => "Aspetta la mossa dell'AI.",
         illegal: () => "Questa mossa qui non è legale.",
         "clear-chat": (most, name) => italian.clearChat(name),
+        "new-game-profile": () => "La nuova partita non è cominciata: hai cambiato profilo mentre aspettava. Ricominciala da questo.",
         "words-empty": () => "Scrivi prima qualcosa.",
         "words-spent": () => "Hai finito le parole per questa mossa: scrivi di nuovo dopo quella dell'AI.",
         "words-long": (most) => `Scrivi al massimo ${most} caratteri.`,
@@ -635,6 +659,8 @@ const italian = {
         "profile-game": () => italian.profile.whilePlaying,
         "game-going": () => "C'è una partita in corso: finiscila prima di portarne un'altra da analizzare.",
         "pgn-unreadable": () => "Chesspal non riesce a leggere questo PGN: controlla di aver copiato la partita intera, intestazioni e mosse.",
+        "game-missing": () => "Questa partita non c'è più: scegline un'altra.",
+        "game-not-archived": () => "La partita appena finita non è ancora salvata: riprova fra un momento.",
         "update-game": () => italian.update.whilePlaying,
         "update-chat": (most, name) => `${name} sta rispondendo: aggiorna quando ha finito.`,
     },

package/dist/page/theme.css

@@ -62,6 +62,19 @@
     --badge-mistake: #d4650f;
     --badge-miss: #c2407d;
     --badge-blunder: #d22c2c;
+    /* The kings' badges on a game over, the same in both themes: the winner's gold crown, the mate in red on white, the flag that fell, the draw */
+    --king-crown: #e0a526;
+    --king-crown-ink: #3b2a00;
+    --king-mate: #c81e1e;
+    --king-flag: #4a4f57;
+    --king-draw: #69727d;
+    /* The two sides as the game's column draws them, in the bar and the chart of who is ahead and in the helps' bars and tiles, the same in both themes:
+       White, Black, and both, each half 3:1 at least with the tile's green tick; their edge keeps the white half in sight on a light card and the black one
+       on a dark card. The board's map and counts keep their own, darker on the squares (Zoe) */
+    --side-white: #f5f5f2;
+    --side-black: #33383f;
+    --side-both: #8a9099;
+    --side-edge: color-mix(in srgb, var(--side-both) 60%, transparent);
     --shadow: 0 1px 2px rgba(29, 39, 51, 0.06), 0 6px 18px rgba(29, 39, 51, 0.06);
     /* On a light page the board keeps a thin edge in its dark squares colour, and a deeper shadow, so its light squares do not melt into the page */
     --board-shadow: 0 0 0 1px color-mix(in oklab, var(--dark-square) 55%, transparent), 0 2px 4px rgba(29, 39, 51, 0.1), 0 10px 28px rgba(29, 39, 51, 0.12);

package/dist/profiles/profiles.js

@@ -23,8 +23,12 @@ export function listProfiles(root) {
  * together make one: the second finds its folder taken.
  */
 export function ensureProfile(root, account) {
+    // Every command asks, so the common answer comes first: a profile is there.
+    if (profileIds(root).length > 0) {
+        return;
+    }
     const id = freeId(root, slugOf(account));
-    if (profileIds(root).length === 0 && claimed(root, id)) {
+    if (claimed(root, id)) {
         fillProfile(root, id, { name: account }, true);
     }
 }

package/dist/server/bell/bell.d.ts

@@ -1,4 +1,4 @@
-import { type IncomingMessage, type ServerResponse } from "node:http";
+import type { IncomingMessage, ServerResponse } from "node:http";
 /** What the chat hears from the doorbell: one line for whatever the player did, never what, only where to read it. */
 export declare const bellLine = "The player acted on the board page: call status to see it.";
 /**
@@ -10,6 +10,7 @@ export declare class Bell {
     private pending;
     private busy;
     private woken;
+    private hooked;
     private readonly news;
     private readonly changed;
     /**
@@ -25,38 +26,34 @@ export declare class Bell {
     get listening(): boolean;
     /** The chat calls a tool, so it is in a turn: true when nobody was listening before. */
     chatCalls(): boolean;
-    /** The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. */
-    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 player's message, or one the host sent for the doorbell or an agent, starts the chat's turn, as the prompt hook says: the hook of the turn
+     * before is let go without a ring, and what the player does on the page meanwhile waits for the turn's end, as during a tool. A chat nobody heard
+     * stays unheard until its first tool, which starts the AI's clock, held till then: the message moves no clock.
+     */
+    chatPrompted(): void;
+    /**
+     * The player acted on the page: the hook waiting hears it now, or the next one as soon as it comes. In a host that runs no hook nothing tells the end of
+     * a turn: an act the chat waits for finds it out of its turn, and nobody hears the player, unless the chat `mayBeAtWork` on the AI's move meanwhile.
+     */
+    ring(mayBeAtWork?: boolean): 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. A ring no hook heard is dropped when
+     * the chat is `told` all of it otherwise: by the player's message that came with the move the prompt hook played.
+     */
+    listen(request: IncomingMessage, response: ServerResponse, told?: boolean): 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, 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.
+ * Notes in the data folder the port a chat's page took off its folder's usual ports, one file per page, for the hook to find it there; then forgets, off
+ * the caller's clock, the notes of its folder whose page is gone: nobody listens at the port, or another folder's page does. A page that answers late
+ * is busy, not gone, and keeps its note. It throws when the note cannot be written.
  */
-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[];
+export declare function notePagePort(home: string, folder: string, port: number, wait?: number): Promise<void>;
+/** Forgets the note of a page that closes, unless another folder's page took its port since; a note that cannot go is left for the next page to clear. */
+export declare function forgetPagePort(home: string, folder: string, port: number): void;
 /** What Codex's Stop hook answers to wake the chat: its turn goes on with the doorbell's line. */
 export declare const codexBellAnswer: string;
 /**
@@ -85,5 +82,3 @@ export type BellHeard = {
 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;