llm-chess-mcp 0.6.0 → 0.7.2

package/README.md

@@ -72,8 +72,11 @@ await server.close();
 The root API also exports `buildServer`, `GameStore`, `ChessError`,
 `ExplorerError`, the service/domain types needed to provide custom
 `AppServices`, and safe chess helpers including `parseImportedPgn`, `pgnOf`,
-and `snapshotChess`. New integrations should use the package root. Legacy
-`dist/` subpath imports remain available for compatibility.
+and `snapshotChess`. The package root is the supported public API. Deep imports
+under `dist/` are intentionally not exported and will fail with
+`ERR_PACKAGE_PATH_NOT_EXPORTED`; use named root exports instead.
+This removes the previous `dist/*` compatibility exports and is a breaking
+change for integrations that imported internal modules.
 
 `bodyTimeoutMs` limits HTTP body upload time; it is not a whole-tool deadline.
 The deprecated `requestTimeoutMs` alias remains supported when `bodyTimeoutMs`
@@ -173,7 +176,7 @@ codex mcp add llm-chess-mcp --command npx --args -y llm-chess-mcp --env LICHESS_
 | Tool | Description |
 |---|---|
 | `create_game` | Create a game (optionally from a FEN), returns `game_id` |
-| `delete_game` | Delete a game and free its session |
+| `delete_game` | Delete a process-shared game and free game capacity |
 | `game_state` | Authoritative state: FEN, turn, revision, check/mate/draw flags, history, last move, castling (optional ASCII) |
 | `game_play_move` | Play a move (SAN or UCI) — the only mutating tool, with stale-position guard |
 | `game_legal_moves` | All legal moves with metadata |
@@ -273,10 +276,11 @@ rejected:
 - Up to 1,000 games are retained per process; idle games expire after one hour.
 - `move_evaluate` accepts at most 10 moves per call.
 - Imported and exported PGNs are limited to 1 MiB, 256 headers, and 4,096
-  plies; stored game histories use the same ply limit. Imports also cap the
-  mainline and variations together at 32,768 structural elements and 16 KiB
-  per lexical token. Every variation is legality-checked; game state retains
-  the mainline. UTF-8 BOMs and standard escaped header values are supported.
+  plies; stored snapshots enforce the same byte, header, token, and ply resource
+  bounds. Imports also cap the mainline and variations together at 32,768
+  structural elements and 16 KiB per lexical token. Every variation is
+  legality-checked; game state retains the mainline. UTF-8 BOMs and standard
+  escaped header values are supported.
 - Custom FENs reject inconsistent castling/en-passant metadata and impossible
   pawn or promotion material.
 - Stockfish accepts up to 32 active or queued analyses. Maia runs at most two
@@ -284,13 +288,18 @@ rejected:
 - Lichess Explorer requests run one at a time and share 429 cooldowns.
 - HTTP retains at most 64 MCP sessions; sessions with no active request expire
   after 30 minutes. An open GET/SSE stream keeps its session active.
-- HTTP accepts bodies up to 2 MiB. After body parsing, it permits 16 concurrent
-  POST dispatches and downstream compute/network jobs process-wide, with two of
-  each per session. A separate bounded control lane keeps MCP cancellation
-  available when normal POST slots are full. Work keeps its slot after a raw
-  disconnect until it settles. HTTP
-  also caps connections at 128 and applies a 15-second body upload deadline
-  plus bounded header, socket, and keep-alive timeouts.
+- HTTP accepts bodies up to 2 MiB under normal body-parser capacity. Once those
+  parsers are full, an overflow request receives only a small, up-to-8 KiB
+  probe; only a complete MCP cancellation notification can proceed, and no
+  accepted parser is preempted. The listener's connection limit bounds overflow
+  probes. After body parsing, it permits 16 concurrent POST dispatches and
+  downstream compute/network jobs process-wide, with two of each per session.
+  A separate bounded control lane prioritizes MCP cancellation when normal
+  dispatch capacity is full. If an existing-session POST response closes before
+  it finishes, its session is closed and its work is aborted; an uncooperative
+  downstream operation still holds capacity until it settles. HTTP also caps
+  connections at 128 and applies a 15-second body upload deadline plus bounded
+  header, socket, and keep-alive timeouts.
 
 Programmatic users can override the HTTP limits through `HttpServerOptions`.
 These safeguards do not replace public-edge quotas: a public deployment must
@@ -303,7 +312,9 @@ its UCI queue boundary, drains queued work during shutdown, and rejects new
 analysis until teardown completes. Lichess fetch and retry waits abort
 immediately. Maia runs native inference in dedicated child processes; cancelling
 active work terminates its child, while queued cancellation is immediate. A raw
-HTTP disconnect alone is not a cancellation signal.
+response disconnect for an existing-session POST closes that session and aborts
+its work. Reconnect with a new session, then re-read the process-shared game
+state before retrying a move.
 
 ## Intents
 

package/dist/analysis-boundary.d.ts

@@ -0,0 +1,2 @@
+import type { SfLine } from "./domain.js";
+export declare function validateAnalysisLines(lines: readonly SfLine[], requestedMultipv: number): void;

package/dist/analysis-boundary.js

@@ -0,0 +1,49 @@
+import { MAX_MULTIPV, WDL_TOTAL } from "./domain.js";
+function validScore(value) {
+    return value === null || (typeof value === "number" && Number.isFinite(value));
+}
+function validWdl(value) {
+    return value === null ||
+        (Array.isArray(value) &&
+            value.length === 3 &&
+            value.every((count) => typeof count === "number" &&
+                Number.isSafeInteger(count) &&
+                count >= 0 &&
+                count <= WDL_TOTAL) &&
+            value[0] + value[1] + value[2] === WDL_TOTAL);
+}
+export function validateAnalysisLines(lines, requestedMultipv) {
+    if (!Number.isSafeInteger(requestedMultipv) ||
+        requestedMultipv < 1 ||
+        requestedMultipv > MAX_MULTIPV) {
+        throw new RangeError("invalid requested analysis multipv");
+    }
+    if (!Array.isArray(lines) || lines.length > requestedMultipv) {
+        throw new RangeError("analysis returned too many lines");
+    }
+    const ranks = new Set();
+    for (const line of lines) {
+        if (typeof line !== "object" ||
+            line === null ||
+            Array.isArray(line) ||
+            !Number.isSafeInteger(line.multipv) ||
+            line.multipv < 1 ||
+            line.multipv > requestedMultipv ||
+            ranks.has(line.multipv)) {
+            throw new RangeError("invalid analysis multipv rank");
+        }
+        ranks.add(line.multipv);
+        if (!validScore(line.scoreCp) || !validScore(line.scoreMate)) {
+            throw new RangeError("analysis line has an invalid score");
+        }
+        if (line.scoreCp !== null && line.scoreMate !== null) {
+            throw new RangeError("analysis line has conflicting scores");
+        }
+        if (!validWdl(line.wdl))
+            throw new RangeError("analysis line has invalid WDL");
+        if (!Array.isArray(line.pv) ||
+            !Array.from(line.pv).every((move) => typeof move === "string" && move.length > 0)) {
+            throw new RangeError("analysis line has invalid PV");
+        }
+    }
+}

package/dist/chess-copy.d.ts

@@ -1,4 +1,7 @@
 import { Chess } from "chess.js";
-export declare function assertSafeFenCounters(fen: string): void;
-export declare function assertLegalPosition(chess: Chess): void;
+export { assertLegalPosition, assertSafeFenCounters, } from "./position-validation.js";
+export declare function snapshotChessWithPgn(chess: Chess): {
+    chess: Chess;
+    pgn: string;
+};
 export declare function snapshotChess(chess: Chess): Chess;

package/dist/chess-copy.js

@@ -1,61 +1,11 @@
 import { Chess } from "chess.js";
+import { materializeMove } from "./chess-move.js";
 import { ChessError } from "./errors.js";
-import { assertPgnPlyLimit, replacePgnHeaders } from "./pgn-shared.js";
-const ORIGINAL_PIECES = {
-    q: 1,
-    r: 2,
-    n: 2,
-};
+import { assertPgnPlyLimit, pgnHeaderIndex, pgnSetupHeaders, replacePgnHeaders, terminalPgnResult, } from "./pgn-shared.js";
+import { serializePgn } from "./pgn-serialize.js";
+import { assertLegalPosition, assertSafeFenCounters, } from "./position-validation.js";
+export { assertLegalPosition, assertSafeFenCounters, } from "./position-validation.js";
 const CHESS_STATE_KEYS = Reflect.ownKeys(new Chess());
-function squareColor(square) {
-    return ((square.charCodeAt(0) - 97 + Number(square[1])) % 2);
-}
-function minimumPawnCaptures(chess, color, promotedPieces, promotedBishops) {
-    const requirements = chess
-        .findPiece({ type: "p", color })
-        .map((square) => ({
-        kind: "pawn",
-        advances: color === "w" ? Number(square[1]) - 2 : 7 - Number(square[1]),
-        file: square.charCodeAt(0) - 97,
-    }));
-    for (const bishopColor of [0, 1]) {
-        for (let count = 0; count < promotedBishops[bishopColor]; count += 1) {
-            requirements.push({ kind: "bishop", color: bishopColor });
-        }
-    }
-    for (let count = 0; count < promotedPieces; count += 1) {
-        requirements.push({ kind: "promotion" });
-    }
-    let costs = new Map([[0, 0]]);
-    for (const requirement of requirements) {
-        const next = new Map();
-        for (const [mask, cost] of costs) {
-            for (let original = 0; original < 8; original += 1) {
-                const bit = 1 << original;
-                if (mask & bit)
-                    continue;
-                let captures = 0;
-                if (requirement.kind === "pawn") {
-                    captures = Math.abs(original - requirement.file);
-                    if (captures > requirement.advances)
-                        continue;
-                }
-                else if (requirement.kind === "bishop") {
-                    const promotionRank = color === "w" ? 8 : 1;
-                    const promotionColor = ((original + promotionRank) % 2);
-                    captures = promotionColor === requirement.color ? 0 : 1;
-                }
-                const nextMask = mask | bit;
-                next.set(nextMask, Math.min(next.get(nextMask) ?? Infinity, cost + captures));
-            }
-        }
-        costs = next;
-    }
-    return Math.min(...costs.values());
-}
-function nonKingMaterial(chess, color) {
-    return ["p", "q", "r", "b", "n"].reduce((total, type) => total + chess.findPiece({ type, color }).length, 0);
-}
 function clonedChess(chess) {
     const state = Object.create(null);
     for (const key of CHESS_STATE_KEYS) {
@@ -82,336 +32,8 @@ function clonedChess(chess) {
 function exactFen(chess) {
     return chess.fen({ forceEnpassantSquare: true });
 }
-const FILES = "abcdefgh";
-function squareAt(file, rank) {
-    return `${FILES[file]}${rank}`;
-}
-function squareCoordinates(square) {
-    return [square.charCodeAt(0) - 97, Number(square[1])];
-}
-function squaresBetween(from, to) {
-    const [fromFile, fromRank] = squareCoordinates(from);
-    const [toFile, toRank] = squareCoordinates(to);
-    const fileDistance = toFile - fromFile;
-    const rankDistance = toRank - fromRank;
-    if (fileDistance !== 0 &&
-        rankDistance !== 0 &&
-        Math.abs(fileDistance) !== Math.abs(rankDistance)) {
-        return [];
-    }
-    const fileStep = Math.sign(fileDistance);
-    const rankStep = Math.sign(rankDistance);
-    const squares = [];
-    let file = fromFile + fileStep;
-    let rank = fromRank + rankStep;
-    while (file !== toFile || rank !== toRank) {
-        squares.push(squareAt(file, rank));
-        file += fileStep;
-        rank += rankStep;
-    }
-    return squares;
-}
-function priorFullmove(fields, previous) {
-    const fullmove = fields[5] ?? "";
-    if (!isSafeDecimal(fullmove, 1))
-        return null;
-    const value = Number(fullmove) - (previous === "b" ? 1 : 0);
-    return value >= 1 ? value : null;
-}
-function priorChess(setup, previous, castling, enPassant, halfmove, fullmove) {
-    try {
-        return new Chess([
-            setup.fen().split(" ")[0],
-            previous,
-            castling,
-            enPassant,
-            String(halfmove),
-            String(fullmove),
-        ].join(" "));
-    }
-    catch {
-        return null;
-    }
-}
-function reachesPosition(prior, move, currentFen) {
-    if (!prior)
-        return false;
-    try {
-        assertLegalPositionInternal(prior, false);
-        prior.move(move);
-        return exactFen(prior) === currentFen;
-    }
-    catch {
-        return false;
-    }
-}
-function hasPiece(chess, square, type, color) {
-    const piece = chess.get(square);
-    return piece?.type === type && piece.color === color;
-}
-function assertCastlingPosition(chess, color) {
-    const rank = color === "w" ? "1" : "8";
-    const rights = chess.getCastlingRights(color);
-    if ((rights.k || rights.q) &&
-        !hasPiece(chess, `e${rank}`, "k", color)) {
-        throw new ChessError("INVALID_FEN", "FEN castling rights require a home king");
-    }
-    if (rights.k && !hasPiece(chess, `h${rank}`, "r", color)) {
-        throw new ChessError("INVALID_FEN", "FEN kingside castling rights require a home rook");
-    }
-    if (rights.q && !hasPiece(chess, `a${rank}`, "r", color)) {
-        throw new ChessError("INVALID_FEN", "FEN queenside castling rights require a home rook");
-    }
-}
-function assertEnPassantPosition(chess) {
-    const fields = chess.fen({ forceEnpassantSquare: true }).split(" ");
-    const target = fields[3];
-    if (!target || target === "-")
-        return;
-    const turn = chess.turn();
-    const file = target[0];
-    const targetRank = turn === "w" ? "6" : "3";
-    const pawnRank = turn === "w" ? "5" : "4";
-    const originRank = turn === "w" ? "7" : "2";
-    const pawnColor = turn === "w" ? "b" : "w";
-    const targetSquare = target;
-    const pawnSquare = `${file}${pawnRank}`;
-    const originSquare = `${file}${originRank}`;
-    if (target[1] !== targetRank ||
-        chess.get(targetSquare) !== undefined ||
-        !hasPiece(chess, pawnSquare, "p", pawnColor) ||
-        chess.get(originSquare) !== undefined ||
-        fields[4] !== "0" ||
-        (turn === "w" && fields[5] === "1")) {
-        throw new ChessError("INVALID_FEN", "FEN en passant target does not match a double pawn move");
-    }
-    const fullmove = fields[5] ?? "";
-    if (!isSafeDecimal(fullmove, 1)) {
-        throw new ChessError("INVALID_FEN", "FEN fullmove number must be a positive safe decimal integer");
-    }
-    const setup = new Chess(fields.join(" "));
-    setup.remove(pawnSquare);
-    setup.put({ type: "p", color: pawnColor }, originSquare);
-    const priorFullmove = turn === "w" ? Number(fullmove) - 1 : Number(fullmove);
-    const priorFen = [
-        setup.fen().split(" ")[0],
-        pawnColor,
-        fields[2],
-        "-",
-        "0",
-        String(priorFullmove),
-    ].join(" ");
-    const prior = new Chess(priorFen);
-    assertLegalPosition(prior);
-    try {
-        prior.move({ from: originSquare, to: pawnSquare });
-    }
-    catch {
-        throw new ChessError("INVALID_FEN", "FEN en passant target does not follow a legal double pawn move");
-    }
-    const transitioned = exactFen(prior).split(" ");
-    transitioned[3] = target;
-    if (transitioned.join(" ") !== fields.join(" ")) {
-        throw new ChessError("INVALID_FEN", "FEN en passant target does not match the previous position");
-    }
-}
-function moveDescriptor(move) {
-    const base = { from: move.from, to: move.to };
-    return move.promotion ? { ...base, promotion: move.promotion } : base;
-}
-function isSafeDecimal(value, minimum) {
-    return (/^(?:0|[1-9]\d*)$/.test(value) &&
-        Number.isSafeInteger(Number(value)) &&
-        Number(value) >= minimum);
-}
-const CAPTURED_PIECES = ["p", "n", "b", "r", "q"];
-function ordinaryDoubleCheckPredecessor(chess, king, checkers) {
-    const currentFen = exactFen(chess);
-    const fields = currentFen.split(" ");
-    const previous = chess.turn() === "w" ? "b" : "w";
-    const active = chess.turn();
-    const fullmove = priorFullmove(fields, previous);
-    const currentHalfmove = Number(fields[4]);
-    if (fullmove === null || !Number.isSafeInteger(currentHalfmove))
-        return false;
-    for (let movedIndex = 0; movedIndex < 2; movedIndex += 1) {
-        const to = checkers[movedIndex];
-        const other = checkers[1 - movedIndex];
-        const moved = chess.get(to);
-        const otherType = chess.get(other)?.type;
-        if (!moved ||
-            moved.color !== previous ||
-            (otherType !== "b" && otherType !== "r" && otherType !== "q")) {
-            continue;
-        }
-        for (const from of squaresBetween(other, king)) {
-            if (chess.get(from) !== undefined)
-                continue;
-            for (const captured of [undefined, ...CAPTURED_PIECES]) {
-                if (captured === "p" &&
-                    (to[1] === "1" || to[1] === "8")) {
-                    continue;
-                }
-                const halfmove = moved.type === "p" || captured ? 0 : currentHalfmove - 1;
-                if (halfmove < 0 || (moved.type === "p" || captured) && currentHalfmove !== 0) {
-                    continue;
-                }
-                const setup = new Chess(currentFen);
-                setup.remove(to);
-                setup.put(moved, from);
-                if (captured)
-                    setup.put({ type: captured, color: active }, to);
-                const prior = priorChess(setup, previous, fields[2], "-", halfmove, fullmove);
-                if (reachesPosition(prior, { from, to }, currentFen))
-                    return true;
-                const promotionRank = previous === "w" ? "8" : "1";
-                const pawnRank = previous === "w" ? "7" : "2";
-                if (moved.type !== "p" &&
-                    moved.type !== "k" &&
-                    to[1] === promotionRank &&
-                    from[1] === pawnRank) {
-                    const promotedSetup = new Chess(currentFen);
-                    promotedSetup.remove(to);
-                    promotedSetup.put({ type: "p", color: previous }, from);
-                    if (captured) {
-                        promotedSetup.put({ type: captured, color: active }, to);
-                    }
-                    const promotionPrior = priorChess(promotedSetup, previous, fields[2], "-", 0, fullmove);
-                    if (currentHalfmove === 0 &&
-                        reachesPosition(promotionPrior, { from, to, promotion: moved.type }, currentFen)) {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-    return false;
-}
-function enPassantDoubleCheckPredecessor(chess) {
-    const currentFen = exactFen(chess);
-    const fields = currentFen.split(" ");
-    if (fields[3] !== "-" || fields[4] !== "0")
-        return false;
-    const previous = chess.turn() === "w" ? "b" : "w";
-    const active = chess.turn();
-    const fullmove = priorFullmove(fields, previous);
-    if (fullmove === null)
-        return false;
-    const destinationRank = previous === "w" ? 6 : 3;
-    const originRank = previous === "w" ? 5 : 4;
-    for (const to of chess.findPiece({ type: "p", color: previous })) {
-        if (Number(to[1]) !== destinationRank)
-            continue;
-        const [toFile] = squareCoordinates(to);
-        const capturedSquare = squareAt(toFile, originRank);
-        if (chess.get(capturedSquare) !== undefined)
-            continue;
-        for (const originFile of [toFile - 1, toFile + 1]) {
-            if (originFile < 0 || originFile > 7)
-                continue;
-            const from = squareAt(originFile, originRank);
-            if (chess.get(from) !== undefined)
-                continue;
-            const setup = new Chess(currentFen);
-            setup.remove(to);
-            setup.put({ type: "p", color: previous }, from);
-            setup.put({ type: "p", color: active }, capturedSquare);
-            const prior = priorChess(setup, previous, fields[2], to, 0, fullmove);
-            if (reachesPosition(prior, { from, to }, currentFen))
-                return true;
-        }
-    }
-    return false;
-}
-function hasDoubleCheckPredecessor(chess, king, checkers) {
-    if (exactFen(chess).split(" ")[3] !== "-")
-        return true;
-    return (ordinaryDoubleCheckPredecessor(chess, king, checkers) ||
-        enPassantDoubleCheckPredecessor(chess));
-}
-export function assertSafeFenCounters(fen) {
-    const fields = fen.split(/\s+/);
-    if (fields.length >= 5 && !isSafeDecimal(fields[4] ?? "", 0)) {
-        throw new ChessError("INVALID_FEN", "FEN halfmove clock must be a non-negative safe decimal integer");
-    }
-    if (fields.length >= 6 && !isSafeDecimal(fields[5] ?? "", 1)) {
-        throw new ChessError("INVALID_FEN", "FEN fullmove number must be a positive safe decimal integer");
-    }
-}
-export function assertLegalPosition(chess) {
-    assertLegalPositionInternal(chess, true);
-}
-function assertLegalPositionInternal(chess, validateDoubleCheck) {
-    for (const color of ["w", "b"]) {
-        if (chess.findPiece({ type: "k", color }).length !== 1) {
-            throw new ChessError("INVALID_FEN", "FEN must contain exactly one king per side");
-        }
-        const pawns = chess.findPiece({ type: "p", color });
-        if (pawns.some((square) => square[1] === "1" || square[1] === "8")) {
-            throw new ChessError("INVALID_FEN", "FEN pawns cannot occupy the first or eighth rank");
-        }
-        if (pawns.length > 8) {
-            throw new ChessError("INVALID_FEN", "FEN cannot contain more than eight pawns per side");
-        }
-        const promotedPieces = Object.entries(ORIGINAL_PIECES).reduce((total, [type, original]) => total +
-            Math.max(0, chess.findPiece({ type: type, color }).length -
-                original), 0);
-        const promotedBishops = [0, 1].map((squareColorValue) => Math.max(0, chess
-            .findPiece({ type: "b", color })
-            .filter((square) => squareColor(square) === squareColorValue)
-            .length - 1));
-        const promoted = promotedPieces + promotedBishops[0] + promotedBishops[1];
-        if (promoted > 8 - pawns.length) {
-            throw new ChessError("INVALID_FEN", "FEN contains more promoted material than missing pawns allow");
-        }
-        assertCastlingPosition(chess, color);
-        const opponent = color === "w" ? "b" : "w";
-        const missingOpponentMaterial = 15 - nonKingMaterial(chess, opponent);
-        if (minimumPawnCaptures(chess, color, promotedPieces, promotedBishops) > missingOpponentMaterial) {
-            throw new ChessError("INVALID_FEN", "FEN pawn files require more captures than opposing material allows");
-        }
-    }
-    assertEnPassantPosition(chess);
-    const turn = chess.turn();
-    const previous = turn === "w" ? "b" : "w";
-    const previousKing = chess.findPiece({ type: "k", color: previous })[0];
-    if (previousKing && chess.isAttacked(previousKing, turn)) {
-        throw new ChessError("INVALID_FEN", "FEN cannot leave the side that just moved in check");
-    }
-    const king = chess.findPiece({ type: "k", color: turn })[0];
-    if (king) {
-        const checkers = chess.attackers(king, previous);
-        const leapers = checkers.filter((square) => {
-            const type = chess.get(square)?.type;
-            return type === "k" || type === "n" || type === "p";
-        });
-        if (checkers.length > 2 || leapers.length > 1) {
-            throw new ChessError("INVALID_FEN", "FEN contains an impossible check topology");
-        }
-        if (validateDoubleCheck &&
-            checkers.length === 2 &&
-            !hasDoubleCheckPredecessor(chess, king, checkers)) {
-            throw new ChessError("INVALID_FEN", "FEN double check has no legal previous move");
-        }
-    }
-}
 function expectedInitialFen(headers) {
-    const values = new Map();
-    for (const [name, value] of headers) {
-        const key = name.toLowerCase();
-        if (values.has(key)) {
-            throw new ChessError("INVALID_PGN", `PGN must not repeat ${name} headers`);
-        }
-        values.set(key, value);
-    }
-    const setup = values.get("setup");
-    const fen = values.get("fen");
-    if (setup !== undefined && setup !== "0" && setup !== "1") {
-        throw new ChessError("INVALID_PGN", "PGN SetUp must be 0 or 1");
-    }
-    if ((setup === "1") !== (fen !== undefined)) {
-        throw new ChessError("INVALID_PGN", "PGN SetUp 1 and FEN headers must appear together");
-    }
+    const { fen } = pgnSetupHeaders(pgnHeaderIndex(headers));
     if (fen === undefined)
         return exactFen(new Chess());
     assertSafeFenCounters(fen);
@@ -446,21 +68,69 @@ function validatedHistory(chess) {
     }
     return { history, initialFen, shadow, sourceHeaders };
 }
-export function snapshotChess(chess) {
-    assertLegalPosition(chess);
-    const { history, initialFen, shadow, sourceHeaders } = validatedHistory(chess);
-    assertPgnPlyLimit(history.length);
-    assertSafeFenCounters(initialFen);
-    const snapshot = new Chess(initialFen);
-    assertLegalPosition(snapshot);
+function commentsByFen(chess, shadow) {
     const getComments = chess.getComments;
     const sourceComments = getComments === Chess.prototype.getComments
         ? Chess.prototype.getComments.call(shadow)
         : getComments.call(chess);
-    const comments = new Map(sourceComments.map(({ fen, comment }) => [
+    return new Map(sourceComments.map(({ fen, comment }) => [
         fen,
         /[{}]/.test(comment) ? comment.replace(/[\r\n]+/g, " ") : comment,
     ]));
+}
+function replayHistory(chess, history, restoreComment) {
+    restoreComment();
+    for (const move of history) {
+        chess.move(materializeMove(move));
+        restoreComment();
+    }
+}
+function snapshotPgn(chess) {
+    const result = terminalPgnResult(chess);
+    const originalResult = chess.getHeaders().Result;
+    if (result !== undefined)
+        chess.setHeader("Result", result);
+    try {
+        const headers = Object.entries(chess.getHeaders());
+        return serializePgn(() => Chess.prototype.pgn.call(chess), headers, Chess.prototype.getComments.call(chess).map(({ comment }) => comment));
+    }
+    finally {
+        if (result !== undefined) {
+            if (originalResult === undefined)
+                chess.removeHeader("Result");
+            else
+                chess.setHeader("Result", originalResult);
+        }
+    }
+}
+function restoreUnsafeComments(snapshot, comments, markerPrefix, markerComments, sourceHeaders) {
+    const escapedPrefix = markerPrefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const marker = new RegExp(`\\{${escapedPrefix}(\\d+)${escapedPrefix}\\}`, "g");
+    const pgn = snapshot.pgn().replace(marker, (_match, index) => {
+        return `;${markerComments[Number(index)]}\n`;
+    });
+    const restored = new Chess();
+    restored.loadPgn(pgn);
+    const restoredHistory = restored.history({ verbose: true });
+    while (restored.undo()) { }
+    replayHistory(restored, restoredHistory, () => {
+        const comment = comments.get(restored.fen());
+        if (comment !== undefined && !/[{}]/.test(comment)) {
+            restored.setComment(comment);
+        }
+    });
+    replacePgnHeaders(restored, sourceHeaders, { removeMissing: true });
+    assertSafeFenCounters(restored.fen());
+    return restored;
+}
+export function snapshotChessWithPgn(chess) {
+    assertLegalPosition(chess);
+    const { history, initialFen, shadow, sourceHeaders } = validatedHistory(chess);
+    assertPgnPlyLimit(history.length);
+    assertSafeFenCounters(initialFen);
+    const snapshot = new Chess(initialFen);
+    assertLegalPosition(snapshot);
+    const comments = commentsByFen(chess, shadow);
     const unsafeComments = [...comments.values()].some((comment) => /[{}]/.test(comment));
     let markerPrefix = "\uE000";
     if (unsafeComments) {
@@ -469,7 +139,7 @@ export function snapshotChess(chess) {
             markerPrefix += "\uE001";
     }
     const markerComments = [];
-    const restoreComment = () => {
+    replayHistory(snapshot, history, () => {
         const comment = comments.get(snapshot.fen());
         if (comment === undefined)
             return;
@@ -480,38 +150,15 @@ export function snapshotChess(chess) {
         const marker = `${markerPrefix}${markerComments.length}${markerPrefix}`;
         markerComments.push(comment);
         snapshot.setComment(marker);
-    };
-    restoreComment();
-    for (const move of history) {
-        snapshot.move(moveDescriptor(move));
-        restoreComment();
-    }
+    });
     assertSafeFenCounters(snapshot.fen());
     if (!unsafeComments) {
         replacePgnHeaders(snapshot, sourceHeaders, { removeMissing: true });
-        return snapshot;
+        return { chess: snapshot, pgn: snapshotPgn(snapshot) };
     }
-    const escapedPrefix = markerPrefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const marker = new RegExp(`\\{${escapedPrefix}(\\d+)${escapedPrefix}\\}`, "g");
-    const pgn = snapshot.pgn().replace(marker, (_match, index) => {
-        return `;${markerComments[Number(index)]}\n`;
-    });
-    const restored = new Chess();
-    restored.loadPgn(pgn);
-    const restoredHistory = restored.history({ verbose: true });
-    while (restored.undo()) { }
-    const restoreSafeComment = () => {
-        const comment = comments.get(restored.fen());
-        if (comment !== undefined && !/[{}]/.test(comment)) {
-            restored.setComment(comment);
-        }
-    };
-    restoreSafeComment();
-    for (const move of restoredHistory) {
-        restored.move(moveDescriptor(move));
-        restoreSafeComment();
-    }
-    replacePgnHeaders(restored, sourceHeaders, { removeMissing: true });
-    assertSafeFenCounters(restored.fen());
-    return restored;
+    const restored = restoreUnsafeComments(snapshot, comments, markerPrefix, markerComments, sourceHeaders);
+    return { chess: restored, pgn: snapshotPgn(restored) };
+}
+export function snapshotChess(chess) {
+    return snapshotChessWithPgn(chess).chess;
 }