@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/board/openings.d.ts

@@ -1,58 +0,0 @@
-import { type ChessMove, type ChessState } from './chess.ts';
-/**
- * An opening book: positions with the ECO code, English name and continuations the
- * table assigns them. The data is compiled out of the game by
- * `tools/compile-openings.mjs` from the vendored lichess tables (`data/openings/`,
- * CC0), so the framework ships this probe logic and no table: a book big enough to
- * matter would blow the bundle budget if it rode along.
- *
- * Positions are keyed by `positionKey`: placement, side to move, castling rights and
- * en passant square, no clocks. Moves ride as UCI strings (`e2e4`, `e7e8q`), which
- * survive JSON untouched; `parseUciMove` turns one back into a `ChessMove`.
- */
-export interface OpeningBookEntry {
-    /** ECO code, present where a known line ends; bare transpositions carry moves but no name */
-    readonly eco?: string;
-    /** English opening name, present where a known line ends */
-    readonly name?: string;
-    readonly moves: readonly string[];
-}
-export interface OpeningBook {
-    readonly version: 1;
-    readonly positions: Record<string, OpeningBookEntry>;
-}
-/**
- * Looks a position up in the book: its continuations, plus the ECO code and name where
- * a known line ends there (mid-line transpositions carry moves but no name). Pure and
- * total: an unknown key is a miss, never an error.
- *
- * @example
- * ```ts
- * import { probeBook, startingChess } from '@datamoc/mw_games/board';
- *
- * const book = {
- *   version: 1 as const,
- *   positions: {
- *     'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -': {
- *       moves: ['b2b4'],
- *     },
- *   },
- * };
- * console.log(probeBook(book, startingChess())?.moves); // ['b2b4']
- * ```
- */
-export declare function probeBook(book: OpeningBook, state: ChessState): OpeningBookEntry | null;
-/**
- * Reads a UCI move (`e2e4`, `e7e8q`) back into a `ChessMove`. The inverse of what the
- * book compiler writes; it checks the shape, not the legality, so the caller matches
- * the result against `legalMoves` before playing it.
- *
- * @example
- * ```ts
- * import { parseUciMove } from '@datamoc/mw_games/board';
- *
- * console.log(parseUciMove('e2e4')); // { from: 12, to: 28 }
- * ```
- */
-export declare function parseUciMove(uci: string): ChessMove;
-//# sourceMappingURL=openings.d.ts.map

package/dist/board/openings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openings.d.ts","sourceRoot":"","sources":["../../src/board/openings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,SAAS,EAAE,KAAK,UAAU,EAAsB,MAAM,YAAY,CAAC;AAElG;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,gBAAgB;IAChC,6FAA6F;IAC7F,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACrD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,gBAAgB,GAAG,IAAI,CAEvF;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAKnD"}

package/dist/board/openings.js

@@ -1,45 +0,0 @@
-import { positionKey, sq } from './chess.js';
-/**
- * Looks a position up in the book: its continuations, plus the ECO code and name where
- * a known line ends there (mid-line transpositions carry moves but no name). Pure and
- * total: an unknown key is a miss, never an error.
- *
- * @example
- * ```ts
- * import { probeBook, startingChess } from '@datamoc/mw_games/board';
- *
- * const book = {
- *   version: 1 as const,
- *   positions: {
- *     'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -': {
- *       moves: ['b2b4'],
- *     },
- *   },
- * };
- * console.log(probeBook(book, startingChess())?.moves); // ['b2b4']
- * ```
- */
-export function probeBook(book, state) {
-    return book.positions[positionKey(state)] ?? null;
-}
-const PROMOTION_LETTER = { q: 'queen', r: 'rook', b: 'bishop', n: 'knight' };
-/**
- * Reads a UCI move (`e2e4`, `e7e8q`) back into a `ChessMove`. The inverse of what the
- * book compiler writes; it checks the shape, not the legality, so the caller matches
- * the result against `legalMoves` before playing it.
- *
- * @example
- * ```ts
- * import { parseUciMove } from '@datamoc/mw_games/board';
- *
- * console.log(parseUciMove('e2e4')); // { from: 12, to: 28 }
- * ```
- */
-export function parseUciMove(uci) {
-    const match = /^([a-h][1-8])([a-h][1-8])([qrbn])?$/.exec(uci);
-    if (!match)
-        throw new Error(`not a UCI move: "${uci}"`);
-    const promotion = match[3] ? PROMOTION_LETTER[match[3]] : undefined;
-    return promotion ? { from: sq(match[1]), to: sq(match[2]), promotion } : { from: sq(match[1]), to: sq(match[2]) };
-}
-//# sourceMappingURL=openings.js.map

package/dist/board/openings.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"openings.js","sourceRoot":"","sources":["../../src/board/openings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,EAAE,EAAuD,MAAM,YAAY,CAAC;AA2BlG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,SAAS,CAAC,IAAiB,EAAE,KAAiB;IAC7D,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC;AACnD,CAAC;AAED,MAAM,gBAAgB,GAAkC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC;AAE5G;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,GAAW;IACvC,MAAM,KAAK,GAAG,qCAAqC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9D,IAAI,CAAC,KAAK;QAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG,GAAG,CAAC,CAAC;IACxD,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACpE,OAAO,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACnH,CAAC"}

package/dist/board/tablebase.d.ts

@@ -1,118 +0,0 @@
-import type { BitboardState } from './bitboard.ts';
-import type { ChessState } from './chess.ts';
-/**
- * Pawnless endgame tablebases: WDL outcomes with distance-to-mate, generated by
- * `tools/build-tablebases.mjs` and probed here. This module ships the probe logic
- * and no table: even a 4-piece ending is megabytes of positions, so a game loads
- * only the endings it wants and keeps them out of the browser bundle otherwise.
- *
- * Scope is exactly white extras against a lone black king (`KQK`, `KRK`, `KBK`,
- * `KNK`, `KQBK`, ...): no pawns, no castling rights, nothing for the black side
- * but its king. Anything outside that is a miss (`null`), never an error.
- *
- * Positions are indexed square-major in a fixed piece order (white king, white
- * extras strongest-first, black king) times the side to move. Values are
- * side-to-move-relative: 0 unknown (illegal sub-positions only), 1 loss, 2 draw,
- * 3 win. The fifty-move rule is adjudicated at probe time from the stored
- * distance: a win too far to force inside the remaining halfmoves is reported a
- * draw (cursed), and likewise a loss too far away (blessed).
- */
-export type TablebaseExtra = 'queen' | 'rook' | 'bishop' | 'knight';
-export interface TablebaseEnding {
-    version: 1;
-    /** canonical id: `K` + extras strongest-first + `K`, e.g. `KQK`, `KQBK` */
-    id: string;
-    white: TablebaseExtra[];
-    /** indexed positions: 64^pieces times the side to move */
-    positions: number;
-    /** run-length plus base64 WDL bytes, one per position */
-    wdl: string;
-    /** run-length plus base64 distance-to-mate, little-endian pairs per position */
-    dtm: string;
-}
-export interface LoadedEnding {
-    id: string;
-    /** kind indices (pawn 0 .. king 5) of the extras, strongest-first */
-    extras: number[];
-    positions: number;
-    wdl: Uint8Array;
-    dtm: Uint16Array;
-}
-export interface TablebaseProbe {
-    outcome: 'win' | 'loss' | 'draw';
-    /** plies to mate (wins) or to being mated (losses); 0 for draws */
-    dtm: number;
-}
-/**
- * The canonical id for white extras: strongest piece first, so `['bishop',
- * 'queen']` and `['queen', 'bishop']` name the same `KQBK` ending.
- *
- * @example
- * ```ts
- * import { tablebaseId } from '@datamoc/mw_games/board';
- *
- * console.log(tablebaseId(['bishop', 'queen'])); // 'KQBK'
- * ```
- */
-export declare function tablebaseId(white: TablebaseExtra[]): string;
-/**
- * Canonical Huffman plus base64, the game decodes with this same
- * dependency-free code. Two dictionary schemes were tried first and both lost
- * to the data: run-length encoding collapsed because a solved ending is a fine
- * win/draw/loss mosaic rather than broad regions, and LZ77 barely beat raw
- * size on the 4-piece mosaics while tripping over its own match flags. Huffman
- * matches the actual skew (draws dominate, distances cluster near zero) with a
- * decoder a reader can hold in their head.
- *
- * @example
- * ```ts
- * import { huffDecode, huffEncode } from '@datamoc/mw_games/board';
- *
- * console.log(huffDecode(huffEncode(new Uint8Array([2, 2, 2, 3])))); // Uint8Array([2, 2, 2, 3])
- * ```
- */
-export declare function huffEncode(raw: Uint8Array): string;
-/**
- * The inverse of `huffEncode`: throws on malformed input rather than guessing,
- * because a corrupt table must fail the load, never misprobe. The symbol count
- * in the header must match the decoded symbols exactly, so truncation fails
- * here instead of probing short.
- *
- * @example
- * ```ts
- * import { huffDecode, huffEncode } from '@datamoc/mw_games/board';
- *
- * console.log(huffDecode(huffEncode(new Uint8Array([2, 2])))); // Uint8Array([2, 2])
- * ```
- */
-export declare function huffDecode(code: string): Uint8Array;
-/**
- * Loads a checked-in ending file into probeable arrays: validates the id against
- * its extras, the position count against the piece count, and both payloads
- * against the count, so a truncated artifact fails here with its ending named.
- *
- * @example
- * ```ts
- * import { loadTablebaseEnding } from '@datamoc/mw_games/board';
- *
- * const ending = loadTablebaseEnding({ version: 1, id: 'KBK', white: ['bishop'], positions: 2, wdl: 'AgEC', dtm: 'AAQAAQ' });
- * console.log(ending.id); // 'KBK'
- * ```
- */
-export declare function loadTablebaseEnding(file: TablebaseEnding): LoadedEnding;
-/**
- * Probes loaded endings for an exact position: its WDL outcome from the side to
- * move's view with the distance, fifty-move-adjudicated against `halfmove` (a win
- * too far to force in time comes back a draw, and likewise a distant loss).
- * Pure and total: anything outside the shipped scope - pawns, rights, black
- * extras, bare kings, an ending the game never loaded - is a miss (`null`).
- *
- * @example
- * ```ts
- * import { probeTablebase, startingChess } from '@datamoc/mw_games/board';
- *
- * console.log(probeTablebase({}, startingChess())); // null - no endings loaded, never an error
- * ```
- */
-export declare function probeTablebase(loaded: Record<string, LoadedEnding>, state: ChessState | BitboardState, halfmove?: number): TablebaseProbe | null;
-//# sourceMappingURL=tablebase.d.ts.map

package/dist/board/tablebase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tablebase.d.ts","sourceRoot":"","sources":["../../src/board/tablebase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAa,UAAU,EAAE,MAAM,YAAY,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEpE,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,CAAC,CAAC;IACX,2EAA2E;IAC3E,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,YAAY;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,qEAAqE;IACrE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,UAAU,CAAC;IAChB,GAAG,EAAE,WAAW,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;IACjC,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;CACZ;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,MAAM,CAO3D;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CA2ClD;AA2CD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAmEnD;AAUD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,YAAY,CA6BvE;AAkCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACpC,KAAK,EAAE,UAAU,GAAG,aAAa,EACjC,QAAQ,SAAI,GACV,cAAc,GAAG,IAAI,CAkCvB"}

package/dist/board/tablebase.js

@@ -1,414 +0,0 @@
-const EXTRA_LETTER = { queen: 'Q', rook: 'R', bishop: 'B', knight: 'N' };
-const LETTER_EXTRA = { Q: 'queen', R: 'rook', B: 'bishop', N: 'knight' };
-const KIND_INDEX = { pawn: 0, knight: 1, bishop: 2, rook: 3, queen: 4, king: 5 };
-/**
- * The canonical id for white extras: strongest piece first, so `['bishop',
- * 'queen']` and `['queen', 'bishop']` name the same `KQBK` ending.
- *
- * @example
- * ```ts
- * import { tablebaseId } from '@datamoc/mw_games/board';
- *
- * console.log(tablebaseId(['bishop', 'queen'])); // 'KQBK'
- * ```
- */
-export function tablebaseId(white) {
-    const order = { queen: 0, rook: 1, bishop: 2, knight: 3 };
-    return `K${white
-        .slice()
-        .sort((a, b) => order[a] - order[b])
-        .map((kind) => EXTRA_LETTER[kind])
-        .join('')}K`;
-}
-const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-function base64Encode(raw) {
-    let out = '';
-    for (let i = 0; i < raw.length; i += 3) {
-        const a = raw[i];
-        const b = i + 1 < raw.length ? raw[i + 1] : 0;
-        const c = i + 2 < raw.length ? raw[i + 2] : 0;
-        out += BASE64[a >> 2] + BASE64[((a & 3) << 4) | (b >> 4)];
-        out += i + 1 < raw.length ? BASE64[((b & 15) << 2) | (c >> 6)] : '=';
-        out += i + 2 < raw.length ? BASE64[c & 63] : '=';
-    }
-    return out;
-}
-function base64Decode(code) {
-    if (code.length % 4 !== 0)
-        throw new Error('tablebase data is not base64: length is not a multiple of 4');
-    const values = new Array(code.length);
-    for (let i = 0; i < code.length; i++) {
-        if (code[i] === '=') {
-            values[i] = -1;
-            continue;
-        }
-        const value = BASE64.indexOf(code[i]);
-        if (value === -1)
-            throw new Error(`tablebase data is not base64: ${code[i]}`);
-        values[i] = value;
-    }
-    const out = [];
-    for (let i = 0; i < values.length; i += 4) {
-        const [a, b, c, d] = [values[i], values[i + 1], values[i + 2], values[i + 3]];
-        if (a === -1 || b === -1)
-            throw new Error('tablebase data is not base64: padding inside a quantum');
-        out.push((a << 2) | (b >> 4));
-        if (c !== -1)
-            out.push(((b & 15) << 4) | (c >> 2));
-        if (d !== -1)
-            out.push(((c & 3) << 6) | d);
-    }
-    return new Uint8Array(out);
-}
-/**
- * Canonical Huffman plus base64, the game decodes with this same
- * dependency-free code. Two dictionary schemes were tried first and both lost
- * to the data: run-length encoding collapsed because a solved ending is a fine
- * win/draw/loss mosaic rather than broad regions, and LZ77 barely beat raw
- * size on the 4-piece mosaics while tripping over its own match flags. Huffman
- * matches the actual skew (draws dominate, distances cluster near zero) with a
- * decoder a reader can hold in their head.
- *
- * @example
- * ```ts
- * import { huffDecode, huffEncode } from '@datamoc/mw_games/board';
- *
- * console.log(huffDecode(huffEncode(new Uint8Array([2, 2, 2, 3])))); // Uint8Array([2, 2, 2, 3])
- * ```
- */
-export function huffEncode(raw) {
-    const counts = new Array(256).fill(0);
-    for (const byte of raw)
-        counts[byte]++;
-    const symbols = counts.map((count, symbol) => ({ count, symbol })).filter((entry) => entry.count > 0);
-    const header = [1, symbols.length];
-    if (symbols.length === 0)
-        return base64Encode(new Uint8Array([1, 0, 0, 0, 0, 0]));
-    if (symbols.length === 1) {
-        header.push(symbols[0].symbol, 0);
-        const packed = new Uint8Array(header.length + 4);
-        packed.set(header, 0);
-        packed[header.length] = raw.length & 255;
-        packed[header.length + 1] = (raw.length >> 8) & 255;
-        packed[header.length + 2] = (raw.length >> 16) & 255;
-        packed[header.length + 3] = (raw.length >> 24) & 255;
-        return base64Encode(packed);
-    }
-    const lengths = huffmanLengths(symbols.map((entry) => entry.count));
-    const ordered = symbols
-        .map((entry, i) => ({ symbol: entry.symbol, length: lengths[i] }))
-        .sort((a, b) => a.symbol - b.symbol);
-    for (const entry of ordered)
-        header.push(entry.symbol);
-    for (const entry of ordered)
-        header.push(entry.length);
-    const codes = canonicalCodes(ordered);
-    const table = new Map();
-    for (let i = 0; i < ordered.length; i++)
-        table.set(ordered[i].symbol, codes[i]);
-    let totalBits = 0;
-    for (const entry of symbols)
-        totalBits += entry.count * table.get(entry.symbol).length;
-    const bytes = new Uint8Array(header.length + 4 + Math.ceil(totalBits / 8));
-    bytes.set(header, 0);
-    bytes[header.length] = raw.length & 255;
-    bytes[header.length + 1] = (raw.length >> 8) & 255;
-    bytes[header.length + 2] = (raw.length >> 16) & 255;
-    bytes[header.length + 3] = (raw.length >> 24) & 255;
-    let bit = 0;
-    const firstDataByte = header.length + 4;
-    for (const byte of raw) {
-        const entry = table.get(byte);
-        for (let k = entry.length - 1; k >= 0; k--) {
-            if ((entry.code >> k) & 1)
-                bytes[firstDataByte + (bit >> 3)] |= 1 << (7 - (bit & 7));
-            bit++;
-        }
-    }
-    return base64Encode(bytes);
-}
-/** code lengths from symbol counts: repeatedly merge the two smallest */
-function huffmanLengths(counts) {
-    const n = counts.length;
-    if (n === 0)
-        return [];
-    const weights = counts.slice();
-    const lengths = new Array(n).fill(0);
-    const active = counts.map((_, i) => i);
-    const mergeOrder = [];
-    while (active.length > 1) {
-        active.sort((a, b) => weights[a] - weights[b]);
-        const a = active.shift();
-        const b = active.shift();
-        mergeOrder.push([a, b]);
-        weights[a] += weights[b];
-        weights[b] = -1;
-        active.push(a);
-    }
-    for (let i = mergeOrder.length - 1; i >= 0; i--) {
-        const [a, b] = mergeOrder[i];
-        lengths[b] = lengths[a] + 1;
-        lengths[a]++;
-    }
-    if (lengths.some((length) => length > 32))
-        throw new Error('tablebase Huffman code too deep');
-    return lengths;
-}
-/** canonical codes from (symbol, length) sorted by symbol: counted, not stored */
-function canonicalCodes(ordered) {
-    const byLength = ordered.slice().sort((a, b) => a.length - b.length || a.symbol - b.symbol);
-    let code = 0;
-    let lastLength = byLength[0].length;
-    const assigned = new Map();
-    for (const entry of byLength) {
-        code <<= entry.length - lastLength;
-        assigned.set(entry.symbol, { code, length: entry.length });
-        code++;
-        lastLength = entry.length;
-    }
-    return ordered.map((entry) => assigned.get(entry.symbol));
-}
-/**
- * The inverse of `huffEncode`: throws on malformed input rather than guessing,
- * because a corrupt table must fail the load, never misprobe. The symbol count
- * in the header must match the decoded symbols exactly, so truncation fails
- * here instead of probing short.
- *
- * @example
- * ```ts
- * import { huffDecode, huffEncode } from '@datamoc/mw_games/board';
- *
- * console.log(huffDecode(huffEncode(new Uint8Array([2, 2])))); // Uint8Array([2, 2])
- * ```
- */
-export function huffDecode(code) {
-    const bytes = base64Decode(code);
-    if (bytes.length < 2)
-        throw new Error('tablebase data holds no header');
-    if (bytes[0] !== 1)
-        throw new Error(`tablebase data version ${bytes[0]} is not 1`);
-    const nSymbols = bytes[1];
-    if (2 + 2 * nSymbols > bytes.length)
-        throw new Error('tablebase data ends inside its header');
-    const symbols = [];
-    const lengths = [];
-    for (let i = 0; i < nSymbols; i++)
-        symbols.push(bytes[2 + i]);
-    for (let i = 0; i < nSymbols; i++)
-        lengths.push(bytes[2 + nSymbols + i]);
-    const at = 2 + 2 * nSymbols;
-    if (nSymbols === 0) {
-        if (at + 4 !== bytes.length)
-            throw new Error('tablebase data trails its empty header');
-        return new Uint8Array(0);
-    }
-    if (nSymbols === 1) {
-        if (at + 4 !== bytes.length)
-            throw new Error('tablebase data trails its single-symbol header');
-        const total = bytes[at] | (bytes[at + 1] << 8) | (bytes[at + 2] << 16) | (bytes[at + 3] << 24);
-        return new Uint8Array(total).fill(symbols[0]);
-    }
-    if (at + 4 > bytes.length)
-        throw new Error('tablebase data ends before its count');
-    const total = bytes[at] | (bytes[at + 1] << 8) | (bytes[at + 2] << 16) | (bytes[at + 3] << 24);
-    const ordered = symbols.map((symbol, i) => ({ symbol, length: lengths[i] }));
-    const codes = canonicalCodes(ordered);
-    const root = {};
-    for (let i = 0; i < ordered.length; i++) {
-        let node = root;
-        for (let k = codes[i].length - 1; k >= 0; k--) {
-            const bit = (codes[i].code >> k) & 1;
-            if (k === 0) {
-                if (bit)
-                    node.one = { symbol: ordered[i].symbol };
-                else
-                    node.zero = { symbol: ordered[i].symbol };
-            }
-            else {
-                if (bit)
-                    node.one = node.one ?? {};
-                else
-                    node.zero = node.zero ?? {};
-                node = (bit ? node.one : node.zero);
-            }
-        }
-    }
-    const out = new Uint8Array(total);
-    let produced = 0;
-    let bit = 0;
-    const firstDataByte = at + 4;
-    const totalBits = (bytes.length - firstDataByte) * 8;
-    while (produced < total) {
-        if (bit >= totalBits)
-            throw new Error('tablebase data ends before its count');
-        let node = root;
-        for (;;) {
-            const byte = bytes[firstDataByte + (bit >> 3)];
-            const value = (byte >> (7 - (bit & 7))) & 1;
-            bit++;
-            node = (value ? node.one : node.zero);
-            if (!node)
-                throw new Error('tablebase data walks off its Huffman tree');
-            if (node.symbol !== undefined)
-                break;
-        }
-        out[produced++] = node.symbol;
-    }
-    for (; bit < totalBits; bit++) {
-        const byte = bytes[firstDataByte + (bit >> 3)];
-        if ((byte >> (7 - (bit & 7))) & 1)
-            throw new Error('tablebase data does not end in zero padding');
-    }
-    return out;
-}
-function huffDecodeU16(code) {
-    const bytes = huffDecode(code);
-    if (bytes.length % 2 !== 0)
-        throw new Error('tablebase distances are not byte pairs');
-    const out = new Uint16Array(bytes.length / 2);
-    for (let i = 0; i < out.length; i++)
-        out[i] = bytes[2 * i] | (bytes[2 * i + 1] << 8);
-    return out;
-}
-/**
- * Loads a checked-in ending file into probeable arrays: validates the id against
- * its extras, the position count against the piece count, and both payloads
- * against the count, so a truncated artifact fails here with its ending named.
- *
- * @example
- * ```ts
- * import { loadTablebaseEnding } from '@datamoc/mw_games/board';
- *
- * const ending = loadTablebaseEnding({ version: 1, id: 'KBK', white: ['bishop'], positions: 2, wdl: 'AgEC', dtm: 'AAQAAQ' });
- * console.log(ending.id); // 'KBK'
- * ```
- */
-export function loadTablebaseEnding(file) {
-    if (file.version !== 1)
-        throw new Error(`${file.id}: unknown tablebase version ${String(file.version)}`);
-    if (file.id !== tablebaseId(file.white))
-        throw new Error(`${file.id}: id does not match its extras`);
-    for (const kind of file.white) {
-        if (!LETTER_EXTRA[EXTRA_LETTER[kind]])
-            throw new Error(`${file.id}: not a tablebase piece: ${String(kind)}`);
-    }
-    const pieces = 2 + file.white.length;
-    let positions = 1;
-    for (let i = 0; i < pieces; i++)
-        positions *= 64;
-    positions *= 2;
-    if (file.positions !== positions)
-        throw new Error(`${file.id}: claims ${file.positions} positions, holds ${positions}`);
-    const wdl = huffDecode(file.wdl);
-    if (wdl.length !== positions)
-        throw new Error(`${file.id}: WDL decodes to ${wdl.length} positions, needs ${positions}`);
-    const dtm = huffDecodeU16(file.dtm);
-    if (dtm.length !== positions)
-        throw new Error(`${file.id}: distances decode to ${dtm.length} positions, need ${positions}`);
-    const strength = { queen: 0, rook: 1, bishop: 2, knight: 3 };
-    return {
-        id: file.id,
-        extras: file.white
-            .slice()
-            .sort((a, b) => strength[a] - strength[b])
-            .map((kind) => KIND_INDEX[kind]),
-        positions,
-        wdl,
-        dtm,
-    };
-}
-function placedPieces(state) {
-    if ('pieces' in state) {
-        const out = [];
-        for (let i = 0; i < 12; i++) {
-            let bb = state.pieces[i];
-            while (bb) {
-                const single = bb & -bb;
-                out.push({ kind: i % 6, side: i < 6 ? 'white' : 'black', square: Math.log2(Number(single)) });
-                bb ^= single;
-            }
-        }
-        return out;
-    }
-    const out = [];
-    state.board.forEach((piece, square) => {
-        if (piece)
-            out.push({ kind: KIND_INDEX[piece.kind], side: piece.side, square });
-    });
-    return out;
-}
-function castlingRights(state) {
-    if ('pieces' in state)
-        return state.castling !== 0;
-    const rights = state.castling;
-    return rights.whiteKingside || rights.whiteQueenside || rights.blackKingside || rights.blackQueenside;
-}
-/**
- * Probes loaded endings for an exact position: its WDL outcome from the side to
- * move's view with the distance, fifty-move-adjudicated against `halfmove` (a win
- * too far to force in time comes back a draw, and likewise a distant loss).
- * Pure and total: anything outside the shipped scope - pawns, rights, black
- * extras, bare kings, an ending the game never loaded - is a miss (`null`).
- *
- * @example
- * ```ts
- * import { probeTablebase, startingChess } from '@datamoc/mw_games/board';
- *
- * console.log(probeTablebase({}, startingChess())); // null - no endings loaded, never an error
- * ```
- */
-export function probeTablebase(loaded, state, halfmove = 0) {
-    if (!Number.isInteger(halfmove) || halfmove < 0)
-        throw new RangeError('halfmove must be a non-negative integer');
-    const pieces = placedPieces(state);
-    const whiteKings = pieces.filter((piece) => piece.kind === 5 && piece.side === 'white');
-    const blackKings = pieces.filter((piece) => piece.kind === 5 && piece.side === 'black');
-    if (whiteKings.length !== 1 || blackKings.length !== 1)
-        return null;
-    if (pieces.some((piece) => piece.kind === 0))
-        return null;
-    if (pieces.some((piece) => piece.kind !== 5 && piece.side === 'black'))
-        return null;
-    if (castlingRights(state))
-        return null;
-    const extras = pieces
-        .filter((piece) => piece.kind !== 5)
-        .sort((a, b) => b.kind - a.kind)
-        .map((piece) => piece.kind);
-    if (!extras.length)
-        return null;
-    const order = { 4: 'Q', 3: 'R', 2: 'B', 1: 'N' };
-    const id = `K${extras.map((kind) => order[kind]).join('')}K`;
-    const ending = loaded[id];
-    if (!ending)
-        return null;
-    const whiteKing = pieces.find((piece) => piece.kind === 5 && piece.side === 'white').square;
-    const blackKing = pieces.find((piece) => piece.kind === 5 && piece.side === 'black').square;
-    const extraSquares = extras.map((kind, i) => {
-        const candidates = pieces.filter((piece) => piece.kind === kind && piece.side === 'white').map((p) => p.square);
-        return candidates.sort((a, b) => a - b)[countBefore(extras, kind, i)];
-    });
-    let index = whiteKing;
-    for (const square of extraSquares)
-        index = index * 64 + square;
-    index = index * 64 + blackKing;
-    index = index * 2 + (state.turn === 'black' ? 1 : 0);
-    const value = ending.wdl[index];
-    if (value === 0)
-        return null;
-    const dtm = ending.dtm[index];
-    let outcome = value === 3 ? 'win' : value === 1 ? 'loss' : 'draw';
-    if (outcome !== 'draw' && dtm > 100 - halfmove)
-        outcome = 'draw';
-    return { outcome, dtm };
-}
-/** which same-kind extra this is: the nth occurrence takes the nth square */
-function countBefore(extras, kind, upto) {
-    let seen = 0;
-    for (let i = 0; i < upto; i++) {
-        if (extras[i] === kind)
-            seen++;
-    }
-    return seen;
-}
-//# sourceMappingURL=tablebase.js.map