chesspal 0.2.4 → 0.3.0

package/dist/games/files.js

@@ -1,5 +1,5 @@
 // Writing the player's files safely: whole or not at all, with failures that say what to do (D-27).
-import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { mkdirSync, renameSync, rmdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 /** Writes a file whole or not at all: a temporary file beside it, then renamed over it (D-27). A failure says what to do about it. */
 export function writeAtomically(path, text) {
     const temporary = `${path}.${process.pid}.tmp`;
@@ -14,6 +14,40 @@ export function writeAtomically(path, text) {
         rmSync(temporary, { force: true });
     }
 }
+/**
+ * Runs `write` while this process alone holds the file's lock, a folder beside it made only if missing, cheaper than a file on Windows: another process
+ * waits, a second at most. A lock older than two seconds is of a process that stopped while it held it, and goes.
+ */
+export function whileLocked(path, write) {
+    const lock = `${path}.lock`;
+    for (let attempt = 1;; attempt++) {
+        try {
+            mkdirSync(lock);
+            break;
+        }
+        catch (error) {
+            // Windows refuses to make a folder another process is deleting: the lock is still held.
+            if (!["EEXIST", "EPERM", "EACCES"].includes(error.code ?? "")) {
+                throw new Error(`${lock} could not be made (${error.message}): check that its folder can be written.`, { cause: error });
+            }
+            if (isStale(lock)) {
+                rmSync(lock, { recursive: true, force: true });
+            }
+            else if (attempt === lockAttempts) {
+                throw new Error(`${lock} is held by another Chesspal writing the game: try again in a moment, or delete that folder when no Chesspal runs.`);
+            }
+            else {
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+            }
+        }
+    }
+    try {
+        return write();
+    }
+    finally {
+        rmdirSync(lock);
+    }
+}
 /** Makes a folder, and those above it, when missing. A failure says what to do about it. */
 export function makeFolder(path) {
     try {
@@ -30,6 +64,13 @@ export function stampOf(path) {
     return stats === undefined ? undefined : `${stats.ino}:${stats.mtimeNs}:${stats.size}`;
 }
 const attempts = 10;
+// A lock is waited for 5 ms at a time, a second at most; one older than two seconds is of a process that stopped while it held it.
+const lockAttempts = 200;
+const staleLock = 2_000;
+function isStale(lock) {
+    const stats = statSync(lock, { throwIfNoEntry: false });
+    return stats !== undefined && Date.now() - stats.mtimeMs > staleLock;
+}
 /**
  * Renames a file or a folder. Windows refuses while another program holds a file in it open (an editor, an antivirus, a sync client): Chesspal waits a
  * little and tries again, half a second at most.

package/dist/games/index.d.ts

@@ -1,9 +1,9 @@
-export { aiHostOf, aiModelOf, noteAiHost, noteAiModel } from "./ai-model.ts";
-export { type Analysis, endAnalysis, gameInAnalysis, startAnalysis } from "./analysis.ts";
+export { aiHostOf, aiModelOf, forgetTheAi, noteAiHost, noteAiModel } from "./ai-model.ts";
+export { type Analysis, type AnalysisStart, endAnalysis, forgetAnalyst, gameInAnalysis, startAnalysis } from "./analysis.ts";
 export { archiveCoached, archivedGame, archivedGames, archivedName, archivedWhen, archiveEnded, archiveGame, archiveName, deleteGame, gameStemOf, isGameName, isOverOnTable, keepToStudy, keptGame, keptGames, listedName, movesPgn, playerPgn, rewriteGame, startOfNewGame, } from "./archive.ts";
 export { type ChatStart, cleanSince, lastChatStart, saveChatStart } from "./chat-start.ts";
 export { type CoachHint, type CoachJudgment, type CoachLead, coachShown, coachStarted, coachWaitingSince, type CoachWords, coachWords, forgetCoach, keepHint, keepJudgment, keepLead, startCoach, withCoach } from "./coach.ts";
-export { bothSidesMoved, type CurrentGame, drawOfferOf, endOf, type GameEnd, gameStamp, loadGame, removeGame, saveGame, type Shown, type Speaker, type TalkLine } from "./current-game.ts";
+export { bothSidesMoved, type CurrentGame, drawOfferOf, endOf, GameChanged, type GameEnd, gameStamp, loadGame, removeGame, rerunIfChanged, saveGame, type Shown, type Speaker, type TalkLine } from "./current-game.ts";
 export { makeFolder, renameOver, writeAtomically } from "./files.ts";
 export { commentWithPlan, currentPlan, planOf, withoutPlans } from "./plans.ts";
 export { endTableTalk, loadTableTalk, saveTableTalk, type TableTalk, tableTalkStamp } from "./table-talk.ts";

package/dist/games/index.js

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

package/dist/home/data-folder.d.ts

@@ -10,3 +10,5 @@ export interface System {
 }
 /** The player's data folder: CHESSPAL_HOME when set, else the system's Documents with Chesspal's folder in it. */
 export declare function dataFolder(system?: System): string;
+/** The table's folder inside the data folder: one for every profile, where the chats the table opens start (D-104). */
+export declare function tableFolder(home: string): string;

package/dist/home/data-folder.js

@@ -3,7 +3,7 @@
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { posix, win32 } from "node:path";
+import { join, posix, win32 } from "node:path";
 /** The player's data folder: CHESSPAL_HOME when set, else the system's Documents with Chesspal's folder in it. */
 export function dataFolder(system = thisSystem()) {
     const chosen = system.env.CHESSPAL_HOME?.trim();
@@ -16,6 +16,10 @@ export function dataFolder(system = thisSystem()) {
     }
     return posix.join(system.platform === "darwin" ? posix.join(system.home, "Documents") : xdgDocuments(system), "Chesspal");
 }
+/** The table's folder inside the data folder: one for every profile, where the chats the table opens start (D-104). */
+export function tableFolder(home) {
+    return join(home, "table");
+}
 // Where Windows keeps Documents for this user, as Explorer's known folder does: the registry names it, with variables such as %USERPROFILE%.
 const shellFolders = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
 function thisSystem() {

package/dist/home/index.d.ts

@@ -1,2 +1,2 @@
-export { dataFolder, type System } from "./data-folder.ts";
+export { dataFolder, type System, tableFolder } from "./data-folder.ts";
 export { openFolder } from "./open-folder.ts";

package/dist/home/index.js

@@ -1,3 +1,3 @@
 // Where the player's data is (D-71): one folder for every chat, apart from the host's folder. Below the commands, beside the games and the profiles.
-export { dataFolder } from "./data-folder.js";
+export { dataFolder, tableFolder } from "./data-folder.js";
 export { openFolder } from "./open-folder.js";

package/dist/host-files/agents.d.ts

@@ -22,5 +22,5 @@ export declare function agentFiles(folder: string): {
     path: string;
     text: string;
 }[];
-/** Instructions for the AI, by their file's name in the package's instructions folder. */
-export declare function instructions(name: string): string;
+/** Instructions for the AI, by their file's name in the package's instructions folder: read once, as the version installed has them. */
+export declare function instructionsFile(name: string): string;

package/dist/host-files/agents.js

@@ -38,10 +38,16 @@ export function agentFiles(folder) {
     const agents = agentSpecs();
     return [...agents.map((agent) => claudeAgentFile(folder, agent)), ...agents.map((agent) => codexAgentFile(folder, agent))];
 }
-/** Instructions for the AI, by their file's name in the package's instructions folder. */
-export function instructions(name) {
-    return readFileSync(new URL(`../../instructions/${name}.md`, import.meta.url), "utf8").trim();
+/** Instructions for the AI, by their file's name in the package's instructions folder: read once, as the version installed has them. */
+export function instructionsFile(name) {
+    let text = instructionTexts.get(name);
+    if (text === undefined) {
+        text = readFileSync(new URL(`../../instructions/${name}.md`, import.meta.url), "utf8").trim();
+        instructionTexts.set(name, text);
+    }
+    return text;
 }
+const instructionTexts = new Map();
 const toolsOf = {
     [quickAgent]: ["ponder"],
     [ownAgent]: ["ponder"],
@@ -51,7 +57,7 @@ const toolsOf = {
 // Codex's quick model for the lower levels: written in its agent, since Codex ignores a model the chat names when it starts one that has it (Priya).
 const codexQuickModel = "gpt-6-luna";
 function agentSpecs() {
-    const ponder = instructions("ponder");
+    const ponder = instructionsFile("ponder");
     const thinking = "Chesspal's opponent thinking on the player's time. Started by the AI in the background after its move, as ai_move says.";
     return [
         { agent: quickAgent, claudeModel: "haiku", codexModel: codexQuickModel, description: thinking, text: ponder },
@@ -61,13 +67,13 @@ function agentSpecs() {
             agent: coachAgent,
             claudeModel: "inherit",
             description: "Chesspal's coach. Started only as Chesspal's answers say, in the background, never to answer the player.",
-            text: instructions("coach"),
+            text: instructionsFile("coach"),
         },
         {
             agent: analystAgent,
             claudeModel: "inherit",
             description: "Chesspal's analyst. Started only as Chesspal's answers say, in the background, to review a game over on the board page; never to answer the player.",
-            text: `${instructions("analyst-agent")}\n${instructions("analysis")}`,
+            text: `${instructionsFile("analyst-agent")}\n${instructionsFile("analysis")}`,
         },
     ];
 }

package/dist/host-files/host-files.d.ts

@@ -1,6 +1,6 @@
 /**
- * Sets up the player's folder for Claude Code and Codex (D-31): .mcp.json with the chesspal server, AGENTS.md with the opponent's instructions between
- * Chesspal's marks, CLAUDE.md importing it, the hosts' settings with the server approved, and their hooks. What the player wrote there stays; it returns
+ * Sets up the player's folder for Claude Code and Codex (D-31): .mcp.json with the chesspal server, AGENTS.md with the lines that start a chat between
+ * Chesspal's marks (D-102), CLAUDE.md importing it, the hosts' settings with the server approved, and their hooks. What the player wrote there stays; it returns
  * the files written.
  */
 export declare function setUpHosts(folder: string, platform: string): string[];
@@ -11,5 +11,7 @@ export declare function setUpHosts(folder: string, platform: string): string[];
 export declare function outdatedHostFiles(folder: string, platform: string): string[];
 /** Where Codex reads a folder's hooks, which it runs only once the player trusts them. */
 export declare function codexHooksPath(folder: string): string;
-/** The instructions of the AI opponent, read from the package wherever it is installed. */
+/** The instructions of the AI opponent, read from the package wherever it is installed: the MCP server's `instructions` tool gives them (D-102). */
 export declare function opponentInstructions(): string;
+/** The lines that start a chat, in the MCP server's instructions and in AGENTS.md: call `instructions`, then `status` (D-102). */
+export declare function startInstructions(): string;

package/dist/host-files/host-files.js

@@ -1,11 +1,11 @@
-// What `chesspal init` writes in a player's folder for each AI host: the opponent's instructions, the MCP server, the hooks and the agents.
+// What `chesspal init` writes in a player's folder for each AI host: the lines that start a chat, the MCP server, the hooks and the agents.
 import { existsSync, readFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { makeFolder, writeAtomically } from "../games/index.js";
-import { agentFiles, instructions } from "./agents.js";
+import { agentFiles, instructionsFile } from "./agents.js";
 /**
- * Sets up the player's folder for Claude Code and Codex (D-31): .mcp.json with the chesspal server, AGENTS.md with the opponent's instructions between
- * Chesspal's marks, CLAUDE.md importing it, the hosts' settings with the server approved, and their hooks. What the player wrote there stays; it returns
+ * Sets up the player's folder for Claude Code and Codex (D-31): .mcp.json with the chesspal server, AGENTS.md with the lines that start a chat between
+ * Chesspal's marks (D-102), CLAUDE.md importing it, the hosts' settings with the server approved, and their hooks. What the player wrote there stays; it returns
  * the files written.
  */
 export function setUpHosts(folder, platform) {
@@ -31,9 +31,13 @@ export function outdatedHostFiles(folder, platform) {
 export function codexHooksPath(folder) {
     return join(folder, ".codex", "hooks.json");
 }
-/** The instructions of the AI opponent, read from the package wherever it is installed. */
+/** The instructions of the AI opponent, read from the package wherever it is installed: the MCP server's `instructions` tool gives them (D-102). */
 export function opponentInstructions() {
-    return instructions("opponent");
+    return instructionsFile("opponent");
+}
+/** The lines that start a chat, in the MCP server's instructions and in AGENTS.md: call `instructions`, then `status` (D-102). */
+export function startInstructions() {
+    return instructionsFile("start");
 }
 // The marks around Chesspal's lines in AGENTS.md: init rewrites what lies between them, and the player's own text stays around them.
 const startMark = "<!-- chesspal: these lines up to the end mark are Chesspal's, and chesspal init rewrites them; write your own after it. -->";
@@ -60,11 +64,14 @@ function mcpFile(folder, platform) {
     const before = isObject(servers.chesspal) ? servers.chesspal : {};
     return changed(path, { ...config, mcpServers: { ...servers, chesspal: { ...chesspalServer(platform), ...(isObject(before.env) ? { env: before.env } : {}) } } });
 }
-/** AGENTS.md with the opponent's instructions between Chesspal's marks: rewritten when they changed, put first in a file that has none. */
+/**
+ * AGENTS.md with the lines that start a chat between Chesspal's marks, which Codex needs beside the server's instructions (D-31, D-102): rewritten when
+ * they changed, put first in a file that has none.
+ */
 function agentsFile(folder) {
     const path = join(folder, "AGENTS.md");
     const before = textOf(path);
-    const block = [startMark, opponentInstructions(), endMark].join("\n");
+    const block = [startMark, startInstructions(), endMark].join("\n");
     if (before === undefined) {
         return { path, text: `${block}\n` };
     }

package/dist/host-files/index.d.ts

@@ -1,2 +1,2 @@
-export { agentHosts, agentTools, analystAgent, coachAgent, hasAgent, instructions, isCodex, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.ts";
-export { codexHooksPath, opponentInstructions, outdatedHostFiles, setUpHosts } from "./host-files.ts";
+export { agentHosts, agentTools, analystAgent, coachAgent, hasAgent, instructionsFile, isCodex, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.ts";
+export { codexHooksPath, opponentInstructions, outdatedHostFiles, setUpHosts, startInstructions } from "./host-files.ts";

package/dist/host-files/index.js

@@ -1,3 +1,3 @@
 // The files through which an AI host finds Chesspal in the player's folder: the server, the opponent's instructions, the hosts' settings.
-export { agentHosts, agentTools, analystAgent, coachAgent, hasAgent, instructions, isCodex, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.js";
-export { codexHooksPath, opponentInstructions, outdatedHostFiles, setUpHosts } from "./host-files.js";
+export { agentHosts, agentTools, analystAgent, coachAgent, hasAgent, instructionsFile, isCodex, onQuickModel, ponderAgentFor, ponderAgents } from "./agents.js";
+export { codexHooksPath, opponentInstructions, outdatedHostFiles, setUpHosts, startInstructions } from "./host-files.js";

package/dist/page/app/app.js

@@ -9,7 +9,7 @@ import { explain } from "../board/explain.js";
 import { kingSigns } from "../board/signs.js";
 import { piecesOf } from "../board/squares.js";
 import { NewGameDialog } from "../dialogs/new-game.js";
-import { NameButton, PictureButton, PictureDialog, ProfilesDialog, Wizard } from "../dialogs/profiles.js";
+import { NameButton, PictureButton, ProfileDialog, ProfilesDialog, Wizard } from "../dialogs/profiles.js";
 import { SettingsPanel } from "../dialogs/settings.js";
 import { playerIn, studiedSides } from "../dialogs/studied.js";
 import { StudyDialog } from "../dialogs/study.js";
@@ -20,6 +20,7 @@ import { howEnded, useDeclined, useJustEnded, useSawEnd } from "../game/ending.j
 import { Steps } from "../game/move-list.js";
 import { useOpeningBook } from "../game/opening-book.js";
 import { aiSpoke, aiWords, analysisTalk, judgmentsOf, playerSpent, playerWords, pliesOf, withBook, withJudgments, withoutReviews } from "../game/plies.js";
+import { GuideDialog } from "../guide/guide.js";
 import { BareButton, HelpsCard, HintLine, MapButton } from "../helps/helps.js";
 import { helpsOf } from "../helps/view.js";
 import { FoldTab } from "../layout/fold-tab.js";
@@ -34,12 +35,14 @@ import { signature } from "../players/model-name.js";
 import { keepSettings } from "../profile/profile.js";
 import { languagesOf, saveSettings, settingsFrom, showSettings } from "../profile/settings.js";
 import { endSoundOf, playSound, soundOf, wakeSounds } from "../sounds/sounds.js";
+import { ChatOpener } from "../table/opener.js";
 import { AiNote, AiWords, Compose, PointSquare, TalkFaces } from "../talk/talk.js";
 import { textFor } from "../text.js";
 import { anchorName, useAnchor } from "./anchor.js";
 import { useBrowseKeys, useFoldKeys, useLegendKey, useMapKey, useWheelSteps } from "./keys.js";
 import { phaseOf, verdictOf } from "./phase.js";
 import { post, sendMessage, sendMove, useServed } from "./served.js";
+import { tabTitle, useTabTitle } from "./title.js";
 /**
  * The page: the board of the game in the player's folder, where the player moves on their turn, the talk with the AI beside it, and the game's column; in the
  * settings the player chose, `start` as this browser remembered them (D-56).
@@ -202,6 +205,9 @@ export function App({ start }) {
     // game a link opens is there to look at: the analyst starts on the player's yes alone (D-89; Zoe and Federico).
     const playedName = game === undefined || game === null ? undefined : anchorName(game.name);
     useAnchor({ ready: served !== undefined, shown: studied !== undefined ? anchorName(studied.name) : idle ? undefined : playedName, played: playedName, going }, viewing, (plies) => goTo(plies ?? total), async (wanted) => await post("/api/study", { game: wanted, look: true }, text, name) === undefined);
+    // The tab names the game and the move shown, as the cards name its players; between games, Chesspal alone.
+    const titled = idle || served === undefined ? undefined : studiedSides(live.record.tags, served.profile.name, playedAs, text.sides, served.profile.accounts);
+    useTabTitle(titled === undefined ? undefined : tabTitle(titled.white.name, titled.black.name, at === 0 ? undefined : plies[at - 1]));
     // The header's theme switch picks the other of the two the page shows, leaving the system's.
     const switchTheme = () => change({ ...settings, theme: document.documentElement.dataset.theme === "dark" ? "light" : "dark" });
     // An action of the player's on the game: the game the server sends next shows it; a refusal shows on the board.
@@ -212,7 +218,9 @@ export function App({ start }) {
     const result = resultOf(live);
     const ended = isOver(result);
     const how = ended ? howEnded(live.outcome, live.record.tags.Termination) : undefined;
-    const winner = result === "1-0" ? "white" : result === "0-1" ? "black" : undefined;
+    // A game closed before any move counts for no one, as Lichess aborts it: no winner, no kings' signs.
+    const aborted = ended && plies.length === 0;
+    const winner = aborted ? undefined : result === "1-0" ? "white" : result === "0-1" ? "black" : undefined;
     const justEnded = useJustEnded(played === undefined || played === null ? undefined : over ? "over" : "going");
     const offer = played?.drawOffer;
     const declined = useDeclined(offer, total, ended);
@@ -228,16 +236,18 @@ export function App({ start }) {
             }
         },
     };
-    const { kind, verdict } = verdictOf(phase, how, winner, offer, declined, text);
+    const { kind, verdict } = aborted && phase === "over" ? { kind: "over", verdict: text.aborted } : verdictOf(phase, how, winner, offer, declined, text);
     const header = (_jsx(Header, { text: text, kind: kind, verdict: verdict, ...(!ended && (offer === "ai" || declined) ? { who: name } : {}), actions: actions, onNewGame: served === undefined ? undefined : () => setDialog("new-game"), 
         // Between games the new one stands out in the player's card (D-77): in the header only when the talk, and the card with it, is folded away.
-        standOut: studied !== undefined || (between && folds.talk !== "open"), onStudy: served === undefined || going ? undefined : () => setDialog("study"), flipped: flipped, onFlip: () => setFlipped(!flipped), sound: sound, onSound: () => change({ ...settings, sound: !sound }), onTheme: switchTheme, onSettings: () => setSetting(true), ...(served === undefined ? {} : { profile: served.profile, onProfile: () => setDialog("profiles") }) }));
+        standOut: studied !== undefined || (between && folds.talk !== "open"), onStudy: served === undefined || going ? undefined : () => setDialog("study"), flipped: flipped, onFlip: () => setFlipped(!flipped), sound: sound, onSound: () => change({ ...settings, sound: !sound }), onTheme: switchTheme, onSettings: () => setSetting(true), onGuide: () => setDialog("guide"), ...(served === undefined ? {} : { profile: served.profile, onProfile: () => setDialog("profiles") }) }));
     const panel = _jsx(SettingsPanel, { open: setting, settings: settings, onChange: change, onClose: () => setSetting(false), text: text });
+    // The guide opens before the page has its data too.
+    const guide = _jsx(GuideDialog, { open: dialog === "guide", onClose: () => setDialog(undefined), text: text });
     if (problem !== undefined) {
         return _jsx("p", { class: "problem", children: problem });
     }
     if (served === undefined || game === undefined) {
-        return (_jsxs(_Fragment, { children: [header, panel] }));
+        return (_jsxs(_Fragment, { children: [header, panel, guide] }));
     }
     // At the first start the page asks who plays (D-23), to complete the profile Chesspal made (D-71): the game comes after.
     if (served.profile.new === true) {
@@ -261,7 +271,7 @@ export function App({ start }) {
     const drawn = hintOpen && hint !== undefined && viewing === undefined && (hint.arrows !== undefined || hint.squares !== undefined) ? hint : review;
     const drawnByCoach = hint !== undefined && drawn === hint;
     // The game over, when this is its last position: the kings' signs, on the board and in the legend.
-    const boardEnd = ended && viewing === undefined && pending === undefined ? { how, winner, player, fresh: justEnded } : undefined;
+    const boardEnd = ended && !aborted && viewing === undefined && pending === undefined ? { how, winner, player, fresh: justEnded } : undefined;
     // The legend has the marks the board shows: none of the helps' or the drawings while the board is bare (D-99).
     const shownBare = bare && helps !== undefined;
     const legendRows = legendOf({
@@ -292,7 +302,10 @@ export function App({ start }) {
     const clockWaits = clock?.waiting === true && !ended && studied === undefined && viewing === undefined && live.position.turn === ai;
     const clockOf = (side) => clock === undefined ? undefined : (_jsx(ClockFace, { clock: clock, side: side, toMove: !ended && live.position.turn === side, held: pending !== undefined || (asleep && side === ai), onFlag: reload, text: text }));
     // Where to wake the chat, under the AI's card (over the board when the talk is folded); the button that starts the clocks, under the player's (Zoe).
-    const asleepNote = asleep ? _jsx("p", { class: "asleep", role: "status", children: sides === undefined ? text.asleep(name) : text.asleepInAnalysis(name) }) : null;
+    // On the table with no chat at it, the note opens one instead (D-104).
+    const table = offline ? undefined : served.table;
+    const opener = table !== undefined && !table.chat ? _jsx(ChatOpener, { table: table, settings: settings, onChange: change, name: name, text: text }) : undefined;
+    const asleepNote = opener ?? (asleep ? _jsx("p", { class: "asleep", role: "status", children: sides === undefined ? text.asleep(name) : text.asleepInAnalysis(name) }) : null);
     const startClocks = clockWaits
         ? (_jsxs("button", { type: "button", class: "command primary start-clocks", onClick: () => act("/api/start", {}), children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M8 5.5v13l10.5-6.5z" }) }), text.startClocks] }))
         : null;
@@ -345,7 +358,7 @@ export function App({ start }) {
         }
     };
     // In analysis the words go with the game and the move shown (D-101).
-    const sendWords = (shown) => {
+    const sendWords = (position) => {
         const words = draft;
         // /clear and the other commands are for Claude's app: written here they would reach the AI as words (Sebastiano's playtest).
         if (isCommand(words)) {
@@ -353,7 +366,7 @@ export function App({ start }) {
             return;
         }
         setUnsent(undefined);
-        void sendMessage(words, text, name, shown).then((refused) => {
+        void sendMessage(words, text, name, position).then((refused) => {
             setUnsent(refused?.text);
             clearSent(refused?.text, words);
         });
@@ -369,8 +382,8 @@ export function App({ start }) {
     };
     // In analysis the AI's note goes with the other side's card and the talk with the player's, turned round with the board as in a game (D-101, Zoe).
     const studiedCard = (side, place) => sides === undefined ? null : (_jsx(PlayerCard, { place: place, 
-        // The player changes their picture in analysis too, from their own side's card.
-        picture: sides[side].who === "player" ? _jsx(PictureButton, { profile: profile, onOpen: () => setDialog("picture"), text: text }) : pictureOf(sides[side], profile, 48, mood), name: sides[side].name, signed: sides[side].who === "ai" && playedBy !== undefined ? signature(playedBy.model, playedBy.effort) : undefined, side: side, taken: material.taken[side], ahead: ahead(side), badges: _jsx(BadgeCounts, { plies: plies, side: side, names: text.badges }), text: text }));
+        // The player opens their profile in analysis too, from their own side's card.
+        picture: sides[side].who === "player" ? _jsx(PictureButton, { profile: profile, onOpen: () => setDialog("profile"), text: text }) : pictureOf(sides[side], profile, 48, mood), name: sides[side].name, signed: sides[side].who === "ai" && playedBy !== undefined ? signature(playedBy.model, playedBy.effort) : undefined, side: side, taken: material.taken[side], ahead: ahead(side), badges: _jsx(BadgeCounts, { plies: plies, side: side, names: text.badges }), text: text }));
     // A game brought to analyse: the page shows it once the server has it in analysis; a refusal stays in the dialog.
     const studyGame = async (studied) => {
         const refused = await post("/api/study", studied, text, name);
@@ -379,7 +392,7 @@ export function App({ start }) {
         }
         return refused?.text;
     };
-    return (_jsx(ChosenSet.Provider, { value: settings.set, children: _jsxs(PointSquare.Provider, { value: pointSquare, children: [panel, _jsx(PictureDialog, { open: dialog === "picture", profile: profile, onClose: () => setDialog(undefined), text: text }), _jsx(ProfilesDialog, { open: dialog === "profiles", profiles: served.profiles, active: profile, locked: going ? text.profile.whilePlaying : undefined, dataFolder: served.dataFolder, onClose: () => setDialog(undefined), text: text }), _jsx(NewGameDialog, { open: dialog === "new-game", choice: choice, going: going, onStart: startNewGame, onClose: () => setDialog(undefined), text: text }), _jsx(StudyDialog, { open: dialog === "study", onStudy: studyGame, onClose: () => setDialog(undefined), you: profile.name, accounts: profile.accounts, ai: name, text: text }), offline ? _jsx("p", { class: "offline", role: "alert", children: text.offline(name) }) : null, served.outdated === true ? _jsx("p", { class: "outdated", role: "status", children: text.outdated(name) }) : null, _jsxs("main", { class: `app${flipped ? " flipped" : ""}${folds.talk === "open" ? "" : ` talk-${folds.talk}`}${folds.game === "folded" ? " folded" : ""}`, inert: offline, children: [header, sides === undefined
+    return (_jsx(ChosenSet.Provider, { value: settings.set, children: _jsxs(PointSquare.Provider, { value: pointSquare, children: [panel, _jsx(ProfileDialog, { open: dialog === "profile", profile: profile, onClose: () => setDialog(undefined), text: text }), _jsx(ProfilesDialog, { open: dialog === "profiles", profiles: served.profiles, active: profile, locked: going ? text.profile.whilePlaying : undefined, dataFolder: served.dataFolder, onEdit: () => setDialog("profile"), onClose: () => setDialog(undefined), text: text }), _jsx(NewGameDialog, { open: dialog === "new-game", choice: choice, going: going, onStart: startNewGame, onClose: () => setDialog(undefined), text: text }), guide, _jsx(StudyDialog, { open: dialog === "study", onStudy: studyGame, onClose: () => setDialog(undefined), you: profile.name, accounts: profile.accounts, ai: name, text: text }), offline ? _jsx("p", { class: "offline", role: "alert", children: text.offline(name) }) : null, served.outdated === true ? _jsx("p", { class: "outdated", role: "status", children: text.outdated(name) }) : null, _jsxs("main", { class: `app${flipped ? " flipped" : ""}${folds.talk === "open" ? "" : ` talk-${folds.talk}`}${folds.game === "folded" ? " folded" : ""}`, inert: offline, children: [header, sides === undefined
                             ? (_jsx(TalkFaces, { name: name, aiPicture: thinker(40), you: profile.name, picture: picture, ...(idle ? {} : { ai, player }), aiMoves: going && !playerToMove, playerMoves: playerToMove, unread: unread || asleep, text: text }))
                             : (_jsx(TalkFaces, { name: sides[ai].name, aiPicture: pictureOf(sides[ai], profile, 40, mood), you: sides[player].name, picture: pictureOf(sides[player], profile, 40, mood), ai: ai, player: player, aiMoves: false, playerMoves: false, unread: asleep, text: text })), _jsx(FoldTab, { column: "talk", folded: folds.talk === "folded", label: thinking === undefined || folds.talk !== "folded" ? text.talk : `${text.talk}: ${text.thinking[thinking]}`, unread: (unread || asleep) && folds.talk === "folded", ...(thinking === undefined || folds.talk !== "folded" ? {} : { mark: _jsx(Thought, { thinking: thinking, words: text.thinking }) }), onFold: fold }), _jsx(FoldTab, { column: "game", folded: folds.game === "folded", label: text.game, onFold: fold }), _jsx("span", { class: "visually-hidden", "aria-live": "polite", children: unread ? text.wrote(name) : "" }), _jsx("div", { class: sides === undefined ? "talk" : "talk studied", id: "talk", children: sides !== undefined && studied !== undefined
                                 ? (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": sides[ai].name, children: [studiedCard(ai, "ai"), asleepNote, _jsx(AiNote, { ...(reviewed === undefined ? {} : { ply: reviewed }), ...(shownOpening === undefined ? {} : { opening: shownOpening }), ...(at === total && closing !== undefined ? { closing } : {}), ...(at === 0 && summary !== undefined ? { summary } : {}), ...(summary === undefined ? { reviewing: true } : {}), name: analyst, by: annotator, mood: mood, ...(settings.voice ? { voice: text.language } : {}), text: text })] }), _jsxs("section", { class: "you-block", "aria-label": sides[player].name, children: [_jsx("div", { class: "chat", children: _jsx(Compose, { lines: analysisTalk(talk, studied.name), newestFirst: false, spent: 0, draft: draft, onDraft: (words) => {
@@ -391,13 +404,13 @@ export function App({ start }) {
                                                     spent: going ? playerSpent(plies, ai, talk) : 0, draft: draft, onDraft: (words) => {
                                                         setDraft(words);
                                                         setUnsent(undefined);
-                                                    }, onSend: sendWords, canMove: playerToMove, name: name, problem: unsent, text: text }), _jsx(PlayerCard, { place: "you", picture: _jsx(PictureButton, { profile: profile, onOpen: () => setDialog("picture"), text: text }), name: _jsx(NameButton, { profile: profile, onOpen: () => setDialog("profiles"), text: text }), side: idle ? undefined : player, taken: material.taken[player], ahead: ahead(player), turn: playerToMove, clock: _jsxs(_Fragment, { children: [clockOf(player), startClocks, nextGame] }), text: text })] })] })) }), _jsxs("div", { 
+                                                    }, onSend: sendWords, canMove: playerToMove, name: name, problem: unsent, text: text }), _jsx(PlayerCard, { place: "you", picture: _jsx(PictureButton, { profile: profile, onOpen: () => setDialog("profile"), text: text }), name: _jsx(NameButton, { profile: profile, onOpen: () => setDialog("profiles"), text: text }), side: idle ? undefined : player, taken: material.taken[player], ahead: ahead(player), turn: playerToMove, clock: _jsxs(_Fragment, { children: [clockOf(player), startClocks, nextGame] }), text: text })] })] })) }), _jsxs("div", { 
                             // Between games the board goes off (D-77): a game the page saw end once its effects are over, its final position less off than the table set.
                             class: between && !justEnded ? "board-wrap off" : "board-wrap", onWheel: wheel, 
                             // A press on the board while the player looks back brings the game as it is: the next one plays.
-                            onPointerDownCapture: viewing === undefined || studied !== undefined ? undefined : (event) => event.button === 0 && goTo(total), children: [_jsx(Board, { fen: shown.position.fen, bottom: flipped ? ai : player, lastMove: shown.lastMove, pointed: pointed, ...(helps === undefined ? {} : { helps }), ...(mapping && helps !== undefined ? { control: helps.strategy.control } : {}), bare: bare && helps !== undefined, ...(review?.badge === undefined ? {} : { badge: { badge: review.badge, name: text.badges[review.badge] } }), ...(drawn === undefined ? {} : { drawn }), nextMove: next, jumped: jumped, check: shown.position.check, end: boardEnd, player: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing === undefined ? refusal : undefined, promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleep || clockWaits)
-                                    ? (_jsxs("div", { class: "over-board", children: [asleep ? _jsx("p", { class: "asleep", role: "status", children: text.asleep(name) }) : null, startClocks] }))
-                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : { analysis: summary === undefined ? { by: analyst } : { by: analyst, summary } }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text })] })] }) }));
+                            onPointerDownCapture: viewing === undefined || studied !== undefined ? undefined : (event) => event.button === 0 && goTo(total), children: [_jsx(Board, { fen: shown.position.fen, bottom: flipped ? ai : player, lastMove: shown.lastMove, pointed: pointed, ...(helps === undefined ? {} : { helps }), ...(mapping && helps !== undefined ? { control: helps.strategy.control } : {}), bare: bare && helps !== undefined, ...(review?.badge === undefined ? {} : { badge: { badge: review.badge, name: text.badges[review.badge] } }), ...(drawn === undefined ? {} : { drawn }), nextMove: next, jumped: jumped, check: shown.position.check, end: boardEnd, player: playerToMove && pending === undefined && viewing === undefined ? player : undefined, selected: selected, targets: selected === undefined || viewing !== undefined ? [] : live.legalMoves(selected), dots: settings.dots, names: settings.squareNames, notice: viewing === undefined ? refusal : undefined, promotion: promoting === undefined || viewing !== undefined || !playerToMove ? undefined : { ...promoting, side: player }, onPromote: (piece) => piece === undefined ? setPromoting(undefined) : play(promoting.from, promoting.to, piece), onSelect: select, onMove: play, onRefuse: refuse, text: text }), folds.talk !== "open" && (asleep || opener !== undefined || clockWaits)
+                                    ? (_jsxs("div", { class: "over-board", children: [opener ?? (asleep ? _jsx("p", { class: "asleep", role: "status", children: text.asleep(name) }) : null), startClocks] }))
+                                    : null] }), studied === undefined ? null : (_jsx("div", { class: "board-steps", children: _jsx(Steps, { shown: at, total: total, onStep: step, text: text }) })), helps === undefined ? null : (_jsxs("div", { class: "board-map", children: [legendAt(true), _jsx(BareButton, { bare: bare, onBare: setBare, text: text }), _jsx(MapButton, { mapping: mapping, onMap: setMapping, text: text }), hint === undefined || viewing !== undefined ? null : _jsx(HintLine, { hint: hint, open: hintOpen, onOpen: openTheHint, text: text })] })), _jsx(GameColumn, { plies: idle ? [] : plies, result: ended ? result : undefined, how: how, lit: justEnded, started: idle ? undefined : played?.started, move: live.position.moveNumber, toMove: live.position.turn, opening: opening, helps: helps === undefined ? undefined : (_jsx(HelpsCard, { helps: helps, judged: judgments, hint: viewing === undefined ? hint : undefined, hintOpen: hintOpen, onHint: openTheHint, onPoint: setPointed, onMap: setMapping, mapping: mapping, onBare: setBare, bare: bare, legend: legend, text: text })), ...(helps === undefined && legendRows.length > 0 ? { legend } : {}), ...(standings === undefined ? {} : { standings }), ...(studied === undefined ? {} : { analysis: summary === undefined ? { by: analyst } : { by: analyst, summary } }), shownPlies: at, onShow: goTo, onStep: step, ...(studied === undefined ? {} : { onDownload: () => download(studied.pgn, pgnName(live.record.tags, "analysis")) }), ...(total === 0 ? {} : { onSaveMoves: () => download(writePgn(movesOnly(live.record)), pgnName(live.record.tags)) }), ...(between && game !== null && replayed.record.moves.length > 0 ? { onAnalyse: () => void studyGame({ last: true }) } : {}), text: text })] })] }) }));
 }
 /** The picture of a player of the game in analysis: the player's own, the AI's Torretta with its mood, or the plain face of someone else. */
 function pictureOf({ who }, profile, size, mood) {

package/dist/page/app/title.js

@@ -0,0 +1,17 @@
+// The tab's title names the game and the move shown, Stefano – Claude, 16. ♞f3, so that the player's bookmarks and tabs tell its games apart.
+import { useEffect } from "preact/hooks";
+import { figurinesOf } from "../../core/index.js";
+/** The title of a game: its players by their first names, White first, so that the move fits in a tab (Zoe), and the move shown with its number, none before the first. */
+export function tabTitle(white, black, shown) {
+    const players = `${firstName(white)} – ${firstName(black)}`;
+    return shown === undefined ? players : `${players}, ${shown.number}${shown.side === "white" ? "." : "..."} ${figurinesOf(shown.san)}`;
+}
+/** Keeps the tab's title, Chesspal's name while no game shows. */
+export function useTabTitle(title) {
+    useEffect(() => {
+        document.title = title ?? "Chesspal";
+    }, [title]);
+}
+function firstName(name) {
+    return name.trim().split(/\s+/)[0] || name;
+}

package/dist/page/avatars/torretta.js

@@ -18,8 +18,8 @@ function useChanged(mood) {
 function Face({ mood }) {
     switch (mood) {
         case "happy":
-            // Eyes closed in two arcs, a wide open smile.
-            return (_jsxs(_Fragment, { children: [_jsx("path", { class: "eyes line", d: "M50.5 78.5a4.5 4.5 0 0 1 9 0M68.5 78.5a4.5 4.5 0 0 1 9 0" }), _jsx("path", { class: "mouth", d: "M57 84h14a7 7 0 0 1-14 0Z" })] }));
+            // Eyes closed in two low arcs, a wide open smile with its corners just rounded.
+            return (_jsxs(_Fragment, { children: [_jsx("path", { class: "eyes line", d: "M50 77.5q5-5.4 10 0M68 77.5q5-5.4 10 0" }), _jsx("path", { class: "mouth", d: "M56.6 83.2H71.4Q73 83.2 72.9 84.6A9 7.8 0 0 1 55.1 84.6Q55 83.2 56.6 83.2Z" })] }));
         case "surprised":
             // Wide eyes and a round mouth.
             return (_jsxs(_Fragment, { children: [_jsxs("g", { class: "eyes", children: [_jsx("circle", { cx: "54.5", cy: "75.5", r: "5.8" }), _jsx("circle", { cx: "73.5", cy: "75.5", r: "5.8" })] }), _jsx("ellipse", { class: "mouth", cx: "64", cy: "88.5", rx: "3.4", ry: "4" })] }));
@@ -27,8 +27,8 @@ function Face({ mood }) {
             // Brows raised in the middle, smaller eyes, a frown; the light turns red.
             return (_jsxs(_Fragment, { children: [_jsx("path", { class: "brows", d: "M50 70L58 67M70 67L78 70" }), _jsxs("g", { class: "eyes", children: [_jsx("circle", { cx: "55", cy: "78.5", r: "3.8" }), _jsx("circle", { cx: "73", cy: "78.5", r: "3.8" })] }), _jsx("path", { class: "mouth line", d: "M56.5 91q7.5-6 15 0" })] }));
         case "thoughtful":
-            // A glance to the side under one raised brow, the mouth pushed to the other side; the light breathes.
-            return (_jsxs(_Fragment, { children: [_jsx("path", { class: "brows", d: "M71 68L80 66" }), _jsxs("g", { class: "eyes", children: [_jsx("circle", { cx: "58", cy: "76.5", r: "3.9" }), _jsx("circle", { cx: "76", cy: "76.5", r: "3.9" })] }), _jsx("path", { class: "mouth line", d: "M52.5 89L63 87" })] }));
+            // The neutral face tilted on the screen, a smaller mouth: the head bent of one who wonders; the light breathes.
+            return (_jsxs("g", { transform: "rotate(-12 64 79)", children: [_jsxs("g", { class: "eyes", children: [_jsx("circle", { cx: "55", cy: "74.5", r: "4.4" }), _jsx("circle", { cx: "73", cy: "74.5", r: "4.4" })] }), _jsx("rect", { class: "mouth", x: "60", y: "86.3", width: "8", height: "3.4", rx: "1.7" })] }));
         case "sad":
             // No brows, the face sunk low: eyes half shut under lids that droop outwards, a deep frown; the light goes out.
             return (_jsxs(_Fragment, { children: [_jsx("path", { class: "eyes", d: "M60.3 77.1A5.6 5.6 0 0 1 49.7 80.9ZM78.3 80.9A5.6 5.6 0 0 1 67.7 77.1Z" }), _jsx("path", { class: "mouth line", d: "M57.5 92.5q6.5-6.5 13 0" })] }));

package/dist/page/dialogs/analyses.js

@@ -45,7 +45,7 @@ export function Analyses({ onStudy, onLoad, you, accounts, ai, text }) {
     return (_jsxs("div", { class: "analyses", children: [_jsxs("label", { class: "search", children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M10.5 17A6.5 6.5 0 1 0 10.5 4A6.5 6.5 0 0 0 10.5 17ZM15.5 15.5L20 20" }) }), _jsx("input", { type: "search", value: query, placeholder: words.search, "aria-label": words.search, spellcheck: false, onInput: (event) => setQuery(event.currentTarget.value) })] }), _jsxs("button", { class: "load-row", type: "button", onClick: onLoad, children: [_jsx("span", { class: "plus", "aria-hidden": "true", children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", children: _jsx("path", { d: "M12 5V19M5 12H19" }) }) }), _jsxs("span", { children: [_jsx("b", { children: words.bring }), _jsx("small", { children: words.bringNote })] })] }), problem === undefined ? null : _jsx("p", { class: "problem", role: "alert", children: problem }), analyses.length > 0 && found.length === 0 ? _jsx("p", { class: "none", children: words.noMatch }) : null, found.length === 0 ? null : (_jsx("ul", { class: "games", "aria-label": words.yours, children: found.map(({ item, named, outcome }) => asking?.name === item.name
                     ? (_jsx(Question, { asked: asking.asked, game: named.sides, when: dayOf(item.date, text.language), by: by(item), busy: busy, onYes: () => void act(item.name, asking.asked), onNo: () => setAsking(undefined), words: words }, item.name))
                     : (_jsxs("li", { class: "game", children: [_jsxs("button", { class: "reopen", type: "button", disabled: busy, onClick: () => open(item.name), children: [_jsx(ResultTile, { result: item.result }), _jsxs("span", { class: "what", children: [_jsx("b", { class: "who", children: named.sides }), _jsx("span", { class: "meta", children: [dayOf(item.date, text.language), words.moves(item.moves), item.opening].filter((part) => part !== undefined).join(" · ") }), item.reviewed ? _jsx(Reviewed, { by: by(item), words: words }) : null] }), _jsxs("span", { class: "score", children: [_jsx("b", { children: scoreOf(item.result) }), outcome === undefined ? _jsx("span", {}) : _jsx(OutcomeBadge, { outcome: outcome, words: words })] })] }), _jsx("span", { class: "row-actions", children: _jsx("button", { class: `icon-button${menu?.name === item.name ? " on" : ""}`, type: "button", title: words.more, "aria-label": words.more, "aria-expanded": menu?.name === item.name, disabled: busy, onClick: (event) => setMenu(menu?.name === item.name ? undefined : { name: item.name, anchor: event.currentTarget }), children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M5 12H5.01M12 12H12.01M19 12H19.01" }) }) }) }), menu?.name === item.name
-                                ? (_jsx(RowMenu, { anchor: menu.anchor, reviewed: item.reviewed, onPick: (asked) => {
+                                ? (_jsx(RowMenu, { anchor: menu.anchor, withReview: item.reviewed || item.begun === true, onPick: (asked) => {
                                         setMenu(undefined);
                                         setAsking({ name: item.name, asked });
                                     }, onClose: () => setMenu(undefined), words: words }))
@@ -53,9 +53,9 @@ export function Analyses({ onStudy, onLoad, you, accounts, ai, text }) {
 }
 /**
  * A row's menu, over the dialog and the page in the browser's top layer, under its button or above it when there is no room: analyse again and delete the
- * analysis, for a game reviewed; delete the game, apart and in red. Scrolling closes it, which would leave its button.
+ * analysis, for a game reviewed or whose review was begun; delete the game, apart and in red. Scrolling closes it, which would leave its button.
  */
-function RowMenu({ anchor, reviewed, onPick, onClose, words }) {
+function RowMenu({ anchor, withReview, onPick, onClose, words }) {
     const menu = useRef(null);
     useLayoutEffect(() => {
         const element = menu.current;
@@ -69,7 +69,7 @@ function RowMenu({ anchor, reviewed, onPick, onClose, words }) {
             window.removeEventListener("resize", onClose);
         };
     }, []);
-    return (_jsxs("div", { ref: menu, class: "row-menu", popover: "manual", children: [reviewed
+    return (_jsxs("div", { ref: menu, class: "row-menu", popover: "manual", children: [withReview
                 ? (_jsxs(_Fragment, { children: [_jsxs("button", { type: "button", onClick: () => onPick("redo"), children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M19 12A7 7 0 1 1 16.5 6.6M17 3V7H13" }) }), _jsxs("span", { children: [words.redo, _jsx("small", { children: words.redoNote })] })] }), _jsxs("button", { type: "button", onClick: () => onPick("unreview"), children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M5 19H19M8 15L4.5 11.5L12 4L18 10L11 17H8ZM8.5 7.5L14.5 13.5" }) }), _jsxs("span", { children: [words.unreview, _jsx("small", { children: words.unreviewNote })] })] }), _jsx("hr", {})] }))
                 : null, _jsxs("button", { class: "danger", type: "button", onClick: () => onPick("remove"), children: [_jsx(TrashIcon, {}), _jsx("span", { children: words.remove })] })] }));
 }

package/dist/page/dialogs/dialog.js

@@ -3,6 +3,9 @@ import { useEffect, useRef } from "preact/hooks";
 /** A dialog over the page, as the settings' one: Esc and a click outside close it; a step inside it goes back with the arrow beside its title. */
 export function Dialog({ open, title, onBack, onClose, text, children }) {
     const dialog = useRef(null);
+    // Open as the page wants it: a dialog the page closed itself, to open another, does not close that one when the browser says it closed.
+    const wanted = useRef(open);
+    wanted.current = open;
     useEffect(() => {
         const element = dialog.current;
         if (open && !element.open) {
@@ -22,5 +25,5 @@ export function Dialog({ open, title, onBack, onClose, text, children }) {
             onClose();
         }
     };
-    return (_jsxs("dialog", { ref: dialog, class: "dialog", "aria-label": title, onClose: onClose, onClick: closeOutside, children: [_jsxs("header", { children: [onBack === undefined ? null : (_jsx("button", { class: "icon-button", type: "button", title: text.profile.back, "aria-label": text.profile.back, onClick: onBack, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M15 6L9 12L15 18" }) }) })), _jsx("h2", { children: title }), _jsx("button", { class: "icon-button", type: "button", title: text.close, "aria-label": text.close, onClick: onClose, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M6 6L18 18M18 6L6 18" }) }) })] }), open ? children : null] }));
+    return (_jsxs("dialog", { ref: dialog, class: "dialog", "aria-label": title, onClose: () => wanted.current && onClose(), onClick: closeOutside, children: [_jsxs("header", { children: [onBack === undefined ? null : (_jsx("button", { class: "icon-button", type: "button", title: text.profile.back, "aria-label": text.profile.back, onClick: onBack, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M15 6L9 12L15 18" }) }) })), _jsx("h2", { children: title }), _jsx("button", { class: "icon-button", type: "button", title: text.close, "aria-label": text.close, onClick: onClose, children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M6 6L18 18M18 6L6 18" }) }) })] }), open ? children : null] }));
 }