chesspal 0.3.3 → 0.3.4

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/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.
 

package/dist/page/helps/helps.css

@@ -622,41 +622,49 @@
     gap: 10px;
 }
 
-/* The three phases in a row, joined by a thin line; the current one in a pill */
+/* The three phases in a row of arrows, each set in the next: the current one full in the accent, those gone by in its tint, those to come unlit */
 .phases {
     display: flex;
-    align-items: center;
     margin: 0;
     padding: 0;
     list-style: none;
     font-size: 12px;
+    line-height: 22px;
+    text-align: center;
     color: var(--soft);
 }
 
+.phases li {
+    flex: 1;
+    padding: 0 6px 0 12px;
+    background: color-mix(in srgb, var(--soft) 14%, transparent);
+    white-space: nowrap;
+    clip-path: polygon(0 0, calc(100% - 8px) 0, 100% 50%, calc(100% - 8px) 100%, 0 100%, 8px 50%);
+}
+
 .phases li + li {
-    flex: 1 1 auto;
-    display: flex;
-    align-items: center;
-    gap: 6px;
-    margin-left: 6px;
+    margin-left: -5px;
 }
 
-.phases li + li::before {
-    content: "";
-    flex: 1;
-    height: 1px;
-    background: var(--line);
+.phases li:first-child {
+    padding-left: 8px;
+    border-radius: 5px 0 0 5px;
+    clip-path: polygon(0 0, calc(100% - 8px) 0, 100% 50%, calc(100% - 8px) 100%, 0 100%);
 }
 
-.phases li span {
-    padding: 1px 9px;
-    white-space: nowrap;
+.phases li:last-child {
+    border-radius: 0 5px 5px 0;
+    clip-path: polygon(0 0, 100% 0, 100% 100%, 0 100%, 8px 50%);
 }
 
-.phases li[aria-current="step"] span {
-    border-radius: 999px;
-    background: color-mix(in srgb, var(--accent) 20%, transparent);
+.phases li.done {
+    background: color-mix(in srgb, var(--accent) 24%, transparent);
     color: var(--ink);
+}
+
+.phases li[aria-current="step"] {
+    background: var(--accent);
+    color: var(--on-accent);
     font-weight: 700;
 }
 

package/dist/page/helps/helps.js

@@ -184,9 +184,9 @@ function squaresIn(line) {
     }
     return [line.white, line.black].flatMap((cell) => typeof cell === "object" ? cell.filter((item) => /^[a-h][1-8]$/.test(item)) : []);
 }
-/** The game's three phases in a row, the current one in a pill. */
+/** The game's three phases in a row of arrows: the current one full, those gone by lit, those to come not. */
 function Phases({ current, words }) {
-    return (_jsx("ol", { class: "phases", children: phases.map((phase) => (_jsx("li", { "aria-current": phase === current ? "step" : undefined, children: _jsx("span", { children: words.phases[phase] }) }, phase))) }));
+    return (_jsx("ol", { class: "phases", children: phases.map((phase, at) => (_jsx("li", { class: at < phases.indexOf(current) ? "done" : undefined, "aria-current": phase === current ? "step" : undefined, children: words.phases[phase] }, phase))) }));
 }
 /** The squares only one side controls and those both do, in a bar as long as their counts, the player's side on the left; each part's title says it in words. */
 function ControlBar({ controlled, sides, you, words }) {

package/dist/page/text.js

@@ -303,7 +303,7 @@ const english = {
         start: "Analyse",
         yours: "Your analyses",
         bring: "Load a game",
-        bringNote: "a PGN played elsewhere, pasted or from a file",
+        bringNote: "from Lichess or Chess.com, or a PGN pasted or from a file",
         search: "Names, models, openings…",
         noMatch: "No game found",
         reviewed: "reviewed",
@@ -324,6 +324,19 @@ const english = {
         askUnreview: (game) => ({ question: `Delete the analysis of ${game}?`, note: "Its badges, notes and the coach's judgments go; the game stays.", yes: "Delete" }),
         askRemove: (game, when) => ({ question: `Delete the game ${game}${when === undefined ? "" : ` of ${when}`}?`, note: "With its analysis. It cannot be undone.", yes: "Delete" }),
         cancel: "Cancel",
+        siteGames: "Your latest games on the sites",
+        siteGamesLoading: "Asking Lichess and Chess.com…",
+        siteGamesNone: "No finished game on the sites.",
+        siteGamesNoAccount: "Your names on Lichess and Chess.com bring your latest games here.",
+        siteGamesProfile: "Add them",
+        bothUnreached: "Lichess and Chess.com aren't answering: we'll try again later",
+        siteGamesRefused: {
+            "game-going": "A game is going on: finish it to bring another.",
+            "no-accounts": "Your profile names no account on Lichess or Chess.com.",
+            "no-network": "Chesspal cannot reach the sites from here.",
+        },
+        playedAs: { white: "You played White", black: "You played Black" },
+        speed: (name) => ({ ultraBullet: "ultrabullet", correspondence: "correspondence", daily: "daily" }[name] ?? readableSpeed(name)),
         download: "Annotated PGN",
         downloadHint: "The game with the review's comments and judgments",
         analyseIt: "Analyse the game",
@@ -716,7 +729,7 @@ const italian = {
         start: "Analizza",
         yours: "Le tue analisi",
         bring: "Carica una partita",
-        bringNote: "un PGN giocato altrove, incollato o da file",
+        bringNote: "da Lichess o Chess.com, o un PGN incollato o da file",
         search: "Nomi, modelli, aperture…",
         noMatch: "Nessuna partita trovata",
         reviewed: "commentata",
@@ -737,6 +750,19 @@ const italian = {
         askUnreview: (game) => ({ question: `Eliminare l'analisi di ${game}?`, note: "Bollini, note e giudizi dell'allenatore si cancellano; la partita resta.", yes: "Elimina" }),
         askRemove: (game, when) => ({ question: `Eliminare la partita ${game}${when === undefined ? "" : ` del ${when}`}?`, note: "Con la sua analisi. Non si può annullare.", yes: "Elimina" }),
         cancel: "Annulla",
+        siteGames: "Le tue ultime partite sui siti",
+        siteGamesLoading: "Chiedo a Lichess e Chess.com…",
+        siteGamesNone: "Nessuna partita finita sui siti.",
+        siteGamesNoAccount: "I tuoi nomi su Lichess e Chess.com portano qui le tue ultime partite.",
+        siteGamesProfile: "Aggiungili",
+        bothUnreached: "Lichess e Chess.com non rispondono: riproviamo più tardi",
+        siteGamesRefused: {
+            "game-going": "C'è una partita in corso: finiscila per portarne un'altra.",
+            "no-accounts": "Il tuo profilo non ha nomi su Lichess o Chess.com.",
+            "no-network": "Da qui Chesspal non raggiunge i siti.",
+        },
+        playedAs: { white: "Hai giocato col Bianco", black: "Hai giocato col Nero" },
+        speed: (name) => ({ ultraBullet: "ultrabullet", classical: "classica", correspondence: "per corrispondenza", daily: "per corrispondenza" }[name] ?? readableSpeed(name)),
         download: "PGN annotato",
         downloadHint: "La partita con i commenti e i giudizi della revisione",
         analyseIt: "Analizza la partita",
@@ -921,3 +947,7 @@ function moveInWords(words, move) {
 function capital(words) {
     return words.charAt(0).toUpperCase() + words.slice(1);
 }
+/** A speed the page does not know, as a word: ultraBullet as «ultra bullet». */
+function readableSpeed(name) {
+    return name.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+}

package/dist/server/mcp/mcp.js

@@ -191,10 +191,10 @@ function track(call) {
     void call.finally(() => running.delete(call));
     return call;
 }
-/** Every hint stated, since the spec reads a missing one as the worst case: everything is local, so no tool reaches the open world. */
+/** Every hint stated, since the spec reads a missing one as the worst case: everything is local, but for the tools that ask the sites the player plays on (D-110). */
 function toolConfig(command) {
     const readOnly = command.readOnly === true;
-    const annotations = { readOnlyHint: readOnly, destructiveHint: command.destructive === true, idempotentHint: readOnly || command.idempotent === true, openWorldHint: false };
+    const annotations = { readOnlyHint: readOnly, destructiveHint: command.destructive === true, idempotentHint: readOnly || command.idempotent === true, openWorldHint: command.openWorld === true };
     const meta = command.alwaysLoad ? { "anthropic/alwaysLoad": true } : undefined;
     // The SDK writes the draft's address in every schema: it says nothing to an AI, and costs tokens in every tool.
     return { description: command.description, inputSchema: z.looseObject({}).meta({ ...shownInput(command), $schema: undefined }), annotations, _meta: meta };

package/dist/server/page/analyses.d.ts

@@ -23,3 +23,8 @@ export interface AnalysisItem {
 export declare function analysesOf(home: string): AnalysisItem[];
 /** Answers the page's deletions, of a game or of its review alone, done as the command line does them: true when the request was one. */
 export declare function answerAnalyses(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
+/**
+ * Sends the player's latest games on the sites, as site_games gives them with their PGNs (D-110); its refusal as a 409, with the code the page says it by in
+ * its own words: a game going on, no name on the sites, no network.
+ */
+export declare function sendSiteGames(response: ServerResponse, served: Served): void;

package/dist/server/page/analyses.js

@@ -1,4 +1,4 @@
-import { bookOpening, deleteGame, deleteReview } from "../../commands/index.js";
+import { bookOpening, deleteGame, deleteReview, siteGames, SiteGamesRefused } from "../../commands/index.js";
 import { aiModelIn, annotatorOf, isReviewed, leadOf, reviewOf } from "../../core/index.js";
 import { archivedGame, archivedGames, gameInAnalysis, gameStemOf, keptGame, keptGames } from "../../games/index.js";
 import { gameFolder } from "../../profiles/index.js";
@@ -33,6 +33,23 @@ export function answerAnalyses(request, response, url, served) {
     });
     return true;
 }
+/**
+ * Sends the player's latest games on the sites, as site_games gives them with their PGNs (D-110); its refusal as a 409, with the code the page says it by in
+ * its own words: a game going on, no name on the sites, no network.
+ */
+export function sendSiteGames(response, served) {
+    runRoute(response, async () => {
+        try {
+            sendJson(response, 200, await siteGames.run({}, served.context));
+        }
+        catch (error) {
+            if (!(error instanceof SiteGamesRefused)) {
+                throw error;
+            }
+            sendJson(response, 409, { error: error.message, refusal: error.refusal });
+        }
+    });
+}
 const deletions = { "/api/delete-game": deleteGame, "/api/delete-review": deleteReview };
 function itemOf(name, read, taken) {
     let record;

package/dist/server/page/game.js

@@ -245,7 +245,7 @@ async function studyFromPage(request, response, served) {
     let brought;
     try {
         // Without what the chat was told: the analyst's instructions stay for the AI's own analyse_game.
-        const opened = last ? lastPlayed(served.context) : game === undefined ? kept(served, pgn) : namedGame(served.context, game);
+        const opened = last ? lastPlayed(served.context) : game === undefined ? await kept(served, pgn) : namedGame(served.context, game);
         reviewed = isReviewed(opened.record);
         brought = !reviewed && !look;
         // A game not yet reviewed is marked as brought, for status to ask the AI to go over it; one reviewed is ready, and the chat sleeps on.
@@ -377,8 +377,8 @@ function lastPlayed(context) {
     return { name, record };
 }
 /** A game brought as a PGN, kept to study as analyse_game keeps it: the one already kept when it is the same game, with its review. */
-function kept(served, pgn) {
-    analyseGame.run({ pgn }, served.context);
+async function kept(served, pgn) {
+    await analyseGame.run({ pgn }, served.context);
     return namedGame(served.context, gameInAnalysis(gameFolder(served.context.home())).game);
 }
 /** The longest PGN the page brings: a long game with its clocks, and the comments a site adds, which go. */

package/dist/server/page/page.js

@@ -9,7 +9,7 @@ import { forgetAnalyst, gameStamp, tableTalkStamp } from "../../games/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { Bell, bellProbe, pagePorts } from "../bell/index.js";
-import { analysesOf, answerAnalyses } from "./analyses.js";
+import { analysesOf, answerAnalyses, sendSiteGames } from "./analyses.js";
 import { answerChat } from "./attach.js";
 import { attachedSeen, chatSeenOf, pageContext } from "./chat.js";
 import { askNewGame, keepPosted, tellWatchers } from "./events.js";
@@ -131,6 +131,9 @@ function answer(request, response, served) {
     else if (path === "/api/analyses") {
         send(response, 200, json, JSON.stringify(analysesOf(served.context.home())));
     }
+    else if (path === "/api/site-games") {
+        sendSiteGames(response, served);
+    }
     else if (path === "/api/events") {
         keepPosted(request, response, served.watchers);
         // A page that opens reads the player's ratings again after a day (D-106).

package/dist/sites/chesscom.d.ts

@@ -1,4 +1,4 @@
 import type { SiteReading } from "../profiles/index.ts";
-import { type Fetch } from "./request.ts";
+import { type Fetch } from "./request/index.ts";
 /** What Chess.com says of a name: undefined when it could not be reached. */
 export declare function chesscomReading(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteReading | undefined>;

package/dist/sites/chesscom.js

@@ -1,5 +1,5 @@
 import { counted } from "./choice.js";
-import { askSite } from "./request.js";
+import { askSite } from "./request/index.js";
 /** What Chess.com says of a name: undefined when it could not be reached. */
 export async function chesscomReading(account, fetch, signal) {
     const statistics = await askSite(`https://api.chess.com/pub/player/${encodeURIComponent(account.toLowerCase())}/stats`, fetch, signal);

package/dist/sites/games/chesscom.d.ts

@@ -0,0 +1,4 @@
+import { type Fetch } from "../request/index.ts";
+import { type SiteGamesAnswer } from "./game.ts";
+/** What Chess.com gives of a name's latest games, the latest first. */
+export declare function chesscomGames(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteGamesAnswer>;