hyperchess-core 0.1.0

package/dist/standalone.js

@@ -0,0 +1,323 @@
+// src/board/hfen.ts
+var IDENTITY_START_TYPE = {
+  A: "E",
+  B: "H",
+  C: "R",
+  D: "N",
+  E: "B",
+  F: "Q",
+  G: "K",
+  H: "B",
+  I: "N",
+  J: "R",
+  K: "H",
+  L: "E",
+  M: "P",
+  N: "P",
+  O: "P",
+  P: "P",
+  Q: "P",
+  R: "P",
+  S: "P",
+  T: "P",
+  U: "P",
+  V: "P",
+  W: "P",
+  X: "P"
+};
+var PROMOTION_TYPES = "QRBNEH";
+function identityStartType(identity) {
+  return IDENTITY_START_TYPE[identity.toUpperCase()];
+}
+function isIdentityChar(c) {
+  return c.length === 1 && IDENTITY_START_TYPE[c.toUpperCase()] !== void 0;
+}
+function parseHfenPosition(position) {
+  const squares = new Array(144).fill(void 0);
+  const ranks = position.split("/");
+  if (ranks.length !== 12) {
+    throw new Error(`HFEN position needs 12 ranks, got ${ranks.length}`);
+  }
+  const identityMode = /[ACDFGIJLMOSTUVWXacdfgijlmostuvwx]/.test(position);
+  ranks.forEach((rankStr, rankFromTop) => {
+    const rank = 11 - rankFromTop;
+    let file = 0;
+    const tokens = rankStr.match(/[A-Za-z]:[A-Za-z]|[A-Za-z]|\d+/g) ?? [];
+    if (tokens.join("") !== rankStr) {
+      throw new Error(`Malformed HFEN rank ${rank + 1}: ${rankStr}`);
+    }
+    for (const token of tokens) {
+      if (/^\d+$/.test(token)) {
+        file += parseInt(token, 10);
+        continue;
+      }
+      if (file >= 12) {
+        throw new Error(`Too many squares on HFEN rank ${rank + 1}`);
+      }
+      let identity;
+      let typeChar;
+      if (token.length === 3) {
+        identity = token[0];
+        typeChar = token[2];
+        if (!PROMOTION_TYPES.includes(typeChar.toUpperCase())) {
+          throw new Error(
+            `Invalid \`id:Type\` type letter '${typeChar}' in ${token}: the type half must be one of ${PROMOTION_TYPES.split("").join(" ")}`
+          );
+        }
+        const identityIsWhite = identity === identity.toUpperCase();
+        const typeIsWhite = typeChar === typeChar.toUpperCase();
+        if (identityIsWhite !== typeIsWhite) {
+          throw new Error(`Type override ${token} changes piece color`);
+        }
+      } else if (identityMode && isIdentityChar(token)) {
+        identity = token;
+        typeChar = token;
+      } else {
+        typeChar = token;
+      }
+      const color = typeChar === typeChar.toUpperCase() ? "white" : "black";
+      const type = token.length === 3 || !identity ? typeChar.toUpperCase() : identityStartType(identity);
+      if (!type) {
+        throw new Error(`Invalid HFEN piece character: ${token}`);
+      }
+      squares[rank * 12 + file] = identity ? { type, color, identity } : { type, color };
+      file += 1;
+    }
+    if (file !== 12) {
+      throw new Error(`HFEN rank ${rank + 1} has ${file} squares, expected 12`);
+    }
+  });
+  return squares;
+}
+function serializeSquare(piece) {
+  const typeChar = piece.color === "white" ? piece.type : piece.type.toLowerCase();
+  if (!piece.identity) {
+    return typeChar;
+  }
+  if (identityStartType(piece.identity) === piece.type) {
+    return piece.identity;
+  }
+  return `${piece.identity}:${typeChar}`;
+}
+function getBoardHfen(board) {
+  const rankSegments = [];
+  for (let rank = 11; rank >= 0; rank--) {
+    let segment = "";
+    let emptyCount = 0;
+    for (let file = 0; file < 12; file++) {
+      const piece = board.pieces[rank * 12 + file];
+      if (!piece) {
+        emptyCount++;
+      } else {
+        if (emptyCount > 0) {
+          segment += emptyCount;
+          emptyCount = 0;
+        }
+        segment += serializeSquare(piece);
+      }
+    }
+    if (emptyCount > 0) segment += emptyCount;
+    rankSegments.push(segment);
+  }
+  let hfen = rankSegments.join("/");
+  hfen += ` ${board.toMove === "white" ? "w" : "b"}`;
+  const castling = (board.castlingRights.whiteKingSide ? "K" : "") + (board.castlingRights.whiteQueenSide ? "Q" : "") + (board.castlingRights.blackKingSide ? "k" : "") + (board.castlingRights.blackQueenSide ? "q" : "");
+  hfen += ` ${castling || "-"}`;
+  if (board.enPassantSquare === -1) {
+    hfen += " -";
+  } else {
+    const col = String.fromCharCode("a".charCodeAt(0) + board.enPassantSquare % 12);
+    const row = Math.floor(board.enPassantSquare / 12) + 1;
+    hfen += ` ${col}${row}`;
+  }
+  hfen += ` ${board.halfmoveClock}`;
+  hfen += ` ${board.fullmoveNumber}`;
+  return hfen;
+}
+
+// src/board/undo.ts
+function undoMove(board) {
+  if (board.history.length === 0) {
+    throw new Error("No moves to undo");
+  }
+  const lastState = board.history[board.history.length - 1];
+  return {
+    pieces: lastState.pieces,
+    toMove: lastState.toMove,
+    enPassantSquare: lastState.enPassantSquare,
+    castlingRights: lastState.castlingRights,
+    halfmoveClock: lastState.halfmoveClock,
+    fullmoveNumber: lastState.fullmoveNumber,
+    history: board.history.slice(0, -1)
+  };
+}
+
+// src/utils/square-notation.ts
+function algebraicToSquare(algebraic) {
+  const file = algebraic.charCodeAt(0) - "a".charCodeAt(0);
+  const rank = parseInt(algebraic.slice(1), 10) - 1;
+  return rank * 12 + file;
+}
+function squareToAlgebraic(square) {
+  const file = String.fromCharCode("a".charCodeAt(0) + square % 12);
+  const rank = Math.floor(square / 12) + 1;
+  return `${file}${rank}`;
+}
+
+// src/wasm/snapshot.ts
+var ENCODE_PIECE_ORDER = ["P", "N", "B", "R", "Q", "K", "E", "H"];
+function decodePieceByte(byte) {
+  if (byte === 0) return void 0;
+  const color = byte <= 8 ? "white" : "black";
+  const type = ENCODE_PIECE_ORDER[(byte <= 8 ? byte : byte - 8) - 1];
+  return { type, color };
+}
+function parseCastlingRights(castlingStr) {
+  return {
+    whiteKingSide: castlingStr.includes("K"),
+    whiteQueenSide: castlingStr.includes("Q"),
+    blackKingSide: castlingStr.includes("k"),
+    blackQueenSide: castlingStr.includes("q")
+  };
+}
+function parseEnPassant(enPassantStr) {
+  if (enPassantStr === "-") return -1;
+  const match = enPassantStr.match(/^([a-l])(1[0-2]|[1-9])$/);
+  if (!match) return -1;
+  return algebraicToSquare(match[1] + match[2]);
+}
+function snapshotFromWasmBoard(wasmBoard, history = []) {
+  const hfen = wasmBoard.hfen();
+  const hfenParts = hfen.split(" ");
+  const [positionStr, toMoveStr, castlingStr, enPassantStr, halfmoveStr, fullmoveStr] = hfenParts;
+  const pieces = Array.from(wasmBoard.encode()).map(decodePieceByte);
+  let identities;
+  try {
+    identities = parseHfenPosition(positionStr);
+  } catch {
+    identities = void 0;
+  }
+  if (identities) {
+    for (let sq = 0; sq < pieces.length; sq++) {
+      const identity = identities[sq]?.identity;
+      const piece = pieces[sq];
+      if (piece && identity) {
+        pieces[sq] = { ...piece, identity };
+      }
+    }
+  }
+  return {
+    pieces,
+    toMove: toMoveStr === "w" ? "white" : "black",
+    enPassantSquare: parseEnPassant(enPassantStr),
+    castlingRights: parseCastlingRights(castlingStr),
+    halfmoveClock: parseInt(halfmoveStr, 10),
+    fullmoveNumber: parseInt(fullmoveStr || "1", 10),
+    history
+  };
+}
+function moveToUci(move) {
+  const promo = move.promotion ? move.promotion.toLowerCase() : "";
+  return `${squareToAlgebraic(move.from)}${squareToAlgebraic(move.to)}${promo}`;
+}
+function uciToMove(uci, board) {
+  const match = uci.match(/^([a-l](?:1[0-2]|[1-9]))([a-l](?:1[0-2]|[1-9]))([qrbneh])?$/);
+  if (!match) {
+    throw new Error(`Invalid UCI move string: ${uci}`);
+  }
+  const from = algebraicToSquare(match[1]);
+  const to = algebraicToSquare(match[2]);
+  const promotion = match[3] ? match[3].toUpperCase() : void 0;
+  const piece = board.pieces[from];
+  const move = { from, to, promotion };
+  if (piece?.type === "K" && Math.abs(from % 12 - to % 12) === 2) {
+    move.isCastling = true;
+  }
+  if (piece?.type === "P" && to === board.enPassantSquare && board.pieces[to] === void 0) {
+    move.isEnPassant = true;
+  }
+  return move;
+}
+
+// src/standalone.ts
+var wasmBoardCtor = null;
+async function initHyperchessCoreStandalone(wasmInput) {
+  const mod = await import("hyperchess-wasm/web");
+  await mod.default(wasmInput);
+  wasmBoardCtor = mod.WasmBoard;
+}
+function requireWasmBoardCtor() {
+  if (!wasmBoardCtor) {
+    throw new Error(
+      "HyperChess WASM engine not initialized \u2014 call and await initHyperchessCoreStandalone() once before using any other function from hyperchess-core/standalone."
+    );
+  }
+  return wasmBoardCtor;
+}
+function loadWasmBoard(hfen) {
+  const Ctor = requireWasmBoardCtor();
+  if (!hfen) {
+    return new Ctor();
+  }
+  const board = Ctor.from_hfen(hfen);
+  if (!board) {
+    throw new Error(`Invalid HFEN: ${hfen}`);
+  }
+  return board;
+}
+function createBoard(hfen) {
+  return snapshotFromWasmBoard(loadWasmBoard(hfen));
+}
+function applyMove(board, move) {
+  const piece = board.pieces[move.from];
+  if (!piece) {
+    throw new Error(`No piece at source square ${move.from}`);
+  }
+  const wasmBoard = loadWasmBoard(getBoardHfen(board));
+  const applied = wasmBoard.apply_move(moveToUci(move));
+  if (!applied) {
+    throw new Error(`Illegal move: ${move.from} -> ${move.to}`);
+  }
+  const history = [
+    ...board.history,
+    {
+      pieces: [...board.pieces],
+      toMove: board.toMove,
+      enPassantSquare: board.enPassantSquare,
+      castlingRights: { ...board.castlingRights },
+      halfmoveClock: board.halfmoveClock,
+      fullmoveNumber: board.fullmoveNumber
+    }
+  ];
+  return snapshotFromWasmBoard(wasmBoard, history);
+}
+function generateLegalMoves(board) {
+  const wasmBoard = loadWasmBoard(getBoardHfen(board));
+  const uci = wasmBoard.legal_moves();
+  if (uci === "") return [];
+  return uci.split(" ").map((m) => uciToMove(m, board));
+}
+function isLegalMove(board, move) {
+  return generateLegalMoves(board).some((m) => m.from === move.from && m.to === move.to);
+}
+function isInCheck(board) {
+  return loadWasmBoard(getBoardHfen(board)).in_check();
+}
+function isCheckmate(board) {
+  return loadWasmBoard(getBoardHfen(board)).termination() === "checkmate";
+}
+function isStalemate(board) {
+  return loadWasmBoard(getBoardHfen(board)).termination() === "stalemate";
+}
+export {
+  applyMove,
+  createBoard,
+  generateLegalMoves,
+  getBoardHfen,
+  initHyperchessCoreStandalone,
+  isCheckmate,
+  isInCheck,
+  isLegalMove,
+  isStalemate,
+  undoMove
+};

package/dist/standalone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.js","sourceRoot":"","sources":["../src/standalone.ts"],"names":[],"mappings":"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"}

package/dist/types/board.d.ts

@@ -0,0 +1,38 @@
+import { Color } from './move';
+import { Piece } from './piece';
+/** Represents the state of a single board */
+export interface Board {
+    /** Pieces on board: square index → piece (or undefined if empty) */
+    pieces: (Piece | undefined)[];
+    /** Whose turn to move */
+    toMove: Color;
+    /** En passant target square (or -1 if none) */
+    enPassantSquare: number;
+    /** Castling rights: bitmask for White-King-Side, etc */
+    castlingRights: CastlingRights;
+    /** Halfmove clock for 50-move rule */
+    halfmoveClock: number;
+    /** Full move number */
+    fullmoveNumber: number;
+    /** Move history (for undo) */
+    history: BoardState[];
+}
+/** Castling availability */
+export interface CastlingRights {
+    whiteKingSide: boolean;
+    whiteQueenSide: boolean;
+    blackKingSide: boolean;
+    blackQueenSide: boolean;
+}
+/** Snapshot of board state for undo */
+export interface BoardState {
+    pieces: (Piece | undefined)[];
+    toMove: Color;
+    enPassantSquare: number;
+    castlingRights: CastlingRights;
+    halfmoveClock: number;
+    fullmoveNumber: number;
+}
+/** HFEN notation (HFEN-I format) */
+export type HfenString = string;
+//# sourceMappingURL=board.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"board.d.ts","sourceRoot":"","sources":["../../src/types/board.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,6CAA6C;AAC7C,MAAM,WAAW,KAAK;IACpB,oEAAoE;IACpE,MAAM,EAAE,CAAC,KAAK,GAAG,SAAS,CAAC,EAAE,CAAC;IAE9B,yBAAyB;IACzB,MAAM,EAAE,KAAK,CAAC;IAEd,+CAA+C;IAC/C,eAAe,EAAE,MAAM,CAAC;IAExB,wDAAwD;IACxD,cAAc,EAAE,cAAc,CAAC;IAE/B,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IAEtB,uBAAuB;IACvB,cAAc,EAAE,MAAM,CAAC;IAEvB,8BAA8B;IAC9B,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED,4BAA4B;AAC5B,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,uCAAuC;AACvC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,CAAC,KAAK,GAAG,SAAS,CAAC,EAAE,CAAC;IAC9B,MAAM,EAAE,KAAK,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,oCAAoC;AACpC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC"}

package/dist/types/board.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// HyperChess Core — hyperchess-core
+// File: packages/core/src/types/board.ts
+// Version: 1.0.0
+// Copyright (c) 2026 HyperChess Developer Team
+export {};
+//# sourceMappingURL=board.js.map

package/dist/types/board.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"board.js","sourceRoot":"","sources":["../../src/types/board.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,oCAAoC;AACpC,yCAAyC;AACzC,iBAAiB;AACjB,+CAA+C"}

package/dist/types/game.d.ts

@@ -0,0 +1,45 @@
+import { Board, HfenString } from './board';
+import { Move, AlgebraicMove } from './move';
+/** Represents a complete game */
+export interface Game {
+    /** Current board state */
+    board: Board;
+    /** All moves played (in algebraic notation) */
+    moves: AlgebraicMove[];
+    /** Metadata about the game */
+    metadata: GameMetadata;
+    /** Game status */
+    status: GameStatus;
+    /**
+     * The HFEN the game started from, if not the default position. Needed so
+     * `removeLastMove` can replay from the correct origin instead of silently
+     * falling back to the default starting position.
+     */
+    startHfen?: HfenString;
+}
+/** Game metadata */
+export interface GameMetadata {
+    event?: string;
+    site?: string;
+    date?: string;
+    round?: string;
+    white?: string;
+    black?: string;
+    whiteElo?: number;
+    blackElo?: number;
+    result?: GameResult;
+    timeControl?: string;
+}
+/** Possible game outcomes */
+export type GameResult = '1-0' | '0-1' | '1/2-1/2' | '*';
+/** Game status */
+export type GameStatus = 'active' | 'checkmate' | 'stalemate' | 'draw' | 'resigned';
+/** Additional game info */
+export interface GameInfo {
+    legalMoves: Move[];
+    inCheck: boolean;
+    inCheckmate: boolean;
+    inStalemate: boolean;
+    canClaimDraw: boolean;
+}
+//# sourceMappingURL=game.d.ts.map

package/dist/types/game.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game.d.ts","sourceRoot":"","sources":["../../src/types/game.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE7C,iCAAiC;AACjC,MAAM,WAAW,IAAI;IACnB,0BAA0B;IAC1B,KAAK,EAAE,KAAK,CAAC;IAEb,+CAA+C;IAC/C,KAAK,EAAE,aAAa,EAAE,CAAC;IAEvB,8BAA8B;IAC9B,QAAQ,EAAE,YAAY,CAAC;IAEvB,kBAAkB;IAClB,MAAM,EAAE,UAAU,CAAC;IAEnB;;;;OAIG;IACH,SAAS,CAAC,EAAE,UAAU,CAAC;CACxB;AAED,oBAAoB;AACpB,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,6BAA6B;AAC7B,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,GAAG,GAAG,CAAC;AAEzD,kBAAkB;AAClB,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,CAAC;AAEpF,2BAA2B;AAC3B,MAAM,WAAW,QAAQ;IACvB,UAAU,EAAE,IAAI,EAAE,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;CACvB"}

package/dist/types/game.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// HyperChess Core — hyperchess-core
+// File: packages/core/src/types/game.ts
+// Version: 1.0.0
+// Copyright (c) 2026 HyperChess Developer Team
+export {};
+//# sourceMappingURL=game.js.map

package/dist/types/game.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"game.js","sourceRoot":"","sources":["../../src/types/game.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,oCAAoC;AACpC,wCAAwC;AACxC,iBAAiB;AACjB,+CAA+C"}

package/dist/types/move.d.ts

@@ -0,0 +1,24 @@
+/** Color/side in the game */
+export type Color = 'white' | 'black';
+/** Square coordinate (0-143 for 12x12 board) */
+export type Square = number;
+/** Promotion piece type */
+export type PromotionPiece = 'Q' | 'R' | 'B' | 'N' | 'E' | 'H';
+/** Represents a single move */
+export interface Move {
+    from: Square;
+    to: Square;
+    promotion?: PromotionPiece;
+    isEnPassant?: boolean;
+    isCastling?: boolean;
+}
+/** Move in algebraic notation (e.g., "e2e4", "a7a8=Q") */
+export type AlgebraicMove = string;
+/**
+ * Move in HSAN — this SDK's algebraic notation (e.g., "e4", "Nxf3"). Named
+ * distinctly from standard chess's SAN since disambiguation, piece letters,
+ * and square range all differ on this 12x12 board with Eagle/Hawk pieces —
+ * "SAN" on its own would misleadingly imply plain standard-chess notation.
+ */
+export type HsanMove = string;
+//# sourceMappingURL=move.d.ts.map

package/dist/types/move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move.d.ts","sourceRoot":"","sources":["../../src/types/move.ts"],"names":[],"mappings":"AAMA,6BAA6B;AAC7B,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC;AAEtC,gDAAgD;AAChD,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAE5B,2BAA2B;AAC3B,MAAM,MAAM,cAAc,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE/D,+BAA+B;AAC/B,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC"}

package/dist/types/move.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// HyperChess Core — hyperchess-core
+// File: packages/core/src/types/move.ts
+// Version: 1.0.0
+// Copyright (c) 2026 HyperChess Developer Team
+export {};
+//# sourceMappingURL=move.js.map

package/dist/types/move.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"move.js","sourceRoot":"","sources":["../../src/types/move.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,oCAAoC;AACpC,wCAAwC;AACxC,iBAAiB;AACjB,+CAA+C"}

package/dist/types/piece.d.ts

@@ -0,0 +1,50 @@
+import { Color } from './move';
+/** Piece type (side-agnostic) */
+export type PieceType = 'P' | 'N' | 'B' | 'R' | 'Q' | 'K' | 'E' | 'H';
+/** Represents a piece on the board */
+export interface Piece {
+    type: PieceType;
+    color: Color;
+    /**
+     * The piece's stable HFEN-I identity character, when known.
+     *
+     * Identity is *which individual piece* this is — the pawn that started on
+     * a3 stays `M` for the whole game, including after it promotes. It is
+     * metadata: it never affects legality or move generation.
+     *
+     * Optional because a board built from a legacy, type-only HFEN has no
+     * identity to carry. When it IS present, `getBoardHfen` round-trips it, so
+     * the SDK stops silently discarding identity every time it re-serializes a
+     * position for the engine.
+     */
+    identity?: string;
+}
+/** Piece position on board */
+export interface PiecePlacement {
+    piece: Piece;
+    square: number;
+}
+/** Piece symbols for display */
+export declare const PIECE_SYMBOLS: {
+    white: {
+        P: string;
+        N: string;
+        B: string;
+        R: string;
+        Q: string;
+        K: string;
+        E: string;
+        H: string;
+    };
+    black: {
+        P: string;
+        N: string;
+        B: string;
+        R: string;
+        Q: string;
+        K: string;
+        E: string;
+        H: string;
+    };
+};
+//# sourceMappingURL=piece.d.ts.map

package/dist/types/piece.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"piece.d.ts","sourceRoot":"","sources":["../../src/types/piece.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE/B,iCAAiC;AACjC,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAEtE,sCAAsC;AACtC,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;IAEb;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,8BAA8B;AAC9B,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,gCAAgC;AAChC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAqBzB,CAAC"}

package/dist/types/piece.js

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// HyperChess Core — hyperchess-core
+// File: packages/core/src/types/piece.ts
+// Version: 1.0.0
+// Copyright (c) 2026 HyperChess Developer Team
+/** Piece symbols for display */
+export const PIECE_SYMBOLS = {
+    white: {
+        P: '♙',
+        N: '♘',
+        B: '♗',
+        R: '♖',
+        Q: '♕',
+        K: '♔',
+        E: '🦅',
+        H: '🦅',
+    },
+    black: {
+        P: '♟',
+        N: '♞',
+        B: '♝',
+        R: '♜',
+        Q: '♛',
+        K: '♚',
+        E: '🦅',
+        H: '🦅',
+    },
+};
+//# sourceMappingURL=piece.js.map

package/dist/types/piece.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"piece.js","sourceRoot":"","sources":["../../src/types/piece.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,oCAAoC;AACpC,yCAAyC;AACzC,iBAAiB;AACjB,+CAA+C;AAiC/C,gCAAgC;AAChC,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,KAAK,EAAE;QACL,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,IAAI;QACP,CAAC,EAAE,IAAI;KACR;IACD,KAAK,EAAE;QACL,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,GAAG;QACN,CAAC,EAAE,IAAI;QACP,CAAC,EAAE,IAAI;KACR;CACF,CAAC"}

package/dist/utils/square-notation.d.ts

@@ -0,0 +1,14 @@
+/** A file letter (a-l) followed by a rank of 1-12 (10-12 are two digits). */
+export declare const SQUARE_TOKEN = "[a-l](?:1[0-2]|[1-9])";
+/** Convert an algebraic square (e.g. "e4", "a12") to a square index (0-143). */
+export declare function algebraicToSquare(algebraic: string): number;
+/**
+ * Convert a square index to algebraic notation (e.g. 0 → "a1", 131 → "l11").
+ *
+ * Ranks 10-12 are two digits on this 12x12 board — building the rank via
+ * char-code arithmetic (as if it were always a single digit) silently
+ * produces non-digit garbage for those ranks; plain integer math + string
+ * concatenation is required instead.
+ */
+export declare function squareToAlgebraic(square: number): string;
+//# sourceMappingURL=square-notation.d.ts.map

package/dist/utils/square-notation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"square-notation.d.ts","sourceRoot":"","sources":["../../src/utils/square-notation.ts"],"names":[],"mappings":"AAMA,6EAA6E;AAC7E,eAAO,MAAM,YAAY,0BAA0B,CAAC;AAEpD,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAI3D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIxD"}

package/dist/utils/square-notation.js

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// HyperChess Core — hyperchess-core
+// File: packages/core/src/utils/square-notation.ts
+// Version: 1.0.0
+// Copyright (c) 2026 HyperChess Developer Team
+/** A file letter (a-l) followed by a rank of 1-12 (10-12 are two digits). */
+export const SQUARE_TOKEN = '[a-l](?:1[0-2]|[1-9])';
+/** Convert an algebraic square (e.g. "e4", "a12") to a square index (0-143). */
+export function algebraicToSquare(algebraic) {
+    const file = algebraic.charCodeAt(0) - 'a'.charCodeAt(0);
+    const rank = parseInt(algebraic.slice(1), 10) - 1;
+    return rank * 12 + file;
+}
+/**
+ * Convert a square index to algebraic notation (e.g. 0 → "a1", 131 → "l11").
+ *
+ * Ranks 10-12 are two digits on this 12x12 board — building the rank via
+ * char-code arithmetic (as if it were always a single digit) silently
+ * produces non-digit garbage for those ranks; plain integer math + string
+ * concatenation is required instead.
+ */
+export function squareToAlgebraic(square) {
+    const file = String.fromCharCode('a'.charCodeAt(0) + (square % 12));
+    const rank = Math.floor(square / 12) + 1;
+    return `${file}${rank}`;
+}
+//# sourceMappingURL=square-notation.js.map

package/dist/utils/square-notation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"square-notation.js","sourceRoot":"","sources":["../../src/utils/square-notation.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,oCAAoC;AACpC,mDAAmD;AACnD,iBAAiB;AACjB,+CAA+C;AAE/C,6EAA6E;AAC7E,MAAM,CAAC,MAAM,YAAY,GAAG,uBAAuB,CAAC;AAEpD,gFAAgF;AAChF,MAAM,UAAU,iBAAiB,CAAC,SAAiB;IACjD,MAAM,IAAI,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IACzD,MAAM,IAAI,GAAG,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;IAClD,OAAO,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;AAC1B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,MAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC;IACpE,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACzC,OAAO,GAAG,IAAI,GAAG,IAAI,EAAE,CAAC;AAC1B,CAAC"}

package/dist/wasm/engine.d.ts

@@ -0,0 +1,23 @@
+import { WasmBoard } from 'hyperchess-wasm';
+export { snapshotFromWasmBoard, moveToUci, uciToMove } from './snapshot';
+/**
+ * Loads a `WasmBoard` from the Rust engine — starting position if `hfen` is
+ * omitted, or parses `hfen` (throws via wasm-pack's `Option::None` → JS
+ * `undefined` if it's invalid; callers should check).
+ *
+ * Imports from the package root, not a specific wasm-pack target subpath:
+ * `hyperchess-wasm`'s package.json resolves this to the `nodejs` target
+ * under Node (loads synchronously via `fs`) and the `bundler` target
+ * everywhere else (a real bundler's module graph resolution is already
+ * async, so no explicit init call is needed here either — see
+ * docs/sdk-plan/WASM-MIGRATION-PLAN.md Phase 5).
+ *
+ * NOT usable for a bundler-free browser deployment (a bare
+ * `<script type="module">` import with no build step) — the `bundler`
+ * target this resolves to there fails to even load (it does a raw
+ * `import ... from "./x.wasm"`, which needs a bundler to handle). See
+ * `../standalone.ts` for that case instead, which uses the `web` target
+ * with an explicit async init and deliberately does NOT import this module.
+ */
+export declare function loadWasmBoard(hfen?: string): WasmBoard;
+//# sourceMappingURL=engine.d.ts.map

package/dist/wasm/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/wasm/engine.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,qBAAqB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAStD"}