@mirasen/chessboard 1.0.7 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @mirasen/chessboard
 
+## 1.1.1
+
+### Patch Changes
+
+- 8b3781c: dependabot: directory '/', update @ktarmyshov/assert
+- 8b3781c: dependabot: directory '/', update es-toolkit
+- 8b3781c: dependabot: directory '/', update typescript-eslint
+- c877d35: dependabot: directory '/', update jsdom
+
+## 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

package/README.md

@@ -8,6 +8,12 @@
 
 A framework-agnostic TypeScript chessboard platform with real chess interaction built in and an extension-driven architecture.
 
+## Try it live
+
+- [Play a chess.js game](https://mirasen.io/chessboard/examples/chessjs.html)
+- [Try the promotion flow](https://mirasen.io/chessboard/examples/promotion.html)
+- [Try the minimal example](https://mirasen.io/chessboard/examples/minimal.html)
+
 ## Why this exists
 
 Most chessboards fall into one of two buckets:
@@ -37,16 +43,22 @@ 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
@@ -62,15 +74,6 @@ Mirasen Chessboard provides a complete modern interaction and visual baseline ou
 npm install @mirasen/chessboard
 ```
 
-## Live examples
-
-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)
-
 ## Usage
 
 ### Minimal example
@@ -95,40 +98,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');
 
@@ -136,70 +124,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());
-
-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
-	};
-}
+// Let the user play white in this example.
+const playerColor = 'w';
 
-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;
+		}
 
-		return gameDestinations.length > 0 ? gameDestinations.map(toBoardDestination) : undefined;
+		const moves = chess.moves({ square: source, verbose: true });
+		const destinations = toBoardMoveDestinations(moves);
+
+		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 keeps the boundary explicit:
 
-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.
+- `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
 
@@ -300,12 +294,16 @@ A board that only renders pieces and leaves everything else to app code often fo
 
 A board that handles everything internally without clean boundaries becomes difficult to evolve, customize, or extend.
 
+### Opt out, not build up
+
 `@mirasen/chessboard` aims for a middle path:
 
 - strong built-in baseline interaction
 - clean internal architecture
 - extension-driven feature growth
 
+Common chessboard behavior is included by default: rendering, interaction, selection, legal target feedback, promotion, and animation. You start from a working interaction baseline and remove or replace extensions only when you want less or need something different.
+
 ## Project direction
 
 This platform is being built as a foundation for richer chess learning and interaction workflows, but the board itself is designed to stand as a serious open-source UI platform in its own right.

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

@@ -239,11 +239,9 @@ export function calculateAnimationPlan(input) {
     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/extensions/factory/runtime.js

@@ -45,8 +45,11 @@ function createExtensionRuntimeSurfaceEvents(getInternalState, runtimeSurfaceEve
                 subscribers = new Set();
                 internalState.eventSubscribers.set(type, subscribers);
             }
+            const sizeBeforeAdd = subscribers.size;
             subscribers.add(extensionDef.id);
-            runtimeSurfaceEvents.subscribeEvent(type);
+            if (sizeBeforeAdd === 0) {
+                runtimeSurfaceEvents.subscribeEvent(type);
+            }
         },
         unsubscribeEvent(type) {
             const internalState = getInternalState();

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/legal-moves/types.js

@@ -6,14 +6,14 @@ export const DEFAULT_CONFIG = {
             color: 'rgb(0, 0, 0)',
             opacity: 0.14
         },
-        radiusRatio: 0.125
-    }, // semi-transparent black
+        radiusRatio: 0.165
+    },
     captureTarget: {
         color: {
             color: 'rgb(0, 0, 0)',
             opacity: 0.14
         },
-        radiusRatio: 0.45,
-        strokeWidthRatio: 0.1
+        radiusRatio: 0.445,
+        strokeWidthRatio: 0.11
     }
 };

package/dist/runtime/mutation/last-move.js

@@ -11,7 +11,7 @@ export const updateLastMoveOnBoardMove = (context, mutationSession) => {
 export const clearLastMoveOnBoardSetPosition = (context, mutationSession) => {
     const { current } = context;
     if (!mutationSession.hasMutation({
-        causes: ['state.board.setPosition', 'state.board.setPiecePosition']
+        causes: ['state.board.setPosition', 'state.board.setPiecePosition', 'state.board.setTurn']
     })) {
         return;
     }

package/dist/state/board/check.d.ts

@@ -1,12 +1,13 @@
 import { Color, ColorShort, MoveRequestInput, Piece, PiecePositionInput, PiecePositionRecord, PiecePositionRecordShort, PiecePositionRecordString, PieceShort, PieceString, Role, RoleShort, SquareString } from './types/input.js';
-import { EmptyPieceCode, MoveRequest, NonEmptyPieceCode, PieceCode, RolePromotionCode, Square, SquareFile, SquareRank } from './types/internal.js';
-import { BoardStateSnapshot } from './types/main.js';
+import { EmptyPieceCode, MoveRequest, NonEmptyPieceCode, PieceCode, PiecePositionSnapshot, PositionSnapshot, RolePromotionCode, Square, SquareFile, SquareRank } from './types/internal.js';
+import type { BoardStateSnapshot } from './types/main.js';
 export declare function isWhitePieceCode(code: NonEmptyPieceCode): boolean;
 export declare function isBlackPieceCode(code: NonEmptyPieceCode): boolean;
 export declare function isOccupied(board: BoardStateSnapshot, sq: Square): boolean;
 export declare function isEmptyPieceCode(code: PieceCode): code is EmptyPieceCode;
 export declare function isNonEmptyPieceCode(code: PieceCode): code is NonEmptyPieceCode;
-export declare function piecePositionsEqual(pos1: BoardStateSnapshot, pos2: BoardStateSnapshot): boolean;
+export declare function piecePositionsEqual(pos1: PiecePositionSnapshot, pos2: PiecePositionSnapshot): boolean;
+export declare function positionsEqual(pos1: PositionSnapshot, pos2: PositionSnapshot): boolean;
 export declare function isRank(n: number): n is SquareRank;
 export declare function isFile(n: number): n is SquareFile;
 export declare function isValidSquare(n: number): n is Square;

package/dist/state/board/check.js

@@ -15,7 +15,7 @@ export function isNonEmptyPieceCode(code) {
     return code !== 0 /* PieceCode.Empty */;
 }
 export function piecePositionsEqual(pos1, pos2) {
-    if (pos1.positionEpoch !== pos2.positionEpoch)
+    if (pos1.pieces.length !== pos2.pieces.length)
         return false;
     for (let i = 0; i < pos1.pieces.length; i++) {
         if (pos1.pieces[i] !== pos2.pieces[i])
@@ -23,6 +23,11 @@ export function piecePositionsEqual(pos1, pos2) {
     }
     return true;
 }
+export function positionsEqual(pos1, pos2) {
+    if (pos1.turn !== pos2.turn)
+        return false;
+    return piecePositionsEqual(pos1, pos2);
+}
 export function isRank(n) {
     return Number.isInteger(n) && n >= 0 && n < 8;
 }

package/dist/state/board/factory.js

@@ -2,7 +2,7 @@ import { cloneDeep } from 'es-toolkit/object';
 import { isNormalizedMoveRequest } from './check.js';
 import { normalizeColor, normalizeMoveRequest } from './normalize.js';
 import { boardParsePiecePositionInput, boardParsePosition } from './position.js';
-import { boardMove, boardSetPosition, boardSetTurn } from './reducers.js';
+import { boardMove, boardSetPiecePosition, boardSetPosition, boardSetTurn } from './reducers.js';
 function createBoardStateInternal(position) {
     const parsedPosition = boardParsePosition(position);
     return {
@@ -16,13 +16,11 @@ export function createBoardState(position) {
     return {
         setPosition(input, mutationSession) {
             const position = boardParsePosition(input);
-            let changed = boardSetPosition(internalState, position.pieces);
-            changed = boardSetTurn(internalState, position.turn) || changed;
-            return mutationSession.addMutation('state.board.setPosition', changed);
+            return mutationSession.addMutation('state.board.setPosition', boardSetPosition(internalState, position));
         },
         setPiecePosition(input, mutationSession) {
             const pieces = boardParsePiecePositionInput(input);
-            return mutationSession.addMutation('state.board.setPiecePosition', boardSetPosition(internalState, pieces));
+            return mutationSession.addMutation('state.board.setPiecePosition', boardSetPiecePosition(internalState, pieces));
         },
         setTurn(turn, mutationSession) {
             const normalizedTurn = normalizeColor(turn);

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

@@ -1,10 +1,10 @@
 import { FenString } from '../types/input.js';
-import { ParsedPosition } from '../types/internal.js';
+import { PositionSnapshot } from '../types/internal.js';
 /**
- * Parse a FEN string into a {@link ParsedPosition}.
+ * Parse a FEN string into a {@link PositionSnapshot}.
  *
  * 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;
+export declare function parseFen(fen: FenString): PositionSnapshot;

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

@@ -74,7 +74,7 @@ function parseTurn(turn) {
     }
 }
 /**
- * Parse a FEN string into a {@link ParsedPosition}.
+ * Parse a FEN string into a {@link PositionSnapshot}.
  *
  * Only the first two FEN fields (piece placement + active color) are required
  * for a board-only representation. The remaining fields (castling, en-passant,

package/dist/state/board/position.d.ts

@@ -1,4 +1,4 @@
 import { PiecePositionInput, PositionInput } from './types/input.js';
-import { ParsedPosition } from './types/internal.js';
+import { PositionSnapshot } from './types/internal.js';
 export declare function boardParsePiecePositionInput(input: PiecePositionInput): Uint8Array;
-export declare function boardParsePosition(input: PositionInput): ParsedPosition;
+export declare function boardParsePosition(input: PositionInput): PositionSnapshot;

package/dist/state/board/reducers.d.ts

@@ -1,8 +1,6 @@
-import { ColorCode, Move, MoveRequest } from './types/internal.js';
+import { ColorCode, Move, MoveRequest, PositionSnapshot } from './types/internal.js';
 import { BoardStateInternal } from './types/main.js';
-export declare function boardSetPosition(state: BoardStateInternal, pieces: Uint8Array): boolean;
-/**
- * Set active color turn.
- */
+export declare function boardSetPiecePosition(state: BoardStateInternal, pieces: Uint8Array): boolean;
 export declare function boardSetTurn(state: BoardStateInternal, turn: ColorCode): boolean;
+export declare function boardSetPosition(state: BoardStateInternal, position: PositionSnapshot): boolean;
 export declare function boardMove(state: BoardStateInternal, request: MoveRequest): Move;

package/dist/state/board/reducers.js

@@ -1,19 +1,26 @@
-import { isEmptyPieceCode } from './check.js';
+import { isEmptyPieceCode, piecePositionsEqual, positionsEqual } from './check.js';
 import { denormalizeSquare } from './denormalize.js';
 import { fromPieceCode, toPieceCode } from './piece.js';
-export function boardSetPosition(state, pieces) {
+export function boardSetPiecePosition(state, pieces) {
+    if (piecePositionsEqual(state, { pieces }))
+        return false; // no-op
     state.pieces = new Uint8Array(pieces);
-    // Increment position epoch to prevent false animation across position resets
     state.positionEpoch++;
     return true;
 }
-/**
- * Set active color turn.
- */
 export function boardSetTurn(state, turn) {
     if (state.turn === turn)
         return false; // no-op
     state.turn = turn;
+    state.positionEpoch++;
+    return true;
+}
+export function boardSetPosition(state, position) {
+    if (positionsEqual(state, position))
+        return false; // no-op
+    state.pieces = new Uint8Array(position.pieces);
+    state.turn = position.turn;
+    state.positionEpoch++;
     return true;
 }
 function buildMoveBase(state, request) {

package/dist/state/board/types/internal.d.ts

@@ -48,7 +48,9 @@ export type MoveBaseSnapshot = ReadonlyDeep<MoveBase>;
 export type MoveSnapshot = ReadonlyDeep<Move>;
 export declare const FILE_START: number;
 export declare const RANK_START: number;
-export type ParsedPosition = {
-    pieces: Uint8Array;
-    turn: ColorCode;
-};
+export interface PiecePositionSnapshot {
+    readonly pieces: Readonly<Uint8Array>;
+}
+export interface PositionSnapshot extends PiecePositionSnapshot {
+    readonly turn: ColorCode;
+}

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.7",
+	"version": "1.1.1",
 	"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"
@@ -57,7 +61,7 @@
 		"check": "tsc --skipLibCheck --noEmit",
 		"check:test": "tsc --project tsconfig-test.json --skipLibCheck --noEmit",
 		"test": "npm run check:test && vitest run --run",
-		"coverage": "vitest run --coverage",
+		"coverage": "npm run check:test && vitest run --coverage",
 		"changeset:version": "changeset version && npm install && npm run format && git add --all",
 		"changeset:publish": "changeset publish"
 	},
@@ -100,5 +104,13 @@
 		"@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
+		}
 	}
 }