chesspal 0.3.2 → 0.3.4

package/dist/page/app/app.js

@@ -43,7 +43,7 @@ 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 { ask, 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
@@ -71,12 +71,23 @@ export function App({ start }) {
     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 = () => {
+    // At the table with no chat, and none opening: what asks for the AI opens the chat's window first, to choose its host and model (D-107, D-109).
+    const chatMissing = () => {
         const table = offline ? undefined : served?.table;
-        const first = table !== undefined && !table.chat && table.opening === undefined;
+        return table !== undefined && !table.chat && table.opening === undefined;
+    };
+    // The chat's window opened for an analysis asks who reviews the game, not whom the player plays (Rosa, Zoe).
+    const [chatToReview, setChatToReview] = useState(false);
+    const askNewGame = () => {
+        const first = chatMissing();
         setChatFirst(first);
+        setChatToReview(false);
         setDialog(first ? "chat" : "new-game");
     };
+    const askChat = () => {
+        setChatToReview(false);
+        setDialog("chat");
+    };
     const closeChat = () => {
         setDialog(chatFirst ? "new-game" : undefined);
         setChatFirst(false);
@@ -302,6 +313,8 @@ export function App({ start }) {
     const summary = studied === undefined ? undefined : gameReviewOf(live.record);
     // An AI is going over the game only when the server says so: with no chat at it, nobody is (Stefano).
     const reviewing = summary === undefined && studied?.reviewing === true && !offline;
+    // With nobody at it, a review not finished says so, and the player brings the game back to the AI (D-109).
+    const completeIt = summary === undefined && studied?.incomplete === true && !offline ? () => void studyGame({ game: studied.name }) : undefined;
     const closing = studied === undefined ? undefined : closingOf(live.record);
     // In analysis the AI's card says who played that game, as its PGN keeps it (D-82), not who plays now.
     const playedBy = studied === undefined ? undefined : aiModelIn(live.record);
@@ -320,7 +333,7 @@ export function App({ start }) {
     // 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, 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 atTable = table === undefined ? null : tableNote({ table, name, inGame: going, onOpen: () => setDialog("chat"), text });
+    const atTable = table === undefined ? null : tableNote({ table, name, inGame: going, onOpen: askChat, text });
     const asleepNote = atTable !== null
         ? atTable
         : asleep && table?.chat !== false
@@ -402,15 +415,19 @@ 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, picture: 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.
+    // A game brought to analyse: the page shows it once the server has it in analysis; a refusal stays in the dialog. One the AI has to go over, with no
+    // chat at the table, opens the chat's window: the analyst works with the chat's model (D-109).
     const studyGame = async (studied) => {
-        const refused = await post("/api/study", studied, text, name);
-        if (refused === undefined) {
-            setDialog(undefined);
+        const sent = await ask("/api/study", studied, text, name);
+        if ("refused" in sent) {
+            return sent.refused.text;
         }
-        return refused?.text;
+        const toReview = sent.answer.reviewed === false && chatMissing();
+        setChatToReview(toReview);
+        setDialog(toReview ? "chat" : undefined);
+        return 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 }), served.update === undefined || served.table === 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", review: chatToReview, 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), onProfile: () => setDialog("profile"), you: profile.name, accounts: profile.accounts, ai: name, text: text }), served.update === undefined || served.table === undefined
                     ? null
                     : (_jsx(UpdateDialog, { open: dialog === "update", version: served.update.version, current: served.version, installing: served.update.installing === true, installed: served.update.installed === true, going: going, chat: served.table.chat ? (served.table.held ? "held" : "byHand") : undefined, name: name, onClose: () => setDialog(undefined), 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) })
@@ -419,11 +436,11 @@ export function App({ start }) {
                         : 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 } : {}), ...(reviewing ? { 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) => {
+                                ? (_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 } : {}), ...(reviewing ? { reviewing: true } : {}), ...(completeIt === undefined ? {} : { onComplete: completeIt }), 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: 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, 
+                                : (_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: askChat, 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);
@@ -434,7 +451,14 @@ export function App({ start }) {
                             // 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" && (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: { by: analyst, ...(summary === undefined ? {} : { summary }), ...(reviewing ? { reviewing: true } : {}) } }), 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 }), _jsx(PageFoot, { version: served.version, text: text })] })] }) }));
+                                    : 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: {
+                                    by: analyst,
+                                    ...(summary === undefined ? {} : { summary }),
+                                    ...(reviewing ? { reviewing: true } : {}),
+                                    ...(completeIt === undefined ? {} : { onComplete: completeIt }),
+                                },
+                            }), 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 }), _jsx(PageFoot, { version: served.version, 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/served.js

@@ -56,17 +56,22 @@ export function useServed(onNewGame) {
  * it sends the player, or undefined.
  */
 export async function post(path, body, text, name) {
+    const sent = await ask(path, body, text, name);
+    return "refused" in sent ? sent.refused : undefined;
+}
+/** Sends a request to the server as `post` does: its answer, or the reason it was refused. */
+export async function ask(path, body, text, name) {
     try {
         const response = await fetch(path, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
         if (response.ok) {
-            return undefined;
+            return { answer: await response.json().catch(() => ({})) };
         }
         const refused = (await response.json());
         const known = refused.refusal === undefined ? undefined : text.refused[refused.refusal];
-        return { text: known?.(refused.most ?? 0, name) ?? refused.error ?? response.statusText, words: refused.refusal?.startsWith("words-") === true };
+        return { refused: { text: known?.(refused.most ?? 0, name) ?? refused.error ?? response.statusText, words: refused.refusal?.startsWith("words-") === true } };
     }
     catch (error) {
-        return { text: String(error), words: false };
+        return { refused: { text: String(error), words: false } };
     }
 }
 /** Sends the player's move to the server, which plays it as the chat would, with the words written for the AI: the reason it was refused, or undefined. */

package/dist/page/dialogs/analyses.js

@@ -2,10 +2,12 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-ru
 // The list of the analyses (D-92): the games analysed or brought to study, found by a search, to open again, analyse again or delete, each row with its
 // menu over the dialog and the question it asks in its place.
 import { useEffect, useLayoutEffect, useRef, useState } from "preact/hooks";
+import { accountSide } from "../../core/index.js";
 import { ResultTile } from "../game/result-tile.js";
 import { signature } from "../players/model-name.js";
+import { OutcomeBadge, outcomeOf } from "./outcome.js";
 import { searched } from "./search.js";
-import { accountSide, playerIn, studiedSides } from "./studied.js";
+import { playerIn, studiedSides } from "./studied.js";
 /** The list, read anew at each opening: the search, the row that loads a game, then a row for each game found, with its menu or its question. */
 export function Analyses({ onStudy, onLoad, you, accounts, ai, text }) {
     const words = text.study;
@@ -109,15 +111,10 @@ function searchText(item, sides, outcome, text) {
     const went = outcome === undefined ? undefined : words.outcome[outcome];
     return [sides, item.aiModel?.model, by(item), item.annotator?.model, dayOf(item.date, text.language), item.opening, scoreOf(item.result), went, state].join(" ");
 }
-/** How a game went for the player, as chess.com marks it: a green square with a plus, a red one with a minus, a grey one with an equals sign. */
-function OutcomeBadge({ outcome, words }) {
-    return (_jsxs("svg", { class: `outcome ${outcome}`, viewBox: "0 0 16 16", role: "img", "aria-label": words.outcome[outcome], children: [_jsx("title", { children: words.outcome[outcome] }), _jsx("rect", { width: "16", height: "16", rx: "4" }), _jsx("path", { d: outcomeSigns[outcome] })] }));
-}
 /** A game the AI reviewed: its speech bubble, and the model that wrote the review when the tags say it. */
 function Reviewed({ by, words }) {
     return (_jsxs("span", { class: "state reviewed", title: by === undefined ? words.reviewed : `${words.reviewed}: ${by}`, children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", role: "img", "aria-label": words.reviewed, children: _jsx("path", { d: "M5 5H19V15.5H11L7 19.5V15.5H5Z" }) }), by === undefined ? null : _jsx("span", { children: by })] }));
 }
-const outcomeSigns = { won: "M5 8h6M8 5v6", lost: "M5 8h6", drawn: "M5 6.5h6M5 9.5h6" };
 /** The tags of a game listed that name its sides. */
 function tagsOf(item) {
     return { White: item.white, Black: item.black, ...(item.site === undefined ? {} : { Site: item.site }) };
@@ -130,13 +127,6 @@ function by(item) {
 function scoreOf(result) {
     return result === "1/2-1/2" ? "½–½" : result.replace("-", "–");
 }
-/** How a game went for the player: won, lost or drawn; nothing for a game without a result. */
-function outcomeOf(result, you) {
-    if (result === "1/2-1/2") {
-        return "drawn";
-    }
-    return result === "1-0" || result === "0-1" ? (result === "1-0") === (you === "white") ? "won" : "lost" : undefined;
-}
 /** A PGN date, 2026.11.04, as the player reads it: «4 nov», with the year when it is not this one. */
 function dayOf(date, language) {
     const [, year, month, day] = /^(\d{4})\.(\d{2})\.(\d{2})$/.exec(date ?? "") ?? [];

package/dist/page/dialogs/dialogs.css

@@ -839,6 +839,97 @@ h3 + .switch {
     cursor: pointer;
 }
 
+/* The latest games on the sites above the paste field (D-110): the analyses' rows, lower, with the side the player had on a small tile; the list takes the
+   height the step leaves at the foot of one screen and scrolls with no scrollbar, fading at its foot as the side column does (Zoe) */
+.site-games .games {
+    max-height: max(174px, calc(100vh - 500px));
+    padding-bottom: 12px;
+    overflow-y: auto;
+    overscroll-behavior: contain;
+    scrollbar-width: none;
+    mask-image: linear-gradient(#000 calc(100% - 16px), transparent);
+}
+
+.site-games .games::-webkit-scrollbar {
+    display: none;
+}
+
+/* While the list comes, a box as tall as it will be, so that nothing moves when it arrives */
+.site-games .asking {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    height: max(174px, calc(100vh - 500px));
+    border: 1px dashed var(--line);
+    border-radius: 10px;
+    color: var(--soft);
+    font-size: 14px;
+}
+
+.analyses.site-games .reopen {
+    gap: 10px;
+    min-height: 52px;
+    padding-left: 8px;
+}
+
+.site-games .reopen:focus-visible {
+    outline-offset: -2px;
+    border-radius: 9px;
+}
+
+.analyses.site-games .tile {
+    width: 34px;
+    height: 34px;
+    border-radius: 7px;
+}
+
+.analyses.site-games .tile .piece {
+    width: 28px;
+    height: 28px;
+}
+
+/* The row picked keeps the accent and a spinner in its mark's place; the others wait, faded as a button that cannot be pressed */
+.site-games .game.picked {
+    border-color: var(--accent);
+}
+
+.site-games .picking .game:not(.picked) {
+    opacity: 0.6;
+}
+
+.site-games .reopen:disabled {
+    cursor: default;
+}
+
+.site-games .score .spinner {
+    justify-self: center;
+}
+
+.site-games > .site-problem {
+    margin: 0 0 8px;
+}
+
+.site-games > .none {
+    margin: 4px 0;
+    text-align: left;
+}
+
+.site-games .add-names {
+    margin-left: 4px;
+    padding: 4px 10px;
+    border: 1px solid var(--line);
+    border-radius: 8px;
+    background: var(--card);
+    color: var(--ink);
+    font: inherit;
+    cursor: pointer;
+}
+
+.site-games .add-names:hover {
+    border-color: var(--accent);
+}
+
 .ask button.yes {
     border-color: var(--asked);
     background: var(--asked);
@@ -882,6 +973,17 @@ h3 + .switch {
     .analyses .ask {
         grid-template-columns: 1fr;
     }
+
+    /* On a phone the mark alone tells how it went, and the meta drops the site */
+    .site-games .score b,
+    .site-games .meta .site {
+        display: none;
+    }
+
+    .analyses.site-games .score {
+        grid-template-columns: 16px;
+        min-width: 0;
+    }
 }
 
 .profile-form textarea:focus-visible,

package/dist/page/dialogs/outcome.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+/** How a game went for the player, as chess.com marks it: a green square with a plus, a red one with a minus, a grey one with an equals sign. */
+export function OutcomeBadge({ outcome, words }) {
+    return (_jsxs("svg", { class: `outcome ${outcome}`, viewBox: "0 0 16 16", role: "img", "aria-label": words.outcome[outcome], children: [_jsx("title", { children: words.outcome[outcome] }), _jsx("rect", { width: "16", height: "16", rx: "4" }), _jsx("path", { d: outcomeSigns[outcome] })] }));
+}
+/** How a game went for the player: won, lost or drawn; nothing for a game without a result. */
+export function outcomeOf(result, you) {
+    if (result === "1/2-1/2") {
+        return "drawn";
+    }
+    return result === "1-0" || result === "0-1" ? (result === "1-0") === (you === "white") ? "won" : "lost" : undefined;
+}
+const outcomeSigns = { won: "M5 8h6M8 5v6", lost: "M5 8h6", drawn: "M5 6.5h6M5 9.5h6" };

package/dist/page/dialogs/site-games.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-runtime";
+// The player's latest games on Lichess and Chess.com (D-110), above the paste field: a row each, which brings that game to study as a pasted PGN would.
+import { useEffect, useState } from "preact/hooks";
+import { Piece } from "../pieces/pieces.js";
+import { OutcomeBadge, outcomeOf } from "./outcome.js";
+/**
+ * The list, asked of the server when the step opens and the profile has a name on a site. `picked` is the game being sent, whose row keeps the accent and
+ * a spinner while the others wait; `problem`, why the server refused it, shown under the list; `onProfile` opens the profile, where the names go.
+ */
+export function SiteGameList({ accounts, picked, problem, onPick, onProfile, text }) {
+    const words = text.study;
+    const named = accounts?.lichess !== undefined || accounts?.chesscom !== undefined;
+    const answer = useSiteGames(named, words.siteGamesRefused);
+    if (!named) {
+        return (_jsxs("div", { class: "field analyses site-games", children: [_jsx("span", { children: words.siteGames }), _jsxs("p", { class: "none", children: [`${words.siteGamesNoAccount} `, _jsx("button", { class: "add-names", type: "button", onClick: onProfile, children: words.siteGamesProfile })] })] }));
+    }
+    return (_jsxs("div", { class: "field analyses site-games", children: [_jsx("span", { children: words.siteGames }), answer === undefined
+                ? (_jsxs("div", { class: "asking", role: "status", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), words.siteGamesLoading] }))
+                : "refusal" in answer
+                    ? _jsx("p", { class: "site-problem", children: answer.refusal })
+                    : (_jsxs(_Fragment, { children: [_jsx(SiteProblems, { answer: answer, text: text }), answer.games.length === 0
+                                ? (answer.answered.length === 0 ? null : _jsx("p", { class: "none", children: words.siteGamesNone }))
+                                : (_jsx("ul", { class: `games${picked === undefined ? "" : " picking"}`, "aria-label": words.siteGames, children: answer.games.map((game) => _jsx(GameRow, { game: game, picked: picked, onPick: onPick, text: text }, game.name)) })), problem === undefined ? null : _jsx("p", { class: "problem", role: "alert", children: problem })] }))] }));
+}
+const siteNames = { "lichess": "Lichess", "chess.com": "Chess.com" };
+/** The sites that did not answer, both in one line, and those without a player by the profile's name, in the profile window's words. */
+function SiteProblems({ answer, text }) {
+    const silent = answer.unreached.length === 2 ? [text.study.bothUnreached] : answer.unreached.map((site) => text.profile.unreached(siteNames[site]));
+    return (_jsxs(_Fragment, { children: [silent.map((line) => _jsx("p", { class: "site-problem unreached", children: line }, line)), answer.unknown.map((site) => _jsx("p", { class: "site-problem", children: text.profile.notFound(siteNames[site]) }, site))] }));
+}
+/** A game's row: the side the player had, the opponent and their rating, when, how fast and how long, the site, the result and how it went for the player. */
+function GameRow({ game, picked, onPick, text }) {
+    const words = text.study;
+    const rated = (name, rating) => rating === undefined ? name : `${name} (${rating})`;
+    const white = rated(game.white, game.whiteRating);
+    const black = rated(game.black, game.blackRating);
+    const opponent = game.player === undefined ? `${white} – ${black}` : game.player === "white" ? black : white;
+    const outcome = game.player === undefined ? undefined : outcomeOf(game.result, game.player);
+    const chosen = picked === game.name;
+    return (_jsx("li", { class: `game${chosen ? " picked" : ""}`, children: _jsxs("button", { class: "reopen", type: "button", disabled: picked !== undefined, onClick: () => onPick(game), children: [game.player === undefined ? null : (_jsx("span", { class: "tile", role: "img", title: words.playedAs[game.player], "aria-label": words.playedAs[game.player], children: _jsx(Piece, { letter: game.player === "white" ? "K" : "k" }) })), _jsxs("span", { class: "what", children: [_jsx("b", { class: "who", children: opponent }), _jsxs("span", { class: "meta", children: [[whenOf(game.played, text.language), words.speed(game.speed), words.moves(game.moves)].join(" · "), _jsx("span", { class: "site", children: ` · ${siteNames[game.site]}` })] })] }), _jsxs("span", { class: "score", children: [_jsx("b", { children: scoreOf(game.result) }), chosen ? _jsx("span", { class: "spinner", "aria-hidden": "true" }) : outcome === undefined ? _jsx("span", {}) : _jsx(OutcomeBadge, { outcome: outcome, words: words })] })] }) }));
+}
+/** When a game ended, in the player's time: «11 nov, 18:26», with the year when it is not this one. */
+function whenOf(played, language) {
+    const when = new Date(played);
+    const day = when.toLocaleDateString(language, { day: "numeric", month: "short", ...(when.getFullYear() === new Date().getFullYear() ? {} : { year: "numeric" }) });
+    return `${day}, ${when.toLocaleTimeString(language, { hour: "2-digit", minute: "2-digit" })}`;
+}
+/** A result as the row shows it: 1–0, 0–1 or ½–½. */
+function scoreOf(result) {
+    return result === "1/2-1/2" ? "½–½" : result.replace("-", "–");
+}
+/** The list asked of the server once, when there is a name to ask by: none while it comes; a refusal in the player's words when the server gives its code. */
+function useSiteGames(asked, refused) {
+    const [answer, setAnswer] = useState(undefined);
+    useEffect(() => {
+        if (!asked) {
+            return;
+        }
+        void fetch("/api/site-games")
+            .then(async (response) => {
+            if (response.ok) {
+                return await response.json();
+            }
+            const { error, refusal } = (await response.json());
+            return { refusal: (refusal === undefined ? undefined : refused[refusal]) ?? error ?? response.statusText };
+        })
+            .catch((error) => ({ refusal: error.message }))
+            .then(setAnswer);
+    }, [asked]);
+    return answer;
+}

package/dist/page/dialogs/studied.js

@@ -1,3 +1,6 @@
+// The players of a game in analysis (D-69), as the page shows them: a game played here names them Player and AI, one played elsewhere by their names; the
+// player's own, by their names on Lichess and chess.com (D-93).
+import { accountSide } from "../../core/index.js";
 /** The player's side in a game in analysis: none when they played neither side, or both. */
 export function playerIn(sides) {
     const white = sides.white.who === "player";
@@ -23,17 +26,3 @@ export function studiedSides(tags, you, ai, sides, accounts) {
     const black = sideOf("black");
     return { white, black, bottom: black.who === "player" && white.who !== "player" ? "black" : "white" };
 }
-/**
- * The side a game loaded from elsewhere names by one of the player's names on the sites (D-93): the one of its site when the Site tag says Lichess or
- * chess.com, either otherwise; none when neither side, or both, has one.
- */
-export function accountSide(tags, accounts) {
-    const site = (tags.Site ?? "").toLowerCase();
-    const names = [
-        site.includes("chess.com") ? undefined : accounts?.lichess,
-        site.includes("lichess") ? undefined : accounts?.chesscom,
-    ].filter((name) => name !== undefined).map((name) => name.trim().toLowerCase());
-    const white = names.includes(tags.White?.trim().toLowerCase() ?? "");
-    const black = names.includes(tags.Black?.trim().toLowerCase() ?? "");
-    return white === black ? undefined : white ? "white" : "black";
-}

package/dist/page/dialogs/study.js

@@ -1,14 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
-// The dialog of the analyses (D-92): the list of the games analysed or brought to study, and a step that loads a game played elsewhere as a PGN, pasted or
-// read from a file, which the server keeps to study and puts in analysis.
+// The dialog of the analyses (D-92): the list of the games analysed or brought to study, and a step that loads a game played elsewhere, one of the latest
+// on the sites (D-110) or a PGN pasted or read from a file, which the server keeps to study and puts in analysis.
 import { useEffect, useRef, useState } from "preact/hooks";
 import { Analyses } from "./analyses.js";
 import { Dialog } from "./dialog.js";
+import { SiteGameList } from "./site-games.js";
 /**
  * The dialog the header's button opens; `onStudy` sends the choice and gives back why the server refused it, or undefined once it took it. The games played
  * here name their sides as their analysis does: the player by `you`, the AI by its model when the game keeps it (D-82), else by `ai`.
  */
-export function StudyDialog({ open, onStudy, onClose, you, accounts, ai, text }) {
+export function StudyDialog({ open, onStudy, onClose, onProfile, you, accounts, ai, text }) {
     const [loading, setLoading] = useState(false);
     // Each opening starts from the list.
     useEffect(() => {
@@ -16,14 +17,17 @@ export function StudyDialog({ open, onStudy, onClose, you, accounts, ai, text })
             setLoading(false);
         }
     }, [open]);
-    return (_jsx(Dialog, { open: open, title: loading ? text.study.bring : text.study.title, onBack: loading ? () => setLoading(false) : undefined, onClose: onClose, text: text, children: loading ? _jsx(LoadForm, { onStudy: onStudy, text: text }) : _jsx(Analyses, { onStudy: onStudy, onLoad: () => setLoading(true), you: you, accounts: accounts, ai: ai, text: text }) }));
+    return (_jsx(Dialog, { open: open, title: loading ? text.study.bring : text.study.title, onBack: loading ? () => setLoading(false) : undefined, onClose: onClose, text: text, children: loading ? _jsx(LoadForm, { onStudy: onStudy, onProfile: onProfile, accounts: accounts, text: text }) : _jsx(Analyses, { onStudy: onStudy, onLoad: () => setLoading(true), you: you, accounts: accounts, ai: ai, text: text }) }));
 }
-/** The step that loads a game played elsewhere: its PGN pasted, or read from a file. */
-function LoadForm({ onStudy, text }) {
+/** The step that loads a game played elsewhere: one of the latest on the sites, or its PGN pasted, or read from a file. */
+function LoadForm({ onStudy, onProfile, accounts, text }) {
     const words = text.study;
     const [pgn, setPgn] = useState("");
     const [problem, setProblem] = useState(undefined);
     const [sending, setSending] = useState(false);
+    // The game of the sites being sent, and why the server refused the last one picked, said under the list.
+    const [picked, setPicked] = useState(undefined);
+    const [pickRefused, setPickRefused] = useState(undefined);
     const field = useRef(null);
     // With a mouse only: on a phone the keyboard would cover the step.
     useEffect(() => {
@@ -31,6 +35,23 @@ function LoadForm({ onStudy, text }) {
             field.current?.focus();
         }
     }, []);
+    const send = (sent) => {
+        setSending(true);
+        setPickRefused(undefined);
+        void onStudy({ pgn: sent }).then((refused) => {
+            setSending(false);
+            setProblem(refused);
+        });
+    };
+    const pick = (game) => {
+        setPicked(game.name);
+        setPickRefused(undefined);
+        setProblem(undefined);
+        void onStudy({ pgn: game.pgn }).then((refused) => {
+            setPicked(undefined);
+            setPickRefused(refused);
+        });
+    };
     const read = (file) => {
         void file?.text().then((read) => {
             setPgn(read);
@@ -39,13 +60,9 @@ function LoadForm({ onStudy, text }) {
     };
     return (_jsxs("form", { class: "profile-form study", onSubmit: (event) => {
             event.preventDefault();
-            setSending(true);
-            void onStudy({ pgn }).then((refused) => {
-                setSending(false);
-                setProblem(refused);
-            });
-        }, children: [_jsxs("label", { class: "field", children: [_jsx("span", { children: words.paste }), _jsx("textarea", { ref: field, rows: 10, value: pgn, spellcheck: false, placeholder: '[White "…"]\n[Black "…"]\n\n1. e4 e5 2. Nf3 …', onInput: (event) => {
+            send(pgn);
+        }, children: [_jsx(SiteGameList, { accounts: accounts, picked: picked, problem: pickRefused, onPick: pick, onProfile: onProfile, text: text }), _jsxs("label", { class: "field", children: [_jsx("span", { children: words.paste }), _jsx("textarea", { ref: field, rows: 4, value: pgn, spellcheck: false, placeholder: '[White "…"]\n[Black "…"]\n\n1. e4 e5 2. Nf3 …', onInput: (event) => {
                             setPgn(event.currentTarget.value);
                             setProblem(undefined);
-                        } })] }), _jsxs("label", { class: "field file", children: [_jsx("span", { children: words.file }), _jsx("input", { type: "file", accept: ".pgn,application/x-chess-pgn,text/plain", onChange: (event) => read(event.currentTarget.files?.[0]) })] }), _jsx("p", { class: "note", children: words.note }), problem === undefined ? null : _jsx("p", { class: "problem", role: "alert", children: problem }), _jsx("button", { class: "start", type: "submit", disabled: pgn.trim() === "" || sending, children: words.start })] }));
+                        } })] }), _jsxs("label", { class: "field file", children: [_jsx("span", { children: words.file }), _jsx("input", { type: "file", accept: ".pgn,application/x-chess-pgn,text/plain", onChange: (event) => read(event.currentTarget.files?.[0]) })] }), _jsx("p", { class: "note", children: words.note }), problem === undefined ? null : _jsx("p", { class: "problem", role: "alert", children: problem }), _jsx("button", { class: "start", type: "submit", disabled: pgn.trim() === "" || sending || picked !== undefined, children: words.start })] }));
 }

package/dist/page/game/column.js

@@ -14,7 +14,7 @@ export function GameColumn({ plies, result, how, lit, started, move, toMove, ope
     const bar = standings === undefined ? undefined : _jsx(LeadBar, { standing: standingAt(standings, shownPlies), shown: shownPlies, text: text });
     return (_jsx("aside", { class: "side", id: "game", "aria-label": text.game, children: started === undefined && analysis === undefined
             ? (_jsxs(_Fragment, { children: [_jsx("p", { class: "card empty", children: text.noGame }), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseLast, onAnalyse: onAnalyse })] }))
-            : (_jsxs(_Fragment, { children: [_jsxs("div", { class: "side-cards", children: [_jsx(GameCard, { plies: plies, result: result, how: how, lit: lit, started: started, move: move, toMove: toMove, bar: bar, text: text }), analysis === undefined || standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: shownPlies, onShow: onShow, text: text }), opening === undefined ? null : _jsx(OpeningCard, { opening: opening, text: text }), helps, analysis?.reviewing !== true ? null : (_jsxs("p", { class: "card review waiting", role: "status", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(analysis.by)] }))] }), _jsxs("div", { class: "side-foot", children: [result !== undefined && plies.length === 0 ? null : _jsx(MoveList, { plies: plies, result: result, shown: shownPlies, onShow: onShow, tools: legend, text: text }), onDownload === undefined && onSaveMoves === undefined ? null : (_jsxs("div", { class: "card analysis-actions", children: [onDownload === undefined ? null : _jsx(SaveButton, { label: text.study.download, hint: text.study.downloadHint, onSave: onDownload }), onSaveMoves === undefined ? null : _jsx(SaveButton, { label: text.saveMoves, hint: text.saveMovesHint, onSave: onSaveMoves })] })), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseIt, onAnalyse: onAnalyse }), _jsx(Steps, { shown: shownPlies, total: plies.length, onStep: onStep, text: text })] })] })) }));
+            : (_jsxs(_Fragment, { children: [_jsxs("div", { class: "side-cards", children: [_jsx(GameCard, { plies: plies, result: result, how: how, lit: lit, started: started, move: move, toMove: toMove, bar: bar, text: text }), analysis?.reviewing !== true ? null : (_jsxs("p", { class: "card review waiting", role: "status", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(analysis.by)] })), analysis?.onComplete === undefined ? null : (_jsxs("div", { class: "card review incomplete", children: [_jsx("p", { role: "status", children: text.incomplete }), _jsx("button", { type: "button", title: text.completeHint, "aria-label": text.completeHint, onClick: analysis.onComplete, children: text.complete })] })), analysis === undefined || standings === undefined ? null : _jsx(LeadChart, { plies: plies, standings: standings, shown: shownPlies, onShow: onShow, text: text }), opening === undefined ? null : _jsx(OpeningCard, { opening: opening, text: text }), helps] }), _jsxs("div", { class: "side-foot", children: [result !== undefined && plies.length === 0 ? null : _jsx(MoveList, { plies: plies, result: result, shown: shownPlies, onShow: onShow, tools: legend, text: text }), onDownload === undefined && onSaveMoves === undefined ? null : (_jsxs("div", { class: "card analysis-actions", children: [onDownload === undefined ? null : _jsx(SaveButton, { label: text.study.download, hint: text.study.downloadHint, onSave: onDownload }), onSaveMoves === undefined ? null : _jsx(SaveButton, { label: text.saveMoves, hint: text.saveMovesHint, onSave: onSaveMoves })] })), onAnalyse === undefined ? null : _jsx(AnalyseButton, { label: text.study.analyseIt, onAnalyse: onAnalyse }), _jsx(Steps, { shown: shownPlies, total: plies.length, onStep: onStep, text: text })] })] })) }));
 }
 /** A button that saves the game as a file in the player's downloads, its tooltip saying what the file holds. */
 function SaveButton({ label, hint, onSave }) {

package/dist/page/game/game.css

@@ -320,6 +320,27 @@
     color: var(--soft);
 }
 
+/* A review nobody is finishing: the note, and beside it the button that brings the game back to the AI (D-109); neutral, as no error (Zoe) */
+.review.incomplete,
+.say.incomplete {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    margin: 0;
+    color: var(--soft);
+}
+
+.review.incomplete button,
+.say.incomplete button {
+    flex: none;
+}
+
+/* On the bubble's tint the button keeps the card's ground, to read as one */
+.say.incomplete button {
+    background: var(--card);
+}
+
 .review ul {
     margin: 0;
     padding-left: 18px;
@@ -497,7 +518,8 @@
     padding: 8px;
 }
 
-.analysis-actions button {
+.analysis-actions button,
+.incomplete button {
     flex: 1;
     display: inline-flex;
     align-items: center;
@@ -513,7 +535,8 @@
     cursor: pointer;
 }
 
-.analysis-actions button:hover {
+.analysis-actions button:hover,
+.incomplete button:hover {
     border-color: var(--accent);
 }
 

package/dist/page/guide/en.md

@@ -54,6 +54,7 @@ No chess engine plays for the AI: every move and every judgment is its own. Ches
 
 - When the game is over, press **Analyse the game**: the AI goes over it and puts its judgments and notes on the moves. Read them by stepping through the moves with the arrows at the foot of the column, or by clicking a move.
 - **Analyses**, in the header, opens your analyses, and loads a game played elsewhere: paste its PGN, or choose a .pgn file.
+- With your names on Lichess and Chess.com in your profile, **Load a game** lists your latest games there: click one to analyse it.
 - Ask the AI about the game in the box under its name.
 - **Annotated PGN** saves the game with its comments.
 

package/dist/page/guide/it.md

@@ -54,6 +54,7 @@ Nessun motore di scacchi gioca al posto dell'AI: ogni mossa e ogni giudizio sono
 
 - A partita finita premi **Analizza la partita**: l'AI la ripassa e mette sulle mosse i suoi giudizi e le sue note. Le leggi scorrendo le mosse con le frecce in fondo alla colonna, o cliccando una mossa.
 - **Analisi**, nell'intestazione, apre le tue analisi e carica una partita giocata altrove: incolla il suo PGN, o scegli un file .pgn.
+- Con i tuoi nomi su Lichess e Chess.com nel profilo, **Carica una partita** elenca le tue ultime partite là: clicca su una per analizzarla.
 - Chiedi all'AI della partita nella casella sotto il suo nome.
 - **PGN annotato** salva la partita coi commenti.