@mirasen/chessboard 0.1.0

package/dist/runtime/mutation/factory.js

@@ -0,0 +1,47 @@
+import { createMutationPipeline } from '../../mutation/pipeline';
+import { extensionSystemUpdatePipe } from './extension-update';
+import { reconcileInteractionSelectionAfterBoardStateChange } from './interaction';
+import { clearLastMoveOnBoardSetPosition, updateLastMoveOnBoardMove } from './last-move';
+import { layoutRefreshGeometryPipe } from './layout';
+import { requestRenderPipe } from './request-render';
+function buildPreviousContext(current) {
+    return {
+        state: current.state.getSnapshot(),
+        layout: current.layout.getSnapshot()
+    };
+}
+export function createRuntimeMutationPipeline() {
+    let previousContext = null;
+    // Construct the pipes
+    const pipes = [
+        updateLastMoveOnBoardMove,
+        clearLastMoveOnBoardSetPosition,
+        reconcileInteractionSelectionAfterBoardStateChange,
+        layoutRefreshGeometryPipe,
+        extensionSystemUpdatePipe,
+        requestRenderPipe
+    ];
+    const basicPipeline = createMutationPipeline(pipes);
+    return {
+        getSession() {
+            return basicPipeline.getSession();
+        },
+        addMutation: basicPipeline.addMutation,
+        run(currentContext) {
+            const pipelineContext = {
+                previous: previousContext,
+                current: currentContext
+            };
+            let didRun = false;
+            try {
+                didRun = basicPipeline.run(pipelineContext);
+            }
+            finally {
+                if (didRun) {
+                    previousContext = buildPreviousContext(currentContext);
+                }
+            }
+            return didRun;
+        }
+    };
+}

package/dist/runtime/mutation/interaction.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeMutationPipe } from './pipeline';
+export declare const reconcileInteractionSelectionAfterBoardStateChange: RuntimeMutationPipe;

package/dist/runtime/mutation/interaction.js

@@ -0,0 +1,34 @@
+import { isEmptyPieceCode } from '../../state/board/check';
+import { selectedEqual } from '../../state/interaction/helpers';
+export const reconcileInteractionSelectionAfterBoardStateChange = (context, mutationSession) => {
+    const { current } = context;
+    if (!mutationSession.hasMutation({ prefixes: ['state.board.'] }) ||
+        mutationSession.hasMutation({
+            causes: [
+                'state.interaction.clear',
+                'runtime.interaction.dropTo',
+                'runtime.interaction.releaseTo'
+            ]
+        })) {
+        return;
+    }
+    const currentSelected = current.state.interaction.selected ?? null;
+    const currentSelectedSquare = currentSelected?.square ?? null;
+    const wouldBeCurrentSelectedPieceCode = currentSelectedSquare !== null
+        ? current.state.board.getPieceCodeAt(currentSelectedSquare)
+        : null;
+    const wouldBeCurrentSelected = currentSelectedSquare !== null &&
+        wouldBeCurrentSelectedPieceCode !== null &&
+        !isEmptyPieceCode(wouldBeCurrentSelectedPieceCode)
+        ? {
+            square: currentSelectedSquare,
+            pieceCode: wouldBeCurrentSelectedPieceCode
+        }
+        : null;
+    const notChanged = selectedEqual(currentSelected, wouldBeCurrentSelected);
+    if (notChanged) {
+        current.state.interaction.updateActiveDestinations(mutationSession);
+        return;
+    }
+    current.state.interaction.clear(mutationSession);
+};

package/dist/runtime/mutation/invalidation.js

@@ -0,0 +1,2 @@
+"use strict";
+// TODO: Mark dirty layers based on upstream changes.

package/dist/runtime/mutation/last-move.d.ts

@@ -0,0 +1,3 @@
+import { RuntimeMutationPipe } from './pipeline';
+export declare const updateLastMoveOnBoardMove: RuntimeMutationPipe;
+export declare const clearLastMoveOnBoardSetPosition: RuntimeMutationPipe;

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

@@ -0,0 +1,19 @@
+import assert from '@ktarmyshov/assert';
+export const updateLastMoveOnBoardMove = (context, mutationSession) => {
+    const { current } = context;
+    if (!mutationSession.hasMutation({ causes: ['state.board.move'] })) {
+        return;
+    }
+    const lastMove = mutationSession.getPayloads('state.board.move')?.[0];
+    assert(lastMove, 'Expected last move payload to be present after state.board.move mutation');
+    current.state.change.setLastMove(lastMove, mutationSession);
+};
+export const clearLastMoveOnBoardSetPosition = (context, mutationSession) => {
+    const { current } = context;
+    if (!mutationSession.hasMutation({
+        causes: ['state.board.setPosition', 'state.board.setPiecePosition']
+    })) {
+        return;
+    }
+    current.state.change.setLastMove(null, mutationSession);
+};

package/dist/runtime/mutation/layout.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeMutationPipe } from './pipeline';
+export declare const layoutRefreshGeometryPipe: RuntimeMutationPipe;

package/dist/runtime/mutation/layout.js

@@ -0,0 +1,8 @@
+export const layoutRefreshGeometryPipe = (context, mutationSession) => {
+    const { current } = context;
+    if (mutationSession.hasMutation({ causes: ['state.view.setOrientation'] })) {
+        current.layout.refreshGeometry({
+            orientation: current.state.view.orientation
+        }, mutationSession);
+    }
+};

package/dist/runtime/mutation/pipeline.d.ts

@@ -0,0 +1,22 @@
+import { ExtensionSystem } from '../../extensions/types/main';
+import { Layout, LayoutSnapshot } from '../../layout/types';
+import { MutationPipe, MutationPipeline } from '../../mutation/types';
+import { RenderSystem } from '../../render/types';
+import { RuntimeState, RuntimeStateSnapshot } from '../../state/types';
+import { RuntimeMutationPayloadByCause } from './types';
+export interface RuntimeMutationPipelineContext {
+    readonly state: RuntimeState;
+    readonly layout: Layout;
+    readonly renderSystem: RenderSystem;
+    readonly extensionSystem: ExtensionSystem;
+}
+export type RuntimeMutationPipeline = MutationPipeline<RuntimeMutationPayloadByCause, RuntimeMutationPipelineContext>;
+export interface RuntimeMutationPipeContextPrevious {
+    readonly state: RuntimeStateSnapshot;
+    readonly layout: LayoutSnapshot;
+}
+export interface RuntimeMutationPipeContext {
+    previous: RuntimeMutationPipeContextPrevious | null;
+    current: RuntimeMutationPipelineContext;
+}
+export type RuntimeMutationPipe = MutationPipe<RuntimeMutationPayloadByCause, RuntimeMutationPipeContext>;

package/dist/runtime/mutation/pipeline.js

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

package/dist/runtime/mutation/request-render.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeMutationPipe } from './pipeline';
+export declare const requestRenderPipe: RuntimeMutationPipe;

package/dist/runtime/mutation/request-render.js

@@ -0,0 +1,29 @@
+import { isFrameRenderable } from '../../extensions/types/basic/update';
+export const requestRenderPipe = (context) => {
+    const { current } = context;
+    const currentFrame = current.extensionSystem.currentFrame;
+    if (currentFrame === null || !isFrameRenderable(currentFrame))
+        return; // no-op if we can't render
+    if (needsRender(context)) {
+        current.renderSystem.requestRender(currentFrame);
+    }
+    if (needsRenderAnimation(context)) {
+        current.renderSystem.requestRenderAnimation();
+    }
+};
+function needsRender(context) {
+    for (const extensionRec of context.current.renderSystem.extensions.values()) {
+        if (extensionRec.extension.invalidation.dirtyLayers !== 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function needsRenderAnimation(context) {
+    for (const extensionRec of context.current.renderSystem.extensions.values()) {
+        if (extensionRec.extension.animation.getAll(['submitted', 'active']).length > 0) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/runtime/mutation/run.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeInternal } from '../types/main';
+export declare function runtimeRunMutationPipeline(state: RuntimeInternal): boolean;

package/dist/runtime/mutation/run.js

@@ -0,0 +1,3 @@
+export function runtimeRunMutationPipeline(state) {
+    return state.mutation.run(state);
+}

package/dist/runtime/mutation/types.d.ts

@@ -0,0 +1,14 @@
+import { LayoutMutationPayloadByCause } from '../../layout/mutation';
+import { MutationSession, ReadonlyMutationSession } from '../../mutation/types';
+import { BoardStateMutationPayloadByCause } from '../../state/board/mutation';
+import { ChangeStateMutationPayloadByCause } from '../../state/change/mutation';
+import { InteractionStateMutationPayloadByCause } from '../../state/interaction/mutation';
+import { ViewStateMutationPayloadByCause } from '../../state/view/mutation';
+type RuntimeOwnMutationPayloadByCause = {
+    'runtime.interaction.dropTo': undefined;
+    'runtime.interaction.releaseTo': undefined;
+};
+export type RuntimeMutationPayloadByCause = BoardStateMutationPayloadByCause & ChangeStateMutationPayloadByCause & InteractionStateMutationPayloadByCause & ViewStateMutationPayloadByCause & LayoutMutationPayloadByCause & RuntimeOwnMutationPayloadByCause;
+export type RuntimeMutationSession = MutationSession<RuntimeMutationPayloadByCause>;
+export type RuntimeReadonlyMutationSession = ReadonlyMutationSession<RuntimeMutationPayloadByCause>;
+export {};

package/dist/runtime/mutation/types.js

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

package/dist/runtime/types/main.d.ts

@@ -0,0 +1,36 @@
+import { AnyExtensionDefinition } from '../../extensions/types/extension';
+import { ExtensionRuntimeSurfaceCommands } from '../../extensions/types/surface/commands';
+import { RuntimeStateInitOptions } from '../../state/types';
+import { InputAdapter } from '../input/adapter/types';
+import { InteractionController } from '../input/controller/types';
+import { RuntimeMutationPipeline, RuntimeMutationPipelineContext } from '../mutation/pipeline';
+export type RuntimeStatus = 'constructing' | 'unmounted' | 'mounted' | 'destroyed';
+export interface RuntimeInternal extends RuntimeMutationPipelineContext {
+    readonly mutation: RuntimeMutationPipeline;
+    readonly interactionController: InteractionController;
+    inputAdapter: InputAdapter | null;
+    resizeObserver: ResizeObserver | null;
+}
+export type GetInternalState = () => RuntimeInternal;
+export interface RuntimeInitOptions {
+    doc: Document;
+    state?: RuntimeStateInitOptions;
+    extensions?: readonly AnyExtensionDefinition[];
+}
+export interface RuntimeInitOptionsInternal extends RuntimeInitOptions {
+    extensionRuntimeSurfaceCommands: ExtensionRuntimeSurfaceCommands;
+    getInternalState: GetInternalState;
+}
+/**
+ * Public interface for the internal runtime.
+ * Orchestrates board state, view state, interaction state, and invalidation.
+ * Board/view/interaction reducers own mutation logic; the runtime coordinates scheduling
+ * and geometry updates in response to state changes.
+ */
+export interface Runtime extends ExtensionRuntimeSurfaceCommands {
+    readonly status: RuntimeStatus;
+    mount(container: HTMLElement): void;
+    unmount(): void;
+    destroy(): void;
+    getExtensionsPublicRecord(): Readonly<Record<string, unknown>>;
+}

package/dist/runtime/types/main.js

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

package/dist/runtime/types/ui-move.d.ts

@@ -0,0 +1,9 @@
+import { ExtensionUIMoveRequestStatus } from '../../extensions/types/context/ui-move';
+import { MoveRequest, Square } from '../../state/board/types/internal';
+import { MoveDestinationSnapshot } from '../../state/interaction/types/internal';
+export interface UIMoveRequestContextInternal {
+    readonly sourceSquare: Square;
+    readonly destination: MoveDestinationSnapshot;
+    status: ExtensionUIMoveRequestStatus;
+    resolvedMoveRequest: MoveRequest | null;
+}

package/dist/runtime/types/ui-move.js

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

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

@@ -0,0 +1,27 @@
+import { Color, ColorShort, MoveRequestInput, Piece, PiecePositionInput, PiecePositionRecord, PiecePositionRecordShort, PiecePositionRecordString, PieceShort, PieceString, Role, RoleShort, SquareString } from './types/input';
+import { EmptyPieceCode, MoveRequest, NonEmptyPieceCode, PieceCode, RolePromotionCode, Square, SquareFile, SquareRank } from './types/internal';
+import { BoardStateSnapshot } from './types/main';
+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 isRank(n: number): n is SquareRank;
+export declare function isFile(n: number): n is SquareFile;
+export declare function isValidSquare(n: number): n is Square;
+export declare function assertValidSquare(n: number): asserts n is Square;
+export declare function isRolePromotionCode(role: number): role is RolePromotionCode;
+export declare function isPieceString(value: unknown): value is PieceString;
+export declare function isSquareString(value: unknown): value is SquareString;
+export declare function isPositionMapString(pos: PiecePositionInput): pos is PiecePositionRecordString;
+export declare function isColorShort(value: unknown): value is ColorShort;
+export declare function isRoleShort(value: unknown): value is RoleShort;
+export declare function isPieceShort(value: unknown): value is PieceShort;
+export declare function isPositionMapShort(pos: PiecePositionInput): pos is PiecePositionRecordShort;
+export declare function isColor(value: unknown): value is Color;
+export declare function isRole(value: unknown): value is Role;
+export declare function isPiece(value: unknown): value is Piece;
+export declare function isPositionMap(pos: PiecePositionInput): pos is PiecePositionRecord;
+export declare function assertValidRoleCode(n: number): asserts n is RolePromotionCode;
+export declare function isNormalizedMoveRequest(input: MoveRequest | MoveRequestInput): input is MoveRequest;

package/dist/state/board/check.js

@@ -0,0 +1,148 @@
+import { SQUARE_COUNT } from './types/internal';
+export function isWhitePieceCode(code) {
+    return code > 0 /* PieceCode.Empty */ && code < 8 /* ColorCode.Black */;
+}
+export function isBlackPieceCode(code) {
+    return code >= 8 /* ColorCode.Black */;
+}
+export function isOccupied(board, sq) {
+    return board.pieces[sq] > 0 /* PieceCode.Empty */;
+}
+export function isEmptyPieceCode(code) {
+    return code === 0 /* PieceCode.Empty */;
+}
+export function isNonEmptyPieceCode(code) {
+    return code !== 0 /* PieceCode.Empty */;
+}
+export function piecePositionsEqual(pos1, pos2) {
+    if (pos1.positionEpoch !== pos2.positionEpoch)
+        return false;
+    for (let i = 0; i < pos1.pieces.length; i++) {
+        if (pos1.pieces[i] !== pos2.pieces[i])
+            return false;
+    }
+    return true;
+}
+export function isRank(n) {
+    return Number.isInteger(n) && n >= 0 && n < 8;
+}
+export function isFile(n) {
+    return Number.isInteger(n) && n >= 0 && n < 8;
+}
+export function isValidSquare(n) {
+    return Number.isInteger(n) && n >= 0 && n < SQUARE_COUNT;
+}
+export function assertValidSquare(n) {
+    if (!isValidSquare(n)) {
+        throw new RangeError(`Invalid square index: ${n}`);
+    }
+}
+export function isRolePromotionCode(role) {
+    return (role === 2 /* RoleCode.Knight */ ||
+        role === 3 /* RoleCode.Bishop */ ||
+        role === 4 /* RoleCode.Rook */ ||
+        role === 5 /* RoleCode.Queen */);
+}
+const PIECE_STRING_REGEX = /^[bw][KQRBNP]$/;
+export function isPieceString(value) {
+    return typeof value === 'string' && PIECE_STRING_REGEX.test(value);
+}
+export function isSquareString(value) {
+    return (typeof value === 'string' &&
+        value.length === 2 &&
+        value[0] >= 'a' &&
+        value[0] <= 'h' &&
+        value[1] >= '1' &&
+        value[1] <= '8');
+}
+export function isPositionMapString(pos) {
+    for (const [sq, piece] of Object.entries(pos)) {
+        if (!isSquareString(sq)) {
+            return false;
+        }
+        if (!isPieceString(piece)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isColorShort(value) {
+    return value === 'w' || value === 'b';
+}
+export function isRoleShort(value) {
+    return (value === 'K' ||
+        value === 'Q' ||
+        value === 'R' ||
+        value === 'B' ||
+        value === 'N' ||
+        value === 'P');
+}
+export function isPieceShort(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'color' in value &&
+        'role' in value &&
+        isColorShort(value.color) &&
+        isRoleShort(value.role));
+}
+export function isPositionMapShort(pos) {
+    for (const [sq, piece] of Object.entries(pos)) {
+        if (!isSquareString(sq)) {
+            return false;
+        }
+        if (!isPieceShort(piece)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isColor(value) {
+    return value === 'white' || value === 'black';
+}
+export function isRole(value) {
+    return (value === 'king' ||
+        value === 'queen' ||
+        value === 'rook' ||
+        value === 'bishop' ||
+        value === 'knight' ||
+        value === 'pawn');
+}
+export function isPiece(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'color' in value &&
+        'role' in value &&
+        isColor(value.color) &&
+        isRole(value.role));
+}
+export function isPositionMap(pos) {
+    for (const [sq, piece] of Object.entries(pos)) {
+        if (!isSquareString(sq)) {
+            return false;
+        }
+        if (!isPiece(piece)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function assertValidRoleCode(n) {
+    if (!isRolePromotionCode(n)) {
+        throw new RangeError(`Invalid role promotion code: ${n}`);
+    }
+}
+export function isNormalizedMoveRequest(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        'from' in input &&
+        'to' in input &&
+        typeof input.from === 'number' &&
+        isValidSquare(input.from) &&
+        typeof input.to === 'number' &&
+        isValidSquare(input.to) &&
+        (input.capturedSquare === undefined ||
+            (typeof input.capturedSquare === 'number' && isValidSquare(input.capturedSquare))) &&
+        (input.promotedTo === undefined ||
+            (typeof input.promotedTo === 'number' && isRolePromotionCode(input.promotedTo))) &&
+        (input.secondary === undefined || isNormalizedMoveRequest(input.secondary)));
+}

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

@@ -0,0 +1,4 @@
+import type { Square, SquareFile, SquareRank } from './types/internal';
+export declare function fileOf(sq: Square): SquareFile;
+export declare function rankOf(sq: Square): SquareRank;
+export declare function squareOf(file: SquareFile, rank: SquareRank): Square;

package/dist/state/board/coords.js

@@ -0,0 +1,9 @@
+export function fileOf(sq) {
+    return Math.trunc(sq % 8);
+}
+export function rankOf(sq) {
+    return Math.trunc(sq / 8);
+}
+export function squareOf(file, rank) {
+    return Math.trunc(rank * 8 + file);
+}

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

@@ -0,0 +1,11 @@
+import { ColorShort, PieceString, RolePromotionShort, RoleShort, SquareString } from './types/input';
+import { ColorCode, Move, MoveBase, MoveCaptured, NonEmptyPieceCode, RoleCode, RolePromotionCode, Square } from './types/internal';
+import { MoveBaseOutput, MoveCapturedOutput, MoveOutput } from './types/output';
+export declare function denormalizeSquare(sq: Square): SquareString;
+export declare function denormalizeColorShort(color: ColorCode): ColorShort;
+export declare function denormalizeRoleShort(role: RoleCode): RoleShort;
+export declare function denormalizeRolePromotionShort(role: RolePromotionCode): RolePromotionShort;
+export declare function denormalizePieceString(code: NonEmptyPieceCode): PieceString;
+export declare function denormalizeMoveBase(move: MoveBase): MoveBaseOutput;
+export declare function denormalizeMoveCaptured(captured: MoveCaptured): MoveCapturedOutput;
+export declare function denormalizeMove(move: Move): MoveOutput;

package/dist/state/board/denormalize.js

@@ -0,0 +1,77 @@
+import { isValidSquare } from './check';
+import { fileOf, rankOf } from './coords';
+import { fromPieceCode } from './piece';
+import { FILE_START, RANK_START } from './types/internal';
+export function denormalizeSquare(sq) {
+    if (!isValidSquare(sq)) {
+        throw new RangeError(`Invalid square index: ${sq}`);
+    }
+    const file = fileOf(sq);
+    const rank = rankOf(sq);
+    const f = String.fromCharCode(FILE_START + file);
+    const r = String.fromCharCode(RANK_START + rank);
+    return `${f}${r}`;
+}
+export function denormalizeColorShort(color) {
+    switch (color) {
+        case 0 /* ColorCode.White */:
+            return 'w';
+        case 8 /* ColorCode.Black */:
+            return 'b';
+        default:
+            throw new RangeError(`Invalid color code: ${color}`);
+    }
+}
+export function denormalizeRoleShort(role) {
+    switch (role) {
+        case 1 /* RoleCode.Pawn */:
+            return 'P';
+        case 6 /* RoleCode.King */:
+            return 'K';
+        case 2 /* RoleCode.Knight */:
+            return 'N';
+        case 3 /* RoleCode.Bishop */:
+            return 'B';
+        case 4 /* RoleCode.Rook */:
+            return 'R';
+        case 5 /* RoleCode.Queen */:
+            return 'Q';
+        default:
+            throw new RangeError(`Invalid role code: ${role}`);
+    }
+}
+export function denormalizeRolePromotionShort(role) {
+    const roleShort = denormalizeRoleShort(role);
+    if (roleShort === 'K' || roleShort === 'P') {
+        throw new RangeError(`Invalid role for promotion: ${role}`);
+    }
+    return roleShort;
+}
+export function denormalizePieceString(code) {
+    const piece = fromPieceCode(code);
+    const colorPrefix = denormalizeColorShort(piece.color);
+    const roleStr = denormalizeRoleShort(piece.role);
+    return `${colorPrefix}${roleStr}`;
+}
+export function denormalizeMoveBase(move) {
+    return {
+        from: denormalizeSquare(move.from),
+        to: denormalizeSquare(move.to),
+        piece: denormalizePieceString(move.piece)
+    };
+}
+export function denormalizeMoveCaptured(captured) {
+    return {
+        square: denormalizeSquare(captured.square),
+        piece: denormalizePieceString(captured.piece)
+    };
+}
+export function denormalizeMove(move) {
+    const baseMove = denormalizeMoveBase(move);
+    return {
+        ...baseMove,
+        ...(move.promotedTo ? { promotedTo: denormalizeRolePromotionShort(move.promotedTo) } : {}),
+        ...(move.captured ? { captured: denormalizeMoveCaptured(move.captured) } : {}),
+        ...(move.secondary ? { secondary: denormalizeMoveBase(move.secondary) } : {})
+    };
+}

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

@@ -0,0 +1,3 @@
+import { PositionInput } from './types/input';
+import { BoardState } from './types/main';
+export declare function createBoardState(position?: PositionInput): BoardState;

package/dist/state/board/factory.js

@@ -0,0 +1,46 @@
+import { cloneDeep } from 'es-toolkit/object';
+import { isNormalizedMoveRequest } from './check';
+import { normalizeColor, normalizeMoveRequest } from './normalize';
+import { boardParsePiecePositionInput, boardParsePosition } from './position';
+import { boardMove, boardSetPosition, boardSetTurn } from './reducers';
+function createBoardStateInternal(position) {
+    const parsedPosition = boardParsePosition(position);
+    return {
+        pieces: parsedPosition.pieces,
+        turn: parsedPosition.turn,
+        positionEpoch: 0
+    };
+}
+export function createBoardState(position) {
+    const internalState = createBoardStateInternal(position ?? 'start');
+    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);
+        },
+        setPiecePosition(input, mutationSession) {
+            const pieces = boardParsePiecePositionInput(input);
+            return mutationSession.addMutation('state.board.setPiecePosition', boardSetPosition(internalState, pieces));
+        },
+        setTurn(turn, mutationSession) {
+            const normalizedTurn = normalizeColor(turn);
+            return mutationSession.addMutation('state.board.setTurn', boardSetTurn(internalState, normalizedTurn));
+        },
+        move(request, mutationSession) {
+            const moveRequest = isNormalizedMoveRequest(request)
+                ? request
+                : normalizeMoveRequest(request);
+            const result = boardMove(internalState, moveRequest);
+            mutationSession.addMutation('state.board.move', true, result);
+            return result;
+        },
+        getPieceCodeAt(square) {
+            return internalState.pieces[square];
+        },
+        getSnapshot() {
+            return cloneDeep(internalState);
+        }
+    };
+}

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

@@ -0,0 +1,9 @@
+import type { MutationSession } from '../../mutation/types';
+import type { MoveSnapshot } from './types/internal';
+export type BoardStateMutationPayloadByCause = {
+    'state.board.setPosition': undefined;
+    'state.board.setPiecePosition': undefined;
+    'state.board.setTurn': undefined;
+    'state.board.move': MoveSnapshot;
+};
+export type BoardStateMutationSession = MutationSession<BoardStateMutationPayloadByCause>;

package/dist/state/board/mutation.js

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

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

@@ -0,0 +1,8 @@
+import { ColorInput, MoveRequestInput, PieceInput, RoleInput, RolePromotionInput, SquareString } from './types/input';
+import { ColorCode, MoveRequest, PieceCode, RoleCode, RolePromotionCode, Square } from './types/internal';
+export declare function normalizeColor(input: ColorInput): ColorCode;
+export declare function normalizeRole(input: RoleInput): RoleCode;
+export declare function normalizePiece(input: PieceInput): PieceCode;
+export declare function normalizeRolePromotion(input: RolePromotionInput): RolePromotionCode;
+export declare function normalizeSquare(s: SquareString): Square;
+export declare function normalizeMoveRequest(move: MoveRequestInput): MoveRequest;