llm-chess-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import * as z from "zod/v4";
+import { Chess } from "chess.js";
+import { loadEnv } from "./env.js";
+import { createGame, createGameFromChess, getGame, deleteGame } from "./games.js";
+import { stockfish } from "./engines/stockfish.js";
+import { humanMoveDistribution } from "./maia3/inference.js";
+import { openingExplorer, explorerEnabled } from "./explorer.js";
+import { computeCandidates, rankByIntent } from "./intents.js";
+import { scoreToCp, classifyCpLoss } from "./eval.js";
+import { ChessError } from "./errors.js";
+const INTENTS = [
+    "best",
+    "strong",
+    "natural",
+    "balanced",
+    "ease_off",
+    "give_chance",
+];
+function text(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function stateOf(chess) {
+    const last = chess.history({ verbose: true }).at(-1);
+    return {
+        fen: chess.fen(),
+        turn: chess.turn(),
+        isCheck: chess.isCheck(),
+        isCheckmate: chess.isCheckmate(),
+        isStalemate: chess.isStalemate(),
+        isDraw: chess.isDraw(),
+        isGameOver: chess.isGameOver(),
+        isInsufficientMaterial: chess.isInsufficientMaterial(),
+        isThreefoldRepetition: chess.isThreefoldRepetition(),
+        isDrawByFiftyMoves: chess.isDrawByFiftyMoves(),
+        moveNumber: chess.moveNumber(),
+        history: chess.history(),
+        lastMove: last ? { san: last.san, uci: last.lan } : null,
+        castling: {
+            whiteKingside: chess.getCastlingRights("w").k,
+            whiteQueenside: chess.getCastlingRights("w").q,
+            blackKingside: chess.getCastlingRights("b").k,
+            blackQueenside: chess.getCastlingRights("b").q,
+        },
+    };
+}
+function parseMove(chess, move) {
+    const verbose = chess.moves({ verbose: true });
+    const san = move.replace(/[+#]$/, "");
+    const bySan = verbose.find((m) => m.san.replace(/[+#]$/, "") === san);
+    if (bySan)
+        return bySan;
+    const byLan = verbose.find((m) => m.lan === move);
+    if (byLan)
+        return byLan;
+    throw new ChessError("ILLEGAL_MOVE", `illegal move: ${move}`);
+}
+function wrap(handler) {
+    return async (args) => {
+        try {
+            return (await handler(args));
+        }
+        catch (e) {
+            if (e instanceof ChessError) {
+                return text({ error: { code: e.code, message: e.message } });
+            }
+            const msg = e instanceof Error ? e.message : String(e);
+            return text({ error: { code: "INTERNAL", message: msg } });
+        }
+    };
+}
+export function buildServer() {
+    const server = new McpServer({ name: "llm-chess-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
+    server.registerTool("create_game", {
+        description: "Create a new chess game and return its game_id. The server is the authoritative source of board state — never track the board yourself. Optionally pass a FEN to start from a custom position.",
+        inputSchema: z.object({
+            fen: z.string().optional(),
+        }),
+    }, wrap(async ({ fen }) => {
+        let id;
+        try {
+            id = createGame(fen);
+        }
+        catch {
+            throw new ChessError("INVALID_FEN", "invalid FEN");
+        }
+        return text({ game_id: id });
+    }));
+    server.registerTool("delete_game", {
+        description: "Delete a game and free its session.",
+        inputSchema: z.object({ game_id: z.string() }),
+    }, wrap(async ({ game_id }) => {
+        const ok = deleteGame(game_id);
+        if (!ok)
+            throw new ChessError("GAME_NOT_FOUND", `game not found: ${game_id}`);
+        return text({ game_id, deleted: true });
+    }));
+    server.registerTool("game_state", {
+        description: "Return the authoritative state of a game: FEN, turn, check/mate/draw flags, move history, last move, castling rights. Use this instead of remembering the board.",
+        inputSchema: z.object({ game_id: z.string() }),
+    }, wrap(async ({ game_id }) => {
+        const { chess } = getGame(game_id);
+        return text({ game_id, ...stateOf(chess) });
+    }));
+    server.registerTool("game_state_ascii", {
+        description: "Return an ASCII diagram of the current board.",
+        inputSchema: z.object({ game_id: z.string() }),
+    }, wrap(async ({ game_id }) => {
+        const { chess } = getGame(game_id);
+        return text({ game_id, board: chess.ascii() });
+    }));
+    server.registerTool("game_play_move", {
+        description: "Play a move (SAN like 'e4' or UCI like 'e2e4') and return the resulting state. This is the ONLY tool that mutates the game. Illegal moves are rejected and the state is unchanged.",
+        inputSchema: z.object({ game_id: z.string(), move: z.string() }),
+    }, wrap(async ({ game_id, move }) => {
+        const { chess } = getGame(game_id);
+        if (chess.isGameOver()) {
+            throw new ChessError("GAME_OVER", "game is already over");
+        }
+        const m = parseMove(chess, move);
+        chess.move({ from: m.from, to: m.to, promotion: m.promotion });
+        return text({ game_id, move: m.san, ...stateOf(chess) });
+    }));
+    server.registerTool("game_legal_moves", {
+        description: "List all legal moves in the current position (SAN, UCI, piece, capture, promotion).",
+        inputSchema: z.object({ game_id: z.string() }),
+    }, wrap(async ({ game_id }) => {
+        const { chess } = getGame(game_id);
+        const moves = chess.moves({ verbose: true }).map((m) => ({
+            san: m.san,
+            uci: m.lan,
+            from: m.from,
+            to: m.to,
+            piece: m.piece,
+            captured: m.captured ?? null,
+            promotion: m.promotion ?? null,
+            isCapture: m.flags.includes("c"),
+            isCheck: m.san.includes("+") || m.san.includes("#"),
+        }));
+        return text({ game_id, count: moves.length, moves });
+    }));
+    server.registerTool("position_analyze", {
+        description: "Run Stockfish on the current position and return the top engine lines (multipv). Scores are from the side-to-move perspective: positive cp = side to move is better; mate N = side to move mates in N. Does NOT mutate the game.",
+        inputSchema: z.object({
+            game_id: z.string(),
+            depth: z.number().int().min(1).max(30).default(15),
+            multipv: z.number().int().min(1).max(10).default(3),
+        }),
+    }, wrap(async ({ game_id, depth, multipv }) => {
+        const { chess } = getGame(game_id);
+        const lines = await stockfish.analyze(chess.fen(), depth, multipv);
+        return text({
+            game_id,
+            fen: chess.fen(),
+            turn: chess.turn(),
+            lines: lines.map((l) => ({
+                multipv: l.multipv,
+                scoreCp: l.scoreCp,
+                scoreMate: l.scoreMate,
+                pv: l.pv,
+            })),
+        });
+    }));
+    server.registerTool("human_move_distribution", {
+        description: "Return the Maia3 human-like move probability distribution for the current position, conditioned on a target Elo. Higher probability = more human-typical at that rating. This is NOT move quality — a high-probability move can still be objectively bad.",
+        inputSchema: z.object({
+            game_id: z.string(),
+            elo: z.number().int().min(600).max(2600).default(1500),
+            oppo_elo: z.number().int().min(600).max(2600).optional(),
+            top_n: z.number().int().min(1).max(20).default(5),
+        }),
+    }, wrap(async ({ game_id, elo, oppo_elo, top_n }) => {
+        const { chess } = getGame(game_id);
+        const moves = await humanMoveDistribution(chess, elo, oppo_elo ?? elo, top_n);
+        return text({ game_id, elo, oppo_elo: oppo_elo ?? elo, moves });
+    }));
+    server.registerTool("move_evaluate", {
+        description: "Evaluate a specific move with Stockfish without mutating the game. Returns the score after the move (from the mover's perspective) plus cpLoss vs the best move and a classification (best/excellent/good/inaccuracy/mistake/blunder).",
+        inputSchema: z.object({
+            game_id: z.string(),
+            move: z.string(),
+            depth: z.number().int().min(1).max(30).default(15),
+        }),
+    }, wrap(async ({ game_id, move, depth }) => {
+        const { chess } = getGame(game_id);
+        const m = parseMove(chess, move);
+        const copy = new Chess(chess.fen());
+        copy.move({ from: m.from, to: m.to, promotion: m.promotion });
+        if (copy.isCheckmate()) {
+            return text({
+                game_id,
+                move: m.san,
+                uci: m.lan,
+                result: "checkmate",
+                scoreCp: null,
+                scoreMate: 0,
+                bestCp: null,
+                cpLoss: null,
+                classification: "best",
+                pv: [],
+            });
+        }
+        if (copy.isStalemate()) {
+            return text({
+                game_id,
+                move: m.san,
+                uci: m.lan,
+                result: "stalemate",
+                scoreCp: 0,
+                scoreMate: null,
+                bestCp: null,
+                cpLoss: null,
+                classification: null,
+                pv: [],
+            });
+        }
+        const [afterLines, beforeLines] = await Promise.all([
+            stockfish.analyze(copy.fen(), depth, 1),
+            stockfish.analyze(chess.fen(), depth, 1),
+        ]);
+        const after = afterLines[0];
+        const before = beforeLines[0];
+        // Stockfish scores are side-to-move perspective. After the move the side
+        // to move is the opponent, so negate to get the mover's perspective.
+        const afterCp = after ? -scoreToCp(after) : null;
+        const beforeCp = before ? scoreToCp(before) : null;
+        const cpLoss = afterCp !== null && beforeCp !== null ? beforeCp - afterCp : null;
+        return text({
+            game_id,
+            move: m.san,
+            uci: m.lan,
+            result: "ongoing",
+            scoreCp: afterCp,
+            scoreMate: after?.scoreMate != null ? -after.scoreMate : null,
+            bestCp: beforeCp,
+            cpLoss,
+            classification: cpLoss !== null ? classifyCpLoss(cpLoss) : null,
+            pv: after?.pv ?? [],
+        });
+    }));
+    server.registerTool("move_candidates", {
+        description: "Combine Stockfish evaluation, Maia3 human probability, and Lichess human statistics into a unified candidate list. Each candidate has sfCp (side-to-move perspective), cpLoss (vs best), maia3Prob (human likelihood, NOT quality), and lichess (real game counts). Use this before choosing a move; the final choice is yours.",
+        inputSchema: z.object({
+            game_id: z.string(),
+            elo: z.number().int().min(600).max(2600).default(1500),
+            sf_depth: z.number().int().min(1).max(30).default(15),
+            sf_multipv: z.number().int().min(1).max(10).default(5),
+            maia_top_n: z.number().int().min(1).max(20).default(5),
+            lichess_db: z.enum(["lichess", "masters"]).default("lichess"),
+            lichess_speeds: z.array(z.string()).default([]),
+            lichess_ratings: z.array(z.number().int()).default([]),
+        }),
+    }, wrap(async ({ game_id, elo, sf_depth, sf_multipv, maia_top_n, lichess_db, lichess_speeds, lichess_ratings, }) => {
+        const { chess } = getGame(game_id);
+        const candidates = await computeCandidates(chess, elo, sf_depth, sf_multipv, maia_top_n, { db: lichess_db, speeds: lichess_speeds, ratings: lichess_ratings });
+        return text({ game_id, elo, candidates });
+    }));
+    server.registerTool("move_candidates_by_intent", {
+        description: "Return candidate moves ranked for a given strategic intent. intents: best (strongest engine move), strong (engine-strong but human-plausible), natural (most human-typical), balanced (blend of strength and human-likeness), ease_off (slightly weaker but human), give_chance (clearly weaker, gives opponent chances).",
+        inputSchema: z.object({
+            game_id: z.string(),
+            intent: z.enum(INTENTS),
+            elo: z.number().int().min(600).max(2600).default(1500),
+            sf_depth: z.number().int().min(1).max(30).default(15),
+            sf_multipv: z.number().int().min(1).max(10).default(8),
+            maia_top_n: z.number().int().min(1).max(20).default(10),
+            lichess_db: z.enum(["lichess", "masters"]).default("lichess"),
+            lichess_speeds: z.array(z.string()).default([]),
+            lichess_ratings: z.array(z.number().int()).default([]),
+        }),
+    }, wrap(async ({ game_id, intent, elo, sf_depth, sf_multipv, maia_top_n, lichess_db, lichess_speeds, lichess_ratings, }) => {
+        const { chess } = getGame(game_id);
+        const candidates = await computeCandidates(chess, elo, sf_depth, sf_multipv, maia_top_n, { db: lichess_db, speeds: lichess_speeds, ratings: lichess_ratings });
+        const ranked = rankByIntent(candidates, intent);
+        return text({ game_id, intent, elo, candidates: ranked });
+    }));
+    server.registerTool("opening_explorer", {
+        description: "Query the Lichess opening explorer for real human game statistics in the current position (requires LICHESS_TOKEN).",
+        inputSchema: z.object({
+            game_id: z.string(),
+            db: z.enum(["lichess", "masters"]).default("lichess"),
+            speeds: z.array(z.string()).default([]),
+            ratings: z.array(z.number().int()).default([]),
+        }),
+    }, wrap(async ({ game_id, db, speeds, ratings }) => {
+        if (!explorerEnabled()) {
+            throw new ChessError("LICHESS_DISABLED", "LICHESS_TOKEN not set; opening explorer is disabled");
+        }
+        const { chess } = getGame(game_id);
+        const result = await openingExplorer(chess, db, speeds, ratings);
+        return text({ game_id, ...result });
+    }));
+    server.registerTool("game_pgn", {
+        description: "Export the current game as PGN.",
+        inputSchema: z.object({ game_id: z.string() }),
+    }, wrap(async ({ game_id }) => {
+        const { chess } = getGame(game_id);
+        return text({ game_id, pgn: chess.pgn() });
+    }));
+    server.registerTool("game_import_pgn", {
+        description: "Import a PGN into a new game. Returns a new game_id with the position after all PGN moves. Rejects malformed or illegal PGN.",
+        inputSchema: z.object({ pgn: z.string() }),
+    }, wrap(async ({ pgn }) => {
+        let chess;
+        try {
+            chess = new Chess();
+            chess.loadPgn(pgn);
+        }
+        catch {
+            throw new ChessError("INVALID_PGN", "invalid or illegal PGN");
+        }
+        const id = createGameFromChess(chess);
+        return text({ game_id: id, ...stateOf(chess) });
+    }));
+    return server;
+}
+loadEnv();
+serveStdio(() => buildServer());

package/dist/intents.js

@@ -0,0 +1,104 @@
+import { stockfish } from "./engines/stockfish.js";
+import { humanMoveDistribution } from "./maia3/inference.js";
+import { openingExplorer, explorerEnabled } from "./explorer.js";
+import { scoreToCp } from "./eval.js";
+function softmax(values, temperature) {
+    const scaled = values.map((v) => v / temperature);
+    const max = Math.max(...scaled);
+    const exps = scaled.map((v) => Math.exp(v - max));
+    const sum = exps.reduce((a, b) => a + b, 0);
+    return exps.map((e) => e / sum);
+}
+export async function computeCandidates(chess, elo, sfDepth, sfMultipv, maiaTopN, lichess) {
+    const [sfLines, maiaMoves, lichessMoves] = await Promise.all([
+        stockfish.analyze(chess.fen(), sfDepth, sfMultipv),
+        humanMoveDistribution(chess, elo, elo, maiaTopN),
+        lichess && explorerEnabled()
+            ? openingExplorer(chess, lichess.db, lichess.speeds, lichess.ratings)
+                .then((r) => r.moves)
+                .catch(() => [])
+            : Promise.resolve([]),
+    ]);
+    const maiaByUci = new Map(maiaMoves.map((m) => [m.uci, m.prob]));
+    const sfByUci = new Map(sfLines.map((l) => [l.pv[0], l]));
+    const lichessByUci = new Map(lichessMoves.map((m) => [m.uci, m]));
+    const bestCp = sfLines.length
+        ? Math.max(...sfLines.map((l) => scoreToCp(l)))
+        : 0;
+    const ucis = new Set([
+        ...sfByUci.keys(),
+        ...maiaByUci.keys(),
+        ...lichessByUci.keys(),
+    ]);
+    const candidates = [];
+    for (const uci of ucis) {
+        const sf = sfByUci.get(uci);
+        const cp = sf ? scoreToCp(sf) : null;
+        candidates.push({
+            uci,
+            san: toSan(chess, uci),
+            sfCp: cp,
+            cpLoss: cp !== null ? bestCp - cp : null,
+            maia3Prob: maiaByUci.get(uci) ?? null,
+            lichess: lichessByUci.get(uci) ?? null,
+        });
+    }
+    return candidates;
+}
+function toSan(chess, uci) {
+    const m = chess.moves({ verbose: true }).find((x) => x.lan === uci);
+    return m ? m.san : uci;
+}
+export function rankByIntent(candidates, intent) {
+    const withSf = candidates.filter((c) => c.sfCp !== null);
+    const bestCp = withSf.length ? Math.max(...withSf.map((c) => c.sfCp)) : 0;
+    const sfProbs = intent === "balanced"
+        ? softmax(candidates.map((x) => x.sfCp ?? -1000), 100)
+        : null;
+    const scored = candidates.map((c) => {
+        let score;
+        switch (intent) {
+            case "best":
+                score = c.sfCp ?? -Infinity;
+                break;
+            case "strong": {
+                const sf = c.sfCp ?? -Infinity;
+                const human = c.maia3Prob ?? 0;
+                score = human > 0 ? sf : -Infinity;
+                break;
+            }
+            case "natural":
+                score = c.maia3Prob ?? 0;
+                break;
+            case "balanced": {
+                const idx = candidates.indexOf(c);
+                score = 0.5 * sfProbs[idx] + 0.5 * (c.maia3Prob ?? 0);
+                break;
+            }
+            case "ease_off": {
+                const gap = bestCp - (c.sfCp ?? -Infinity);
+                const inRange = gap >= 30 && gap <= 80;
+                score = inRange ? c.maia3Prob ?? 0 : -Infinity;
+                break;
+            }
+            case "give_chance": {
+                const gap = bestCp - (c.sfCp ?? -Infinity);
+                const inRange = gap >= 80 && gap <= 150;
+                score = inRange ? c.maia3Prob ?? 0 : -Infinity;
+                break;
+            }
+        }
+        return { c, score };
+    });
+    const ranked = scored
+        .filter((x) => x.score !== -Infinity)
+        .sort((a, b) => b.score - a.score)
+        .map((x) => x.c);
+    if (ranked.length === 0 && (intent === "ease_off" || intent === "give_chance")) {
+        const human = candidates.filter((c) => c.maia3Prob !== null);
+        return human
+            .sort((a, b) => (a.sfCp ?? -Infinity) - (b.sfCp ?? -Infinity))
+            .slice(0, 5);
+    }
+    return ranked;
+}

package/dist/maia3/inference.js

@@ -0,0 +1,76 @@
+import * as ort from "onnxruntime-node";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { buildInput } from "./tokenize.js";
+import { vocabIndex } from "./vocab.js";
+import { mirrorMove } from "./mirror.js";
+const MODEL_KEY = process.env.MAIA3_MODEL || "5m";
+let session = null;
+let sessionPromise = null;
+function modelPath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(here, "../../models", `maia3-${MODEL_KEY}.onnx`),
+        resolve(process.cwd(), "models", `maia3-${MODEL_KEY}.onnx`),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    throw new Error(`maia3 model not found (models/maia3-${MODEL_KEY}.onnx). Run \`pnpm export:maia3\` first.`);
+}
+async function getSession() {
+    if (session)
+        return session;
+    if (sessionPromise)
+        return sessionPromise;
+    sessionPromise = ort.InferenceSession.create(modelPath()).then((s) => {
+        session = s;
+        return s;
+    });
+    return sessionPromise;
+}
+function softmax(logits) {
+    let max = -Infinity;
+    for (let i = 0; i < logits.length; i++)
+        if (logits[i] > max)
+            max = logits[i];
+    let sum = 0;
+    const out = new Float32Array(logits.length);
+    for (let i = 0; i < logits.length; i++) {
+        out[i] = Math.exp(logits[i] - max);
+        sum += out[i];
+    }
+    for (let i = 0; i < out.length; i++)
+        out[i] /= sum;
+    return out;
+}
+export async function humanMoveDistribution(chess, elo, oppoElo, topN) {
+    const s = await getSession();
+    const legal = chess.moves({ verbose: true });
+    if (legal.length === 0)
+        return [];
+    const input = buildInput(chess);
+    const tokens = new ort.Tensor("float32", input, [1, 64, 96]);
+    const selfElo = new ort.Tensor("int64", BigInt64Array.from([BigInt(elo)]), [1]);
+    const oppoEloTensor = new ort.Tensor("int64", BigInt64Array.from([BigInt(oppoElo)]), [1]);
+    const feeds = { tokens, self_elo: selfElo, oppo_elo: oppoEloTensor };
+    const results = await s.run(feeds);
+    const logits = results.logits_move.data;
+    const turn = chess.turn();
+    const legalMask = new Float32Array(logits.length).fill(-Infinity);
+    for (const m of legal) {
+        const uci = turn === "w" ? m.lan : mirrorMove(m.lan);
+        const idx = vocabIndex(uci);
+        legalMask[idx] = logits[idx];
+    }
+    const probs = softmax(legalMask);
+    const ranked = legal
+        .map((m) => {
+        const uci = turn === "w" ? m.lan : mirrorMove(m.lan);
+        return { uci: m.lan, san: m.san, prob: probs[vocabIndex(uci)] };
+    })
+        .sort((a, b) => b.prob - a.prob);
+    return ranked.slice(0, topN);
+}

package/dist/maia3/mirror.js

@@ -0,0 +1,10 @@
+const FILES = "abcdefgh";
+export function mirrorSquare(sq) {
+    return sq[0] + String(9 - Number(sq[1]));
+}
+export function mirrorMove(uci) {
+    return mirrorSquare(uci.slice(0, 2)) + mirrorSquare(uci.slice(2, 4)) + uci.slice(4);
+}
+export function squareName(rank, file) {
+    return FILES[file] + String(rank + 1);
+}

package/dist/maia3/tokenize.js

@@ -0,0 +1,55 @@
+import { Chess } from "chess.js";
+const PIECE_MAP = { p: 1, n: 2, b: 3, r: 4, q: 5, k: 6 };
+export const HISTORY = 8;
+export const TOKEN_DIM = 12;
+export const INPUT_DIM = TOKEN_DIM * HISTORY;
+function tokenizeBoard(chess) {
+    const tokens = new Float32Array(64 * TOKEN_DIM);
+    const turn = chess.turn();
+    const board = chess.board();
+    for (let s = 0; s < 64; s++) {
+        const rank = Math.floor(s / 8);
+        const file = s % 8;
+        let piece;
+        if (turn === "w") {
+            piece = board[7 - rank][file];
+        }
+        else {
+            const p = board[rank][file];
+            piece = p ? { type: p.type, color: p.color === "w" ? "b" : "w" } : null;
+        }
+        if (piece) {
+            const mapped = PIECE_MAP[piece.type];
+            const token = mapped + (piece.color === "b" ? 6 : 0);
+            tokens[s * TOKEN_DIM + (token - 1)] = 1;
+        }
+    }
+    return tokens;
+}
+function historyPositions(chess) {
+    const moves = chess.history({ verbose: true });
+    const positions = [new Chess()];
+    const replay = new Chess();
+    for (const m of moves) {
+        replay.move({ from: m.from, to: m.to, promotion: m.promotion });
+        positions.push(new Chess(replay.fen()));
+    }
+    return positions;
+}
+export function buildInput(chess) {
+    const positions = historyPositions(chess);
+    const recent = positions.slice(-HISTORY);
+    const boards = recent.map(tokenizeBoard);
+    const pad = HISTORY - boards.length;
+    const input = new Float32Array(64 * INPUT_DIM);
+    for (let s = 0; s < 64; s++) {
+        for (let h = 0; h < HISTORY; h++) {
+            const idx = h - pad;
+            const b = idx < 0 ? boards[0] : boards[idx];
+            for (let t = 0; t < TOKEN_DIM; t++) {
+                input[s * INPUT_DIM + h * TOKEN_DIM + t] = b[s * TOKEN_DIM + t];
+            }
+        }
+    }
+    return input;
+}

package/dist/maia3/vocab.js

@@ -0,0 +1,32 @@
+import { squareName } from "./mirror.js";
+const FILES = "abcdefgh";
+const PROMO = ["q", "r", "b", "n"];
+export const VOCAB_SIZE = 4352;
+export const MOVE_VOCAB = (() => {
+    const moves = [];
+    for (let fromRank = 0; fromRank < 8; fromRank++) {
+        for (let fromFile = 0; fromFile < 8; fromFile++) {
+            const from = squareName(fromRank, fromFile);
+            for (let toRank = 0; toRank < 8; toRank++) {
+                for (let toFile = 0; toFile < 8; toFile++) {
+                    moves.push(from + squareName(toRank, toFile));
+                }
+            }
+        }
+    }
+    for (let fromFile = 0; fromFile < 8; fromFile++) {
+        for (let toFile = 0; toFile < 8; toFile++) {
+            for (const piece of PROMO) {
+                moves.push(FILES[fromFile] + "7" + FILES[toFile] + "8" + piece);
+            }
+        }
+    }
+    return moves;
+})();
+const VOCAB_INDEX = new Map(MOVE_VOCAB.map((m, i) => [m, i]));
+export function vocabIndex(uci) {
+    const i = VOCAB_INDEX.get(uci);
+    if (i === undefined)
+        throw new Error(`move not in vocab: ${uci}`);
+    return i;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};