@mirasen/chessboard 1.0.6 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @mirasen/chessboard
 
+## 1.1.0
+
+### Minor Changes
+
+- 3956358: Add a stable chess.js adapter with pure move conversion helpers.
+
+### Patch Changes
+
+- 3956358: Fix lifted-drag animation suppression for compound moves.
+- 3956358: Fix `onUIMove` so it only fires for committed UI moves.
+
+## 1.0.7
+
+### Patch Changes
+
+- 92c3a69: Fix promotion animation planning when cancelling deferred promotion moves after a previous promotion.
+- 92c3a69: Fix piece suppression updates during deferred move animations.
+
 ## 1.0.6
 
 ### Patch Changes

package/README.md

@@ -37,16 +37,23 @@ The default first-party extension baseline includes rendering, events, selection
 - `promotion`
 - `autoPromote`
 
+The package also includes `chess.js` adapter helpers for connecting legal destinations, UI moves, external moves, promotion, castling, and en passant without writing special-move glue code by hand.
+
 That means the board already covers a meaningful baseline chess UX instead of stopping at “draw squares and pieces”.
 
 ### Built-in chessboard behavior
 
-Mirasen Chessboard provides a complete modern interaction and visual baseline out of the box: selection, deselection, reselection, drag-to-move, release targeting, legal destinations, promotion, auto-promotion, and state-diff animation. Moves are resolved on release rather than committed immediately on press, giving users a more forgiving interaction flow. Because animation is driven by board-state transitions, pieces can move, appear, disappear, promote, or return smoothly without app-level glue code.
+Mirasen Chessboard provides a complete modern interaction and visual baseline out of the box: selection, deselection, reselection, drag-to-move, release targeting, legal destinations, promotion, auto-promotion, and state-diff animation.
+
+Moves are resolved on release rather than committed immediately on press, giving users a more forgiving interaction flow. Because animation is driven by board-state transitions, pieces can move, appear, disappear, promote, castle, or return smoothly without app-level rendering glue code.
+
+Rules and legality still belong to your game layer. Use the built-in `chess.js` adapter when you want a ready-made bridge from `chess.js` legal moves and move results into the board.
 
 ## Highlights
 
 - Real built-in chess interaction
-- Easy game/rules layer integration
+- **Easy game/rules integration** — connect your own game model, or use the built-in `chess.js` adapter
+- Works on desktop and mobile out of the box, with pointer-based mouse and touch interaction
 - State-diff animation beyond simple move events
 - Extension-driven architecture
 - First-party baseline extensions
@@ -67,8 +74,8 @@ Interactive examples are available on the Mirasen website:
 
 - [Examples overview](https://mirasen.io/chessboard/examples/)
 - [Minimal interactive example](https://mirasen.io/chessboard/examples/minimal.html)
-- [Legal moves example](https://mirasen.io/chessboard/examples/legal-moves.html)
 - [Promotion example](https://mirasen.io/chessboard/examples/promotion.html)
+- [chess.js game example](https://mirasen.io/chessboard/examples/chessjs.html)
 
 ## Usage
 
@@ -94,40 +101,25 @@ board.setMovability({
 });
 ```
 
-### Connect to a game/rules layer
+### Connect to chess.js
 
-`@mirasen/chessboard` handles board interaction and move intent. Your application can keep chess rules and game state in its own game/rules layer.
+`@mirasen/chessboard` owns board interaction, rendering, promotion UI, and animation.  
+Your game/rules layer owns legality and game state.
 
-A typical integration uses a small adapter between your game move format and the board move format. The `game` object below represents your own chess rules layer, such as chess.js, a server-backed game model, or a custom engine.
+For `chess.js`, use the built-in adapter:
+
+```bash
+npm install chess.js
+```
 
 ```ts
+import { createBoard } from '@mirasen/chessboard';
 import {
-	createBoard,
-	type MoveDestinationInput,
-	type MoveOutput,
-	type MoveRequestInput
-} from '@mirasen/chessboard';
-
-type GameMove = {
-	from: string;
-	to: string;
-	capturedSquare?: string;
-	secondary?: {
-		from: string;
-		to: string;
-	};
-	promotedTo?: 'queen' | 'rook' | 'bishop' | 'knight';
-};
-
-type GameDestination = {
-	to: string;
-	capturedSquare?: string;
-	secondary?: {
-		from: string;
-		to: string;
-	};
-	promotedTo?: ('queen' | 'rook' | 'bishop' | 'knight')[];
-};
+	toBoardMove,
+	toBoardMoveDestinations,
+	toGameMove
+} from '@mirasen/chessboard/adapters/chessjs';
+import { Chess } from 'chess.js';
 
 const element = document.getElementById('board');
 
@@ -135,70 +127,76 @@ if (!element) {
 	throw new Error('Missing board element');
 }
 
-const game = createYourGameEngine(); // Your app/game layer.
+const chess = new Chess();
 const board = createBoard({
 	element
 });
 
-board.setPosition(game.getPosition());
+// Let the user play white in this example.
+const playerColor = 'w';
 
-function toBoardDestination(gameDestination: GameDestination): MoveDestinationInput {
-	return {
-		to: gameDestination.to,
-		capturedSquare: gameDestination.capturedSquare,
-		secondary: gameDestination.secondary, // e.g. castling.
-		promotedTo: gameDestination.promotedTo
-	};
-}
-
-function toBoardMoveRequest(gameMove: GameMove): MoveRequestInput {
-	return {
-		from: gameMove.from,
-		to: gameMove.to,
-		capturedSquare: gameMove.capturedSquare,
-		secondary: gameMove.secondary,
-		promotedTo: gameMove.promotedTo
-	};
-}
-
-function toGameMove(move: MoveOutput): GameMove {
-	return {
-		from: move.from,
-		to: move.to,
-		capturedSquare: move.capturedSquare,
-		secondary: move.secondary,
-		promotedTo: move.promotedTo
-	};
-}
+board.setPosition(chess.fen());
 
 board.setMovability({
 	mode: 'strict',
-	destinations: (source): MoveDestinationInput[] | undefined => {
-		const gameDestinations = game.getDestinationsFor(source);
+	destinations: (source) => {
+		// During the computer's turn, do not allow user moves.
+		if (chess.turn() !== playerColor) {
+			return undefined;
+		}
+
+		const moves = chess.moves({ square: source, verbose: true });
+		const destinations = toBoardMoveDestinations(moves);
 
-		return gameDestinations.length > 0 ? gameDestinations.map(toBoardDestination) : undefined;
+		return destinations.length > 0 ? destinations : undefined;
 	}
 });
 
 board.extensions.events.setOnUIMove((move) => {
-	// The board accepted and applied this UI move.
-	// Keep your game/rules layer in sync.
-	game.move(toGameMove(move));
+	// The board has already accepted and applied this UI move.
+	// Keep chess.js in sync.
+	chess.move(toGameMove(move));
+
+	if (!chess.isGameOver()) {
+		makeRandomComputerMove();
+	}
 });
 
-function applyExternalMove(gameMove: GameMove) {
-	// Apply moves that come from outside the board UI:
-	// server, engine, opponent, imported game, replay, etc.
-	game.move(gameMove);
+function makeRandomComputerMove() {
+	const moves = chess.moves({ verbose: true });
+	const randomMove = moves[Math.floor(Math.random() * moves.length)];
+
+	if (!randomMove) {
+		return;
+	}
+
+	// Apply the move to chess.js first.
+	const appliedMove = chess.move(randomMove);
 
-	// Then animate/apply the same move on the board.
-	board.move(toBoardMoveRequest(gameMove));
+	// Then apply and animate the same move on the board.
+	board.move(toBoardMove(appliedMove));
+}
+
+function resetGame() {
+	chess.reset();
+	board.setPosition(chess.fen());
 }
 ```
 
-`MoveDestinationInput` can describe more than a target square. For example, `secondary` can represent paired piece movement (e.g. castling), `capturedSquare` can represent captures away from the destination square (e.g. en passant), and `promotedTo` can represent promotion choices.
+The adapter exposes three small conversion helpers:
+
+- `toGameMove` converts a board UI move into a move accepted by `chess.move(...)`.
+- `toBoardMove` converts a `chess.js` move result into a board move request for external or computer moves.
+- `toBoardMoveDestinations` converts verbose legal `chess.js` moves into strict board destinations.
 
-This lets your game/rules layer own chess legality and game state while the board owns interaction, selection, targeting, visual feedback, promotion UI, animation, and its own displayed position.
+This keeps the boundary explicit:
+
+- `chess.js` decides which moves are legal.
+- The board handles interaction, legal targets, promotion UI, castling/en-passant board updates, and animation.
+- User moves flow from the board into `chess.js`.
+- External moves flow from `chess.js` back into the board.
+
+`toBoardMoveDestinations` preserves special move information such as promotion choices, en passant capture squares, and castling secondary rook movement, so those flows work through the normal board pipeline.
 
 ### Promotion and auto-promotion
 
@@ -325,3 +323,7 @@ For details, see:
 
 - [./assets/pieces/chessnut/ATTRIBUTION.md](./assets/pieces/chessnut/ATTRIBUTION.md)
 - [./assets/pieces/chessnut/LICENSE.txt](./assets/pieces/chessnut/LICENSE.txt)
+
+```
+
+```

package/dist/adapters/chessjs/index.d.ts

@@ -0,0 +1 @@
+export { toBoardMove, toBoardMoveDestinations, toGameMove } from './main.js';

package/dist/adapters/chessjs/index.js

@@ -0,0 +1 @@
+export { toBoardMove, toBoardMoveDestinations, toGameMove } from './main.js';

package/dist/adapters/chessjs/main.d.ts

@@ -0,0 +1,19 @@
+import type { Chess, Move } from 'chess.js';
+import type { MoveRequestInput } from '../../state/board/types/input.js';
+import type { MoveOutput } from '../../state/board/types/output.js';
+import type { MoveDestinationInput } from '../../state/interaction/types/input.js';
+type ChessJsMoveInput = Exclude<Parameters<Chess['move']>[0], string | null>;
+/**
+ * Convert a board MoveOutput into the object notation accepted by chess.move().
+ */
+export declare function toGameMove(move: MoveOutput): ChessJsMoveInput;
+/**
+ * Convert a chess.js Move object into MoveRequestInput.
+ */
+export declare function toBoardMove(move: Move): MoveRequestInput;
+/**
+ * Convert readonly chess.js verbose moves into readonly MoveDestinationInput[].
+ * Merges promotion variants for the same from/to/special-move identity into one destination.
+ */
+export declare function toBoardMoveDestinations(moves: readonly Move[]): MoveDestinationInput[];
+export {};

package/dist/adapters/chessjs/main.js

@@ -0,0 +1,134 @@
+const BOARD_TO_CHESSJS = {
+    Q: 'q',
+    R: 'r',
+    B: 'b',
+    N: 'n'
+};
+const CHESSJS_TO_BOARD = {
+    q: 'Q',
+    r: 'R',
+    b: 'B',
+    n: 'N'
+};
+function toBoardPromotion(p) {
+    const result = CHESSJS_TO_BOARD[p];
+    if (!result) {
+        throw new Error(`Unsupported chess.js promotion symbol: "${p}"`);
+    }
+    return result;
+}
+function toChessJsPromotion(p) {
+    const result = BOARD_TO_CHESSJS[p];
+    if (!result) {
+        throw new Error(`Unsupported board promotion symbol: "${p}"`);
+    }
+    return result;
+}
+/**
+ * Convert a board MoveOutput into the object notation accepted by chess.move().
+ */
+export function toGameMove(move) {
+    const result = {
+        from: move.from,
+        to: move.to
+    };
+    if (move.promotedTo) {
+        result.promotion = toChessJsPromotion(move.promotedTo);
+    }
+    return result;
+}
+/**
+ * Convert a chess.js Move object into MoveRequestInput.
+ */
+export function toBoardMove(move) {
+    const result = {
+        from: move.from,
+        to: move.to
+    };
+    if (move.isPromotion()) {
+        if (!move.promotion) {
+            throw new Error('Promotion move missing promotion piece');
+        }
+        result.promotedTo = toBoardPromotion(move.promotion);
+    }
+    if (move.isEnPassant()) {
+        const file = move.to[0];
+        const toRank = parseInt(move.to[1], 10);
+        const capturedRank = move.color === 'w' ? toRank - 1 : toRank + 1;
+        result.capturedSquare = `${file}${capturedRank}`;
+    }
+    if (move.isKingsideCastle()) {
+        if (move.from === 'e1' && move.to === 'g1') {
+            result.secondary = { from: 'h1', to: 'f1' };
+        }
+        else if (move.from === 'e8' && move.to === 'g8') {
+            result.secondary = { from: 'h8', to: 'f8' };
+        }
+        else {
+            throw new Error(`Unsupported chess.js kingside castling move: ${move.from}-${move.to}`);
+        }
+    }
+    else if (move.isQueensideCastle()) {
+        if (move.from === 'e1' && move.to === 'c1') {
+            result.secondary = { from: 'a1', to: 'd1' };
+        }
+        else if (move.from === 'e8' && move.to === 'c8') {
+            result.secondary = { from: 'a8', to: 'd8' };
+        }
+        else {
+            throw new Error(`Unsupported chess.js queenside castling move: ${move.from}-${move.to}`);
+        }
+    }
+    return result;
+}
+/**
+ * Convert readonly chess.js verbose moves into readonly MoveDestinationInput[].
+ * Merges promotion variants for the same from/to/special-move identity into one destination.
+ */
+export function toBoardMoveDestinations(moves) {
+    if (moves.length === 0)
+        return [];
+    const destinations = [];
+    const keyToIndex = new Map();
+    for (const move of moves) {
+        const boardMove = toBoardMove(move);
+        // Build identity key: from + to + capturedSquare + secondary
+        const key = [
+            boardMove.from,
+            boardMove.to,
+            boardMove.capturedSquare ?? '',
+            boardMove.secondary ? `${boardMove.secondary.from}-${boardMove.secondary.to}` : ''
+        ].join('|');
+        const existingIdx = keyToIndex.get(key);
+        if (existingIdx !== undefined) {
+            // Merge promotion into existing destination
+            const existing = destinations[existingIdx];
+            if (boardMove.promotedTo) {
+                if (!existing.promotedTo) {
+                    existing.promotedTo = [];
+                }
+                if (!existing.promotedTo.includes(boardMove.promotedTo)) {
+                    existing.promotedTo.push(boardMove.promotedTo);
+                }
+            }
+        }
+        else {
+            // Create new destination
+            const dest = {
+                to: boardMove.to
+            };
+            if (boardMove.capturedSquare) {
+                dest.capturedSquare = boardMove.capturedSquare;
+            }
+            if (boardMove.secondary) {
+                dest.secondary = boardMove.secondary;
+            }
+            if (boardMove.promotedTo) {
+                dest.promotedTo = [boardMove.promotedTo];
+            }
+            keyToIndex.set(key, destinations.length);
+            destinations.push(dest);
+        }
+    }
+    return destinations;
+}

package/dist/animation/planner.js

@@ -2,6 +2,7 @@ import assert from '@ktarmyshov/assert';
 import { isNonEmptyPieceCode } from '../state/board/check.js';
 import { fileOf, rankOf } from '../state/board/coords.js';
 import { SQUARE_COUNT } from '../state/board/types/internal.js';
+import { baseMovesEqual } from '../state/change/helpers.js';
 // ---------------------------------------------------------------------------
 // Precomputed squared distance: (dFile² + dRank²) for all square pairs.
 // Max value = 7² + 7² = 98, fits in Uint8.  Index: a * 64 + b.
@@ -55,7 +56,7 @@ function buildExcludeForDrop(lastMove) {
 function buildEffectiveAnimationPlanningSnapshot(state) {
     const request = state.change.deferredUIMoveRequest;
     if (request === null)
-        return state; // nothing to do
+        return { ...state, lastMoveSource: 'state' }; // nothing to do
     const newPieces = new Uint8Array(state.board.pieces);
     const from = request.sourceSquare;
     const to = request.destination.to;
@@ -73,40 +74,41 @@ function buildEffectiveAnimationPlanningSnapshot(state) {
         piece: pieceCode
     };
     const newChange = {
+        ...state.change,
         deferredUIMoveRequest: null,
         lastMove: newLastMove
     };
     return {
         ...state,
         board: newBoard,
-        change: newChange
+        change: newChange,
+        lastMoveSource: 'projected-deferred-ui-move'
     };
 }
-/**
- * When a promotion was already auto-resolved/auto-promoted (no deferredUIMoveRequest but
- * lastMove.promotedTo is set), the current board already contains the promoted
- * piece (e.g. queen) on the target square.  For animation planning we
- * temporarily replace it with the original piece (pawn) so that the greedy
- * matching can build a proper move track from→to instead of separate fades.
- *
- * After the animation finishes the promoted piece will "snap" into view on
- * the next render frame.
- */
-function buildPromotionEffectiveCurrent(state) {
-    const lastMove = state.change.lastMove;
-    if (state.change.deferredUIMoveRequest !== null ||
+function normalizePromotionEffectiveCurrent(previous, current) {
+    const lastMove = current.change.lastMove;
+    if (current.change.deferredUIMoveRequest !== null ||
         lastMove === null ||
         lastMove.promotedTo === undefined) {
-        return state; // not an auto-resolved/auto-promoted move — nothing to do
+        return current;
     }
-    const newPieces = new Uint8Array(state.board.pieces);
+    if (previous.lastMoveSource === 'projected-deferred-ui-move') {
+        const previousLastMove = previous.change.lastMove;
+        if (previousLastMove === null || !baseMovesEqual(previousLastMove, lastMove)) {
+            return current;
+        }
+    }
+    else if (previous.board.pieces[lastMove.from] !== lastMove.piece) {
+        return current;
+    }
+    const newPieces = new Uint8Array(current.board.pieces);
     newPieces[lastMove.to] = lastMove.piece;
     const newBoard = {
-        ...state.board,
+        ...current.board,
         pieces: newPieces
     };
     return {
-        ...state,
+        ...current,
         board: newBoard
     };
 }
@@ -231,17 +233,15 @@ export function calculateAnimationPlan(input) {
     // 2) Detect lifted-piece drop and prepare exclude spec
     const droppedMove = detectLiftedPieceDrop(effectivePrevious, effectiveCurrent);
     const exclude = droppedMove !== null ? buildExcludeForDrop(droppedMove) : EMPTY_EXCLUDE;
-    // 3) Normalize current for auto-resolved/auto-promoted move (pawn→queen on target square)
-    const planningCurrent = buildPromotionEffectiveCurrent(effectiveCurrent);
+    // 3) Normalize current promoted piece when the promoted move belongs to this transition
+    const planningCurrent = normalizePromotionEffectiveCurrent(effectivePrevious, effectiveCurrent);
     // 4) Calculate tracks
     const tracks = calculateTracks(effectivePrevious.board, planningCurrent.board, exclude);
     // 5) Build suppressedSquares: track-derived + excluded drop endpoints
     const suppressed = collectSuppressedSquaresFromTracks(tracks);
-    if (droppedMove !== null) {
-        // The dropped move was intentionally suppressed (no move track emitted),
-        // but the base render must still hide both endpoints.
-        suppressed.add(droppedMove.from);
-        suppressed.add(droppedMove.to);
-    }
-    return { tracks, suppressedSquares: suppressed };
+    const result = {
+        tracks,
+        suppressedSquares: suppressed
+    };
+    return result;
 }

package/dist/animation/types.d.ts

@@ -30,14 +30,17 @@ export interface AnimationSession {
     duration: number;
 }
 export type AnimationSessionSnapshot = ReadonlyDeep<AnimationSession>;
-export interface AnimationPlanningSnapshot {
+export interface AnimationPlanningInputSnapshot {
     readonly board: BoardStateSnapshot;
     readonly change: ChangeStateSnapshot;
     readonly interaction: InteractionStateSnapshot;
 }
+export interface AnimationPlanningSnapshot extends AnimationPlanningInputSnapshot {
+    readonly lastMoveSource: 'state' | 'projected-deferred-ui-move';
+}
 export interface AnimationPlanningInput {
-    previous: AnimationPlanningSnapshot;
-    current: AnimationPlanningSnapshot;
+    previous: AnimationPlanningInputSnapshot;
+    current: AnimationPlanningInputSnapshot;
 }
 export interface AnimationPlan {
     readonly tracks: readonly AnimationTrack[];

package/dist/extensions/first-party/board-events/factory.js

@@ -40,8 +40,17 @@ function createBoardEventsInstance() {
                     currentFrame: context.currentFrame
                 });
             }
-            if (context.mutation.hasMutation({ causes: ['state.change.setLastMove'] }) &&
-                context.currentFrame.state.change.lastMove) {
+            const lastMoveChanged = context.mutation.hasMutation({
+                causes: ['state.change.setLastMove']
+            });
+            const interactionCompleted = context.mutation.hasMutation({
+                causes: [
+                    'runtime.interaction.completeCoreDragTo',
+                    'runtime.interaction.completeExtensionDragTo',
+                    'runtime.interaction.resolveDeferredUIMoveRequest'
+                ]
+            });
+            if (interactionCompleted && lastMoveChanged && context.currentFrame.state.change.lastMove) {
                 internalState.onUIMove?.(denormalizeMove(context.currentFrame.state.change.lastMove));
             }
         },

package/dist/extensions/first-party/main-renderer/pieces/update.js

@@ -6,7 +6,7 @@ import { calculateSuppressedSquares } from './suppress.js';
 export function rendererPiecesOnUpdate(state, context, animationSuppressedSquares) {
     if (!isUpdateContextRenderable(context) ||
         !context.mutation.hasMutation({
-            prefixes: ['state.board.', 'state.interaction.'],
+            prefixes: ['state.'],
             causes: ['layout.refreshGeometry']
         })) {
         return;

package/dist/state/board/fen/main.d.ts

@@ -0,0 +1,10 @@
+import { FenString } from '../types/input.js';
+import { ParsedPosition } from '../types/internal.js';
+/**
+ * Parse a FEN string into a {@link ParsedPosition}.
+ *
+ * Only the first two FEN fields (piece placement + active color) are required
+ * for a board-only representation. The remaining fields (castling, en-passant,
+ * half-move clock, full-move number) are accepted but ignored.
+ */
+export declare function parseFen(fen: FenString): ParsedPosition;

package/dist/state/board/fen/main.js

@@ -0,0 +1,94 @@
+import { SQUARE_COUNT } from '../types/internal.js';
+/**
+ * Direct FEN character → PieceCode lookup.
+ * Uppercase = White, lowercase = Black.
+ */
+const FEN_PIECE_MAP = {
+    P: 1 /* PieceCode.WhitePawn */,
+    N: 2 /* PieceCode.WhiteKnight */,
+    B: 3 /* PieceCode.WhiteBishop */,
+    R: 4 /* PieceCode.WhiteRook */,
+    Q: 5 /* PieceCode.WhiteQueen */,
+    K: 6 /* PieceCode.WhiteKing */,
+    p: 9 /* PieceCode.BlackPawn */,
+    n: 10 /* PieceCode.BlackKnight */,
+    b: 11 /* PieceCode.BlackBishop */,
+    r: 12 /* PieceCode.BlackRook */,
+    q: 13 /* PieceCode.BlackQueen */,
+    k: 14 /* PieceCode.BlackKing */
+};
+/**
+ * Parse the piece-placement section of a FEN string into a Uint8Array[64].
+ *
+ * FEN ranks are ordered 8→1 (top to bottom), but our board indexing is
+ * a1=0, b1=1, ..., h1=7, a2=8, ..., h8=63.
+ * So rank 8 maps to indices 56–63 and rank 1 to indices 0–7.
+ */
+function parsePiecePlacement(placement) {
+    const pieces = new Uint8Array(SQUARE_COUNT); // initialized to 0 (PieceCode.Empty)
+    const ranks = placement.split('/');
+    if (ranks.length !== 8) {
+        throw new Error(`Invalid FEN piece placement: expected 8 ranks separated by '/', got ${ranks.length}`);
+    }
+    for (let rankIdx = 0; rankIdx < 8; rankIdx++) {
+        // FEN rank index 0 = rank 8 (board row 7), index 7 = rank 1 (board row 0)
+        const boardRow = 7 - rankIdx;
+        const baseSquare = boardRow * 8;
+        const rankStr = ranks[rankIdx];
+        let file = 0;
+        for (let i = 0; i < rankStr.length; i++) {
+            const ch = rankStr[i];
+            if (ch >= '1' && ch <= '8') {
+                // Skip empty squares
+                file += ch.charCodeAt(0) - '0'.charCodeAt(0);
+            }
+            else {
+                const piece = FEN_PIECE_MAP[ch];
+                if (piece === undefined) {
+                    throw new Error(`Invalid FEN piece character: '${ch}'`);
+                }
+                if (file >= 8) {
+                    throw new Error(`Invalid FEN piece placement: too many squares in rank ${8 - rankIdx}`);
+                }
+                pieces[baseSquare + file] = piece;
+                file++;
+            }
+        }
+        if (file !== 8) {
+            throw new Error(`Invalid FEN piece placement: rank ${8 - rankIdx} has ${file} squares instead of 8`);
+        }
+    }
+    return pieces;
+}
+/**
+ * Parse the active-color field of a FEN string.
+ */
+function parseTurn(turn) {
+    switch (turn) {
+        case 'w':
+            return 0 /* ColorCode.White */;
+        case 'b':
+            return 8 /* ColorCode.Black */;
+        default:
+            throw new Error(`Invalid FEN turn field: expected 'w' or 'b', got '${turn}'`);
+    }
+}
+/**
+ * Parse a FEN string into a {@link ParsedPosition}.
+ *
+ * Only the first two FEN fields (piece placement + active color) are required
+ * for a board-only representation. The remaining fields (castling, en-passant,
+ * half-move clock, full-move number) are accepted but ignored.
+ */
+export function parseFen(fen) {
+    const parts = fen
+        .replace(/^\uFEFF/, '')
+        .trim()
+        .split(/\s+/);
+    if (parts.length < 2) {
+        throw new Error(`Invalid FEN string: expected at least 2 space-separated fields, got ${parts.length}`);
+    }
+    const pieces = parsePiecePlacement(parts[0]);
+    const turn = parseTurn(parts[1]);
+    return { pieces, turn };
+}

package/dist/state/board/position.js

@@ -1,4 +1,4 @@
-import { parse } from '@echecs/fen';
+import { parseFen } from './fen/main.js';
 import { normalizeColor, normalizePiece, normalizeSquare } from './normalize.js';
 import { SQUARE_COUNT } from './types/internal.js';
 const START_POSITION_RECORD_STRING = {
@@ -63,18 +63,7 @@ function isPositionInputObject(input) {
     return typeof input === 'object' && input !== null && !Array.isArray(input);
 }
 function boardParsePositionInputFen(input) {
-    const position = parse(input);
-    if (!position) {
-        throw new Error('Failed to parse FEN string');
-    }
-    const piecePositionRecord = {};
-    for (const [square, piece] of position.board) {
-        piecePositionRecord[square] = { role: piece.type, color: piece.color };
-    }
-    return {
-        pieces: boardParsePositionInputRecord(piecePositionRecord),
-        turn: normalizeColor(position.turn)
-    };
+    return parseFen(input);
 }
 export function boardParsePosition(input) {
     if (input === 'start') {

package/dist/state/change/helpers.d.ts

@@ -1,7 +1,8 @@
-import type { MoveRequest, MoveRequestBase, MoveSnapshot } from '../board/types/internal.js';
+import type { MoveBaseSnapshot, MoveRequest, MoveRequestBase, MoveSnapshot } from '../board/types/internal.js';
 import { MoveDestinationSnapshot } from '../interaction/types/internal.js';
 import { ChangeStateSnapshot } from './types/main.js';
 import { PendingUIMoveRequestSnapshot } from './types/ui-move.js';
+export declare function baseMovesEqual(moveA: MoveBaseSnapshot, moveB: MoveBaseSnapshot): boolean;
 export declare function movesEqual(moveA: MoveSnapshot | null, moveB: MoveSnapshot | null): boolean;
 export declare function moveRequestBasesEqual(requestA: MoveRequestBase | null, requestB: MoveRequestBase | null): boolean;
 export declare function moveRequestsEqual(requestA: MoveRequest | null, requestB: MoveRequest | null): boolean;

package/dist/state/change/helpers.js

@@ -1,5 +1,5 @@
 import { setsEqual } from '../../helpers/util.js';
-function baseMovesEqual(moveA, moveB) {
+export function baseMovesEqual(moveA, moveB) {
     const diffs = [
         moveA.from !== moveB.from,
         moveA.to !== moveB.to,

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@mirasen/chessboard",
 	"description": "Framework-agnostic TypeScript chessboard platform with real chess interaction built in.",
-	"version": "1.0.6",
+	"version": "1.1.0",
 	"license": "MIT",
 	"author": {
 		"name": "Mirasen",
@@ -42,6 +42,10 @@
 			"types": "./dist/extensions/build/index.d.ts",
 			"import": "./dist/extensions/build/index.js"
 		},
+		"./adapters/chessjs": {
+			"types": "./dist/adapters/chessjs/index.d.ts",
+			"import": "./dist/adapters/chessjs/index.js"
+		},
 		"./unstable/*": {
 			"types": "./dist/*.d.ts",
 			"import": "./dist/*.js"
@@ -79,6 +83,7 @@
 		"@eslint/js": "^10.0.1",
 		"@types/node": "^25.5.0",
 		"@vitest/coverage-istanbul": "^4.1.0",
+		"chess.js": "^1.4.0",
 		"eslint": "^10.0.2",
 		"eslint-config-prettier": "^10.1.2",
 		"globals": "^17.4.0",
@@ -96,9 +101,16 @@
 		"node": ">=20"
 	},
 	"dependencies": {
-		"@echecs/fen": "^2.1.0",
 		"@ktarmyshov/assert": "^0.1.9",
 		"es-toolkit": "^1.45.1",
 		"type-fest": "^5.5.0"
+	},
+	"peerDependencies": {
+		"chess.js": "^1.4.0"
+	},
+	"peerDependenciesMeta": {
+		"chess.js": {
+			"optional": true
+		}
 	}
 }