chesspal 0.3.0 → 0.3.1

package/dist/commands/context.d.ts

@@ -41,6 +41,8 @@ export interface Context {
      * (D-71); null in a chat no tool has shown the game yet, none outside a chat.
      */
     positionSeen?: SeenPosition | null | undefined;
+    /** The first position a tool showed the chat: a chat that has seen no other since has only greeted the player, and a new game keeps it (D-57). */
+    positionFirstSeen?: SeenPosition | undefined;
     /** The instructions the MCP server gave in this chat, by their name and the chat's start: each comes once a chat (D-68); none on the command line. */
     told?: Set<string>;
     /** Who makes this tool call, as far as the host ties it to the call (D-81); none on the command line. */

package/dist/page/app/app.js

@@ -35,7 +35,7 @@ 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 { AiNameButton, ChatDialog, tableNote } from "../table/window.js";
 import { AiNote, AiWords, Compose, PointSquare, TalkFaces } from "../talk/talk.js";
 import { textFor } from "../text.js";
 import { anchorName, useAnchor } from "./anchor.js";
@@ -67,6 +67,18 @@ export function App({ start }) {
     };
     const [dialog, setDialog] = useState(undefined);
     const { data: served, problem, offline, reload } = useServed(() => setDialog("new-game"));
+    // Nuova partita with no chat at the table asks for one first (D-107): the chat's window, then the new game's, however the first closes.
+    const [chatFirst, setChatFirst] = useState(false);
+    const askNewGame = () => {
+        const table = offline ? undefined : served?.table;
+        const first = table !== undefined && !table.chat && table.opening === undefined;
+        setChatFirst(first);
+        setDialog(first ? "chat" : "new-game");
+    };
+    const closeChat = () => {
+        setDialog(chatFirst ? "new-game" : undefined);
+        setChatFirst(false);
+    };
     const [selected, setSelected] = useState(undefined);
     const [refusal, setRefusal] = useState(undefined);
     // A pawn taken to the last rank waits for the player to choose what it becomes.
@@ -237,7 +249,7 @@ export function App({ start }) {
         },
     };
     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"), 
+    const header = (_jsx(Header, { text: text, kind: kind, verdict: verdict, ...(!ended && (offer === "ai" || declined) ? { who: name } : {}), actions: actions, onNewGame: served === undefined ? undefined : askNewGame, 
         // 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), 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 });
@@ -302,16 +314,20 @@ 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).
-    // On the table with no chat at it, the note opens one instead (D-104).
+    // On the table, what its chat is doing stands there, and in a game with no chat at it a line that opens the chat's window (D-107).
     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 atTable = table === undefined ? null : tableNote({ table, name, inGame: going, onOpen: () => setDialog("chat"), text });
+    const asleepNote = atTable !== null
+        ? atTable
+        : asleep && table?.chat !== false
+            ? _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;
     // Between games the next starts from the player's card, where the clock and the button that starts it stand in a game (D-77).
     const nextGame = between
-        ? (_jsxs("button", { type: "button", class: "command primary next-game", onClick: () => setDialog("new-game"), children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M12 5V19M5 12H19" }) }), text.newGame] }))
+        ? (_jsxs("button", { type: "button", class: "command primary next-game", onClick: askNewGame, children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M12 5V19M5 12H19" }) }), text.newGame] }))
         : null;
     // Words sent leave the box; what the player wrote on while they went stays.
     const clearSent = (refused, words) => {
@@ -392,14 +408,14 @@ export function App({ start }) {
         }
         return refused?.text;
     };
-    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
+    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 }), table === undefined ? null : _jsx(ChatDialog, { open: dialog === "chat", table: table, settings: settings, onChange: change, name: name, onClose: closeChat, 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) => {
+                                ? (_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 } : {}), 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) => {
                                                             setDraft(words);
                                                             setUnsent(undefined);
                                                         }, onSend: () => sendWords({ game: studied.name, at }), canMove: false, name: name, problem: unsent, about: { ...(at === 0 ? {} : { ply: plies[at - 1] }), onShow: goTo }, text: text }) }), studiedCard(player, "you")] })] }))
-                                : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: name, signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text.language } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
+                                : (_jsxs(_Fragment, { children: [_jsxs("section", { class: "ai-block", "aria-label": name, children: [_jsx(PlayerCard, { place: "ai", picture: thinker(48), name: table === undefined ? name : _jsx(AiNameButton, { name: name, table: table, onOpen: () => setDialog("chat"), text: text }), signed: signed, side: idle ? undefined : ai, ...(idle ? {} : { level: text.start.levels[level] }), taken: material.taken[ai], ahead: ahead(ai), clock: clockOf(ai), text: text }), asleepNote, _jsx(AiWords, { words: aiWords(plies, ai, talk), newestFirst: !flipped, ...(settings.voice ? { voice: text } : {}) })] }), _jsxs("section", { class: "you-block", "aria-label": profile.name, children: [_jsx(Compose, { lines: said, newestFirst: flipped, 
                                                     // Between games, and before the first, the player writes freely, a line at a time, as the AI does (D-74, D-77).
                                                     spent: going ? playerSpent(plies, ai, talk) : 0, draft: draft, onDraft: (words) => {
                                                         setDraft(words);
@@ -408,8 +424,8 @@ export function App({ start }) {
                             // 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 || opener !== undefined || clockWaits)
-                                    ? (_jsxs("div", { class: "over-board", children: [opener ?? (asleep ? _jsx("p", { class: "asleep", role: "status", children: text.asleep(name) }) : null), startClocks] }))
+                            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" && (asleepNote !== null || clockWaits)
+                                    ? (_jsxs("div", { class: "over-board", children: [asleepNote, 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. */

package/dist/page/dialogs/profiles.js

@@ -197,8 +197,8 @@ function refusalText(refused, text) {
 }
 // Zoe's camera, on the picture to change.
 const cameraIcon = (_jsxs("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: [_jsx("path", { d: "M4 8H7L9 5H15L17 8H20V19H4Z" }), _jsx("circle", { cx: "12", cy: "13", r: "3.5" })] }));
-// The profile in use, in the menu, and a field saved in the profile window.
-const checkIcon = (_jsx("svg", { class: "icon in-use", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M5 12.5L10 17.5L19 7.5" }) }));
+/** The tick on the choice in use: the profile, a name saved, the chat at the table. */
+export const checkIcon = (_jsx("svg", { class: "icon in-use", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M5 12.5L10 17.5L19 7.5" }) }));
 // The room of the tick beside a field not saved yet.
 const noTick = _jsx("svg", { class: "icon in-use", viewBox: "0 0 24 24", "aria-hidden": "true" });
 // The pencil on the player's picture and beside them in the menu: their profile opens.

package/dist/page/layout/layout.css

@@ -602,32 +602,6 @@
         min-height: 0;
         overflow-y: auto;
     }
-
-    /* On a short column the table's note keeps its buttons and drops the commands to type, then the box and the words go: they wait for a chat anyway.
-       In analysis the cards are taller and the AI's note needs room too */
-    @container talk (max-height: 560px) {
-        .opener-command {
-            display: none;
-        }
-    }
-
-    @container talk (max-height: 500px) {
-        .ai-block:has(> .opener) + .you-block > :is(.sent, .compose) {
-            display: none;
-        }
-    }
-
-    @container talk (max-height: 640px) {
-        .talk.studied .opener-command {
-            display: none;
-        }
-    }
-
-    @container talk (max-height: 580px) {
-        .talk.studied > .ai-block:has(> .opener) + .you-block > .chat {
-            display: none;
-        }
-    }
 }
 
 /* The game's column, which folds from its tab */

package/dist/page/style.css

@@ -5,7 +5,7 @@
 @import "board/board.css";
 @import "talk/talk.css";
 @import "talk/chat.css";
-@import "table/opener.css";
+@import "table/table.css";
 @import "game/game.css";
 @import "helps/helps.css";
 @import "legend/legend.css";

package/dist/page/table/table.css

@@ -0,0 +1,123 @@
+/* The chat's window (D-107): narrow, a row for each host, its button with the tick of the one at the table and its model and effort under their titles,
+   their columns shared through the subgrid; the command to type instead */
+.dialog:has(> .chat-hosts) {
+    width: min(460px, calc(100vw - 32px));
+}
+
+.chat-hosts {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) auto auto;
+    gap: 6px;
+    margin: 8px 0 12px;
+}
+
+.chat-head,
+.chat-host {
+    display: grid;
+    grid-column: 1 / -1;
+    grid-template-columns: subgrid;
+}
+
+.chat-head {
+    color: var(--soft);
+    font-size: 12px;
+}
+
+.chat-host .choice {
+    min-width: 0;
+    font-size: 15px;
+    text-align: left;
+}
+
+.chat-host .choice span {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+}
+
+.chat-host .in-use {
+    flex: none;
+    width: 18px;
+    height: 18px;
+    color: var(--accent);
+}
+
+.chat-host .choice[aria-disabled="true"] {
+    border-color: var(--line);
+    opacity: 0.6;
+    cursor: default;
+}
+
+.chat-host select {
+    padding: 4px;
+    border: 1px solid var(--line);
+    border-radius: 6px;
+    background: var(--card);
+    color: var(--ink);
+    font: inherit;
+    font-size: 13px;
+}
+
+/* Empty, the state takes no room */
+.chat-state:empty {
+    display: none;
+}
+
+.chat-command {
+    color: var(--soft);
+    font-size: 12.5px;
+}
+
+/* Each command whole on its line; two families, so the browser does not shrink the monospace */
+.chat-command code {
+    font-family: ui-monospace, monospace;
+    white-space: nowrap;
+    user-select: all;
+}
+
+/* The note on a start again that waits, with its ↻ and ×; in a game with no chat at the table, a line that opens the chat's window */
+.table-note {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.table-note > span {
+    flex: 1;
+}
+
+.table-note .icon-button {
+    flex: none;
+    width: 30px;
+    height: 30px;
+}
+
+.over-board > .table-note button {
+    pointer-events: auto;
+}
+
+.no-chat-line {
+    display: inline-flex;
+    align-items: center;
+    padding: 0;
+    border: 0;
+    background: none;
+    color: inherit;
+    font: inherit;
+    text-align: left;
+    text-decoration: underline;
+    text-underline-offset: 3px;
+    cursor: pointer;
+}
+
+/* No chat at the table: a hollow ring before the AI's name, and before the line that says so */
+.no-chat {
+    flex: none;
+    width: 8px;
+    height: 8px;
+    margin-right: 5px;
+    border: 1.5px solid var(--soft);
+    border-radius: 50%;
+}

package/dist/page/table/window.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useEffect, useState } from "preact/hooks";
+import { Dialog } from "../dialogs/dialog.js";
+import { checkIcon } from "../dialogs/profiles.js";
+/** The chat's window: closed once a chat opens or starts again, the page then saying where it stands. */
+export function ChatDialog({ open, table, settings, onChange, name, onClose, text }) {
+    const [sending, setSending] = useState(false);
+    const [failed, setFailed] = useState(false);
+    useEffect(() => setFailed(false), [open]);
+    const words = text.table;
+    const installed = table.hosts.filter((host) => host.installed && host.name in choiceKeys);
+    // A chat opened by hand is the player's: Chesspal cannot start it again. Its rows stay readable, as the ones waiting.
+    const byHand = table.chat && !table.held;
+    const busy = sending || table.opening !== undefined || table.waiting === true;
+    const choose = async (host) => {
+        setSending(true);
+        setFailed(false);
+        const done = table.chat ? await restartChat(host) : await openChat(host);
+        setSending(false);
+        if (done) {
+            onClose();
+        }
+        else {
+            setFailed(true);
+        }
+    };
+    // While a chat opens or waits to start again, the rows wait too, and the note says why.
+    const note = installed.length === 0
+        ? words.install(name)
+        : busy
+            ? chatState(table, name, text) ?? words.choose
+            : byHand
+                ? words.byHand(name)
+                : table.chat
+                    ? words.restartHint
+                    : words.choose;
+    const offersChoices = installed.some((host) => host.models.length > 0 || host.efforts.length > 0);
+    // The chat at the table started with other choices than the ones kept now: its row starts it again with these, else it only closes the window.
+    const started = table.held ? table.started : undefined;
+    const changed = (host) => started !== undefined && (chosen(host, "model", settings) !== (started.model ?? "") || chosen(host, "effort", settings) !== (started.effort ?? ""));
+    return (_jsxs(Dialog, { open: open, title: words.title, onClose: onClose, text: text, children: [_jsx("p", { class: "note", children: note }), _jsxs("div", { class: "chat-hosts", role: "group", "aria-label": words.title, children: [offersChoices
+                        ? (_jsxs("div", { class: "chat-head", "aria-hidden": "true", children: [_jsx("span", {}), _jsx("span", { children: words.model }), _jsx("span", { children: words.effort })] }))
+                        : null, installed.map((host) => {
+                        const atTable = table.chat && table.host === host.name;
+                        const off = busy || byHand;
+                        const again = !atTable || changed(host);
+                        return (_jsxs("div", { class: "chat-host", children: [_jsxs("button", { class: "choice", type: "button", title: atTable && again ? words.restartChanged : undefined, "aria-current": atTable ? "true" : undefined, "aria-disabled": off, onClick: off ? undefined : again ? () => void choose(host.name) : onClose, children: [_jsx("span", { children: hostTitles[host.name] ?? host.name }), atTable ? (again ? restartIcon : checkIcon) : null] }), _jsx(Choice, { host: host, kind: "model", settings: settings, onChange: onChange, text: text }), _jsx(Choice, { host: host, kind: "effort", settings: settings, onChange: onChange, text: text })] }, host.name));
+                    })] }), _jsx("p", { class: "chat-state", role: "status", children: failed ? (table.chat ? words.notRestarted : words.failed) : null }), table.chat || installed.length === 0 ? null : (_jsxs("p", { class: "chat-command", children: [words.typeIt, " ", installed.map((host, index) => (_jsxs("span", { children: [index === 0 ? "" : " · ", _jsx("code", { children: host.command })] }, host.name)))] }))] }));
+}
+/** The AI's name on its card, which opens the chat's window: with no chat at the table, a hollow ring before it says so. */
+export function AiNameButton({ name, table, onOpen, text }) {
+    const title = table.chat ? text.table.change : text.table.noChat;
+    return (_jsxs("button", { class: "profile-name ai-name", type: "button", title: title, "aria-label": `${name}: ${title}`, "aria-haspopup": "dialog", onClick: onOpen, children: [table.chat ? null : _jsx("span", { class: "no-chat", "aria-hidden": "true" }), _jsx("span", { children: name }), _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M7 10L12 15L17 10" }) })] }));
+}
+/**
+ * The note on the chat at the table where the asleep note stands: one opening or starting again; one waiting to, with a ↻ that starts it at once and a ×
+ * that lets the request go; in a game with no chat at the table, a line that opens the chat's window. None otherwise.
+ */
+export function tableNote({ table, name, inGame, onOpen, text }) {
+    const words = text.table;
+    const state = chatState(table, name, text);
+    if (table.waiting === true) {
+        return (_jsxs("p", { class: "asleep table-note", role: "status", children: [_jsx("span", { children: state }), _jsx("button", { class: "icon-button", type: "button", title: words.restartNow, "aria-label": words.restartNow, onClick: () => void endWaiting(true), children: restartIcon }), _jsx("button", { class: "icon-button", type: "button", title: words.cancel, "aria-label": words.cancel, onClick: () => void endWaiting(false), children: _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M6 6L18 18M18 6L6 18" }) }) })] }));
+    }
+    if (state !== undefined) {
+        return _jsx("p", { class: "asleep", role: "status", children: state });
+    }
+    if (!table.chat && inGame) {
+        return (_jsx("p", { class: "asleep table-note", role: "status", children: _jsxs("button", { class: "no-chat-line", type: "button", "aria-haspopup": "dialog", onClick: onOpen, children: [_jsx("span", { class: "no-chat", "aria-hidden": "true" }), words.noChat] }) }));
+    }
+    return null;
+}
+/** What the page says of the chat at the table: one opening, starting again, or waiting to; nothing else. */
+export function chatState(table, name, text) {
+    const words = text.table;
+    if (table.waiting === true) {
+        return words.waiting(name);
+    }
+    return table.opening === "chat" ? words.opening : table.opening === "again" ? words.again(name) : table.opening === "restart" ? words.restart : undefined;
+}
+const hostTitles = { claude: "Claude Code", codex: "Codex" };
+// The settings that keep each host's choice.
+const choiceKeys = {
+    claude: { model: "claudeModel", effort: "claudeEffort" },
+    codex: { model: "codexModel", effort: "codexEffort" },
+};
+/** The ↻ of a chat that starts again. */
+const restartIcon = (_jsx("svg", { class: "icon in-use", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M19.5 12a7.5 7.5 0 1 1-2.2-5.3M19.5 4.5v4h-4" }) }));
+/** A host's model or effort as the settings keep it: "" for the host's own, and for a choice it no longer offers. */
+function chosen(host, kind, settings) {
+    const key = choiceKeys[host.name][kind];
+    const offered = kind === "model" ? host.models : host.efforts;
+    return offered.includes(settings[key]) ? settings[key] : "";
+}
+/** A host's model or effort: a dash keeps the host's own; a choice it no longer offers shows as the dash. Its title says what it stands at, the dash too. */
+function Choice({ host, kind, settings, onChange, text }) {
+    const key = choiceKeys[host.name][kind];
+    const offered = kind === "model" ? host.models : host.efforts;
+    const value = chosen(host, kind, settings);
+    const title = hostTitles[host.name] ?? host.name;
+    if (offered.length === 0) {
+        return _jsx("span", {});
+    }
+    return (_jsxs("select", { "aria-label": `${text.table[kind]}, ${title}`, title: `${text.table[kind]}: ${value === "" ? text.table.asHost(title) : value}`, value: value, onChange: (event) => onChange({ ...settings, [key]: event.currentTarget.value }), children: [_jsx("option", { value: "", children: "\u2014" }), offered.map((one) => _jsx("option", { value: one, children: shortName(one) }, one))] }));
+}
+// Codex's models without the "gpt-" they all start with, so the choice stays narrow; the title keeps the whole name.
+function shortName(value) {
+    return value.replace(/^gpt-/, "");
+}
+/** Asks the table to open a terminal with a chat in the host: whether it did. */
+function openChat(host) {
+    return asked("/api/table/chat", { host }, (answer) => answer.opened === true);
+}
+/** Asks the table to start at once the chat that waits to start again, cutting its answer, or to let the request go. */
+function endWaiting(now) {
+    return asked("/api/table/waiting", { now }, () => true);
+}
+/** Asks the table to start its chat again with the host, at once or once it has ended its answer: whether it took the request. */
+function restartChat(host) {
+    return asked("/api/table/restart", { host }, (answer) => answer.restarting === true || answer.waiting === true);
+}
+async function asked(path, body, done) {
+    try {
+        const response = await fetch(path, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+        return response.ok && done((await response.json()));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/page/talk/chat.css

@@ -55,10 +55,21 @@
     }
 }
 
-/* The AI's answers on the left, in its bubbles, without the tail that points at the Torretta: it is not by them */
+/* The AI's answers on the left, in its bubbles, each with a small Torretta at its foot instead of the tail that points at the big one: it is not by them (Stefano) */
 .sent li.from-ai {
     align-self: flex-start;
-    align-items: flex-start;
+    flex-direction: row;
+    align-items: flex-end;
+    gap: 6px;
+}
+
+.sent li.from-ai > .torretta {
+    flex: none;
+}
+
+/* The bubble's foot level with the Torretta's, spaced as the player's lines are */
+.sent li.from-ai > .say {
+    margin: 0;
 }
 
 .talk.studied .sent .say::before,

package/dist/page/talk/talk.js

@@ -60,7 +60,7 @@ export function Legend({ review, words }) {
 /**
  * The player's words of the game, the newest by the box they write in with how far it got, and the box: Enter or the button sends the words alone, the next
  * move takes them with it. 200 characters from one move of the AI's to the next: once they are written, the box goes until its move (D-54). In analysis the
- * AI's answers are in the same thread, and each line of the player's names the move it was written on (D-101).
+ * AI's answers are in the same thread, each by a small Torretta, and each line of the player's names the move it was written on (D-101).
  */
 export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, canMove, name, problem, about, text }) {
     const list = useRef(null);
@@ -76,7 +76,7 @@ export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, can
         }
     };
     return (_jsxs(_Fragment, { children: [_jsx("ol", { ref: list, class: "sent", "aria-live": "polite", children: inOrder(lines.map((line, index) => (_jsxs("li", { class: line.who === "ai" ? "from-ai" : undefined, style: about === undefined ? aged(lines.length - 1 - index) : reread(index, lastAnswer), children: [line.who === "ai"
-                            ? (_jsx("p", { class: "say", children: _jsx(Marked, { text: line.text }) }))
+                            ? (_jsxs(_Fragment, { children: [_jsx(Torretta, { size: 24 }), _jsx("p", { class: "say", children: _jsx(Marked, { text: line.text }) })] }))
                             : (_jsxs("p", { class: "said", children: [about === undefined || line.shown?.move === undefined ? null : _jsx(ShownMove, { move: line.shown.move, onShow: () => about.onShow(line.shown.at), text: text }), line.text] })), index === lastWritten ? _jsx(Status, { heard: line.heard, name: name, text: text }) : null] }, index))), newestFirst) }), left <= 0 ? null : (_jsxs("form", { class: about === undefined ? "compose" : "compose asking", onSubmit: (event) => {
                     event.preventDefault();
                     submit();

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];