chesspal 0.1.0 → 0.2.0

package/dist/page/{talk.js → talk/talk.js}

@@ -1,34 +1,25 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "preact/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-runtime";
 // The talk on the board page (D-51, D-53): the AI's words in bubbles that point at the Torretta, the player's above the box they write in.
 import { createContext } from "preact";
 import { useContext, useEffect, useLayoutEffect, useRef } from "preact/hooks";
-import { BadgeIcon, NoteIcon } from "./badges.js";
-import { signature } from "./model-name.js";
-import { Figurines } from "./move-list.js";
-import { talkLimits } from "./plies.js";
-import { Torretta } from "./torretta.js";
+import { Torretta } from "../avatars/torretta.js";
+import { BadgeIcon, NoteIcon } from "../game/badges.js";
+import { Figurines } from "../game/move-list.js";
+import { talkLimits } from "../game/plies.js";
+import { signature } from "../players/model-name.js";
 import { hush, speak } from "./voice.js";
-/**
- * The AI's words of the game, a bubble each, the newest by the Torretta: below it, or above it on a board turned round; the first points at it. With the helps
- * on, its judgment of the player's last move comes newest, in a line that opens on its note (D-78).
- */
-export function AiWords({ words, newestFirst, voice, judged, text }) {
+/** The AI's words of the game, a bubble each, the newest by the Torretta: below it, or above it on a board turned round; the first points at it. */
+export function AiWords({ words, newestFirst, voice }) {
     const list = useRef(null);
     useOnlyWhole(list, words, newestFirst);
     useSpokenNews(words, voice);
-    const says = (_jsx("ol", { ref: list, class: "says", "aria-live": "polite", children: inOrder(words.map((word, index) => (_jsx("li", { class: "say", style: aged(words.length - 1 - index), children: _jsx(Marked, { text: word }) }, index))), newestFirst) }));
-    // The judgment sits by the Torretta, out of the bubbles' order: it never pushes the AI's words away.
-    if (judged === undefined) {
-        return says;
-    }
-    const line = _jsx(Judged, { ply: judged, text: text });
-    return newestFirst ? _jsxs(_Fragment, { children: [line, says] }) : _jsxs(_Fragment, { children: [says, line] });
+    return (_jsx("ol", { ref: list, class: "says", "aria-live": "polite", children: inOrder(words.map((word, index) => (_jsx("li", { class: "say", style: aged(words.length - 1 - index), children: _jsx(Marked, { text: word }) }, index))), newestFirst) }));
 }
 /**
  * The AI's word on the move shown of a game in analysis (D-69), in a bubble that points down at the Torretta beside the AI's name: the move, its badge by name,
  * and its note when it wrote one; read out as the player steps through the game. The Torretta and the name stay when the move has no word.
  */
-export function AiNote({ ply, opening, closing, summary, name, by, mood, voice, text }) {
+export function AiNote({ ply, opening, closing, summary, reviewing, name, by, mood, voice, text }) {
     // On a move of the book without the AI's note, the AI reports what the book says: the opening in the title, the variation under it.
     const book = ply?.review?.note === undefined ? opening : undefined;
     const shown = ply?.review ?? (book === undefined ? undefined : { badge: "book" });
@@ -42,13 +33,9 @@ export function AiNote({ ply, opening, closing, summary, name, by, mood, voice,
         return hush;
     }, [spoken, voice]);
     // The Torretta stays in sight through the whole analysis, under its bubbles, which show only where it wrote something.
-    return (_jsxs("div", { class: "ai-note", "aria-live": "polite", children: [ply === undefined || shown === undefined ? null : (_jsxs("p", { class: `say move-note ${shown.badge ?? ""}`, children: [_jsxs("span", { class: "head", children: [shown.badge === undefined ? _jsx(NoteIcon, {}) : _jsx(BadgeIcon, { badge: shown.badge }), _jsxs("b", { children: [_jsxs("span", { class: "visually-hidden", children: [ply.number, ply.side === "white" ? "." : "...", ply.san] }), _jsxs("span", { "aria-hidden": "true", children: [_jsxs("span", { class: "move-number", children: [ply.number, ply.side === "white" ? "." : "..."] }), _jsx(Figurines, { san: ply.san, side: ply.side })] })] }), " ", title] }), note === undefined ? null : (_jsx("span", { class: "note", children: _jsx(Marked, { text: note }) })), shown.arrows === undefined && shown.squares === undefined ? null : _jsx(Legend, { review: shown, text: text })] })), summary === undefined ? null : _jsx(GameReview, { by: name, summary: summary, text: text }), closing === undefined ? null : (_jsx("p", { class: "say closing", children: _jsx(Marked, { text: closing }) })), _jsxs("p", { class: "who", children: [_jsx(Torretta, { size: 36, mood: mood }), _jsxs("span", { class: "signed", children: [name, by === undefined ? null : _jsx("small", { children: signature(by.annotator, by.effort) })] })] })] }));
-}
-/** The AI's judgment of the player's move, with the helps on: its badge and the move in a line, which opens on its note (D-78). */
-function Judged({ ply, text }) {
-    const { badge, note } = ply.review ?? {};
-    const head = (_jsxs(_Fragment, { children: [badge === undefined ? _jsx(NoteIcon, {}) : _jsx(BadgeIcon, { badge: badge }), _jsxs("b", { children: [_jsxs("span", { class: "move-number", children: [ply.number, ply.side === "white" ? "." : "..."] }), _jsx(Figurines, { san: ply.san, side: ply.side })] }), " ", badge === undefined ? null : text.badges[badge]] }));
-    return (_jsx("div", { class: `say move-note judged ${badge ?? ""}`, children: note === undefined ? _jsx("span", { class: "head", children: head }) : (_jsxs("details", { children: [_jsx("summary", { class: "head", children: head }), _jsx("span", { class: "note", children: _jsx(Marked, { text: note }) })] })) }));
+    return (_jsxs("div", { class: "ai-note", "aria-live": "polite", children: [ply === undefined || shown === undefined ? null : (_jsxs("p", { class: `say move-note ${shown.badge ?? ""}`, children: [_jsxs("span", { class: "head", children: [shown.badge === undefined ? _jsx(NoteIcon, {}) : _jsx(BadgeIcon, { badge: shown.badge }), _jsxs("b", { children: [_jsxs("span", { class: "visually-hidden", children: [ply.number, ply.side === "white" ? "." : "...", ply.san] }), _jsxs("span", { "aria-hidden": "true", children: [_jsxs("span", { class: "move-number", children: [ply.number, ply.side === "white" ? "." : "..."] }), _jsx(Figurines, { san: ply.san, side: ply.side })] })] }), " ", title] }), note === undefined ? null : (_jsx("span", { class: "note", children: _jsx(Marked, { text: note }) })), shown.arrows === undefined && shown.squares === undefined ? null : _jsx(Legend, { review: shown, words: text.drawn })] })), summary === undefined ? null : _jsx(GameReview, { by: name, summary: summary, text: text }), closing === undefined ? null : (_jsx("p", { class: "say closing", children: _jsx(Marked, { text: closing }) })), reviewing === true
+                ? (_jsxs("p", { class: "say reviewing", children: [_jsx("span", { class: "spinner", "aria-hidden": "true" }), text.reviewing(name)] }))
+                : null, _jsxs("p", { class: "who", children: [_jsx(Torretta, { size: 36, mood: mood }), _jsxs("span", { class: "signed", children: [name, by === undefined ? null : _jsx("small", { children: signature(by.annotator, by.effort) })] })] })] }));
 }
 /** The squares and moves in the AI's words, such as e3, Cxe4, 7.Nd4 or O-O: in bold, as the player looks for them on the board. */
 export function Marked({ text }) {
@@ -57,31 +44,18 @@ export function Marked({ text }) {
             ? (_jsx("b", { children: _jsx(OnBoard, { text: part }) }, index))
             : _jsx(OnBoard, { text: part }, index)) }));
 }
-/** Where the pointer is among the squares and moves in the AI's words (T-111): the board lights that square up. */
+/** Where the pointer is among the squares and moves in the AI's words: the board lights that square up. */
 export const PointSquare = createContext(() => undefined);
-function OnBoard({ text }) {
-    const point = useContext(PointSquare);
-    return (_jsx(_Fragment, { children: text.split(boardWords).map((part, index) => index % 2 === 1
-            ? _jsx("b", { class: "on-board", onPointerEnter: () => point(squareIn(part)), onPointerLeave: (event) => event.pointerType === "mouse" && point(undefined), children: part }, index)
-            : part) }));
-}
-/** The square a word names: a square, or where a move goes, the last square in it; none for a castling. */
-function squareIn(word) {
-    return /[a-h][1-8](?!.*[a-h][1-8])/.exec(word)?.[0];
-}
 // **a few words** the AI put in bold, as Markdown writes them.
 const boldWords = /\*\*(.+?)\*\*/;
 // A square or a move in SAN or with the pieces' figurines (D-86, D-87), with its number if it has one; the capture group keeps it in split's parts.
 const boardWords = /(?<![\p{L}\d])((?:\d+\.(?:\.\.)?\s?)?(?:O-O(?:-O)?|[KQRBN♔-♟]?[a-h]?[1-8]?x?[a-h][1-8](?:=[QRBN♔-♟])?)[+#]?[!?]{0,2})(?![\p{L}\d])/u;
-/** The AI's word on the whole game (D-69), in the Torretta's bubble at the start of the game: a paragraph, and its points as a list. */
-function GameReview({ by, summary, text }) {
-    const [lead = "", ...points] = summary.split(/\s*•\s+/);
-    return (_jsxs("section", { class: "say review", "aria-label": text.reviewBy(by), children: [_jsxs("p", { class: "head", children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M12 4V20M8 20H16M5 7H19M5 7L2.5 13A2.5 2 0 0 0 7.5 13ZM19 7L16.5 13A2.5 2 0 0 0 21.5 13Z" }) }), text.reviewBy(by)] }), lead === "" ? null : (_jsx("p", { children: _jsx(Marked, { text: lead }) })), points.length === 0 ? null : (_jsx("ul", { children: points.map((point, index) => (_jsx("li", { children: _jsx(Marked, { text: point }) }, index))) }))] }));
-}
-/** What the colours drawn with a note mean, the ones it uses: the AI's legend, for the player (D-69). */
-function Legend({ review, text }) {
+/**
+ * What the colours drawn with a note or the coach's hint mean, the ones it uses, in the words of who drew them: the legend, for the player (D-69, Zoe).
+ */
+export function Legend({ review, words }) {
     const used = [...new Set([...(review.arrows ?? []), ...(review.squares ?? [])].map((drawn) => drawn.colour))];
-    return (_jsx("span", { class: "legend", children: used.map((colour) => (_jsxs("span", { class: colour, children: [_jsx("i", { "aria-hidden": "true" }), text.drawn[colour]] }, colour))) }));
+    return (_jsx("span", { class: "legend", children: used.map((colour) => (_jsxs("span", { class: colour, children: [_jsx("i", { "aria-hidden": "true" }), words[colour]] }, colour))) }));
 }
 /**
  * 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
@@ -110,12 +84,31 @@ export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, can
                                 : _jsx("span", { class: "hint", children: !blank && canMove ? text.withMove : "" }), _jsxs("button", { class: "send", type: "submit", disabled: blank, children: [text.send, _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M5 12H18M13 7L18 12L13 17" }) })] })] })] }))] }));
 }
 /**
- * The talk narrowed to a card beside the board (T-84): the Torretta above, the player below, each with their name and side written down the card, a ring on
+ * The talk narrowed to a card beside the board: the Torretta above, the player below, each with their name and side written down the card, a ring on
  * whoever moves and a dot on the Torretta when the AI spoke meanwhile.
  */
 export function TalkFaces({ name, aiPicture, you, picture, ai, player, aiMoves, playerMoves, unread, text }) {
     return (_jsxs("div", { class: "faces", children: [_jsx(RailPlayer, { place: "ai", picture: aiPicture ?? _jsx(Torretta, { size: 40 }), name: name, ...(ai === undefined ? {} : { side: text.sides[ai] }), moves: aiMoves, unread: unread }), _jsx(RailPlayer, { place: "you", picture: picture, name: you, ...(player === undefined ? {} : { side: text.sides[player] }), moves: playerMoves })] }));
 }
+function OnBoard({ text }) {
+    const point = useContext(PointSquare);
+    return (_jsx(_Fragment, { children: text.split(boardWords).map((part, index) => index % 2 === 1
+            ? (_jsx("b", { class: "on-board", onPointerEnter: () => point(squareIn(part)), onPointerLeave: (event) => event.pointerType === "mouse" && point(undefined), children: _jsx(Takes, { move: part }) }, index))
+            : part) }));
+}
+/** A move with its capture's x light, as the move list writes it: the piece and the squares stand out (Stefano, for readers with ADHD). */
+function Takes({ move }) {
+    return _jsx(_Fragment, { children: move.split("x").map((part, index) => index === 0 ? part : [_jsx("span", { class: "takes", children: "x" }, index), part]) });
+}
+/** The square a word names: a square, or where a move goes, the last square in it; none for a castling. */
+function squareIn(word) {
+    return /[a-h][1-8](?!.*[a-h][1-8])/.exec(word)?.[0];
+}
+/** The AI's word on the whole game (D-69), in the Torretta's bubble at the start of the game: a paragraph, and its points as a list. */
+function GameReview({ by, summary, text }) {
+    const [lead = "", ...points] = summary.split(/\s*•\s+/);
+    return (_jsxs("section", { class: "say review", "aria-label": text.reviewBy(by), children: [_jsxs("p", { class: "head", children: [_jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M12 4V20M8 20H16M5 7H19M5 7L2.5 13A2.5 2 0 0 0 7.5 13ZM19 7L16.5 13A2.5 2 0 0 0 21.5 13Z" }) }), text.reviewBy(by)] }), lead === "" ? null : (_jsx("p", { children: _jsx(Marked, { text: lead }) })), points.length === 0 ? null : (_jsx("ul", { children: points.map((point, index) => (_jsx("li", { children: _jsx(Marked, { text: point }) }, index))) }))] }));
+}
 function RailPlayer({ place, picture, name, side, moves, unread = false }) {
     return (_jsxs("div", { class: `rail-player ${place}${moves ? " moving" : ""}`, children: [_jsx("span", { class: `face${unread ? " unread" : ""}`, children: picture }), _jsxs("span", { class: "rail-name", children: [name, " ", side === undefined ? null : _jsxs("span", { class: "note", children: ["\u00B7 ", side] })] })] }));
 }

package/dist/page/text.js

@@ -31,6 +31,7 @@ const english = {
     marksColour: "Arrows and marked squares",
     play: "Play",
     dots: "Dots on the legal moves",
+    squareNames: "The square's name under the pointer",
     explain: "Explain the moves refused",
     bookBadges: "Mark the book moves",
     helps: "The AI teaches as you play",
@@ -39,7 +40,7 @@ const english = {
     names: {
         nitida: "Nitida",
         torretta: "Torretta",
-        cburnett: "cburnett",
+        capablanca: "Capablanca",
         azzurro: "Blue",
         verde: "Green",
         noce: "Walnut",
@@ -61,7 +62,10 @@ const english = {
     moves: "Moves",
     steps: { first: "Start", back: "Previous move", forward: "Next move", last: "Back to the game" },
     noGame: "No game yet: press + to start one, or ask for one in the chat.",
-    saveMoves: "Save the moves (PGN)",
+    foldCard: "Fold the card",
+    openCard: "Open the card",
+    saveMoves: "Moves-only PGN",
+    saveMovesHint: "The moves alone, to open on Lichess or chess.com",
     noGameNow: "No game in progress",
     analysing: "Analysis in progress",
     badges: {
@@ -78,6 +82,18 @@ const english = {
     },
     reviewBy: (name) => `${name}'s review`,
     drawn: { green: "better", red: "threat", yellow: "another way", blue: "plan" },
+    lead: {
+        hint: "Who is ahead, in pawns, as the AI estimates it: Chesspal does not compute it",
+        chart: "How the game went",
+        chartHint: "Who was ahead move by move, as the AI estimated it: click to go to that move",
+        even: "Even",
+        none: "No estimate yet",
+        earlier: "Estimated before the last move",
+        drawn: "Drawn on the board",
+        ahead: (side, pawns) => `${side === "white" ? "White" : "Black"} ahead by ${pawns} pawns`,
+        mate: (side, moves) => `${side === "white" ? "White" : "Black"} mates in ${moves}`,
+        mated: (side) => `${side === "white" ? "White" : "Black"} is mated`,
+    },
     reviewing: (name) => `${name} is going over the game…`,
     you: "You",
     ai: "AI",
@@ -108,8 +124,10 @@ const english = {
     canGo: "a legal move",
     boardLabel: (turn, lastMove) => `Chessboard, ${english.toMove(turn)}${lastMove === undefined ? "" : `, last move ${lastMove}`}`,
     clearChat: (name) => `Before a new game, clear your chat with ${name}: in the window where you opened ${name}, not here, write /clear, then a message such as "new game". A clean chat plays faster.`,
+    outdated: (name) => `Chesspal has been updated, but this folder still has its old files: close the chat with ${name}, run chesspal init in this folder, and open a new chat.`,
     offline: (name) => `${name} is not connected. Write it a message in the window where you opened ${name}, not in this page's chat: the page connects again by itself.`,
     startClocks: "Start",
+    thinking: { move: "Thinking about its move", ponder: "Thinking while you play" },
     asleep: (name) => `${name} is not listening: write a message, such as "hi", in the window where you opened ${name}, not here. Its clock waits until it answers.`,
     commandHere: (name) => `/clear and the other commands go in the window where you opened ${name}, not here.`,
     refused: {
@@ -183,6 +201,8 @@ const english = {
         yourPicture: "Your picture: change it",
         avatars: { "short-hair": "Short hair", bun: "Bun", glasses: "Glasses", beanie: "Beanie", beard: "Beard", curls: "Curls", moustache: "Moustache", "silver-bob": "Silver bob", cat: "Cat", owl: "Owl" },
         whilePlaying: "Finish the game, or resign, before changing player.",
+        username: "your username",
+        accountTitle: "With your name there, a game you load from there knows which side is yours.",
         badImage: "That picture won't open: try another photo (the ones from a phone usually work).",
     },
     start: {
@@ -208,21 +228,45 @@ const english = {
         note: "The game is kept to study; the AI goes over it with you in the chat.",
         start: "Analyse",
         yours: "Your analyses",
-        bring: "Bring a game",
+        bring: "Load a game",
+        bringNote: "a PGN played elsewhere, pasted or from a file",
+        search: "Names, models, openings…",
+        noMatch: "No game found",
         reviewed: "reviewed",
         unreviewed: "to review",
         moves: (count) => `${count} ${count === 1 ? "move" : "moves"}`,
-        download: "Save PGN",
+        outcome: { won: "won", lost: "lost", drawn: "drawn" },
+        more: "More",
+        redo: "Analyse again",
+        redoNote: "with your chat's model and effort",
+        unreview: "Delete the analysis",
+        unreviewNote: "the game stays, to review",
+        remove: "Delete the game",
+        askRedo: (game, by) => ({
+            question: `Analyse ${game} again?`,
+            note: `${by === undefined ? "The review" : `The review by ${by}`} is deleted; your chat's analyst writes it again, with the model and effort it has now.`,
+            yes: "Analyse again",
+        }),
+        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",
+        download: "Annotated PGN",
+        downloadHint: "The game with the review's comments and judgments",
         analyseIt: "Analyse the game",
         analyseLast: "Analyse the last game",
     },
     helpsCard: {
         title: "Helps",
+        coach: "The coach",
+        showHint: "Show hint",
+        hideHint: "Hide hint",
+        drawn: { green: "idea", red: "threat", yellow: "line", blue: "target" },
         tactics: "Tactics",
         strategy: "Strategy",
         map: "Map",
         mapHint: "Hold it, or the M key, to see who controls each square; on a phone, a touch turns it on and off",
-        hold: "hold",
+        bare: "Hide the drawings",
+        bareHint: "Hold it to see the board without the arrows, the marked squares and the helps' signs; on a phone, a touch hides them and shows them again",
         attackers: "attackers",
         defenders: "defenders",
         undefended: "no defender",
@@ -231,8 +275,20 @@ const english = {
         pinnedTo: (letter) => `pinned to the ${englishNames[letter]}`,
         pinnedBy: (letter) => `by the ${englishNames[letter]}`,
         nothingAtRisk: "No piece at risk, no pins.",
-        checks: (side, toMove) => `${side === "white" ? "White" : "Black"}'s checks${toMove ? "" : `, if it were ${side === "white" ? "White" : "Black"}'s move`}`,
+        line: (kind, side, you, toMove) => {
+            const name = side === "white" ? "White" : "Black";
+            if (you === undefined) {
+                return kind === "risk" ? `${name}'s pieces at risk` : kind === "pin" ? `${name}'s pinned pieces` : `${name}'s checks${toMove ? "" : `, if it were ${name}'s move`}`;
+            }
+            if (kind === "check") {
+                return side === you ? `Checks you ${toMove ? "can" : "could"} give` : `Checks the opponent ${toMove ? "can" : "could"} give you`;
+            }
+            return `${side === you ? "Your" : "The opponent's"} ${kind === "risk" ? "pieces at risk" : "pinned pieces"}`;
+        },
         loose: "Pieces neither attacked nor defended",
+        yours: "yours",
+        theirs: "the opponent's",
+        you: "(you)",
         white: "White",
         black: "Black",
         rows: {
@@ -248,14 +304,17 @@ const english = {
             bishopPair: ["Bishop pair", "Both bishops still on the board."],
             space: ["Space (squares in the enemy's half)", "How many squares of the enemy's half one's pieces attack."],
             undeveloped: ["Minor pieces not developed", "Knights and bishops still on their first squares."],
-            castled: ["Castling", "How it castled; not yet while it still can, no more once the king or the rooks have moved."],
+            castled: ["Castling", "How it castled; a dash while it still can, a cross once the king or the rooks have moved."],
             kingAttacks: ["Enemy attacks around the king", "How many enemy attacks fall on the squares next to the king."],
         },
+        groups: { pawns: "Pawns", pieces: "Pieces", king: "King" },
         yes: "yes",
         notYet: "not yet",
         noMore: "no more",
-        phases: { opening: "opening", middlegame: "middlegame", endgame: "endgame" },
-        openFiles: (files) => `Open files: ${files}`,
+        phases: { opening: "Opening", middlegame: "Middlegame", endgame: "Endgame" },
+        openFiles: "Open files",
+        control: "Squares controlled",
+        both: "both",
         controlled: (white, black, both) => `Squares only White's ${white}, only Black's ${black}, both ${both}`,
         oppositeBishops: "Bishops of opposite colours",
         repetitions: (times) => `This position has stood ${times} times`,
@@ -291,6 +350,7 @@ const italian = {
     marksColour: "Frecce e case segnate",
     play: "Gioco",
     dots: "Pallini sulle mosse legali",
+    squareNames: "Il nome della casa sotto il puntatore",
     explain: "Spiega le mosse vietate",
     bookBadges: "Segna le mosse da libro",
     helps: "L'AI ti insegna mentre giochi",
@@ -299,7 +359,7 @@ const italian = {
     names: {
         nitida: "Nitida",
         torretta: "Torretta",
-        cburnett: "cburnett",
+        capablanca: "Capablanca",
         azzurro: "Azzurro",
         verde: "Verde",
         noce: "Noce",
@@ -321,7 +381,10 @@ const italian = {
     moves: "Mosse",
     steps: { first: "Inizio", back: "Mossa precedente", forward: "Mossa successiva", last: "Torna alla partita" },
     noGame: "Nessuna partita: premi + per iniziarne una, o chiedila nella chat.",
-    saveMoves: "Scarica le mosse (PGN)",
+    foldCard: "Chiudi la scheda",
+    openCard: "Apri la scheda",
+    saveMoves: "PGN solo mosse",
+    saveMovesHint: "Solo le mosse, da aprire su Lichess o chess.com",
     noGameNow: "Nessuna partita in corso",
     analysing: "Analisi in corso",
     badges: {
@@ -338,6 +401,18 @@ const italian = {
     },
     reviewBy: (name) => `Il giudizio di ${name}`,
     drawn: { green: "meglio", red: "minaccia", yellow: "altra via", blue: "piano" },
+    lead: {
+        hint: "Chi è avanti, in pedoni, secondo la stima dell'AI: Chesspal non lo calcola",
+        chart: "Andamento della partita",
+        chartHint: "Chi era avanti mossa per mossa, secondo la stima dell'AI: clicca per andare a quella mossa",
+        even: "Pari",
+        none: "Ancora nessuna stima",
+        earlier: "Stimata prima dell'ultima mossa",
+        drawn: "Patta sulla scacchiera",
+        ahead: (side, pawns) => `Il ${side === "white" ? "Bianco" : "Nero"} è avanti di ${pawns} pedoni`,
+        mate: (side, moves) => `Il ${side === "white" ? "Bianco" : "Nero"} dà matto in ${moves}`,
+        mated: (side) => `Matto al ${side === "white" ? "Bianco" : "Nero"}`,
+    },
     reviewing: (name) => `${name} sta analizzando la partita…`,
     you: "Tu",
     ai: "AI",
@@ -368,8 +443,10 @@ const italian = {
     canGo: "mossa possibile",
     boardLabel: (turn, lastMove) => `Scacchiera, ${italian.toMove(turn)}${lastMove === undefined ? "" : `, ultima mossa ${lastMove}`}`,
     clearChat: (name) => `Prima di una nuova partita azzera la conversazione con ${name}: nella finestra dove hai aperto ${name}, non qui, scrivi /clear e poi un messaggio, per esempio "nuova partita". Con la chat pulita l'AI gioca più veloce.`,
+    outdated: (name) => `Chesspal è stato aggiornato, ma questa cartella ha ancora i file di prima: chiudi la chat con ${name}, esegui chesspal init in questa cartella e apri una chat nuova.`,
     offline: (name) => `${name} è scollegato. Scrivigli un messaggio nella finestra dove hai aperto ${name}, non nella chat di questa pagina: la pagina si ricollega da sola.`,
     startClocks: "Inizia",
+    thinking: { move: "Sta pensando alla sua mossa", ponder: "Pensa mentre giochi tu" },
     asleep: (name) => `${name} non ti sta ascoltando: scrivi un messaggio, per esempio "ciao", nella finestra dove hai aperto ${name}, non qui. Il suo orologio aspetta che risponda.`,
     commandHere: (name) => `/clear e gli altri comandi vanno scritti nella finestra dove hai aperto ${name}, non qui.`,
     refused: {
@@ -444,6 +521,8 @@ const italian = {
         yourPicture: "La tua immagine: cambiala",
         avatars: { "short-hair": "Capelli corti", bun: "Chignon", glasses: "Occhiali", beanie: "Berretto", beard: "Barba", curls: "Ricci", moustache: "Baffi", "silver-bob": "Caschetto grigio", cat: "Gatto", owl: "Gufo" },
         whilePlaying: "Finisci la partita, o abbandona, prima di cambiare giocatore.",
+        username: "il tuo nome utente",
+        accountTitle: "Col tuo nome lì, una partita che carichi da lì sa qual è la tua parte.",
         badImage: "Questa immagine non si apre: prova con un'altra foto (quelle del telefono di solito vanno bene).",
     },
     start: {
@@ -469,31 +548,67 @@ const italian = {
         note: "La partita resta tra quelle da studiare; l'AI la commenta con te nella chat.",
         start: "Analizza",
         yours: "Le tue analisi",
-        bring: "Porta una partita",
+        bring: "Carica una partita",
+        bringNote: "un PGN giocato altrove, incollato o da file",
+        search: "Nomi, modelli, aperture…",
+        noMatch: "Nessuna partita trovata",
         reviewed: "commentata",
         unreviewed: "da commentare",
         moves: (count) => `${count} ${count === 1 ? "mossa" : "mosse"}`,
-        download: "Scarica PGN",
+        outcome: { won: "vinta", lost: "persa", drawn: "patta" },
+        more: "Altro",
+        redo: "Rifai l'analisi",
+        redoNote: "con il modello e l'effort della tua chat",
+        unreview: "Elimina l'analisi",
+        unreviewNote: "la partita resta, da commentare",
+        remove: "Elimina la partita",
+        askRedo: (game, by) => ({
+            question: `Rifare l'analisi di ${game}?`,
+            note: `${by === undefined ? "L'analisi" : `L'analisi di ${by}`} si cancella; la rifà l'analista della tua chat, col modello e l'effort che ha ora.`,
+            yes: "Rifai",
+        }),
+        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",
+        download: "PGN annotato",
+        downloadHint: "La partita con i commenti e i giudizi della revisione",
         analyseIt: "Analizza la partita",
         analyseLast: "Analizza l'ultima partita",
     },
     helpsCard: {
         title: "Aiuti",
+        coach: "L'allenatore",
+        showHint: "Mostra il suggerimento",
+        hideHint: "Nascondi il suggerimento",
+        drawn: { green: "idea", red: "minaccia", yellow: "linea", blue: "obiettivo" },
         tactics: "Tattica",
         strategy: "Strategia",
         map: "Mappa",
         mapHint: "Tienilo premuto, o tieni premuto il tasto M, per vedere chi controlla ogni casa; sul telefono un tocco la accende e la spegne",
-        hold: "tieni premuto",
+        bare: "Nascondi i disegni",
+        bareHint: "Tienilo premuto per vedere la scacchiera senza frecce, case segnate e segni degli aiuti; sul telefono un tocco li nasconde e li rimostra",
         attackers: "attaccanti",
         defenders: "difensori",
         undefended: "nessun difensore",
-        cheaper: "un attaccante vale meno",
+        cheaper: "un attaccante vale meno di lui",
         outnumbered: "più attaccanti che difensori",
         pinnedTo: (letter) => `davanti ${italianWith("a", letter)}`,
         pinnedBy: (letter) => italianWith("da", letter),
         nothingAtRisk: "Nessun pezzo in pericolo, nessuna inchiodatura.",
-        checks: (side, toMove) => `Scacchi del ${side === "white" ? "Bianco" : "Nero"}${toMove ? "" : ", se toccasse a lui"}`,
+        line: (kind, side, you, toMove) => {
+            const name = side === "white" ? "Bianco" : "Nero";
+            if (you === undefined) {
+                return kind === "risk" ? `Pezzi del ${name} in pericolo` : kind === "pin" ? `Pezzi del ${name} inchiodati` : `Scacchi del ${name}${toMove ? "" : ", se toccasse a lui"}`;
+            }
+            if (kind === "check") {
+                return side === you ? `Scacchi che ${toMove ? "puoi" : "potresti"} dare` : `Scacchi che l'avversario ${toMove ? "può" : "potrebbe"} darti`;
+            }
+            return `${side === you ? "I tuoi pezzi" : "I pezzi avversari"} ${kind === "risk" ? "in pericolo" : "inchiodati"}`;
+        },
         loose: "Pezzi né attaccati né difesi",
+        yours: "tuoi",
+        theirs: "avversari",
+        you: "(tu)",
         white: "Bianco",
         black: "Nero",
         rows: {
@@ -509,14 +624,17 @@ const italian = {
             bishopPair: ["Coppia degli alfieri", "Tutti e due gli alfieri ancora sulla scacchiera."],
             space: ["Spazio (case nella metà avversaria)", "Quante case della metà avversaria attaccano i propri pezzi."],
             undeveloped: ["Pezzi minori non sviluppati", "Cavalli e alfieri ancora sulle case di partenza."],
-            castled: ["Arrocco", "Come ha arroccato; non ancora finché può farlo, non più quando il re o le torri si sono già mossi."],
+            castled: ["Arrocco", "Come ha arroccato; un trattino finché può ancora farlo, una croce quando il re o le torri si sono già mossi."],
             kingAttacks: ["Attacchi nemici attorno al re", "Quanti attacchi nemici cadono sulle case accanto al re."],
         },
+        groups: { pawns: "Pedoni", pieces: "Pezzi", king: "Re" },
         yes: "sì",
         notYet: "non ancora",
         noMore: "non più",
-        phases: { opening: "apertura", middlegame: "mediogioco", endgame: "finale" },
-        openFiles: (files) => `Colonne aperte: ${files}`,
+        phases: { opening: "Apertura", middlegame: "Mediogioco", endgame: "Finale" },
+        openFiles: "Colonne aperte",
+        control: "Case controllate",
+        both: "tutti e due",
         controlled: (white, black, both) => `Case solo del Bianco ${white}, solo del Nero ${black}, di tutti e due ${both}`,
         oppositeBishops: "Alfieri di colore contrario",
         repetitions: (times) => `Questa posizione si è vista ${times} volte`,