gigaboard 1.2.3

package/dist/chunk-J6GGNP5S.js

@@ -0,0 +1,1104 @@
+import { ensureMagicTablesLoaded, ensureZobristLoaded, makeSan } from 'gigachess';
+import { Chess } from 'gigachess/chessjs';
+
+// src/core/adapters/gigachess.ts
+
+// src/core/types.ts
+var MOVE2_PROMO_NONE = 0;
+var MOVE2_PROMO_KNIGHT = 1;
+var MOVE2_PROMO_BISHOP = 2;
+var MOVE2_PROMO_ROOK = 3;
+var MOVE2_PROMO_QUEEN = 4;
+function packMove(from, to, promo = MOVE2_PROMO_NONE) {
+  return (from & 63 | (to & 63) << 6 | (promo & 15) << 12) & 65535;
+}
+function unpackMove(move) {
+  const w = move & 65535;
+  return {
+    from: w & 63,
+    to: w >>> 6 & 63,
+    promo: w >>> 12 & 15
+  };
+}
+var Color = {
+  White: 0,
+  Black: 1
+};
+var PieceType = {
+  Pawn: 0,
+  Knight: 1,
+  Bishop: 2,
+  Rook: 3,
+  Queen: 4,
+  King: 5
+};
+var BOARD_CELL_EMPTY = 0;
+var BOARD_CELL_WP = 1;
+var BOARD_CELL_WN = 2;
+var BOARD_CELL_WB = 3;
+var BOARD_CELL_WR = 4;
+var BOARD_CELL_WQ = 5;
+var BOARD_CELL_WK = 6;
+var BOARD_CELL_BP = 7;
+var BOARD_CELL_BN = 8;
+var BOARD_CELL_BB = 9;
+var BOARD_CELL_BR = 10;
+var BOARD_CELL_BQ = 11;
+var BOARD_CELL_BK = 12;
+function toSquareIndex(n) {
+  if (process.env["NODE_ENV"] !== "production") {
+    if (!Number.isInteger(n) || n < 0 || n > 63) {
+      throw new RangeError(`SquareIndex out of range: ${n}`);
+    }
+  }
+  return n;
+}
+function isSquareIndex(n) {
+  return Number.isInteger(n) && n >= 0 && n <= 63;
+}
+function encodeBoardCell(color, type) {
+  return 1 + type + color * 6;
+}
+function isEmptyCell(cell) {
+  return cell === 0;
+}
+function colorOf(cell) {
+  return cell > 6 ? 1 : 0;
+}
+function pieceTypeOf(cell) {
+  return (cell - 1) % 6;
+}
+
+// src/core/adapters/gigachess.ts
+void ensureMagicTablesLoaded().catch(() => {
+});
+void ensureZobristLoaded().catch(() => {
+});
+function preloadGigachessAdapter() {
+  return Promise.all([ensureMagicTablesLoaded(), ensureZobristLoaded()]).then(() => void 0);
+}
+function algebraicOf(sq) {
+  const file = sq & 7;
+  const rank = sq >> 3;
+  return `${String.fromCharCode(97 + file)}${rank + 1}`;
+}
+function squareIndexOf(alg) {
+  const file = alg.charCodeAt(0) - 97;
+  const rank = alg.charCodeAt(1) - 49;
+  return rank * 8 + file;
+}
+function promoRole(code) {
+  switch (code) {
+    case 1:
+      return 1;
+    // Knight
+    case 2:
+      return 2;
+    // Bishop
+    case 3:
+      return 3;
+    // Rook
+    case 4:
+      return 4;
+    // Queen
+    default:
+      return void 0;
+  }
+}
+function promoChar(piece) {
+  switch (piece) {
+    case 1:
+      return "n";
+    case 2:
+      return "b";
+    case 3:
+      return "r";
+    case 4:
+      return "q";
+    default:
+      return void 0;
+  }
+}
+function createGigachessAdapter(fen) {
+  const chess = fen === void 0 ? new Chess() : new Chess(fen);
+  const makeMove = (from, to, promotion) => {
+    try {
+      const fromAlg = algebraicOf(from);
+      const toAlg = algebraicOf(to);
+      const promo = promoChar(promotion);
+      const res = chess.move({
+        from: fromAlg,
+        to: toAlg,
+        ...promo ? { promotion: promo } : {}
+      });
+      if (res === null) return null;
+      if (res.flags.includes("k")) {
+        return res.color === "w" ? packMove(4, 7, 0) : packMove(60, 63, 0);
+      }
+      if (res.flags.includes("q")) {
+        return res.color === "w" ? packMove(4, 0, 0) : packMove(60, 56, 0);
+      }
+      const pCode = res.promotion ? res.promotion === "n" ? 1 : res.promotion === "b" ? 2 : res.promotion === "r" ? 3 : 4 : 0;
+      return packMove(from, to, pCode);
+    } catch {
+      return null;
+    }
+  };
+  const undo = () => {
+    const res = chess.undo();
+    if (res === null) return null;
+    if (res.flags.includes("k")) {
+      return res.color === "w" ? packMove(4, 7, 0) : packMove(60, 63, 0);
+    }
+    if (res.flags.includes("q")) {
+      return res.color === "w" ? packMove(4, 0, 0) : packMove(60, 56, 0);
+    }
+    const from = squareIndexOf(res.from);
+    const to = squareIndexOf(res.to);
+    const pCode = res.promotion ? res.promotion === "n" ? 1 : res.promotion === "b" ? 2 : res.promotion === "r" ? 3 : 4 : 0;
+    return packMove(from, to, pCode);
+  };
+  const legalMoves = (from) => {
+    const moves = from === void 0 ? chess.moves({ verbose: true }) : chess.moves({ verbose: true, square: algebraicOf(from) });
+    const out = [];
+    for (let i = 0; i < moves.length; i++) {
+      const m = moves[i];
+      if (m === void 0) continue;
+      if (m.flags.includes("k")) {
+        out.push(m.color === "w" ? packMove(4, 7, 0) : packMove(60, 63, 0));
+      } else if (m.flags.includes("q")) {
+        out.push(m.color === "w" ? packMove(4, 0, 0) : packMove(60, 56, 0));
+      } else {
+        const f = squareIndexOf(m.from);
+        const t = squareIndexOf(m.to);
+        const pCode = m.promotion ? m.promotion === "n" ? 1 : m.promotion === "b" ? 2 : m.promotion === "r" ? 3 : 4 : 0;
+        out.push(packMove(f, t, pCode));
+      }
+    }
+    return out;
+  };
+  const readBoard = (out) => {
+    if (process.env["NODE_ENV"] !== "production") {
+      if (out.length !== 64) {
+        throw new RangeError("readBoard: out.length must be 64");
+      }
+    }
+    out.fill(0);
+    const b = chess.boardInstance;
+    for (let sq = 0; sq < 64; sq++) {
+      const p = b.pieceAt(sq);
+      if (p !== void 0) {
+        out[sq] = encodeBoardCell(p.color, p.role);
+      }
+    }
+  };
+  const san = (move) => {
+    const { from, to, promo } = unpackMove(move);
+    const role = promoRole(promo);
+    return makeSan(
+      {
+        from,
+        to,
+        ...role !== void 0 ? { promotion: role } : {}
+      },
+      chess.pos
+    );
+  };
+  return {
+    makeMove,
+    undo,
+    legalMoves,
+    readBoard,
+    fen: () => chess.fen(),
+    turn: () => chess.turn() === "w" ? Color.White : Color.Black,
+    hash: () => chess.zobrist(),
+    inCheck: () => chess.inCheck(),
+    san,
+    isGameOver: () => chess.isGameOver(),
+    load: (f) => chess.load(f),
+    reset: () => chess.reset(),
+    dispose: () => {
+    }
+  };
+}
+
+// src/core/animation-planner.ts
+var MOVE_FROM_MASK = 63;
+var MOVE_TO_SHIFT = 6;
+var MOVE_TO_MASK = 63;
+var MOVE_PROMO_SHIFT = 12;
+var MOVE_PROMO_MASK = 15;
+var PROMO_PIECE = [
+  null,
+  PieceType.Knight,
+  PieceType.Bishop,
+  PieceType.Rook,
+  PieceType.Queen
+];
+function planAnimations(prev, next, move) {
+  if (process.env["NODE_ENV"] !== "production") {
+    if (prev.length !== 64 || next.length !== 64) {
+      throw new RangeError("planAnimations: board buffers must be length 64");
+    }
+  }
+  if (move !== null) {
+    return planFromMove(prev, next, move);
+  }
+  return planFromDiff(prev, next);
+}
+function planFromMove(prev, next, move) {
+  const from = move & MOVE_FROM_MASK;
+  const to = move >> MOVE_TO_SHIFT & MOVE_TO_MASK;
+  const promoCode = move >> MOVE_PROMO_SHIFT & MOVE_PROMO_MASK;
+  const pieceBefore = prev[from];
+  const pieceAfter = next[to];
+  const targetBefore = prev[to];
+  if (!isEmptyCell(pieceBefore) && pieceTypeOf(pieceBefore) === PieceType.King) {
+    const isFriendlyRookTarget = !isEmptyCell(targetBefore) && colorOf(targetBefore) === colorOf(pieceBefore) && pieceTypeOf(targetBefore) === PieceType.Rook;
+    const isKingCapturesRookCanonical = from === 4 && (to === 7 || to === 0) || from === 60 && (to === 63 || to === 56);
+    const isKingTwoSquares = from === 4 && (to === 6 || to === 2) || from === 60 && (to === 62 || to === 58);
+    if (isFriendlyRookTarget || isKingCapturesRookCanonical || isKingTwoSquares) {
+      const isKingside = (to & 7) > (from & 7);
+      const kingRank = from >> 3;
+      const base = kingRank << 3;
+      const kingFrom = from;
+      const kingTo = base + (isKingside ? 6 : 2);
+      const rookFrom = base + (isKingside ? 7 : 0);
+      const rookTo = base + (isKingside ? 5 : 3);
+      return [
+        {
+          kind: "castle",
+          kingFrom,
+          kingTo,
+          rookFrom,
+          rookTo
+        }
+      ];
+    }
+  }
+  if (!isEmptyCell(pieceBefore) && pieceTypeOf(pieceBefore) === PieceType.Pawn && (from & 7) !== (to & 7) && isEmptyCell(targetBefore)) {
+    const capturedSquare = from & -8 | to & 7;
+    const captured = prev[capturedSquare];
+    return [
+      {
+        kind: "en-passant",
+        from,
+        to,
+        capturedSquare,
+        piece: pieceBefore,
+        captured
+      }
+    ];
+  }
+  if (promoCode > 0) {
+    const captured = isEmptyCell(targetBefore) ? null : targetBefore;
+    return [
+      {
+        kind: "promotion",
+        from,
+        to,
+        pieceBefore,
+        pieceAfter,
+        captured
+      }
+    ];
+  }
+  if (!isEmptyCell(targetBefore)) {
+    return [
+      {
+        kind: "capture",
+        from,
+        to,
+        piece: pieceBefore,
+        captured: targetBefore
+      }
+    ];
+  }
+  return [{ kind: "move", from, to, piece: pieceBefore }];
+}
+function planFromDiff(prev, next) {
+  const descriptors = [];
+  for (let i = 0; i < 64; i++) {
+    const a = prev[i];
+    const b = next[i];
+    if (a === b) continue;
+    const at = i;
+    if (!isEmptyCell(a) && isEmptyCell(b)) {
+      descriptors.push({ kind: "disappear", at, piece: a });
+    } else if (isEmptyCell(a) && !isEmptyCell(b)) {
+      descriptors.push({ kind: "appear", at, piece: b });
+    } else {
+      descriptors.push({ kind: "disappear", at, piece: a });
+      descriptors.push({ kind: "appear", at, piece: b });
+    }
+  }
+  return descriptors;
+}
+function decodePackedMove(m) {
+  const from = m & MOVE_FROM_MASK;
+  const to = m >> MOVE_TO_SHIFT & MOVE_TO_MASK;
+  const promoCode = m >> MOVE_PROMO_SHIFT & MOVE_PROMO_MASK;
+  const promotion = PROMO_PIECE[promoCode] ?? null;
+  const isCastle = from === 4 && (to === 7 || to === 0 || to === 6 || to === 2) || from === 60 && (to === 63 || to === 56 || to === 62 || to === 58);
+  const kind = promotion !== null ? "promotion" : isCastle ? "castle" : "normal";
+  return { from, to, kind, promotion };
+}
+var animationInspect = {
+  colorOf,
+  pieceTypeOf,
+  // Re-export the Color / PieceType enums so consumers can compare without
+  // extra imports.
+  Color,
+  PieceType
+};
+
+// src/core/arrow-model.ts
+function arrowKey(arrow) {
+  let key = `${arrow.from}|${arrow.to}|${arrow.color}`;
+  if (arrow.brush !== void 0) key += `|b:${arrow.brush}`;
+  if (arrow.label !== void 0) key += `|l:${arrow.label.text}`;
+  if (arrow.customSvg !== void 0) key += `|s:${arrow.customSvg.html}`;
+  if (arrow.below === true) key += "|below";
+  return key;
+}
+function freezeArrow(a) {
+  const out = { from: a.from, to: a.to, color: a.color };
+  if (a.brush !== void 0) out.brush = a.brush;
+  if (a.label !== void 0) out.label = Object.freeze({ ...a.label });
+  if (a.customSvg !== void 0) out.customSvg = Object.freeze({ ...a.customSvg });
+  if (a.below === true) out.below = true;
+  if (a.managed === true) out.managed = true;
+  return Object.freeze(out);
+}
+var EMPTY_ARROWS = Object.freeze([]);
+function createArrowModel() {
+  const byKey = /* @__PURE__ */ new Map();
+  let changed = false;
+  let cached = EMPTY_ARROWS;
+  const invalidate = () => {
+    cached = null;
+  };
+  const has = (arrow) => byKey.has(arrowKey(arrow));
+  const add = (arrow) => {
+    const key = arrowKey(arrow);
+    if (byKey.has(key)) {
+      changed = false;
+      return;
+    }
+    byKey.set(key, freezeArrow(arrow));
+    changed = true;
+    invalidate();
+  };
+  const remove = (arrow) => {
+    changed = byKey.delete(arrowKey(arrow));
+    if (changed) invalidate();
+  };
+  const toggle = (arrow) => {
+    const key = arrowKey(arrow);
+    if (byKey.has(key)) {
+      byKey.delete(key);
+      changed = true;
+      invalidate();
+      return false;
+    }
+    byKey.set(key, freezeArrow(arrow));
+    changed = true;
+    invalidate();
+    return true;
+  };
+  const clear = () => {
+    changed = byKey.size > 0;
+    byKey.clear();
+    if (changed) invalidate();
+  };
+  const dropWhere = (remove2) => {
+    let mutated = false;
+    for (const [key, arrow] of byKey) {
+      if (remove2(arrow)) {
+        byKey.delete(key);
+        mutated = true;
+      }
+    }
+    changed = mutated;
+    if (mutated) invalidate();
+  };
+  const clearUser = () => dropWhere((a) => a.managed !== true);
+  const clearManaged = () => dropWhere((a) => a.managed === true);
+  const setManaged = (arrows) => {
+    const nextKeys = /* @__PURE__ */ new Set();
+    let mutated = false;
+    for (let i = 0; i < arrows.length; i++) {
+      const raw = arrows[i];
+      if (raw === void 0) continue;
+      const marked = raw.managed === true ? raw : { ...raw, managed: true };
+      const key = arrowKey(marked);
+      if (nextKeys.has(key)) continue;
+      nextKeys.add(key);
+      if (!byKey.has(key)) {
+        byKey.set(key, freezeArrow(marked));
+        mutated = true;
+      }
+    }
+    for (const [key, arrow] of byKey) {
+      if (arrow.managed === true && !nextKeys.has(key)) {
+        byKey.delete(key);
+        mutated = true;
+      }
+    }
+    changed = mutated;
+    if (mutated) invalidate();
+  };
+  const setAll = (arrows) => {
+    const nextKeys = /* @__PURE__ */ new Set();
+    let mutated = false;
+    for (let i = 0; i < arrows.length; i++) {
+      const a = arrows[i];
+      if (a === void 0) continue;
+      const key = arrowKey(a);
+      if (nextKeys.has(key)) continue;
+      nextKeys.add(key);
+      if (!byKey.has(key)) {
+        byKey.set(key, freezeArrow(a));
+        mutated = true;
+      }
+    }
+    if (byKey.size !== nextKeys.size) {
+      for (const key of byKey.keys()) {
+        if (!nextKeys.has(key)) {
+          byKey.delete(key);
+          mutated = true;
+        }
+      }
+    }
+    changed = mutated;
+    if (mutated) invalidate();
+  };
+  return {
+    get arrows() {
+      if (cached === null) {
+        cached = Object.freeze([...byKey.values()]);
+      }
+      return cached;
+    },
+    has,
+    add,
+    remove,
+    toggle,
+    clear,
+    clearUser,
+    clearManaged,
+    setAll,
+    setManaged,
+    get lastChanged() {
+      return changed;
+    }
+  };
+}
+function makeArrow(from, to, color) {
+  return Object.freeze({ from, to, color });
+}
+
+// src/core/drag-controller.ts
+var DEFAULT_ACTIVATION_DISTANCE = 4;
+function createDragController(options = {}) {
+  const activationDistance = options.activationDistance ?? DEFAULT_ACTIVATION_DISTANCE;
+  if (!Number.isFinite(activationDistance) || activationDistance < 0) {
+    throw new RangeError(
+      `DragController: activationDistance must be a non-negative number, got ${activationDistance}`
+    );
+  }
+  const thresholdSq = activationDistance * activationDistance;
+  let state = { kind: "idle" };
+  const pointerDown = (from, pointerId, x, y) => {
+    if (state.kind !== "idle") return false;
+    state = { kind: "pending", from, pointerId, originX: x, originY: y };
+    return true;
+  };
+  const pointerMove = (pointerId, x, y) => {
+    if (state.kind === "idle") return null;
+    if (state.pointerId !== pointerId) return null;
+    if (state.kind === "pending") {
+      const dx = x - state.originX;
+      const dy = y - state.originY;
+      if (dx * dx + dy * dy < thresholdSq) {
+        return null;
+      }
+      const from = state.from;
+      state = { kind: "dragging", from, pointerId, x, y };
+      return { kind: "drag-start", from };
+    }
+    state = { kind: "dragging", from: state.from, pointerId, x, y };
+    return { kind: "drag-move", from: state.from, x, y };
+  };
+  const pointerUp = (pointerId, x, y) => {
+    if (state.kind === "idle") return null;
+    if (state.pointerId !== pointerId) return null;
+    if (state.kind === "dragging") {
+      const event2 = { kind: "drop", from: state.from, x, y, wasDrag: true };
+      state = { kind: "idle" };
+      return event2;
+    }
+    const event = { kind: "click", from: state.from };
+    state = { kind: "idle" };
+    return event;
+  };
+  const cancel = () => {
+    if (state.kind === "idle") return null;
+    const event = { kind: "cancel", from: state.from };
+    state = { kind: "idle" };
+    return event;
+  };
+  return {
+    get state() {
+      return state;
+    },
+    pointerDown,
+    pointerMove,
+    pointerUp,
+    cancel
+  };
+}
+
+// src/core/legal-move-index.ts
+function makeKey(hash, from) {
+  if (typeof hash === "bigint") {
+    return `${hash}_${from}`;
+  }
+  return `${hash.lo}_${hash.hi}_${from}`;
+}
+function createLegalMoveIndex(options = {}) {
+  const capacity = options.capacity ?? 1024;
+  if (!Number.isInteger(capacity) || capacity < 1) {
+    throw new RangeError(`LegalMoveIndex: capacity must be a positive integer, got ${capacity}`);
+  }
+  const entries = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  const get = (hash, from) => {
+    const key = makeKey(hash, from);
+    const hit = entries.get(key);
+    if (hit === void 0) {
+      misses++;
+      return void 0;
+    }
+    entries.delete(key);
+    entries.set(key, hit);
+    hits++;
+    return hit;
+  };
+  const set = (hash, from, tos) => {
+    const key = makeKey(hash, from);
+    if (entries.has(key)) {
+      entries.delete(key);
+    } else if (entries.size >= capacity) {
+      const oldest = entries.keys().next().value;
+      if (oldest !== void 0) entries.delete(oldest);
+    }
+    entries.set(key, tos);
+  };
+  const clear = () => {
+    entries.clear();
+  };
+  const resetStats = () => {
+    hits = 0;
+    misses = 0;
+  };
+  return {
+    get,
+    set,
+    clear,
+    resetStats,
+    get size() {
+      return entries.size;
+    },
+    capacity,
+    get hits() {
+      return hits;
+    },
+    get misses() {
+      return misses;
+    }
+  };
+}
+
+// src/core/premove-buffer.ts
+function freezePremove(p) {
+  if (p.promotion === void 0) {
+    return Object.freeze({ from: p.from, to: p.to });
+  }
+  return Object.freeze({ from: p.from, to: p.to, promotion: p.promotion });
+}
+var EMPTY_PREMOVES = Object.freeze([]);
+function createPremoveBuffer() {
+  const queue = [];
+  let cached = EMPTY_PREMOVES;
+  const peek = () => queue[0];
+  const push = (premove) => {
+    queue.push(freezePremove(premove));
+    cached = null;
+  };
+  const shift = () => {
+    const head = queue.shift();
+    if (head !== void 0) cached = null;
+    return head;
+  };
+  const clear = () => {
+    if (queue.length > 0) {
+      queue.length = 0;
+      cached = null;
+    }
+  };
+  return {
+    get all() {
+      if (cached === null) {
+        cached = Object.freeze([...queue]);
+      }
+      return cached;
+    },
+    peek,
+    push,
+    shift,
+    clear,
+    get length() {
+      return queue.length;
+    }
+  };
+}
+function makePremove(from, to, promotion) {
+  return promotion === void 0 ? Object.freeze({ from, to }) : Object.freeze({ from, to, promotion });
+}
+
+// src/core/subscribe-store.ts
+function createBoardStore(initial) {
+  let snapshot = initial;
+  const globalListeners = /* @__PURE__ */ new Set();
+  const squareListeners = new Array(64);
+  const notify = (set) => {
+    for (const l of [...set]) l();
+  };
+  const getSnapshot = () => snapshot;
+  const subscribe = (listener) => {
+    globalListeners.add(listener);
+    let alive = true;
+    return () => {
+      if (!alive) return;
+      alive = false;
+      globalListeners.delete(listener);
+    };
+  };
+  const subscribeSquare = (index, listener) => {
+    let set = squareListeners[index];
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      squareListeners[index] = set;
+    }
+    set.add(listener);
+    let alive = true;
+    return () => {
+      if (!alive) return;
+      alive = false;
+      set.delete(listener);
+    };
+  };
+  const commit = (next) => {
+    if (next === snapshot) return;
+    const prev = snapshot;
+    snapshot = next;
+    const prevBoard = prev.board;
+    const nextBoard = next.board;
+    if (prevBoard !== nextBoard) {
+      for (let i = 0; i < 64; i++) {
+        if (prevBoard[i] !== nextBoard[i]) {
+          const set = squareListeners[i];
+          if (set && set.size > 0) notify(set);
+        }
+      }
+    }
+    if (globalListeners.size > 0) notify(globalListeners);
+  };
+  return { getSnapshot, subscribe, subscribeSquare, commit };
+}
+
+// src/core/board-model.ts
+var EMPTY_SET = Object.freeze(
+  /* @__PURE__ */ new Set()
+);
+function moveTo(m) {
+  return m >> 6 & 63;
+}
+function normalizeCastlingTarget(from, to) {
+  if (from === 4) {
+    if (to === 6) return 7;
+    if (to === 2) return 0;
+  } else if (from === 60) {
+    if (to === 62) return 63;
+    if (to === 58) return 56;
+  }
+  return to;
+}
+function createBoardModel(engine, options = {}) {
+  const freezeSnapshots = options.freezeSnapshots ?? process.env["NODE_ENV"] !== "production";
+  const legalMoveIndex = createLegalMoveIndex(options.legalMoveIndex ?? {});
+  const arrowModel = createArrowModel();
+  const premoveBuffer = createPremoveBuffer();
+  const drag = createDragController(options.dragController ?? {});
+  const history = [];
+  const redoStack = [];
+  let selected = null;
+  let lastMove = null;
+  let lastAnimations = [];
+  let disposed = false;
+  const stageBuffer = new Uint8Array(64);
+  const readBoardCopy = () => {
+    engine.readBoard(stageBuffer);
+    return new Uint8Array(stageBuffer);
+  };
+  const computeLegalTargets = (fromBoard) => {
+    if (selected === null) return EMPTY_SET;
+    const pieceOnSquare = fromBoard[selected];
+    if (pieceOnSquare === 0 || pieceOnSquare === void 0) return EMPTY_SET;
+    const hash = engine.hash();
+    let tos = legalMoveIndex.get(hash, selected);
+    if (tos === void 0) {
+      const moves = engine.legalMoves(selected);
+      const buf = new Uint8Array(moves.length);
+      for (let i = 0; i < moves.length; i++) {
+        const m = moves[i];
+        if (m === void 0) continue;
+        buf[i] = moveTo(m);
+      }
+      legalMoveIndex.set(hash, selected, buf);
+      tos = buf;
+    }
+    if (tos.length === 0) return EMPTY_SET;
+    const set = /* @__PURE__ */ new Set();
+    for (let i = 0; i < tos.length; i++) {
+      const t = tos[i];
+      if (t !== void 0) set.add(t);
+    }
+    return set;
+  };
+  const buildSnapshot = () => {
+    const board = readBoardCopy();
+    const legalTargets = computeLegalTargets(board);
+    const snap = {
+      board,
+      turn: engine.turn(),
+      hash: engine.hash(),
+      lastMove,
+      selected,
+      legalTargets,
+      inCheck: engine.inCheck(),
+      isGameOver: engine.isGameOver(),
+      historyPly: history.length,
+      historyLength: history.length + redoStack.length,
+      arrows: arrowModel.arrows,
+      premoves: premoveBuffer.all
+    };
+    return freezeSnapshots ? Object.freeze(snap) : snap;
+  };
+  const store = createBoardStore(buildSnapshot());
+  const commitWith = (triggerMove) => {
+    const prev = store.getSnapshot();
+    const next = buildSnapshot();
+    lastAnimations = planAnimations(prev.board, next.board, triggerMove);
+    store.commit(next);
+  };
+  const tryApplyPremoves = () => {
+    let last = null;
+    while (premoveBuffer.length > 0) {
+      const pm = premoveBuffer.peek();
+      if (pm === void 0) break;
+      const m = engine.makeMove(pm.from, pm.to, pm.promotion);
+      if (m === null) {
+        premoveBuffer.clear();
+        break;
+      }
+      premoveBuffer.shift();
+      history.push(m);
+      last = m;
+    }
+    return last;
+  };
+  const selectSquare = (index) => {
+    if (selected === index) return;
+    selected = index;
+    commitWith(null);
+  };
+  const tryMove = (from, to, promotion) => {
+    const resolvedTo = normalizeCastlingTarget(from, to);
+    let m = engine.makeMove(from, resolvedTo, promotion);
+    if (m === null && resolvedTo !== to) {
+      m = engine.makeMove(from, to, promotion);
+    }
+    if (m === null) return null;
+    redoStack.length = 0;
+    history.push(m);
+    lastMove = m;
+    selected = null;
+    const last = tryApplyPremoves();
+    if (last === null) {
+      commitWith(m);
+    } else {
+      lastMove = last;
+      commitWith(null);
+    }
+    return m;
+  };
+  const undo = () => {
+    const m = engine.undo();
+    if (m === null) return null;
+    redoStack.push(m);
+    history.pop();
+    lastMove = history[history.length - 1] ?? null;
+    selected = null;
+    commitWith(null);
+    return m;
+  };
+  const redo = () => {
+    const m = redoStack.pop();
+    if (m === void 0) return null;
+    const from = m & 63;
+    const to = moveTo(m);
+    const promoBits = m >> 12 & 15;
+    const promotion = promoBits > 0 ? promoBits : void 0;
+    const applied = engine.makeMove(from, to, promotion);
+    if (applied === null) {
+      return null;
+    }
+    history.push(applied);
+    lastMove = applied;
+    selected = null;
+    commitWith(applied);
+    return applied;
+  };
+  const goto = (ply) => {
+    if (!Number.isInteger(ply) || ply < 0) return;
+    const total = history.length + redoStack.length;
+    if (ply > total) return;
+    while (history.length > ply) {
+      const m = engine.undo();
+      if (m === null) break;
+      redoStack.push(m);
+      history.pop();
+    }
+    while (history.length < ply) {
+      const m = redoStack.pop();
+      if (m === void 0) break;
+      const from = m & 63;
+      const to = moveTo(m);
+      const promoBits = m >> 12 & 15;
+      const promotion = promoBits > 0 ? promoBits : void 0;
+      const applied = engine.makeMove(from, to, promotion);
+      if (applied === null) break;
+      history.push(applied);
+    }
+    lastMove = history[history.length - 1] ?? null;
+    selected = null;
+    commitWith(null);
+  };
+  const load = (fen) => {
+    engine.load(fen);
+    history.length = 0;
+    redoStack.length = 0;
+    premoveBuffer.clear();
+    arrowModel.clear();
+    selected = null;
+    lastMove = null;
+    legalMoveIndex.clear();
+    commitWith(null);
+  };
+  const syncPosition = ({
+    fen,
+    managedArrows,
+    preserveUserArrows = false
+  }) => {
+    const positionChanged = engine.fen() !== fen;
+    if (positionChanged) {
+      engine.load(fen);
+      history.length = 0;
+      redoStack.length = 0;
+      premoveBuffer.clear();
+      if (preserveUserArrows) {
+        if (managedArrows !== void 0) {
+          arrowModel.setManaged(managedArrows);
+        }
+      } else {
+        arrowModel.clear();
+        if (managedArrows !== void 0) {
+          arrowModel.setManaged(managedArrows);
+        }
+      }
+      selected = null;
+      lastMove = null;
+      legalMoveIndex.clear();
+      commitWith(null);
+      return;
+    }
+    if (managedArrows === void 0) {
+      return;
+    }
+    arrowModel.setManaged(managedArrows);
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const reset = () => {
+    engine.reset();
+    history.length = 0;
+    redoStack.length = 0;
+    premoveBuffer.clear();
+    arrowModel.clear();
+    selected = null;
+    lastMove = null;
+    legalMoveIndex.clear();
+    commitWith(null);
+  };
+  const isLegal = (from, to, promotion) => {
+    const resolvedTo = normalizeCastlingTarget(from, to);
+    const hash = engine.hash();
+    const cached = legalMoveIndex.get(hash, from);
+    if (cached !== void 0 && promotion === void 0) {
+      for (let i = 0; i < cached.length; i++) {
+        if (cached[i] === resolvedTo || cached[i] === to) return true;
+      }
+      return false;
+    }
+    const moves = engine.legalMoves(from);
+    for (let i = 0; i < moves.length; i++) {
+      const m = moves[i];
+      if (m === void 0) continue;
+      const target = moveTo(m);
+      if (target !== resolvedTo && target !== to) continue;
+      if (promotion === void 0) return true;
+      const promoBits = m >> 12 & 15;
+      if (promoBits === 0) return true;
+      if (promoBits === promotion) return true;
+    }
+    return false;
+  };
+  const legalFrom = (from) => {
+    const hash = engine.hash();
+    let tos = legalMoveIndex.get(hash, from);
+    if (tos === void 0) {
+      const moves = engine.legalMoves(from);
+      const buf = new Uint8Array(moves.length);
+      for (let i = 0; i < moves.length; i++) {
+        const m = moves[i];
+        if (m === void 0) continue;
+        buf[i] = moveTo(m);
+      }
+      legalMoveIndex.set(hash, from, buf);
+      tos = buf;
+    }
+    if (tos.length === 0) return EMPTY_SET;
+    const set = /* @__PURE__ */ new Set();
+    for (let i = 0; i < tos.length; i++) {
+      const t = tos[i];
+      if (t !== void 0) {
+        set.add(t);
+        if (from === 4) {
+          if (t === 7) set.add(6);
+          else if (t === 0) set.add(2);
+        } else if (from === 60) {
+          if (t === 63) set.add(62);
+          else if (t === 56) set.add(58);
+        }
+      }
+    }
+    return set;
+  };
+  const addArrow = (arrow) => {
+    arrowModel.add(arrow);
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const removeArrow = (arrow) => {
+    arrowModel.remove(arrow);
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const toggleArrow = (arrow) => {
+    arrowModel.toggle(arrow);
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const clearArrows = () => {
+    arrowModel.clear();
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const clearUserArrows = () => {
+    arrowModel.clearUser();
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const clearManagedArrows = () => {
+    arrowModel.clearManaged();
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const setArrows = (arrows) => {
+    arrowModel.setAll(arrows);
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const setManagedArrows = (arrows) => {
+    arrowModel.setManaged(arrows);
+    if (arrowModel.lastChanged) commitWith(null);
+  };
+  const queuePremove = (premove) => {
+    premoveBuffer.push(premove);
+    commitWith(null);
+  };
+  const clearPremoves = () => {
+    if (premoveBuffer.length === 0) return;
+    premoveBuffer.clear();
+    commitWith(null);
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    engine.dispose();
+    legalMoveIndex.clear();
+    history.length = 0;
+    redoStack.length = 0;
+    premoveBuffer.clear();
+    arrowModel.clear();
+  };
+  return {
+    getSnapshot: () => store.getSnapshot(),
+    subscribe: (l) => store.subscribe(l),
+    subscribeSquare: (i, l) => store.subscribeSquare(i, l),
+    selectSquare,
+    tryMove,
+    undo,
+    redo,
+    goto,
+    load,
+    syncPosition,
+    reset,
+    isLegal,
+    legalFrom,
+    addArrow,
+    removeArrow,
+    toggleArrow,
+    clearArrows,
+    clearUserArrows,
+    clearManagedArrows,
+    setArrows,
+    setManagedArrows,
+    queuePremove,
+    clearPremoves,
+    drag,
+    legalMoveCache: legalMoveIndex,
+    engine,
+    get lastAnimations() {
+      return lastAnimations;
+    },
+    dispose
+  };
+}
+
+// src/core/engine-adapter.ts
+function writeBoardCell(out, index, cell) {
+  out[index] = cell;
+}
+
+// src/core/index.ts
+var PACKAGE_VERSION = "0.1.0-alpha";
+
+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 };
+//# sourceMappingURL=chunk-J6GGNP5S.js.map
+//# sourceMappingURL=chunk-J6GGNP5S.js.map