@mirasen/chessboard 0.1.0

package/dist/state/board/normalize.js

@@ -0,0 +1,76 @@
+import { isPieceString, isRolePromotionCode, isValidSquare } from './check';
+import { FILE_START, RANK_START } from './types/internal';
+export function normalizeColor(input) {
+    switch (input) {
+        case 'white':
+        case 'w':
+            return 0 /* ColorCode.White */;
+        case 'black':
+        case 'b':
+            return 8 /* ColorCode.Black */;
+        default:
+            throw new RangeError(`Invalid color input: ${input}`);
+    }
+}
+export function normalizeRole(input) {
+    switch (input) {
+        case 'P':
+        case 'pawn':
+            return 1 /* RoleCode.Pawn */;
+        case 'N':
+        case 'knight':
+            return 2 /* RoleCode.Knight */;
+        case 'B':
+        case 'bishop':
+            return 3 /* RoleCode.Bishop */;
+        case 'R':
+        case 'rook':
+            return 4 /* RoleCode.Rook */;
+        case 'Q':
+        case 'queen':
+            return 5 /* RoleCode.Queen */;
+        case 'K':
+        case 'king':
+            return 6 /* RoleCode.King */;
+        default:
+            throw new RangeError(`Invalid role input: ${input}`);
+    }
+}
+export function normalizePiece(input) {
+    const [color, role] = isPieceString(input)
+        ? [input[0], input[1]]
+        : [input.color, input.role];
+    const colorCode = normalizeColor(color);
+    const roleCode = normalizeRole(role);
+    return colorCode + roleCode;
+}
+export function normalizeRolePromotion(input) {
+    const role = normalizeRole(input);
+    if (!isRolePromotionCode(role)) {
+        throw new RangeError(`Invalid role promotion input (cannot promote to ${role}): ${input}`);
+    }
+    return role;
+}
+export function normalizeSquare(s) {
+    const file = Math.trunc(s.charCodeAt(0) - FILE_START);
+    const rank = Math.trunc(s.charCodeAt(1) - RANK_START);
+    const sq = Math.trunc(rank * 8 + file);
+    if (!isValidSquare(sq)) {
+        throw new TypeError(`Invalid algebraic square: ${s}`);
+    }
+    return sq;
+}
+export function normalizeMoveRequest(move) {
+    return {
+        from: normalizeSquare(move.from),
+        to: normalizeSquare(move.to),
+        ...(move.capturedSquare && { capturedSquare: normalizeSquare(move.capturedSquare) }),
+        ...(move.promotedTo && { promotedTo: normalizeRolePromotion(move.promotedTo) }),
+        ...(move.secondary && {
+            secondary: {
+                from: normalizeSquare(move.secondary.from),
+                to: normalizeSquare(move.secondary.to)
+            }
+        })
+    };
+}

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

@@ -0,0 +1,3 @@
+import { ColorCode, NonEmptyPieceCode, PieceCode, PieceCoded, RoleCode } from './types/internal';
+export declare function toPieceCode(role: RoleCode, color: ColorCode): PieceCode;
+export declare function fromPieceCode(code: NonEmptyPieceCode): PieceCoded;

package/dist/state/board/piece.js

@@ -0,0 +1,11 @@
+export function toPieceCode(role, color) {
+    return color + role;
+}
+export function fromPieceCode(code) {
+    if (code <= 0 /* PieceCode.Empty */) {
+        throw new RangeError(`Invalid piece code: ${code}`);
+    }
+    const color = code >= 8 /* ColorCode.Black */ ? 8 /* ColorCode.Black */ : 0 /* ColorCode.White */;
+    const role = color === 8 /* ColorCode.Black */ ? code - 8 /* ColorCode.Black */ : code;
+    return { role: role, color };
+}

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

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

package/dist/state/board/position.js

@@ -0,0 +1,94 @@
+import { parse } from '@echecs/fen';
+import { normalizeColor, normalizePiece, normalizeSquare } from './normalize';
+import { SQUARE_COUNT } from './types/internal';
+const START_POSITION_RECORD_STRING = {
+    a1: 'wR',
+    b1: 'wN',
+    c1: 'wB',
+    d1: 'wQ',
+    e1: 'wK',
+    f1: 'wB',
+    g1: 'wN',
+    h1: 'wR',
+    a2: 'wP',
+    b2: 'wP',
+    c2: 'wP',
+    d2: 'wP',
+    e2: 'wP',
+    f2: 'wP',
+    g2: 'wP',
+    h2: 'wP',
+    a8: 'bR',
+    b8: 'bN',
+    c8: 'bB',
+    d8: 'bQ',
+    e8: 'bK',
+    f8: 'bB',
+    g8: 'bN',
+    h8: 'bR',
+    a7: 'bP',
+    b7: 'bP',
+    c7: 'bP',
+    d7: 'bP',
+    e7: 'bP',
+    f7: 'bP',
+    g7: 'bP',
+    h7: 'bP'
+    // All other squares are implicitly empty (undefined)
+};
+function boardParsePositionInputRecord(input) {
+    const out = new Uint8Array(SQUARE_COUNT);
+    for (const [sq, piece] of Object.entries(input)) {
+        const square = normalizeSquare(sq);
+        const pieceCode = normalizePiece(piece);
+        out[square] = pieceCode;
+    }
+    return out;
+}
+const START_POSITION_ARRAY = boardParsePositionInputRecord(START_POSITION_RECORD_STRING);
+export function boardParsePiecePositionInput(input) {
+    const out = new Uint8Array(SQUARE_COUNT);
+    if (input === 'start') {
+        out.set(START_POSITION_ARRAY);
+        return out;
+    }
+    for (const [sq, piece] of Object.entries(input)) {
+        const square = normalizeSquare(sq);
+        const pieceCode = normalizePiece(piece);
+        out[square] = pieceCode;
+    }
+    return out;
+}
+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)
+    };
+}
+export function boardParsePosition(input) {
+    if (input === 'start') {
+        return {
+            pieces: START_POSITION_ARRAY,
+            turn: 0 /* ColorCode.White */
+        };
+    }
+    if (isPositionInputObject(input)) {
+        return {
+            pieces: boardParsePiecePositionInput(input.pieces ?? 'start'),
+            turn: normalizeColor(input.turn ?? 'white')
+        };
+    }
+    // So this one is FEN string left
+    return boardParsePositionInputFen(input);
+}

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

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

package/dist/state/board/reducers.js

@@ -0,0 +1,80 @@
+import { isEmptyPieceCode } from './check';
+import { denormalizeSquare } from './denormalize';
+import { fromPieceCode, toPieceCode } from './piece';
+export function boardSetPosition(state, pieces) {
+    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;
+    return true;
+}
+function buildMoveBase(state, request) {
+    const from = request.from;
+    const to = request.to;
+    if (from === to) {
+        throw new RangeError(`Source and destination squares are the same: ${from}`);
+    }
+    const moved = state.pieces[from];
+    if (isEmptyPieceCode(moved)) {
+        throw new RangeError(`Cannot move from empty square: ${from}`);
+    }
+    return {
+        from,
+        to,
+        piece: moved
+    };
+}
+function buildMove(state, request) {
+    const base = buildMoveBase(state, request);
+    let captured;
+    const captureSq = request.capturedSquare ?? request.to;
+    const codeAtCapture = state.pieces[captureSq];
+    if (!isEmptyPieceCode(codeAtCapture)) {
+        captured = { piece: codeAtCapture, square: captureSq };
+    }
+    let secondary;
+    if (request.secondary) {
+        secondary = buildMoveBase(state, request.secondary);
+        if (secondary.from === base.to ||
+            secondary.to === base.to ||
+            secondary.from === base.from ||
+            secondary.to === base.from) {
+            throw new RangeError(`Secondary move squares cannot overlap with primary move squares: ${denormalizeSquare(secondary.from)}, ${denormalizeSquare(secondary.to)} vs ${denormalizeSquare(base.from)}, ${denormalizeSquare(base.to)}`);
+        }
+    }
+    return {
+        ...base,
+        ...(captured && { captured }),
+        ...(request.promotedTo && { promotedTo: request.promotedTo }),
+        ...(secondary && { secondary })
+    };
+}
+export function boardMove(state, request) {
+    const move = buildMove(state, request);
+    const moved = fromPieceCode(move.piece);
+    const newPieceCode = move.promotedTo
+        ? toPieceCode(move.promotedTo, moved.color)
+        : move.piece;
+    state.pieces[move.to] = newPieceCode;
+    state.pieces[move.from] = 0 /* PieceCode.Empty */;
+    if (move.captured && move.captured.square !== move.to) {
+        state.pieces[move.captured.square] = 0 /* PieceCode.Empty */;
+    }
+    if (move.secondary) {
+        state.pieces[move.secondary.to] = move.secondary.piece;
+        state.pieces[move.secondary.from] = 0 /* PieceCode.Empty */;
+    }
+    // Toggle turn
+    state.turn = state.turn === 0 /* ColorCode.White */ ? 8 /* ColorCode.Black */ : 0 /* ColorCode.White */;
+    // Increment position epoch
+    state.positionEpoch++;
+    return move;
+}

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

@@ -0,0 +1,35 @@
+import { TMoveRequest } from './template';
+export type Color = 'white' | 'black';
+export type ColorShort = 'w' | 'b';
+export type ColorInput = Color | ColorShort;
+export type Role = 'pawn' | 'knight' | 'bishop' | 'rook' | 'queen' | 'king';
+export type RoleShort = 'P' | 'N' | 'B' | 'R' | 'Q' | 'K';
+export type RoleInput = Role | RoleShort;
+export type RolePromotion = Exclude<Role, 'king' | 'pawn'>;
+export type RolePromotionShort = Exclude<RoleShort, 'P' | 'K'>;
+export type RolePromotionInput = RolePromotion | RolePromotionShort;
+export type FileChar = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
+export type RankChar = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8';
+export type SquareString = `${FileChar}${RankChar}`;
+export interface Piece {
+    color: Color;
+    role: Role;
+}
+export interface PieceShort {
+    color: ColorShort;
+    role: RoleShort;
+}
+export type PieceString = `${ColorShort}${RoleShort}`;
+export type PieceInput = Piece | PieceShort | PieceString;
+export type PiecePositionRecord = Partial<Record<SquareString, Piece>>;
+export type PiecePositionRecordShort = Partial<Record<SquareString, PieceShort>>;
+export type PiecePositionRecordString = Partial<Record<SquareString, PieceString>>;
+export type PiecePositionInputRecord = PiecePositionRecord | PiecePositionRecordShort | PiecePositionRecordString;
+export type PiecePositionInput = 'start' | PiecePositionInputRecord;
+export type PositionInputObject = {
+    pieces?: PiecePositionInput;
+    turn?: ColorInput;
+};
+export type FenString = string;
+export type PositionInput = 'start' | PositionInputObject | FenString;
+export type MoveRequestInput = TMoveRequest<SquareString, RolePromotionInput>;

package/dist/state/board/types/input.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,54 @@
+import type { ReadonlyDeep } from 'type-fest';
+import { TMove, TMoveBase, TMoveCaptured, TMoveRequest, TMoveRequestBase } from './template';
+export type Square = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63;
+export declare const SQUARE_COUNT = 64;
+export type SquareFile = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export type SquareRank = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export declare const enum RoleCode {
+    Pawn = 1,
+    Knight = 2,
+    Bishop = 3,
+    Rook = 4,
+    Queen = 5,
+    King = 6
+}
+export type RolePromotionCode = Exclude<RoleCode, RoleCode.King | RoleCode.Pawn>;
+export declare const enum ColorCode {
+    White = 0,
+    Black = 8
+}
+export declare const enum PieceCode {
+    Empty = 0,
+    WhitePawn = 1,
+    WhiteKnight = 2,
+    WhiteBishop = 3,
+    WhiteRook = 4,
+    WhiteQueen = 5,
+    WhiteKing = 6,
+    BlackPawn = 9,
+    BlackKnight = 10,
+    BlackBishop = 11,
+    BlackRook = 12,
+    BlackQueen = 13,
+    BlackKing = 14
+}
+export type EmptyPieceCode = Extract<PieceCode, PieceCode.Empty>;
+export type NonEmptyPieceCode = Exclude<PieceCode, PieceCode.Empty>;
+export declare const ALL_NON_EMPTY_PIECE_CODES: NonEmptyPieceCode[];
+export interface PieceCoded {
+    role: RoleCode;
+    color: ColorCode;
+}
+export type MoveRequestBase = TMoveRequestBase<Square>;
+export type MoveRequest = TMoveRequest<Square, RolePromotionCode>;
+export type MoveBase = TMoveBase<Square, NonEmptyPieceCode>;
+export type Move = TMove<Square, NonEmptyPieceCode, RolePromotionCode>;
+export type MoveCaptured = TMoveCaptured<Square, NonEmptyPieceCode>;
+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;
+};

package/dist/state/board/types/internal.js

@@ -0,0 +1,17 @@
+export const SQUARE_COUNT = 64;
+export const ALL_NON_EMPTY_PIECE_CODES = [
+    1 /* PieceCode.WhitePawn */,
+    2 /* PieceCode.WhiteKnight */,
+    3 /* PieceCode.WhiteBishop */,
+    4 /* PieceCode.WhiteRook */,
+    5 /* PieceCode.WhiteQueen */,
+    6 /* PieceCode.WhiteKing */,
+    9 /* PieceCode.BlackPawn */,
+    10 /* PieceCode.BlackKnight */,
+    11 /* PieceCode.BlackBishop */,
+    12 /* PieceCode.BlackRook */,
+    13 /* PieceCode.BlackQueen */,
+    14 /* PieceCode.BlackKing */
+];
+export const FILE_START = 'a'.charCodeAt(0);
+export const RANK_START = '1'.charCodeAt(0);

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

@@ -0,0 +1,18 @@
+import { ReadonlyDeep } from 'type-fest';
+import { BoardStateMutationSession } from '../mutation';
+import { ColorInput, MoveRequestInput, PiecePositionInput, PositionInput } from './input';
+import { ColorCode, Move, MoveRequest, PieceCode, Square } from './internal';
+export interface BoardStateInternal {
+    pieces: Uint8Array;
+    turn: ColorCode;
+    positionEpoch: number;
+}
+export type BoardStateSnapshot = ReadonlyDeep<BoardStateInternal>;
+export interface BoardState {
+    setPosition(input: PositionInput, mutationSession: BoardStateMutationSession): boolean;
+    setPiecePosition(input: PiecePositionInput, mutationSession: BoardStateMutationSession): boolean;
+    setTurn(turn: ColorInput, mutationSession: BoardStateMutationSession): boolean;
+    move(request: MoveRequestInput | MoveRequest, mutationSession: BoardStateMutationSession): Move;
+    getPieceCodeAt(square: Square): PieceCode;
+    getSnapshot(): BoardStateSnapshot;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import { PieceString, RolePromotionShort, SquareString } from './input';
+import { TMove, TMoveBase, TMoveCaptured } from './template';
+export type MoveBaseOutput = TMoveBase<SquareString, PieceString>;
+export type MoveCapturedOutput = TMoveCaptured<SquareString, PieceString>;
+export type MoveOutput = TMove<SquareString, PieceString, RolePromotionShort>;

package/dist/state/board/types/output.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,23 @@
+export interface TMoveRequestBase<TSquare> {
+    from: TSquare;
+    to: TSquare;
+}
+export interface TMoveRequest<TSquare, TPromotion> extends TMoveRequestBase<TSquare> {
+    capturedSquare?: TSquare;
+    promotedTo?: TPromotion;
+    secondary?: TMoveRequestBase<TSquare>;
+}
+export interface TMoveCaptured<TSquare, TPiece> {
+    square: TSquare;
+    piece: TPiece;
+}
+export interface TMoveBase<TSquare, TPiece> {
+    from: TSquare;
+    to: TSquare;
+    piece: TPiece;
+}
+export interface TMove<TSquare, TPiece, TPromotion> extends TMoveBase<TSquare, TPiece> {
+    captured?: TMoveCaptured<TSquare, TPiece>;
+    promotedTo?: TPromotion;
+    secondary?: TMoveBase<TSquare, TPiece>;
+}

package/dist/state/board/types/template.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import type { ChangeState } from './types';
+export declare function createChangeState(): ChangeState;

package/dist/state/change/factory.js

@@ -0,0 +1,28 @@
+import { cloneDeep } from 'es-toolkit/object';
+import { changeStateSetDeferredUIMoveRequestContext, changeStateSetLastMove } from './reducers';
+function createChangeStateInternal() {
+    return {
+        lastMove: null,
+        deferredUIMoveRequestContext: null
+    };
+}
+export function createChangeState() {
+    const internalState = createChangeStateInternal();
+    return {
+        get lastMove() {
+            return cloneDeep(internalState.lastMove);
+        },
+        setLastMove(move, mutationSession) {
+            return mutationSession.addMutation('state.change.setLastMove', changeStateSetLastMove(internalState, move));
+        },
+        getSnapshot() {
+            return {
+                ...cloneDeep(internalState),
+                deferredUIMoveRequestContext: internalState.deferredUIMoveRequestContext?.getSnapshot() ?? null
+            };
+        },
+        setDeferredUIMoveRequestContext(context, mutationSession) {
+            return mutationSession.addMutation('state.change.setDeferredUIMoveRequestContext', changeStateSetDeferredUIMoveRequestContext(internalState, context));
+        }
+    };
+}

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

@@ -0,0 +1,8 @@
+import { ExtensionUIMoveRequestContextSnapshot } from '../../extensions/types/context/ui-move';
+import type { MoveRequest, MoveRequestBase, MoveSnapshot } from '../board/types/internal';
+import { MoveDestinationSnapshot } from '../interaction/types/internal';
+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;
+export declare function moveDestinationsEqual(destA: MoveDestinationSnapshot | null, destB: MoveDestinationSnapshot | null): boolean;
+export declare function uiMoveRequestContextsEqual(contextA: ExtensionUIMoveRequestContextSnapshot | null, contextB: ExtensionUIMoveRequestContextSnapshot | null): boolean;

package/dist/state/change/helpers.js

@@ -0,0 +1,86 @@
+import { setsEqual } from '../../helpers/util';
+function baseMovesEqual(moveA, moveB) {
+    const diffs = [
+        moveA.from !== moveB.from,
+        moveA.to !== moveB.to,
+        moveA.piece !== moveB.piece
+    ];
+    return !diffs.some(Boolean);
+}
+export function movesEqual(moveA, moveB) {
+    if (moveA === null && moveB === null) {
+        return true;
+    }
+    if (moveA === null || moveB === null) {
+        return false;
+    }
+    if (!baseMovesEqual(moveA, moveB)) {
+        return false;
+    }
+    const diffs = [
+        moveA.promotedTo !== moveB.promotedTo,
+        moveA.captured?.piece !== moveB.captured?.piece,
+        moveA.captured?.square !== moveB.captured?.square
+    ];
+    if (diffs.some(Boolean)) {
+        return false;
+    }
+    // Now check secondary moves
+    if (moveA.secondary === undefined && moveB.secondary === undefined) {
+        return true;
+    }
+    if (moveA.secondary === undefined || moveB.secondary === undefined) {
+        return false;
+    }
+    return movesEqual(moveA.secondary, moveB.secondary);
+}
+export function moveRequestBasesEqual(requestA, requestB) {
+    if (requestA === null && requestB === null) {
+        return true;
+    }
+    if (requestA === null || requestB === null) {
+        return false;
+    }
+    return requestA.from === requestB.from && requestA.to === requestB.to;
+}
+export function moveRequestsEqual(requestA, requestB) {
+    if (requestA === null && requestB === null) {
+        return true;
+    }
+    if (requestA === null || requestB === null) {
+        return false;
+    }
+    // Compare relevant properties of MoveRequest here
+    // Assuming MoveRequest has properties 'from' and 'to' for example
+    return (moveRequestBasesEqual(requestA, requestB) &&
+        requestA.capturedSquare === requestB.capturedSquare &&
+        requestA.promotedTo === requestB.promotedTo &&
+        moveRequestBasesEqual(requestA.secondary ?? null, requestB.secondary ?? null));
+}
+export function moveDestinationsEqual(destA, destB) {
+    if (destA === null && destB === null) {
+        return true;
+    }
+    if (destA === null || destB === null) {
+        return false;
+    }
+    return (destA.to === destB.to &&
+        destA.capturedSquare === destB.capturedSquare &&
+        setsEqual(new Set(destA.promotedTo ?? []), new Set(destB.promotedTo ?? [])) &&
+        moveRequestBasesEqual(destA.secondary ?? null, destB.secondary ?? null));
+}
+export function uiMoveRequestContextsEqual(contextA, contextB) {
+    if (contextA === null && contextB === null) {
+        return true;
+    }
+    if (contextA === null || contextB === null) {
+        return false;
+    }
+    // Compare relevant properties of UIMoveRequestContext here
+    // Assuming UIMoveRequestContext has properties 'from' and 'to' for example
+    return (contextA.status === contextB.status &&
+        contextA.sourceSquare === contextB.sourceSquare &&
+        moveDestinationsEqual(contextA.destination, contextB.destination) &&
+        contextA.canBeAutoResolved === contextB.canBeAutoResolved &&
+        moveRequestsEqual(contextA.resolvedMoveRequest, contextB.resolvedMoveRequest));
+}

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

@@ -0,0 +1,6 @@
+import type { MutationSession } from '../../mutation/types';
+export type ChangeStateMutationPayloadByCause = {
+    'state.change.setLastMove': undefined;
+    'state.change.setDeferredUIMoveRequestContext': undefined;
+};
+export type ChangeStateMutationSession = MutationSession<ChangeStateMutationPayloadByCause>;

package/dist/state/change/mutation.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import { ExtensionUIMoveRequestContext } from '../../extensions/types/context/ui-move';
+import type { MoveSnapshot } from '../board/types/internal';
+import type { ChangeStateInternal } from './types';
+export declare function changeStateSetLastMove(state: ChangeStateInternal, move: MoveSnapshot | null): boolean;
+export declare function changeStateSetDeferredUIMoveRequestContext(state: ChangeStateInternal, context: ExtensionUIMoveRequestContext): boolean;

package/dist/state/change/reducers.js

@@ -0,0 +1,16 @@
+import { cloneDeep } from 'es-toolkit/object';
+import { movesEqual, uiMoveRequestContextsEqual } from './helpers';
+export function changeStateSetLastMove(state, move) {
+    if (movesEqual(state.lastMove, move)) {
+        return false; // No change
+    }
+    state.lastMove = cloneDeep(move);
+    return true;
+}
+export function changeStateSetDeferredUIMoveRequestContext(state, context) {
+    if (uiMoveRequestContextsEqual(state.deferredUIMoveRequestContext, context)) {
+        return false; // No change
+    }
+    state.deferredUIMoveRequestContext = context;
+    return true;
+}

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

@@ -0,0 +1,17 @@
+import type { ReadonlyDeep } from 'type-fest';
+import { ExtensionUIMoveRequestContext, ExtensionUIMoveRequestContextSnapshot } from '../../extensions/types/context/ui-move';
+import type { MoveSnapshot } from '../board/types/internal';
+import type { ChangeStateMutationSession } from './mutation';
+export interface ChangeStateInternal {
+    lastMove: MoveSnapshot | null;
+    deferredUIMoveRequestContext: ExtensionUIMoveRequestContext | null;
+}
+export type ChangeStateSnapshot = ReadonlyDeep<Omit<ChangeStateInternal, 'deferredUIMoveRequestContext'>> & {
+    deferredUIMoveRequestContext: ExtensionUIMoveRequestContextSnapshot | null;
+};
+export interface ChangeState {
+    readonly lastMove: MoveSnapshot | null;
+    setLastMove(move: MoveSnapshot | null, mutationSession: ChangeStateMutationSession): boolean;
+    setDeferredUIMoveRequestContext(context: ExtensionUIMoveRequestContext, mutationSession: ChangeStateMutationSession): boolean;
+    getSnapshot(): ChangeStateSnapshot;
+}

package/dist/state/change/types.js

@@ -0,0 +1 @@
+export {};

package/dist/state/factory.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeState, RuntimeStateInitOptions } from './types';
+export declare function createRuntimeState(options: RuntimeStateInitOptions): RuntimeState;