@mirasen/chessboard 0.1.0

package/dist/render/rendering/state.js

@@ -0,0 +1,48 @@
+import { updateElementAttributes } from '../svg/helpers';
+import { validateIsMounted } from './helpers';
+export function checkNeedsRender(state) {
+    for (const extensionRec of state.extensions.values()) {
+        if (extensionRec.extension.invalidation.dirtyLayers !== 0) {
+            return true;
+        }
+    }
+    return false;
+}
+export function performRenderPass(state, request) {
+    validateIsMounted(state);
+    if (!request) {
+        throw new Error('render() called without a valid render request');
+    }
+    if (!request.layout.geometry) {
+        throw new Error('render() called without a valid layout geometry');
+    }
+    const currentSize = request.layout.geometry.boardSize;
+    const prevSize = state.currentFrame?.layout.geometry?.boardSize;
+    if (currentSize !== prevSize) {
+        const size = String(currentSize);
+        updateElementAttributes(state.svgRoots.svgRoot, {
+            width: size,
+            height: size,
+            viewBox: `0 0 ${size} ${size}`
+        });
+    }
+    // Check if we have any invalidation states
+    if (!checkNeedsRender(state)) {
+        // Save the last rendered common base context
+        state.currentFrame = request;
+        return; // no-op
+    }
+    // Now run over the extensions that have invalidation layers marked and call their render method
+    for (const extensionRec of state.extensions.values()) {
+        if (extensionRec.extension.invalidation.dirtyLayers !== 0) {
+            const context = {
+                currentFrame: request,
+                invalidation: extensionRec.extension.invalidation
+            };
+            extensionRec.extension.instance.render?.(context);
+            extensionRec.extension.invalidation.clear();
+        }
+    }
+    // Save the last rendered common base context
+    state.currentFrame = request;
+}

package/dist/render/rendering/visuals.d.ts

@@ -0,0 +1,3 @@
+import { TransientInput } from '../../extensions/types/basic/transient-visuals';
+import { RenderSystemInternal } from '../types';
+export declare function performRenderTransientVisualsPass(state: RenderSystemInternal, request: TransientInput): void;

package/dist/render/rendering/visuals.js

@@ -0,0 +1,21 @@
+import { validateIsMounted } from './helpers';
+export function performRenderTransientVisualsPass(state, request) {
+    validateIsMounted(state);
+    const currentFrame = state.currentFrame;
+    if (!currentFrame) {
+        throw new Error('renderTransientVisuals() called but no previous render state found. render() must be called before renderTransientVisuals().');
+    }
+    // Loop over the subscribers and call renderTransientVisuals on each)
+    const context = {
+        currentFrame,
+        transientInput: request
+    };
+    for (const extensionId of state.transientVisualsSubscribers) {
+        const extensionRec = state.extensions.get(extensionId);
+        if (!extensionRec) {
+            throw new Error(`Extension with id ${extensionId} is subscribed to transient visuals but not found in render system extensions.`);
+        }
+        const extension = extensionRec.extension.instance;
+        extension.renderTransientVisuals?.(context);
+    }
+}

package/dist/render/scheduler/scheduler.d.ts

@@ -0,0 +1,2 @@
+import { Scheduler, SchedulerOptions } from './types';
+export declare function createScheduler(opts: SchedulerOptions): Scheduler;

package/dist/render/scheduler/scheduler.js

@@ -0,0 +1,53 @@
+export function createScheduler(opts) {
+    const { render } = opts;
+    let scheduled = false;
+    let runId = 0;
+    let rafHandle = null;
+    const flushCore = () => {
+        if (!scheduled && rafHandle == null) {
+            // Maybe was cancelled after the rAF callback was scheduled but before it fired.
+            return;
+        }
+        // Reset scheduled flags first to allow schedule() during render to queue the next frame.
+        scheduled = false;
+        if (rafHandle != null) {
+            rafHandle = null;
+        }
+        render();
+    };
+    return {
+        schedule() {
+            const raf = globalThis.requestAnimationFrame;
+            if (scheduled || rafHandle != null)
+                return;
+            scheduled = true;
+            const id = ++runId;
+            rafHandle = raf(() => {
+                if (id !== runId)
+                    return; // ignore stale callbacks invalidated by flushNow()
+                flushCore();
+            });
+        },
+        flushNow() {
+            // Invalidate any pending rAF render immediately.
+            if (scheduled) {
+                runId++;
+                scheduled = false;
+            }
+            if (rafHandle != null) {
+                const caf = globalThis.cancelAnimationFrame;
+                caf(rafHandle);
+                rafHandle = null;
+            }
+            flushCore();
+        },
+        cancel() {
+            scheduled = false;
+            if (rafHandle != null) {
+                const caf = globalThis.cancelAnimationFrame;
+                caf(rafHandle);
+            }
+            rafHandle = null;
+        }
+    };
+}

package/dist/render/scheduler/types.d.ts

@@ -0,0 +1,12 @@
+export type RenderCallback = () => void;
+export interface SchedulerOptions {
+    render: RenderCallback;
+}
+export interface Scheduler {
+    /** Request a render; multiple calls before the next frame coalesce into one. */
+    schedule(): void;
+    /** Flush immediately (synchronous), useful for deterministic tests or SSR. */
+    flushNow(): void;
+    /** Cancel any pending frame. */
+    cancel(): void;
+}

package/dist/render/scheduler/types.js

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

package/dist/render/svg/factory.d.ts

@@ -0,0 +1,4 @@
+import { ExtensionAllocatedSlotsInternal, ExtensionSlotName } from '../../extensions/types/basic/mount';
+import { RenderSystemInitOptionsInternal, SvgRoots } from '../types';
+export declare function createSvgRoots(options: RenderSystemInitOptionsInternal): SvgRoots;
+export declare function allocateExtensionSlotRoots(svgRoots: SvgRoots, extensionId: string, slots: readonly ExtensionSlotName[]): ExtensionAllocatedSlotsInternal;

package/dist/render/svg/factory.js

@@ -0,0 +1,38 @@
+import { createSvgElement } from './helpers';
+export function createSvgRoots(options) {
+    const { doc } = options;
+    const svgRoot = createSvgElement(doc, 'svg', { 'data-chessboard-id': 'svg-root' });
+    const result = {
+        svgRoot,
+        defs: createSvgElement(doc, 'defs', { 'data-chessboard-id': 'defs-root' }),
+        board: createSvgElement(doc, 'g', { 'data-chessboard-id': 'board-root' }),
+        coordinates: createSvgElement(doc, 'g', { 'data-chessboard-id': 'coordinates-root' }),
+        underPieces: createSvgElement(doc, 'g', { 'data-chessboard-id': 'under-pieces-root' }),
+        pieces: createSvgElement(doc, 'g', { 'data-chessboard-id': 'pieces-root' }),
+        overPieces: createSvgElement(doc, 'g', { 'data-chessboard-id': 'over-pieces-root' }),
+        animation: createSvgElement(doc, 'g', { 'data-chessboard-id': 'animation-root' }),
+        underDrag: createSvgElement(doc, 'g', { 'data-chessboard-id': 'under-drag-root' }),
+        drag: createSvgElement(doc, 'g', { 'data-chessboard-id': 'drag-root' }),
+        overDrag: createSvgElement(doc, 'g', { 'data-chessboard-id': 'over-drag-root' })
+    };
+    // Attach layers in the correct order
+    svgRoot.appendChild(result.defs);
+    svgRoot.appendChild(result.board);
+    svgRoot.appendChild(result.coordinates);
+    svgRoot.appendChild(result.underPieces);
+    svgRoot.appendChild(result.pieces);
+    svgRoot.appendChild(result.overPieces);
+    svgRoot.appendChild(result.animation);
+    svgRoot.appendChild(result.underDrag);
+    svgRoot.appendChild(result.drag);
+    svgRoot.appendChild(result.overDrag);
+    return result;
+}
+export function allocateExtensionSlotRoots(svgRoots, extensionId, slots) {
+    const result = {};
+    for (const slot of slots) {
+        const id = `extension-slot-root-${slot}-${extensionId}`;
+        result[slot] = createSvgElement(svgRoots[slot], 'g', { 'data-chessboard-id': id });
+    }
+    return result;
+}

package/dist/render/svg/helpers.d.ts

@@ -0,0 +1,18 @@
+import { Square } from '../../state/board/types/internal';
+export declare const SVG_NS = "http://www.w3.org/2000/svg";
+/**
+ * Helper to compute light/dark square parity.
+ * Returns true for light squares, false for dark.
+ * Convention: a1 is dark in many sets; here we follow theming from state (renderer decides).
+ * If you need the classic pattern where a1 is dark, use: (file + rank) % 2 === 1
+ */
+export declare function isLightSquare(sq: Square): boolean;
+export type SvgElementNames = keyof SVGElementTagNameMap;
+export type SvgElementAttributes = Record<string, string>;
+export type SvgElementOtherAttributes = SvgElementAttributes;
+export type SvgElementWithIdAttributes = SvgElementAttributes & {
+    'data-chessboard-id': string;
+};
+export declare function createSvgElement<K extends SvgElementNames>(parentOrDoc: Element | Document, name: K, attrs: SvgElementWithIdAttributes): SVGElementTagNameMap[K];
+export declare function updateElementAttributes(element: Element, attrs: SvgElementOtherAttributes): void;
+export declare function clearElementChildren(element: Element): void;

package/dist/render/svg/helpers.js

@@ -0,0 +1,34 @@
+import { fileOf, rankOf } from '../../state/board/coords';
+export const SVG_NS = 'http://www.w3.org/2000/svg';
+/**
+ * Helper to compute light/dark square parity.
+ * Returns true for light squares, false for dark.
+ * Convention: a1 is dark in many sets; here we follow theming from state (renderer decides).
+ * If you need the classic pattern where a1 is dark, use: (file + rank) % 2 === 1
+ */
+export function isLightSquare(sq) {
+    const f = fileOf(sq);
+    const r = rankOf(sq);
+    return ((f + r) & 1) === 1;
+}
+export function createSvgElement(parentOrDoc, name, attrs) {
+    const doc = parentOrDoc instanceof Document ? parentOrDoc : parentOrDoc.ownerDocument;
+    const el = doc.createElementNS(SVG_NS, name);
+    for (const [key, value] of Object.entries(attrs)) {
+        el.setAttribute(key, value);
+    }
+    if (parentOrDoc instanceof Element) {
+        parentOrDoc.appendChild(el);
+    }
+    return el;
+}
+export function updateElementAttributes(element, attrs) {
+    for (const [key, value] of Object.entries(attrs)) {
+        element.setAttribute(key, value);
+    }
+}
+export function clearElementChildren(element) {
+    while (element.firstChild) {
+        element.removeChild(element.firstChild);
+    }
+}

package/dist/render/types.d.ts

@@ -0,0 +1,42 @@
+import { ALL_EXTENSION_SLOTS, ExtensionAllocatedSlotsInternal, ExtensionSlotSvgRoots } from '../extensions/types/basic/mount';
+import { RenderFrameSnapshot } from '../extensions/types/basic/render';
+import { TransientInput } from '../extensions/types/basic/transient-visuals';
+import { ExtensionSystemExtensionRecord, ExtensionSystemSharedDataForRenderSystem } from '../extensions/types/main';
+import { Scheduler } from './scheduler/types';
+export interface SvgRoots extends ExtensionSlotSvgRoots<typeof ALL_EXTENSION_SLOTS> {
+    readonly svgRoot: SVGSVGElement;
+    readonly defs: SVGDefsElement;
+}
+export interface RenderExtensionRecordRender {
+    readonly slots: ExtensionAllocatedSlotsInternal;
+}
+export interface RenderExtensionRecord {
+    readonly id: string;
+    readonly extension: ExtensionSystemExtensionRecord;
+    readonly render: RenderExtensionRecordRender;
+}
+export interface RenderSystemInternal {
+    container: HTMLElement | null;
+    currentFrame: RenderFrameSnapshot | null;
+    readonly scheduler: Scheduler;
+    readonly svgRoots: SvgRoots;
+    readonly extensions: Map<string, RenderExtensionRecord>;
+    readonly transientVisualsSubscribers: ReadonlySet<string>;
+}
+export interface RenderSystemInitOptions {
+    doc: Document;
+    sharedDataFromExtensionSystem: ExtensionSystemSharedDataForRenderSystem;
+}
+export interface RenderSystemInitOptionsInternal extends RenderSystemInitOptions {
+    performRender: () => void;
+}
+export interface RenderSystem {
+    readonly extensions: ReadonlyMap<string, RenderExtensionRecord>;
+    requestRender(request?: RenderFrameSnapshot): void;
+    requestRenderAnimation(): void;
+    requestRenderVisuals(request: TransientInput): void;
+    mount(element: HTMLElement): void;
+    unmount(): void;
+    readonly isMounted: boolean;
+    readonly container: HTMLElement | null;
+}

package/dist/render/types.js

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

package/dist/runtime/factory/helpers.d.ts

@@ -0,0 +1,6 @@
+import { Square } from '../../state/board/types/internal';
+import { RuntimeInternal } from '../types/main';
+/**
+ * Helper functions for common flow for dropTo and releaseTo interactions
+ */
+export declare function uiMoveCompleteTo(state: RuntimeInternal, target: Square): void;

package/dist/runtime/factory/helpers.js

@@ -0,0 +1,42 @@
+import assert from '@ktarmyshov/assert';
+import { isEmptyPieceCode } from '../../state/board/check';
+import { canMoveTo } from '../input/controller/helpers';
+import { createUIMoveRequestContext } from './ui-move';
+function assertResolvedAfterAutoResolve(state) {
+    if (state.status !== 'resolved') {
+        throw new Error('UI move request must be resolved after autoresolve');
+    }
+}
+/**
+ * Helper functions for common flow for dropTo and releaseTo interactions
+ */
+export function uiMoveCompleteTo(state, target) {
+    const mutationSession = state.mutation.getSession();
+    const interaction = state.state.interaction;
+    const dragSession = interaction.dragSession;
+    assert(dragSession !== null, 'dropTo/releaseTo requires an active drag session');
+    assert(dragSession.targetSquare === target, 'dropTo/releaseTo target must match drag session current target');
+    assert(interaction.selected !== null, 'dropTo/releaseTo requires a selected piece');
+    assert(!isEmptyPieceCode(interaction.selected.pieceCode), 'Selected piece must be valid');
+    assert(dragSession.sourceSquare === interaction.selected.square, 'drag session source must match selected square');
+    assert(canMoveTo(interaction.getSnapshot(), target), 'dropTo/releaseTo target must be a valid move destination');
+    // canMoveTo already confirmed we can move, but if 'FREE' movability it can be that there are no activeDestinations for the target square, so we need to handle that case as well
+    const destination = interaction.activeDestinations.get(target) ?? { to: target };
+    const moveRequestContext = createUIMoveRequestContext(dragSession.sourceSquare, destination);
+    state.extensionSystem.onUIMoveRequest(moveRequestContext);
+    if (moveRequestContext.status === 'deferred') {
+        state.state.change.setDeferredUIMoveRequestContext(moveRequestContext, mutationSession);
+    }
+    else if (moveRequestContext.status === 'unresolved') {
+        // Try to auto-resolve if possible (e.g. if there are no promotion choices to be made)
+        moveRequestContext.autoresolve();
+        assertResolvedAfterAutoResolve(moveRequestContext);
+    }
+    if (moveRequestContext.status === 'resolved') {
+        const moveRequest = moveRequestContext.resolvedMoveRequest;
+        if (moveRequest !== null) {
+            state.state.board.move(moveRequest, mutationSession);
+        }
+    }
+    interaction.clear(mutationSession);
+}

package/dist/runtime/factory/input.d.ts

@@ -0,0 +1,3 @@
+import { RuntimeInteractionSurface } from '../input/controller/types';
+import { GetInternalState } from '../types/main';
+export declare function createRuntimeInteractionSurface(state: GetInternalState): RuntimeInteractionSurface;

package/dist/runtime/factory/input.js

@@ -0,0 +1,98 @@
+import assert from '@ktarmyshov/assert';
+import { isEmptyPieceCode } from '../../state/board/check';
+import { runtimeRunMutationPipeline } from '../mutation/run';
+import { uiMoveCompleteTo } from './helpers';
+export function createRuntimeInteractionSurface(state) {
+    return {
+        getInteractionStateSnapshot() {
+            const internalState = state();
+            return internalState.state.interaction.getSnapshot();
+        },
+        getPieceCodeAt(square) {
+            const internalState = state();
+            return internalState.state.board.getPieceCodeAt(square);
+        },
+        startLiftedDrag(source, target) {
+            const internalState = state();
+            const interactionMutationSession = internalState.mutation.getSession();
+            const interaction = internalState.state.interaction;
+            const pieceCode = internalState.state.board.getPieceCodeAt(source);
+            assert(!isEmptyPieceCode(pieceCode), 'Cannot start a lifted-piece-drag session from an empty square');
+            const interactionSource = {
+                square: source,
+                pieceCode
+            };
+            interaction.setSelected(interactionSource, interactionMutationSession);
+            const dragSession = {
+                type: 'lifted-piece-drag',
+                sourceSquare: interactionSource.square,
+                sourcePieceCode: interactionSource.pieceCode,
+                targetSquare: target
+            };
+            interaction.setDragSession(dragSession, interactionMutationSession);
+            runtimeRunMutationPipeline(internalState);
+        },
+        transientInput(input) {
+            const internalState = state();
+            internalState.renderSystem.requestRenderVisuals(input);
+        },
+        dropTo(target) {
+            const internalState = state();
+            const mutationSession = internalState.mutation.getSession();
+            const interaction = internalState.state.interaction;
+            const dragSession = interaction.dragSession;
+            assert(dragSession !== null, 'dropTo requires an active drag session');
+            assert(dragSession.type === 'lifted-piece-drag', 'dropTo requires a lifted-piece-drag session');
+            uiMoveCompleteTo(internalState, target);
+            mutationSession.addMutation('runtime.interaction.dropTo', true);
+            runtimeRunMutationPipeline(internalState);
+        },
+        releaseTo(target) {
+            const internalState = state();
+            const mutationSession = internalState.mutation.getSession();
+            const interaction = internalState.state.interaction;
+            const dragSession = interaction.dragSession;
+            assert(dragSession !== null, 'releaseTo requires an active drag session');
+            assert(dragSession.type === 'release-targeting', 'releaseTo requires a release-targeting session');
+            uiMoveCompleteTo(internalState, target);
+            mutationSession.addMutation('runtime.interaction.releaseTo', true);
+            runtimeRunMutationPipeline(internalState);
+        },
+        startReleaseTargetingDrag(source, target) {
+            const internalState = state();
+            const mutationSession = internalState.mutation.getSession();
+            const interaction = internalState.state.interaction;
+            assert(interaction.selected !== null, 'startReleaseTargetingDrag requires a selected piece');
+            assert(interaction.selected.square === source, 'startReleaseTargetingDrag source must match selected square');
+            const dragSession = {
+                type: 'release-targeting',
+                sourceSquare: source,
+                sourcePieceCode: interaction.selected.pieceCode,
+                targetSquare: target
+            };
+            interaction.setDragSession(dragSession, mutationSession);
+            runtimeRunMutationPipeline(internalState);
+        },
+        cancelActiveInteraction() {
+            const internalState = state();
+            const mutationSession = internalState.mutation.getSession();
+            internalState.state.interaction.clearActive(mutationSession);
+            runtimeRunMutationPipeline(internalState);
+        },
+        cancelInteraction() {
+            const internalState = state();
+            const mutationSession = internalState.mutation.getSession();
+            internalState.state.interaction.clear(mutationSession);
+            runtimeRunMutationPipeline(internalState);
+        },
+        updateDragSessionCurrentTarget(target) {
+            const internalState = state();
+            const interactionMutationSession = internalState.mutation.getSession();
+            const interaction = internalState.state.interaction;
+            const currentDragSession = interaction.dragSession;
+            assert(currentDragSession !== null, 'No active drag session to update');
+            internalState.state.interaction.updateDragSessionCurrentTarget(target, interactionMutationSession);
+            runtimeRunMutationPipeline(internalState);
+        }
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { Runtime, RuntimeInitOptions } from '../types/main';
+export declare function createRuntime(options: RuntimeInitOptions): Runtime;

package/dist/runtime/factory/main.js

@@ -0,0 +1,182 @@
+import assert from '@ktarmyshov/assert';
+import { createExtensionSystem } from '../../extensions/factory/main';
+import { assertFrameRenderable } from '../../extensions/types/basic/update';
+import { createLayout } from '../../layout/factory';
+import { createRenderSystem } from '../../render/factory';
+import { isNonEmptyPieceCode } from '../../state/board/check';
+import { normalizeSquare } from '../../state/board/normalize';
+import { createRuntimeState } from '../../state/factory';
+import { createInteractionController } from '../input/controller/factory';
+import { runtimeDestroy, runtimeMount, runtimeUnmount } from '../lifecycle';
+import { createRuntimeMutationPipeline } from '../mutation/factory';
+import { runtimeRunMutationPipeline } from '../mutation/run';
+import { createRuntimeInteractionSurface } from './input';
+function createRuntimeInternal(options) {
+    const extensionSystem = createExtensionSystem(options);
+    const render = createRenderSystem({
+        doc: options.doc,
+        sharedDataFromExtensionSystem: extensionSystem.getSharedDataForRenderSystem()
+    });
+    return {
+        state: createRuntimeState(options.state ?? {}),
+        layout: createLayout(),
+        mutation: createRuntimeMutationPipeline(),
+        renderSystem: render,
+        extensionSystem: extensionSystem,
+        resizeObserver: null,
+        inputAdapter: null,
+        interactionController: createInteractionController({
+            surface: createRuntimeInteractionSurface(options.getInternalState)
+        })
+    };
+}
+function createExtensionRuntimeSurfaceCommands(getInternalState) {
+    return {
+        setPosition(input) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.board.setPosition(input, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
+        setPiecePosition(input) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.board.setPiecePosition(input, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
+        setTurn(turn) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.board.setTurn(turn, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
+        move(request) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const move = state.state.board.move(request, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return move;
+        },
+        requestRender(request) {
+            const state = getInternalState();
+            if (request.state) {
+                const renderRequest = {
+                    isMounted: state.renderSystem.isMounted,
+                    state: state.state.getSnapshot(),
+                    layout: state.layout.getSnapshot()
+                };
+                assertFrameRenderable(renderRequest);
+                state.renderSystem.requestRender(renderRequest);
+            }
+        },
+        setOrientation(orientation) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.view.setOrientation(orientation, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
+        setMovability(movability) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.interaction.setMovability(movability, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
+        select(square) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            let interactionStateSelected = null;
+            if (square !== null) {
+                const normalizedSquare = normalizeSquare(square);
+                const piece = state.state.board.getPieceCodeAt(normalizedSquare);
+                assert(isNonEmptyPieceCode(piece), 'Selected square is expected to have a piece');
+                interactionStateSelected = {
+                    square: normalizedSquare,
+                    pieceCode: piece
+                };
+            }
+            const changed = state.state.interaction.setSelected(interactionStateSelected, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
+        clearActiveInteraction() {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.interaction.clearActive(mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
+        clearInteraction() {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.interaction.clear(mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
+        getSnapshot() {
+            const state = getInternalState();
+            return {
+                state: state.state.getSnapshot(),
+                layout: state.layout.getSnapshot()
+            };
+        }
+    };
+}
+export function createRuntime(options) {
+    let internalState = null;
+    let internalStatus = 'constructing';
+    function getInternalState() {
+        if (internalStatus === 'constructing' || internalStatus === 'destroyed') {
+            throw new Error(`Cannot access internal state when runtime is ${internalStatus}`);
+        }
+        if (!internalState) {
+            throw new Error('Internal state is not initialized');
+        }
+        return internalState;
+    }
+    // Create RuntimeExtensionSurface to pass to the extension system for initialization of extension instances
+    const extensionSurface = createExtensionRuntimeSurfaceCommands(getInternalState);
+    // Now construct the internal state
+    const optionsInternal = {
+        ...options,
+        extensionRuntimeSurfaceCommands: extensionSurface,
+        getInternalState
+    };
+    internalState = createRuntimeInternal(optionsInternal);
+    // Initial creation, so we mark board position as mutated to trigger mutation pipeline
+    internalState.mutation.addMutation('state.board.setPosition', true);
+    // We will have two different interfaces here
+    // One is returned, one is for controller - with different methods
+    // At the moment our assumption that controller will use Runtime but not opposite direction
+    // So we can construct these two objects separately so they would not be huge!
+    // TODO: const inputControllerSurface = createRuntimeInputControllerSurface(internalState);
+    // Initial run to process initial mutations and set up previousContext for the next runs
+    internalStatus = 'unmounted';
+    internalState.mutation.run(internalState);
+    return {
+        get status() {
+            return internalStatus;
+        },
+        mount(container) {
+            runtimeMount(getInternalState(), container);
+            internalStatus = 'mounted';
+        },
+        unmount() {
+            runtimeUnmount(getInternalState());
+            internalStatus = 'unmounted';
+        },
+        destroy() {
+            runtimeDestroy(getInternalState());
+            internalStatus = 'destroyed';
+            internalState = null;
+        },
+        ...extensionSurface,
+        getExtensionsPublicRecord() {
+            return getInternalState().extensionSystem.getPublicRecord();
+        }
+    };
+}

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

@@ -0,0 +1,4 @@
+import { ExtensionUIMoveRequestContext } from '../../extensions/types/context/ui-move';
+import { Square } from '../../state/board/types/internal';
+import { MoveDestinationSnapshot } from '../../state/interaction/types/internal';
+export declare function createUIMoveRequestContext(sourceSquare: Square, destination: MoveDestinationSnapshot): ExtensionUIMoveRequestContext;