gigaboard 1.2.3

package/dist/core.d.cts

@@ -0,0 +1,164 @@
+export { c as createGigachessAdapter, p as preloadGigachessAdapter } from './gigachess-3BDD--yT.cjs';
+import { c as colorOf, p as pieceTypeOf, P as PackedMove, S as SquareIndex, a as PieceType, A as AnimDescriptor, b as Arrow, d as Premove } from './board-model-BvJOtwQ3.cjs';
+export { e as ArrowCustomSvg, f as ArrowLabel, B as BOARD_CELL_BB, g as BOARD_CELL_BK, h as BOARD_CELL_BN, i as BOARD_CELL_BP, j as BOARD_CELL_BQ, k as BOARD_CELL_BR, l as BOARD_CELL_EMPTY, m as BOARD_CELL_WB, n as BOARD_CELL_WK, o as BOARD_CELL_WN, q as BOARD_CELL_WP, r as BOARD_CELL_WQ, s as BOARD_CELL_WR, t as BoardCell, u as BoardModel, v as BoardModelOptions, w as BoardSnapshot, x as BoardStore, C as CancelEvent, y as ClickEvent, z as Color, D as DragController, F as DragControllerOptions, G as DragEvent, H as DragMoveEvent, I as DragStartEvent, J as DragState, K as DropEvent, E as EngineAdapter, L as LegalMoveEntry, M as LegalMoveIndex, N as LegalMoveIndexOptions, O as MOVE2_PROMO_BISHOP, Q as MOVE2_PROMO_KNIGHT, R as MOVE2_PROMO_NONE, T as MOVE2_PROMO_QUEEN, U as MOVE2_PROMO_ROOK, V as PositionHash, W as SyncPositionOptions, X as Unsubscribe, Z as ZobristKey, Y as createBoardModel, _ as createBoardStore, $ as createDragController, a0 as createLegalMoveIndex, a1 as encodeBoardCell, a2 as isEmptyCell, a3 as isSquareIndex, a4 as packMove, a5 as toSquareIndex, a6 as unpackMove, a7 as writeBoardCell } from './board-model-BvJOtwQ3.cjs';
+
+/**
+ * Animation planner: diff two board snapshots and classify the change.
+ *
+ * The planner is called on every commit. Given `(prevBoard, nextBoard)` and
+ * optionally the packed `Move` that was played, it produces an
+ * `AnimDescriptor[]` describing what the UI should animate. The React layer
+ * feeds the descriptors into WAAPI (`element.animate(...)`) — the planner
+ * itself knows nothing about DOM, time, or easing.
+ *
+ * When the caller supplies the packed move we take the fast path: the kind,
+ * source, target, capture, promotion are all encoded in 16 bits. When no
+ * move is available (e.g. `load(fen)`, `reset()`, `redo()` of an arbitrary
+ * history entry), we fall back to a byte-level diff and classify
+ * conservatively as `appear` / `disappear`.
+ */
+
+/**
+ * Plan animations for the transition `prev → next`.
+ *
+ * @param prev Previous board bytes (length 64).
+ * @param next New board bytes (length 64).
+ * @param move Optional packed move that caused the transition. Enables the
+ *   fast path; without it the planner falls back to a byte-level diff.
+ */
+declare function planAnimations(prev: Readonly<Uint8Array>, next: Readonly<Uint8Array>, move: PackedMove | null): AnimDescriptor[];
+/**
+ * Lightweight, side-effect-free inspector. Used by tests to decompose a
+ * packed move without pulling an engine as a runtime dep.
+ */
+declare function decodePackedMove(m: PackedMove): {
+    from: SquareIndex;
+    to: SquareIndex;
+    kind: "normal" | "promotion" | "en-passant" | "castle";
+    promotion: PieceType | null;
+};
+/**
+ * Expose colour / piece-type extraction from a `BoardCell` without re-importing
+ * `types.ts`. Used by the React layer when it needs to know "is this white's
+ * pawn?" cheaply.
+ */
+declare const animationInspect: {
+    colorOf: typeof colorOf;
+    pieceTypeOf: typeof pieceTypeOf;
+    Color: {
+        readonly White: 0;
+        readonly Black: 1;
+    };
+    PieceType: {
+        readonly Pawn: 0;
+        readonly Knight: 1;
+        readonly Bishop: 2;
+        readonly Rook: 3;
+        readonly Queen: 4;
+        readonly King: 5;
+    };
+};
+
+/**
+ * Arrow set with stable identity by `(from, to, color)`.
+ *
+ * The model is intentionally tiny: it owns nothing the UI cares about (colors,
+ * hit-tests, rendering) beyond the three identifying fields. The renderer is
+ * responsible for drawing; the model is responsible for *which arrows exist*.
+ */
+
+/** The arrow-set API. */
+interface ArrowModel {
+    /** Current set of arrows, oldest first, as a frozen snapshot. */
+    readonly arrows: readonly Arrow[];
+    /** `true` if an arrow with the same `(from, to, color)` is present. */
+    has(arrow: Arrow): boolean;
+    /** Add an arrow. No-op if an identical one already exists. */
+    add(arrow: Arrow): void;
+    /** Remove an arrow. No-op if it isn't present. */
+    remove(arrow: Arrow): void;
+    /**
+     * Convenience: remove if present, add if not. Returns the new presence
+     * (`true` if the arrow is in the set after the call).
+     */
+    toggle(arrow: Arrow): boolean;
+    /** Drop every arrow, managed or not. */
+    clear(): void;
+    /**
+     * Drop only **user-drawn** arrows (anything without `managed: true`).
+     *
+     * Used by the board's reflex-clearing hooks (`clearArrowsOnClick`,
+     * `clearArrowsOnMove`) so engine / app-owned annotations survive the
+     * user's click-to-dismiss gesture. Reports `lastChanged` like every
+     * other mutator.
+     */
+    clearUser(): void;
+    /** Drop only **managed** arrows (those with `managed: true`). */
+    clearManaged(): void;
+    /**
+     * Atomic replace of the **managed** subset. User-drawn arrows are
+     * untouched. Every incoming arrow is stamped `managed: true` — callers
+     * don't have to set the flag explicitly, and the method's name carries
+     * the intent. Identity preservation works the same way as
+     * {@link setAll}: arrows whose identity key already exists are reused
+     * from the stored frozen instances so consumer `Object.is` checks stay
+     * cheap across commits.
+     */
+    setManaged(arrows: readonly Arrow[]): void;
+    /**
+     * Replace the entire arrow set in one atomic step. Preserves identity
+     * for arrows whose `(from, to, color)` tuple was already present —
+     * freshly-provided arrows are frozen and keyed; removed ones are
+     * dropped. Single `lastChanged` flag covers the whole batch.
+     */
+    setAll(arrows: readonly Arrow[]): void;
+    /** Whether the last call actually changed the state. */
+    readonly lastChanged: boolean;
+}
+/** Create an empty arrow model. */
+declare function createArrowModel(): ArrowModel;
+/** Helper: build a frozen `Arrow` literal. Validates branded types in dev. */
+declare function makeArrow(from: SquareIndex, to: SquareIndex, color: string): Arrow;
+
+/**
+ * Premove queue.
+ *
+ * When it isn't our turn and we drag a piece to a target, the intended move
+ * is queued as a `Premove`. After the opponent replies, the board model
+ * attempts to apply queued premoves in order; each one that is now legal
+ * plays, and on the first illegal premove the queue is cleared (standard
+ * lichess/chess.com behaviour — a busted premove discards everything after
+ * it too).
+ */
+
+/** Premove queue API. */
+interface PremoveBuffer {
+    /** FIFO snapshot of the current queue. */
+    readonly all: readonly Premove[];
+    /** The premove at the head of the queue, or `undefined` if empty. */
+    peek(): Premove | undefined;
+    /** Append a premove. */
+    push(premove: Premove): void;
+    /** Remove and return the head premove, or `undefined` if empty. */
+    shift(): Premove | undefined;
+    /** Drop every premove. */
+    clear(): void;
+    /** Current queue length. */
+    readonly length: number;
+}
+/** Create an empty premove buffer. */
+declare function createPremoveBuffer(): PremoveBuffer;
+/** Helper: build a frozen `Premove` literal with safe optional handling. */
+declare function makePremove(from: SquareIndex, to: SquareIndex, promotion?: PieceType): Premove;
+
+/**
+ * `gigaboard/core` — framework-agnostic state machine for Gigaboard.
+ *
+ * Zero React, zero DOM. This barrel is hand-curated; sub-modules are never
+ * re-exported wholesale so consumers can tree-shake aggressively.
+ */
+
+/** Package version. Baked in at build time by the consumer's bundler. */
+declare const PACKAGE_VERSION = "0.1.0-alpha";
+
+export { AnimDescriptor, Arrow, type ArrowModel, PACKAGE_VERSION, PackedMove, PieceType, Premove, type PremoveBuffer, SquareIndex, animationInspect, colorOf, createArrowModel, createPremoveBuffer, decodePackedMove, makeArrow, makePremove, pieceTypeOf, planAnimations };

package/dist/core.d.ts

@@ -0,0 +1,164 @@
+export { c as createGigachessAdapter, p as preloadGigachessAdapter } from './gigachess-DolQlR82.js';
+import { c as colorOf, p as pieceTypeOf, P as PackedMove, S as SquareIndex, a as PieceType, A as AnimDescriptor, b as Arrow, d as Premove } from './board-model-BvJOtwQ3.js';
+export { e as ArrowCustomSvg, f as ArrowLabel, B as BOARD_CELL_BB, g as BOARD_CELL_BK, h as BOARD_CELL_BN, i as BOARD_CELL_BP, j as BOARD_CELL_BQ, k as BOARD_CELL_BR, l as BOARD_CELL_EMPTY, m as BOARD_CELL_WB, n as BOARD_CELL_WK, o as BOARD_CELL_WN, q as BOARD_CELL_WP, r as BOARD_CELL_WQ, s as BOARD_CELL_WR, t as BoardCell, u as BoardModel, v as BoardModelOptions, w as BoardSnapshot, x as BoardStore, C as CancelEvent, y as ClickEvent, z as Color, D as DragController, F as DragControllerOptions, G as DragEvent, H as DragMoveEvent, I as DragStartEvent, J as DragState, K as DropEvent, E as EngineAdapter, L as LegalMoveEntry, M as LegalMoveIndex, N as LegalMoveIndexOptions, O as MOVE2_PROMO_BISHOP, Q as MOVE2_PROMO_KNIGHT, R as MOVE2_PROMO_NONE, T as MOVE2_PROMO_QUEEN, U as MOVE2_PROMO_ROOK, V as PositionHash, W as SyncPositionOptions, X as Unsubscribe, Z as ZobristKey, Y as createBoardModel, _ as createBoardStore, $ as createDragController, a0 as createLegalMoveIndex, a1 as encodeBoardCell, a2 as isEmptyCell, a3 as isSquareIndex, a4 as packMove, a5 as toSquareIndex, a6 as unpackMove, a7 as writeBoardCell } from './board-model-BvJOtwQ3.js';
+
+/**
+ * Animation planner: diff two board snapshots and classify the change.
+ *
+ * The planner is called on every commit. Given `(prevBoard, nextBoard)` and
+ * optionally the packed `Move` that was played, it produces an
+ * `AnimDescriptor[]` describing what the UI should animate. The React layer
+ * feeds the descriptors into WAAPI (`element.animate(...)`) — the planner
+ * itself knows nothing about DOM, time, or easing.
+ *
+ * When the caller supplies the packed move we take the fast path: the kind,
+ * source, target, capture, promotion are all encoded in 16 bits. When no
+ * move is available (e.g. `load(fen)`, `reset()`, `redo()` of an arbitrary
+ * history entry), we fall back to a byte-level diff and classify
+ * conservatively as `appear` / `disappear`.
+ */
+
+/**
+ * Plan animations for the transition `prev → next`.
+ *
+ * @param prev Previous board bytes (length 64).
+ * @param next New board bytes (length 64).
+ * @param move Optional packed move that caused the transition. Enables the
+ *   fast path; without it the planner falls back to a byte-level diff.
+ */
+declare function planAnimations(prev: Readonly<Uint8Array>, next: Readonly<Uint8Array>, move: PackedMove | null): AnimDescriptor[];
+/**
+ * Lightweight, side-effect-free inspector. Used by tests to decompose a
+ * packed move without pulling an engine as a runtime dep.
+ */
+declare function decodePackedMove(m: PackedMove): {
+    from: SquareIndex;
+    to: SquareIndex;
+    kind: "normal" | "promotion" | "en-passant" | "castle";
+    promotion: PieceType | null;
+};
+/**
+ * Expose colour / piece-type extraction from a `BoardCell` without re-importing
+ * `types.ts`. Used by the React layer when it needs to know "is this white's
+ * pawn?" cheaply.
+ */
+declare const animationInspect: {
+    colorOf: typeof colorOf;
+    pieceTypeOf: typeof pieceTypeOf;
+    Color: {
+        readonly White: 0;
+        readonly Black: 1;
+    };
+    PieceType: {
+        readonly Pawn: 0;
+        readonly Knight: 1;
+        readonly Bishop: 2;
+        readonly Rook: 3;
+        readonly Queen: 4;
+        readonly King: 5;
+    };
+};
+
+/**
+ * Arrow set with stable identity by `(from, to, color)`.
+ *
+ * The model is intentionally tiny: it owns nothing the UI cares about (colors,
+ * hit-tests, rendering) beyond the three identifying fields. The renderer is
+ * responsible for drawing; the model is responsible for *which arrows exist*.
+ */
+
+/** The arrow-set API. */
+interface ArrowModel {
+    /** Current set of arrows, oldest first, as a frozen snapshot. */
+    readonly arrows: readonly Arrow[];
+    /** `true` if an arrow with the same `(from, to, color)` is present. */
+    has(arrow: Arrow): boolean;
+    /** Add an arrow. No-op if an identical one already exists. */
+    add(arrow: Arrow): void;
+    /** Remove an arrow. No-op if it isn't present. */
+    remove(arrow: Arrow): void;
+    /**
+     * Convenience: remove if present, add if not. Returns the new presence
+     * (`true` if the arrow is in the set after the call).
+     */
+    toggle(arrow: Arrow): boolean;
+    /** Drop every arrow, managed or not. */
+    clear(): void;
+    /**
+     * Drop only **user-drawn** arrows (anything without `managed: true`).
+     *
+     * Used by the board's reflex-clearing hooks (`clearArrowsOnClick`,
+     * `clearArrowsOnMove`) so engine / app-owned annotations survive the
+     * user's click-to-dismiss gesture. Reports `lastChanged` like every
+     * other mutator.
+     */
+    clearUser(): void;
+    /** Drop only **managed** arrows (those with `managed: true`). */
+    clearManaged(): void;
+    /**
+     * Atomic replace of the **managed** subset. User-drawn arrows are
+     * untouched. Every incoming arrow is stamped `managed: true` — callers
+     * don't have to set the flag explicitly, and the method's name carries
+     * the intent. Identity preservation works the same way as
+     * {@link setAll}: arrows whose identity key already exists are reused
+     * from the stored frozen instances so consumer `Object.is` checks stay
+     * cheap across commits.
+     */
+    setManaged(arrows: readonly Arrow[]): void;
+    /**
+     * Replace the entire arrow set in one atomic step. Preserves identity
+     * for arrows whose `(from, to, color)` tuple was already present —
+     * freshly-provided arrows are frozen and keyed; removed ones are
+     * dropped. Single `lastChanged` flag covers the whole batch.
+     */
+    setAll(arrows: readonly Arrow[]): void;
+    /** Whether the last call actually changed the state. */
+    readonly lastChanged: boolean;
+}
+/** Create an empty arrow model. */
+declare function createArrowModel(): ArrowModel;
+/** Helper: build a frozen `Arrow` literal. Validates branded types in dev. */
+declare function makeArrow(from: SquareIndex, to: SquareIndex, color: string): Arrow;
+
+/**
+ * Premove queue.
+ *
+ * When it isn't our turn and we drag a piece to a target, the intended move
+ * is queued as a `Premove`. After the opponent replies, the board model
+ * attempts to apply queued premoves in order; each one that is now legal
+ * plays, and on the first illegal premove the queue is cleared (standard
+ * lichess/chess.com behaviour — a busted premove discards everything after
+ * it too).
+ */
+
+/** Premove queue API. */
+interface PremoveBuffer {
+    /** FIFO snapshot of the current queue. */
+    readonly all: readonly Premove[];
+    /** The premove at the head of the queue, or `undefined` if empty. */
+    peek(): Premove | undefined;
+    /** Append a premove. */
+    push(premove: Premove): void;
+    /** Remove and return the head premove, or `undefined` if empty. */
+    shift(): Premove | undefined;
+    /** Drop every premove. */
+    clear(): void;
+    /** Current queue length. */
+    readonly length: number;
+}
+/** Create an empty premove buffer. */
+declare function createPremoveBuffer(): PremoveBuffer;
+/** Helper: build a frozen `Premove` literal with safe optional handling. */
+declare function makePremove(from: SquareIndex, to: SquareIndex, promotion?: PieceType): Premove;
+
+/**
+ * `gigaboard/core` — framework-agnostic state machine for Gigaboard.
+ *
+ * Zero React, zero DOM. This barrel is hand-curated; sub-modules are never
+ * re-exported wholesale so consumers can tree-shake aggressively.
+ */
+
+/** Package version. Baked in at build time by the consumer's bundler. */
+declare const PACKAGE_VERSION = "0.1.0-alpha";
+
+export { AnimDescriptor, Arrow, type ArrowModel, PACKAGE_VERSION, PackedMove, PieceType, Premove, type PremoveBuffer, SquareIndex, animationInspect, colorOf, createArrowModel, createPremoveBuffer, decodePackedMove, makeArrow, makePremove, pieceTypeOf, planAnimations };

package/dist/core.js

@@ -0,0 +1,3 @@
+export { BOARD_CELL_BB, BOARD_CELL_BK, BOARD_CELL_BN, BOARD_CELL_BP, BOARD_CELL_BQ, BOARD_CELL_BR, BOARD_CELL_EMPTY, BOARD_CELL_WB, BOARD_CELL_WK, BOARD_CELL_WN, BOARD_CELL_WP, BOARD_CELL_WQ, BOARD_CELL_WR, Color, MOVE2_PROMO_BISHOP, MOVE2_PROMO_KNIGHT, MOVE2_PROMO_NONE, MOVE2_PROMO_QUEEN, MOVE2_PROMO_ROOK, PACKAGE_VERSION, PieceType, animationInspect, colorOf, createArrowModel, createBoardModel, createBoardStore, createDragController, createGigachessAdapter, createLegalMoveIndex, createPremoveBuffer, decodePackedMove, encodeBoardCell, isEmptyCell, isSquareIndex, makeArrow, makePremove, packMove, pieceTypeOf, planAnimations, preloadGigachessAdapter, toSquareIndex, unpackMove, writeBoardCell } from './chunk-J6GGNP5S.js';
+//# sourceMappingURL=core.js.map
+//# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"core.js"}

package/dist/create-image-piece-set-BcmRKGql.d.cts

@@ -0,0 +1,100 @@
+import { ReactNode } from 'react';
+
+/**
+ * Shared piece-renderer factory.
+ *
+ * Every piece set shipped by `gigaboard/pieces` is a URL-based set — a
+ * thin map from board-cell → image URL. This factory builds a memoised
+ * {@link PieceRenderer} around such a map, so every set file is two lines
+ * of configuration plus a URL table.
+ *
+ * ### Why images, not inline SVG?
+ *
+ * The React packages target <15 KB gzip. Shipping 12 detailed SVG paths
+ * per set × 4 sets would blow that budget immediately. URL-based sets
+ * push the bytes onto the browser's image cache, where the pieces are
+ * decoded exactly once per session and shared across every board.
+ *
+ * ### Render cost
+ *
+ * One `<img>` per occupied square. The image is `pointer-events: none`
+ * so it never intercepts drag/click; the piece layer on the board owns
+ * hit testing. Each renderer is pure and does not allocate on the hot
+ * path — the URL lookup is a constant-time array read.
+ */
+
+/** Shape a consumer's `PieceRenderer` prop expects. */
+type PieceRenderer = (args: {
+    readonly cell: number;
+    readonly square: number;
+}) => ReactNode;
+/**
+ * 12-entry URL table, indexed by board cell `1..12`. Cell `0` is the
+ * empty square and is never looked up. Use {@link BOARD_CELL_KEY} to
+ * remember which index maps to which piece.
+ */
+type PieceUrlTable = Readonly<{
+    /** white pawn (cell 1) */ 1: string;
+    /** white knight (cell 2) */ 2: string;
+    /** white bishop (cell 3) */ 3: string;
+    /** white rook (cell 4) */ 4: string;
+    /** white queen (cell 5) */ 5: string;
+    /** white king (cell 6) */ 6: string;
+    /** black pawn (cell 7) */ 7: string;
+    /** black knight (cell 8) */ 8: string;
+    /** black bishop (cell 9) */ 9: string;
+    /** black rook (cell 10) */ 10: string;
+    /** black queen (cell 11) */ 11: string;
+    /** black king (cell 12) */ 12: string;
+}>;
+/** Readable cell labels for the table — useful for callers building sets. */
+declare const BOARD_CELL_KEY: Readonly<{
+    readonly wP: 1;
+    readonly wN: 2;
+    readonly wB: 3;
+    readonly wR: 4;
+    readonly wQ: 5;
+    readonly wK: 6;
+    readonly bP: 7;
+    readonly bN: 8;
+    readonly bB: 9;
+    readonly bR: 10;
+    readonly bQ: 11;
+    readonly bK: 12;
+}>;
+/**
+ * Build a {@link PieceRenderer} backed by a URL table. The returned
+ * function is referentially stable AND allocates **zero** React elements
+ * on the hot path: we pre-materialise one `<img>` element per piece
+ * code at factory time and hand out the same element for every call with
+ * the same cell.
+ *
+ * Why pre-materialise? The renderer is called inside `<PieceSlot/>` on
+ * every move that touches its square. Returning a fresh React element
+ * per call means React's reconciler has to shallow-diff the new element
+ * against the last one to decide whether DOM changed. A pool of 12
+ * frozen elements (one per piece code) bypasses that entirely — React
+ * short-circuits on identity.
+ */
+declare function createImagePieceSet(urls: PieceUrlTable): PieceRenderer;
+/**
+ * Helper that builds a chess.com-style PNG CDN URL for a given piece style.
+ *
+ * chess.com serves piece artwork at:
+ *     `https://images.chesscomfiles.com/chess-themes/pieces/<style>/<size>/<colorPiece>.png`
+ *
+ * where `colorPiece` is one of `wp wn wb wr wq wk bp bn bb br bq bk`. The
+ * `size` options are `150` (default), `300`, etc. We pin to 150 by default
+ * because boards render at roughly that density on desktop, and larger
+ * sizes inflate page weight without perceptible benefit.
+ *
+ * @param style chess.com piece-style slug. Known values include `neo`
+ *              (chess.com's default), `alpha`, `bases`, `cases`, `classic`,
+ *              `club`, `condal`, `graffiti`, `leipzig`, `marble`, `maya`,
+ *              `metal`, `modern`, `nature`, `neo_wood`, `newspaper`, `ocean`,
+ *              `sky`, `space`, `tournament`, `vintage`, `wood`.
+ * @param size  One of chess.com's supported pixel sizes (default 150).
+ */
+declare function chesscomPieceUrls(style: string, size?: 150 | 300): PieceUrlTable;
+
+export { BOARD_CELL_KEY as B, type PieceRenderer as P, type PieceUrlTable as a, createImagePieceSet as b, chesscomPieceUrls as c };

package/dist/create-image-piece-set-BcmRKGql.d.ts

@@ -0,0 +1,100 @@
+import { ReactNode } from 'react';
+
+/**
+ * Shared piece-renderer factory.
+ *
+ * Every piece set shipped by `gigaboard/pieces` is a URL-based set — a
+ * thin map from board-cell → image URL. This factory builds a memoised
+ * {@link PieceRenderer} around such a map, so every set file is two lines
+ * of configuration plus a URL table.
+ *
+ * ### Why images, not inline SVG?
+ *
+ * The React packages target <15 KB gzip. Shipping 12 detailed SVG paths
+ * per set × 4 sets would blow that budget immediately. URL-based sets
+ * push the bytes onto the browser's image cache, where the pieces are
+ * decoded exactly once per session and shared across every board.
+ *
+ * ### Render cost
+ *
+ * One `<img>` per occupied square. The image is `pointer-events: none`
+ * so it never intercepts drag/click; the piece layer on the board owns
+ * hit testing. Each renderer is pure and does not allocate on the hot
+ * path — the URL lookup is a constant-time array read.
+ */
+
+/** Shape a consumer's `PieceRenderer` prop expects. */
+type PieceRenderer = (args: {
+    readonly cell: number;
+    readonly square: number;
+}) => ReactNode;
+/**
+ * 12-entry URL table, indexed by board cell `1..12`. Cell `0` is the
+ * empty square and is never looked up. Use {@link BOARD_CELL_KEY} to
+ * remember which index maps to which piece.
+ */
+type PieceUrlTable = Readonly<{
+    /** white pawn (cell 1) */ 1: string;
+    /** white knight (cell 2) */ 2: string;
+    /** white bishop (cell 3) */ 3: string;
+    /** white rook (cell 4) */ 4: string;
+    /** white queen (cell 5) */ 5: string;
+    /** white king (cell 6) */ 6: string;
+    /** black pawn (cell 7) */ 7: string;
+    /** black knight (cell 8) */ 8: string;
+    /** black bishop (cell 9) */ 9: string;
+    /** black rook (cell 10) */ 10: string;
+    /** black queen (cell 11) */ 11: string;
+    /** black king (cell 12) */ 12: string;
+}>;
+/** Readable cell labels for the table — useful for callers building sets. */
+declare const BOARD_CELL_KEY: Readonly<{
+    readonly wP: 1;
+    readonly wN: 2;
+    readonly wB: 3;
+    readonly wR: 4;
+    readonly wQ: 5;
+    readonly wK: 6;
+    readonly bP: 7;
+    readonly bN: 8;
+    readonly bB: 9;
+    readonly bR: 10;
+    readonly bQ: 11;
+    readonly bK: 12;
+}>;
+/**
+ * Build a {@link PieceRenderer} backed by a URL table. The returned
+ * function is referentially stable AND allocates **zero** React elements
+ * on the hot path: we pre-materialise one `<img>` element per piece
+ * code at factory time and hand out the same element for every call with
+ * the same cell.
+ *
+ * Why pre-materialise? The renderer is called inside `<PieceSlot/>` on
+ * every move that touches its square. Returning a fresh React element
+ * per call means React's reconciler has to shallow-diff the new element
+ * against the last one to decide whether DOM changed. A pool of 12
+ * frozen elements (one per piece code) bypasses that entirely — React
+ * short-circuits on identity.
+ */
+declare function createImagePieceSet(urls: PieceUrlTable): PieceRenderer;
+/**
+ * Helper that builds a chess.com-style PNG CDN URL for a given piece style.
+ *
+ * chess.com serves piece artwork at:
+ *     `https://images.chesscomfiles.com/chess-themes/pieces/<style>/<size>/<colorPiece>.png`
+ *
+ * where `colorPiece` is one of `wp wn wb wr wq wk bp bn bb br bq bk`. The
+ * `size` options are `150` (default), `300`, etc. We pin to 150 by default
+ * because boards render at roughly that density on desktop, and larger
+ * sizes inflate page weight without perceptible benefit.
+ *
+ * @param style chess.com piece-style slug. Known values include `neo`
+ *              (chess.com's default), `alpha`, `bases`, `cases`, `classic`,
+ *              `club`, `condal`, `graffiti`, `leipzig`, `marble`, `maya`,
+ *              `metal`, `modern`, `nature`, `neo_wood`, `newspaper`, `ocean`,
+ *              `sky`, `space`, `tournament`, `vintage`, `wood`.
+ * @param size  One of chess.com's supported pixel sizes (default 150).
+ */
+declare function chesscomPieceUrls(style: string, size?: 150 | 300): PieceUrlTable;
+
+export { BOARD_CELL_KEY as B, type PieceRenderer as P, type PieceUrlTable as a, createImagePieceSet as b, chesscomPieceUrls as c };

package/dist/gigachess-3BDD--yT.d.cts

@@ -0,0 +1,22 @@
+import { E as EngineAdapter } from './board-model-BvJOtwQ3.cjs';
+
+/**
+ * Synchronous engine adapter wrapping `gigachess`.
+ *
+ * Provides a zero-WASM, pure JavaScript chess engine adapter with instant
+ * synchronous initialization (<0.5 ms), incremental { lo, hi } Zobrist hashing,
+ * and canonical King-captures-Rook castling representation (Move2).
+ */
+
+/**
+ * Preload gigachess sliding-attack magic tables and Polyglot Zobrist tables ahead of time.
+ */
+declare function preloadGigachessAdapter(): Promise<void>;
+/**
+ * Create a gigachess-backed engine adapter synchronously.
+ *
+ * @param fen Optional starting FEN.
+ */
+declare function createGigachessAdapter(fen?: string): EngineAdapter;
+
+export { createGigachessAdapter as c, preloadGigachessAdapter as p };

package/dist/gigachess-DolQlR82.d.ts

@@ -0,0 +1,22 @@
+import { E as EngineAdapter } from './board-model-BvJOtwQ3.js';
+
+/**
+ * Synchronous engine adapter wrapping `gigachess`.
+ *
+ * Provides a zero-WASM, pure JavaScript chess engine adapter with instant
+ * synchronous initialization (<0.5 ms), incremental { lo, hi } Zobrist hashing,
+ * and canonical King-captures-Rook castling representation (Move2).
+ */
+
+/**
+ * Preload gigachess sliding-attack magic tables and Polyglot Zobrist tables ahead of time.
+ */
+declare function preloadGigachessAdapter(): Promise<void>;
+/**
+ * Create a gigachess-backed engine adapter synchronously.
+ *
+ * @param fen Optional starting FEN.
+ */
+declare function createGigachessAdapter(fen?: string): EngineAdapter;
+
+export { createGigachessAdapter as c, preloadGigachessAdapter as p };