llm-chess-mcp 0.4.10 → 0.6.0

package/README.md

@@ -13,13 +13,14 @@ judgment; the MCP server handles all the computation.
 | Engine | Role | Runtime |
 |---|---|---|
 | **Stockfish 18** (WASM) | Objective evaluation, best moves, multipv | In-process (npm `stockfish`) |
-| **Maia3 5M** (ONNX) | Human-like move probabilities conditioned on Elo | In-process (`onnxruntime-node`) |
+| **Maia3 5M** (ONNX) | Human-like move probabilities conditioned on Elo | Dedicated Node child processes (`onnxruntime-node`) |
 | **Lichess explorer** | Real human game statistics | HTTP (needs token) |
 
-Everything runs inside the Node process. No external engine process or Python
-runtime is required at deploy time. The published package bundles the Maia3 5M
-model; other export variants are not runtime options unless their ONNX files are
-provided separately.
+No external engine executable or Python runtime is required at deploy time.
+Stockfish runs in the server process, while Maia inference runs in dedicated
+Node child processes. The published package bundles the Maia3 5M model; other
+export variants are not runtime options unless their ONNX files are provided
+separately.
 
 ## Build from source
 
@@ -68,6 +69,12 @@ const server = await serveHttp({ port: 3000, bodyTimeoutMs: 15_000 });
 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.
+
 `bodyTimeoutMs` limits HTTP body upload time; it is not a whole-tool deadline.
 The deprecated `requestTimeoutMs` alias remains supported when `bodyTimeoutMs`
 is omitted.
@@ -200,9 +207,10 @@ human-readable summary and must not be parsed as data.
   `best / excellent / good / inaccuracy / mistake / blunder`.
 - `maia3Prob` is a **human-likelihood**, not move quality. A high-probability move
   can still be objectively bad.
-- Analysis continuations return `pv` in UCI and the same legal prefix in
-  `pvSan` as SAN. If an engine line contains an invalid move, `pvSan` stops
-  before it while the original `pv` remains unchanged.
+- Successful analysis continuations return corresponding `pv` and `pvSan`
+  arrays of equal length in UCI and SAN. An invalid engine continuation is
+  rejected at the internal tool boundary instead of returning a truncated
+  `pvSan`.
 
 ## Candidate structure
 
@@ -264,20 +272,23 @@ 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 PGNs are limited to 1 MiB, 256 headers, and 4,096 plies across the
-  mainline and variations, plus 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.
+- 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.
 - Custom FENs reject inconsistent castling/en-passant metadata and impossible
   pawn or promotion material.
-- Stockfish accepts up to 32 active or queued analyses.
+- Stockfish accepts up to 32 active or queued analyses. Maia runs at most two
+  inferences concurrently and queues up to 32 more.
 - 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. It permits 16 concurrent POSTs and downstream
-  compute/network jobs process-wide, with two of each per session. A separately
-  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
+- 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.
 
@@ -289,10 +300,10 @@ proxy.
 MCP cancellation notifications, session deletion, and server shutdown propagate
 to body uploads and Stockfish, Maia, and Lichess work. Stockfish stops safely at
 its UCI queue boundary, drains queued work during shutdown, and rejects new
-analysis until teardown completes. Lichess fetch and retry waits abort immediately. ONNX
-Runtime cannot interrupt an inference already executing, so Maia discards its
-result after the native call returns. A raw HTTP disconnect alone is not a
-cancellation signal.
+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.
 
 ## Intents
 

package/dist/chess-copy.js

@@ -1,68 +1,50 @@
 import { Chess } from "chess.js";
 import { ChessError } from "./errors.js";
+import { assertPgnPlyLimit, replacePgnHeaders } from "./pgn-shared.js";
 const ORIGINAL_PIECES = {
     q: 1,
     r: 2,
     n: 2,
 };
-const CANONICAL_PGN_HEADERS = new Map([
-    "Event",
-    "Site",
-    "Date",
-    "Round",
-    "White",
-    "Black",
-    "Result",
-    "SetUp",
-    "FEN",
-].map((name) => [name.toLowerCase(), name]));
-function restoreHeaders(chess, sourceHeaders) {
-    const sourceNames = new Set(sourceHeaders.map(([key]) => key.toLowerCase()));
-    for (const key of Object.keys(chess.getHeaders())) {
-        if (!sourceNames.has(key.toLowerCase()))
-            chess.removeHeader(key);
-    }
-    const names = new Map();
-    for (const key of Object.keys(chess.getHeaders())) {
-        const existing = names.get(key.toLowerCase());
-        if (existing)
-            existing.push(key);
-        else
-            names.set(key.toLowerCase(), [key]);
-    }
-    for (const [key, value] of sourceHeaders) {
-        const lower = key.toLowerCase();
-        const canonical = CANONICAL_PGN_HEADERS.get(lower) ?? key;
-        for (const existing of names.get(lower) ?? []) {
-            if (existing !== canonical)
-                chess.removeHeader(existing);
-        }
-        chess.setHeader(canonical, value);
-        names.set(lower, [canonical]);
-    }
-}
+const CHESS_STATE_KEYS = Reflect.ownKeys(new Chess());
 function squareColor(square) {
     return ((square.charCodeAt(0) - 97 + Number(square[1])) % 2);
 }
-function minimumPawnCaptures(chess, color) {
-    const pawns = chess
+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,
-    }))
-        .sort((left, right) => left.file - right.file);
+    }));
+    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 pawn of pawns) {
+    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;
-                const captures = Math.abs(original - pawn.file);
-                if (captures > pawn.advances)
-                    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));
             }
@@ -74,6 +56,95 @@ function minimumPawnCaptures(chess, color) {
 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) {
+        const descriptor = Object.getOwnPropertyDescriptor(chess, key);
+        if (!descriptor || !("value" in descriptor)) {
+            throw new ChessError("INVALID_FEN", "chess state cannot be cloned");
+        }
+        Object.defineProperty(state, key, {
+            configurable: true,
+            enumerable: true,
+            value: descriptor.value,
+            writable: true,
+        });
+    }
+    try {
+        const clone = structuredClone(state);
+        Object.setPrototypeOf(clone, Chess.prototype);
+        return clone;
+    }
+    catch {
+        throw new ChessError("INVALID_FEN", "chess state cannot be cloned");
+    }
+}
+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;
@@ -114,6 +185,35 @@ function assertEnPassantPosition(chess) {
         (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 };
@@ -124,6 +224,111 @@ function isSafeDecimal(value, minimum) {
         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)) {
@@ -134,6 +339,9 @@ export function assertSafeFenCounters(fen) {
     }
 }
 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");
@@ -148,22 +356,18 @@ export function assertLegalPosition(chess) {
         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].reduce((total, squareColorValue) => total +
-            Math.max(0, chess
-                .findPiece({ type: "b", color })
-                .filter((square) => squareColor(square) === squareColorValue)
-                .length - 1), 0);
-        const promoted = promotedPieces + promotedBishops;
+        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 opponentPawns = chess.findPiece({ type: "p", color: opponent }).length;
         const missingOpponentMaterial = 15 - nonKingMaterial(chess, opponent);
-        const possibleOpponentPromotions = 8 - opponentPawns;
-        if (minimumPawnCaptures(chess, color) >
-            missingOpponentMaterial + possibleOpponentPromotions) {
+        if (minimumPawnCaptures(chess, color, promotedPieces, promotedBishops) > missingOpponentMaterial) {
             throw new ChessError("INVALID_FEN", "FEN pawn files require more captures than opposing material allows");
         }
     }
@@ -174,19 +378,89 @@ export function assertLegalPosition(chess) {
     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");
+    }
+    if (fen === undefined)
+        return exactFen(new Chess());
+    assertSafeFenCounters(fen);
+    let initial;
+    try {
+        initial = new Chess(fen);
+    }
+    catch {
+        throw new ChessError("INVALID_FEN", "invalid FEN");
+    }
+    assertLegalPosition(initial);
+    return exactFen(initial);
+}
+function validatedHistory(chess) {
+    const sourceFen = exactFen(chess);
+    const sourceHeaders = Object.entries(chess.getHeaders());
+    const shadow = clonedChess(chess);
+    const history = Chess.prototype.history.call(shadow, {
+        verbose: true,
+    });
+    if (history.some((move) => move.from === move.to)) {
+        throw new ChessError("INVALID_PGN", "null moves are not supported");
+    }
+    if (exactFen(shadow) !== sourceFen) {
+        throw new ChessError("INVALID_FEN", "current position does not match move history");
+    }
+    const initial = clonedChess(chess);
+    while (Chess.prototype.undo.call(initial)) { }
+    const initialFen = exactFen(initial);
+    if (initialFen !== expectedInitialFen(sourceHeaders)) {
+        throw new ChessError("INVALID_PGN", "move history does not match PGN setup headers");
+    }
+    return { history, initialFen, shadow, sourceHeaders };
 }
 export function snapshotChess(chess) {
     assertLegalPosition(chess);
-    const history = chess.history({ verbose: true });
-    const initialFen = history[0]?.before ?? chess.fen();
+    const { history, initialFen, shadow, sourceHeaders } = validatedHistory(chess);
+    assertPgnPlyLimit(history.length);
     assertSafeFenCounters(initialFen);
     const snapshot = new Chess(initialFen);
     assertLegalPosition(snapshot);
-    const comments = new Map(chess.getComments().map(({ fen, comment }) => [
+    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 }) => [
         fen,
         /[{}]/.test(comment) ? comment.replace(/[\r\n]+/g, " ") : comment,
     ]));
-    const sourceHeaders = Object.entries(chess.getHeaders());
     const unsafeComments = [...comments.values()].some((comment) => /[{}]/.test(comment));
     let markerPrefix = "\uE000";
     if (unsafeComments) {
@@ -214,7 +488,7 @@ export function snapshotChess(chess) {
     }
     assertSafeFenCounters(snapshot.fen());
     if (!unsafeComments) {
-        restoreHeaders(snapshot, sourceHeaders);
+        replacePgnHeaders(snapshot, sourceHeaders, { removeMissing: true });
         return snapshot;
     }
     const escapedPrefix = markerPrefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -237,7 +511,7 @@ export function snapshotChess(chess) {
         restored.move(moveDescriptor(move));
         restoreSafeComment();
     }
-    restoreHeaders(restored, sourceHeaders);
+    replacePgnHeaders(restored, sourceHeaders, { removeMissing: true });
     assertSafeFenCounters(restored.fen());
     return restored;
 }

package/dist/cli.js

@@ -29,6 +29,9 @@ export function parseCli(args) {
     let help = false;
     let hasHttpOption = false;
     const allowedHosts = [];
+    if (args.includes("-h") || args.includes("--help")) {
+        return { transport, host, port, path, allowedHosts, help: true };
+    }
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === undefined)
@@ -93,21 +96,23 @@ export function parseCli(args) {
     if (!isCanonicalHttpPath(path)) {
         throw new Error("--path must be an absolute URL path without query or fragment");
     }
+    const canonicalHost = canonicalHttpHostname(host);
     const canonicalAllowedHosts = allowedHosts.map(canonicalHttpHostname);
-    if (!host || canonicalAllowedHosts.some((value) => value === null)) {
+    if (canonicalHost === null ||
+        canonicalAllowedHosts.some((value) => value === null)) {
         throw new Error("HTTP hostnames must be non-empty hostnames");
     }
     if (transport === "stdio" && hasHttpOption) {
         throw new Error("HTTP options require --transport http");
     }
     if (transport === "http" &&
-        isWildcardHttpBindHost(host) &&
+        isWildcardHttpBindHost(canonicalHost) &&
         canonicalAllowedHosts.length === 0) {
         throw new Error("wildcard HTTP binding requires at least one --allowed-host");
     }
     return {
         transport,
-        host,
+        host: canonicalHost,
         port,
         path,
         allowedHosts: canonicalAllowedHosts,