@mirasen/chessboard 0.1.0 → 1.0.0-rc.0

package/dist/layout/types.d.ts

@@ -1,11 +1,11 @@
 import { ReadonlyDeep } from 'type-fest';
-import { ColorCode } from '../state/board/types/internal';
-import { RenderGeometry } from './geometry/types';
-import { LayoutMutationSession } from './mutation';
+import { ColorCode } from '../state/board/types/internal.js';
+import { SceneRenderGeometry, Size } from './geometry/types.js';
+import { LayoutMutationSession } from './mutation.js';
 export interface LayoutInternal {
-    boardSize: number | null;
+    sceneSize: Size | null;
     orientation: ColorCode | null;
-    geometry: RenderGeometry | null;
+    geometry: SceneRenderGeometry | null;
     layoutEpoch: number;
 }
 export type LayoutSnapshot = ReadonlyDeep<LayoutInternal>;
@@ -14,9 +14,9 @@ export interface LayoutRefreshOptions {
     orientation?: ColorCode;
 }
 export interface Layout {
-    readonly boardSize: number | null;
+    readonly sceneSize: Size | null;
     readonly orientation: ColorCode | null;
-    readonly geometry: RenderGeometry | null;
+    readonly geometry: SceneRenderGeometry | null;
     readonly layoutEpoch: number;
     refreshGeometry(options: LayoutRefreshOptions, mutationSession: LayoutMutationSession): boolean;
     getSnapshot(): LayoutSnapshot;

package/dist/mutation/pipeline.d.ts

@@ -1,2 +1,2 @@
-import type { MutationPipe, MutationPipeline } from './types';
+import type { MutationPipe, MutationPipeline } from './types.js';
 export declare function createMutationPipeline<PayloadByCause extends Record<string, unknown>, Context>(pipes: readonly MutationPipe<PayloadByCause, Context>[]): MutationPipeline<PayloadByCause, Context>;

package/dist/mutation/pipeline.js

@@ -1,4 +1,4 @@
-import { createMutationSession } from './session';
+import { createMutationSession } from './session.js';
 export function createMutationPipeline(pipes) {
     const registeredPipes = [...pipes];
     const session = createMutationSession();

package/dist/mutation/session.d.ts

@@ -1,3 +1,3 @@
-import type { MutationCause, MutationSession, ReadonlyMutationSession } from './types';
+import type { MutationCause, MutationSession, ReadonlyMutationSession } from './types.js';
 export declare function createReadonlyMutationSession<PayloadByCause extends Record<string, unknown>>(payloads: ReadonlyMap<MutationCause<PayloadByCause>, PayloadByCause[MutationCause<PayloadByCause>][] | undefined>, clone?: boolean): ReadonlyMutationSession<PayloadByCause>;
 export declare function createMutationSession<PayloadByCause extends Record<string, unknown>>(): MutationSession<PayloadByCause>;

package/dist/render/factory.d.ts

@@ -1,2 +1,2 @@
-import { RenderSystem, RenderSystemInitOptions } from './types';
+import { RenderSystem, RenderSystemInitOptions } from './types.js';
 export declare function createRenderSystem(options: RenderSystemInitOptions): RenderSystem;

package/dist/render/factory.js

@@ -1,10 +1,10 @@
-import { renderMount, renderUnmount } from './mount';
-import { performAnimationCleanup, performAnimationPass } from './rendering/animation';
-import { validateIsMounted } from './rendering/helpers';
-import { performRenderPass } from './rendering/state';
-import { performRenderTransientVisualsPass } from './rendering/visuals';
-import { createScheduler } from './scheduler/scheduler';
-import { allocateExtensionSlotRoots, createSvgRoots } from './svg/factory';
+import { renderMount, renderUnmount } from './mount.js';
+import { performAnimationCleanup, performAnimationPass } from './rendering/animation.js';
+import { validateIsMounted } from './rendering/helpers.js';
+import { performRenderPass } from './rendering/state.js';
+import { performRenderTransientVisualsPass } from './rendering/visuals.js';
+import { createScheduler } from './scheduler/scheduler.js';
+import { allocateExtensionSlotRoots, createSvgRoots } from './svg/factory.js';
 function createRenderInternal(options) {
     const svgRoots = createSvgRoots(options);
     const scheduler = createScheduler({

package/dist/render/mount.d.ts

@@ -1,3 +1,3 @@
-import { RenderSystemInternal } from './types';
+import { RenderSystemInternal } from './types.js';
 export declare function renderMount(state: RenderSystemInternal, element: HTMLElement): void;
 export declare function renderUnmount(state: RenderSystemInternal): void;

package/dist/render/mount.js

@@ -1,5 +1,5 @@
-import { validateIsMounted, validateIsNotMounted } from './rendering/helpers';
-import { clearElementChildren } from './svg/helpers';
+import { validateIsMounted, validateIsNotMounted } from './rendering/helpers.js';
+import { clearElementChildren } from './svg/helpers.js';
 export function renderMount(state, element) {
     validateIsNotMounted(state);
     state.container = element;
@@ -8,13 +8,13 @@ export function renderMount(state, element) {
     // Now call onMount for all extensions with their slot roots
     for (const extensionRec of state.extensions.values()) {
         const slotRoots = extensionRec.render.slots;
-        extensionRec.extension.instance.mount({ slotRoots });
+        extensionRec.extension.instance.mount?.({ slotRoots });
     }
 }
 export function renderUnmount(state) {
     validateIsMounted(state);
     for (const extensionRec of state.extensions.values()) {
-        extensionRec.extension.instance.unmount();
+        extensionRec.extension.instance.unmount?.();
         // clear the slot roots
         for (const slotRoot of Object.values(extensionRec.render.slots)) {
             clearElementChildren(slotRoot);

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

@@ -1,4 +1,4 @@
-import { RenderSystemInternal } from '../types';
+import { RenderSystemInternal } from '../types.js';
 export interface RenderAnimationResult {
     requestRenderAnimation: boolean;
     requestRender: boolean;

package/dist/render/rendering/animation.js

@@ -1,4 +1,4 @@
-import { validateIsMounted } from './helpers';
+import { validateIsMounted } from './helpers.js';
 /**
  * Runs deferred physical cleanup for all sessions that were marked pendingCleanup
  * in a previous animation pass. Called at the end of performRenderPass (after stable

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

@@ -1,3 +1,3 @@
-import { RenderSystemInternal } from '../types';
+import { RenderSystemInternal } from '../types.js';
 export declare function validateIsMounted(state: RenderSystemInternal): void;
 export declare function validateIsNotMounted(state: RenderSystemInternal): void;

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

@@ -1,4 +1,4 @@
-import { RenderFrameSnapshot } from '../../extensions/types/basic/render';
-import { RenderSystemInternal } from '../types';
+import { RenderFrameSnapshot } from '../../extensions/types/basic/render.js';
+import { RenderSystemInternal } from '../types.js';
 export declare function checkNeedsRender(state: RenderSystemInternal): boolean;
 export declare function performRenderPass(state: RenderSystemInternal, request: RenderFrameSnapshot | null): void;

package/dist/render/rendering/state.js

@@ -1,5 +1,6 @@
-import { updateElementAttributes } from '../svg/helpers';
-import { validateIsMounted } from './helpers';
+import { sceneSizesEqual } from '../../layout/geometry/helpers.js';
+import { updateElementAttributes } from '../svg/helpers.js';
+import { validateIsMounted } from './helpers.js';
 export function checkNeedsRender(state) {
     for (const extensionRec of state.extensions.values()) {
         if (extensionRec.extension.invalidation.dirtyLayers !== 0) {
@@ -16,14 +17,13 @@ export function performRenderPass(state, 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);
+    const currentSize = request.layout.geometry.sceneSize;
+    const prevSize = state.currentFrame?.layout.geometry?.sceneSize ?? null;
+    if (!sceneSizesEqual(currentSize, prevSize)) {
         updateElementAttributes(state.svgRoots.svgRoot, {
-            width: size,
-            height: size,
-            viewBox: `0 0 ${size} ${size}`
+            width: currentSize.width.toString(),
+            height: currentSize.height.toString(),
+            viewBox: `0 0 ${currentSize.width} ${currentSize.height}`
         });
     }
     // Check if we have any invalidation states

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

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

package/dist/render/rendering/visuals.js

@@ -1,4 +1,4 @@
-import { validateIsMounted } from './helpers';
+import { validateIsMounted } from './helpers.js';
 export function performRenderTransientVisualsPass(state, request) {
     validateIsMounted(state);
     const currentFrame = state.currentFrame;

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

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

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

@@ -1,4 +1,4 @@
-import { ExtensionAllocatedSlotsInternal, ExtensionSlotName } from '../../extensions/types/basic/mount';
-import { RenderSystemInitOptionsInternal, SvgRoots } from '../types';
+import { ExtensionAllocatedSlotsInternal, ExtensionSlotName } from '../../extensions/types/basic/mount.js';
+import { RenderSystemInitOptionsInternal, SvgRoots } from '../types.js';
 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

@@ -1,4 +1,4 @@
-import { createSvgElement } from './helpers';
+import { createSvgElement } from './helpers.js';
 export function createSvgRoots(options) {
     const { doc } = options;
     const svgRoot = createSvgElement(doc, 'svg', { 'data-chessboard-id': 'svg-root' });

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

@@ -1,4 +1,4 @@
-import { Square } from '../../state/board/types/internal';
+import { Square } from '../../state/board/types/internal.js';
 export declare const SVG_NS = "http://www.w3.org/2000/svg";
 /**
  * Helper to compute light/dark square parity.

package/dist/render/svg/helpers.js

@@ -1,4 +1,4 @@
-import { fileOf, rankOf } from '../../state/board/coords';
+import { fileOf, rankOf } from '../../state/board/coords.js';
 export const SVG_NS = 'http://www.w3.org/2000/svg';
 /**
  * Helper to compute light/dark square parity.

package/dist/render/types.d.ts

@@ -1,8 +1,8 @@
-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';
+import { ALL_EXTENSION_SLOTS, ExtensionAllocatedSlotsInternal, ExtensionSlotSvgRoots } from '../extensions/types/basic/mount.js';
+import { RenderFrameSnapshot } from '../extensions/types/basic/render.js';
+import { TransientInput } from '../extensions/types/basic/transient-visuals.js';
+import { ExtensionSystemExtensionRecord, ExtensionSystemSharedDataForRenderSystem } from '../extensions/types/main.js';
+import { Scheduler } from './scheduler/types.js';
 export interface SvgRoots extends ExtensionSlotSvgRoots<typeof ALL_EXTENSION_SLOTS> {
     readonly svgRoot: SVGSVGElement;
     readonly defs: SVGDefsElement;

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

@@ -0,0 +1,3 @@
+import { ExtensionRuntimeSurfaceEvents } from '../../extensions/types/surface/events.js';
+import { GetInternalState } from '../types/main.js';
+export declare function createExtensionRuntimeSurfaceEvents(getInternalState: GetInternalState): ExtensionRuntimeSurfaceEvents;

package/dist/runtime/factory/events.js

@@ -0,0 +1,18 @@
+import assert from '@ktarmyshov/assert';
+import { NEED_EVENT_TYPES } from '../input/adapter/types.js';
+export function createExtensionRuntimeSurfaceEvents(getInternalState) {
+    return {
+        subscribeEvent(type) {
+            const internalState = getInternalState();
+            assert(internalState.inputAdapter, 'Input adapter not available in the current runtime state');
+            internalState.inputAdapter.subscribeEvent(type);
+        },
+        unsubscribeEvent(type) {
+            const internalState = getInternalState();
+            assert(internalState.inputAdapter, 'Input adapter not available in the current runtime state');
+            if (!NEED_EVENT_TYPES.has(type)) {
+                internalState.inputAdapter.unsubscribeEvent(type);
+            }
+        }
+    };
+}

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

@@ -1,5 +1,5 @@
-import { Square } from '../../state/board/types/internal';
-import { RuntimeInternal } from '../types/main';
+import { Square } from '../../state/board/types/internal.js';
+import { RuntimeInternal } from '../types/main.js';
 /**
  * Helper functions for common flow for dropTo and releaseTo interactions
  */

package/dist/runtime/factory/helpers.js

@@ -1,9 +1,9 @@
 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') {
+import { isEmptyPieceCode } from '../../state/board/check.js';
+import { createPendingUIMoveRequest } from '../../state/change/factory/ui-move.js';
+import { canMoveTo } from '../input/controller/helpers.js';
+function assertResolvedAfterAutoResolve(request) {
+    if (request.status !== 'resolved') {
         throw new Error('UI move request must be resolved after autoresolve');
     }
 }
@@ -22,18 +22,18 @@ export function uiMoveCompleteTo(state, target) {
     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);
+    const pendingUIMoveRequest = createPendingUIMoveRequest(dragSession.sourceSquare, destination);
+    state.extensionSystem.onUIMoveRequest({ request: pendingUIMoveRequest });
+    if (pendingUIMoveRequest.status === 'deferred') {
+        state.state.change.setDeferredUIMoveRequest(pendingUIMoveRequest, mutationSession);
     }
-    else if (moveRequestContext.status === 'unresolved') {
+    else if (pendingUIMoveRequest.status === 'unresolved') {
         // Try to auto-resolve if possible (e.g. if there are no promotion choices to be made)
-        moveRequestContext.autoresolve();
-        assertResolvedAfterAutoResolve(moveRequestContext);
+        pendingUIMoveRequest.autoresolve();
+        assertResolvedAfterAutoResolve(pendingUIMoveRequest);
     }
-    if (moveRequestContext.status === 'resolved') {
-        const moveRequest = moveRequestContext.resolvedMoveRequest;
+    if (pendingUIMoveRequest.status === 'resolved') {
+        const moveRequest = pendingUIMoveRequest.resolvedMoveRequest;
         if (moveRequest !== null) {
             state.state.board.move(moveRequest, mutationSession);
         }

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

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

package/dist/runtime/factory/input.js

@@ -1,7 +1,8 @@
 import assert from '@ktarmyshov/assert';
-import { isEmptyPieceCode } from '../../state/board/check';
-import { runtimeRunMutationPipeline } from '../mutation/run';
-import { uiMoveCompleteTo } from './helpers';
+import { isEmptyPieceCode } from '../../state/board/check.js';
+import { isDragSessionCoreOwned } from '../../state/interaction/helpers.js';
+import { runtimeRunMutationPipeline } from '../mutation/run.js';
+import { uiMoveCompleteTo } from './helpers.js';
 export function createRuntimeInteractionSurface(state) {
     return {
         getInteractionStateSnapshot() {
@@ -24,6 +25,7 @@ export function createRuntimeInteractionSurface(state) {
             };
             interaction.setSelected(interactionSource, interactionMutationSession);
             const dragSession = {
+                owner: 'core',
                 type: 'lifted-piece-drag',
                 sourceSquare: interactionSource.square,
                 sourcePieceCode: interactionSource.pieceCode,
@@ -36,27 +38,27 @@ export function createRuntimeInteractionSurface(state) {
             const internalState = state();
             internalState.renderSystem.requestRenderVisuals(input);
         },
-        dropTo(target) {
+        completeCoreDragTo(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');
+            assert(dragSession !== null, 'completeDragTo requires an active drag session');
+            assert(isDragSessionCoreOwned(dragSession), 'completeDragTo can only be called for core-owned drag sessions');
             uiMoveCompleteTo(internalState, target);
-            mutationSession.addMutation('runtime.interaction.dropTo', true);
+            mutationSession.addMutation('runtime.interaction.completeDragTo', true, dragSession);
             runtimeRunMutationPipeline(internalState);
         },
-        releaseTo(target) {
+        completeExtensionDrag(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);
+            assert(dragSession !== null, 'completeExtensionDrag requires an active drag session');
+            assert(!isDragSessionCoreOwned(dragSession), 'completeExtensionDrag can only be called for extension-owned drag sessions');
+            assert(dragSession.targetSquare === target, 'The target square in completeExtensionDrag must match the current target square of the drag session');
+            internalState.extensionSystem.completeDrag(dragSession);
+            internalState.state.interaction.setDragSession(null, mutationSession);
         },
         startReleaseTargetingDrag(source, target) {
             const internalState = state();
@@ -65,6 +67,7 @@ export function createRuntimeInteractionSurface(state) {
             assert(interaction.selected !== null, 'startReleaseTargetingDrag requires a selected piece');
             assert(interaction.selected.square === source, 'startReleaseTargetingDrag source must match selected square');
             const dragSession = {
+                owner: 'core',
                 type: 'release-targeting',
                 sourceSquare: source,
                 sourcePieceCode: interaction.selected.pieceCode,
@@ -93,6 +96,10 @@ export function createRuntimeInteractionSurface(state) {
             assert(currentDragSession !== null, 'No active drag session to update');
             internalState.state.interaction.updateDragSessionCurrentTarget(target, interactionMutationSession);
             runtimeRunMutationPipeline(internalState);
+        },
+        onEvent(context) {
+            const internalState = state();
+            internalState.extensionSystem.onEvent(context);
         }
     };
 }

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

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

package/dist/runtime/factory/main.js

@@ -1,16 +1,17 @@
 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';
+import { createExtensionSystem } from '../../extensions/factory/main.js';
+import { assertFrameRenderable } from '../../extensions/types/basic/update.js';
+import { createLayout } from '../../layout/factory.js';
+import { createRenderSystem } from '../../render/factory.js';
+import { isNonEmptyPieceCode } from '../../state/board/check.js';
+import { normalizeSquare } from '../../state/board/normalize.js';
+import { createRuntimeState } from '../../state/factory.js';
+import { createInteractionController } from '../input/controller/factory.js';
+import { runtimeDestroy, runtimeMount, runtimeUnmount } from '../lifecycle.js';
+import { createRuntimeMutationPipeline } from '../mutation/factory.js';
+import { runtimeRunMutationPipeline } from '../mutation/run.js';
+import { createExtensionRuntimeSurfaceEvents } from './events.js';
+import { createRuntimeInteractionSurface } from './input.js';
 function createRuntimeInternal(options) {
     const extensionSystem = createExtensionSystem(options);
     const render = createRenderSystem({
@@ -30,7 +31,7 @@ function createRuntimeInternal(options) {
         })
     };
 }
-function createExtensionRuntimeSurfaceCommands(getInternalState) {
+function createExtensionRuntimeSurfaceCommandsInternalSurface(getInternalState) {
     return {
         setPosition(input) {
             const state = getInternalState();
@@ -103,6 +104,13 @@ function createExtensionRuntimeSurfaceCommands(getInternalState) {
             runtimeRunMutationPipeline(state);
             return changed;
         },
+        startDrag(session) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.interaction.setDragSession(session, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
         clearActiveInteraction() {
             const state = getInternalState();
             const mutationSession = state.mutation.getSession();
@@ -117,6 +125,36 @@ function createExtensionRuntimeSurfaceCommands(getInternalState) {
             runtimeRunMutationPipeline(state);
             return changed;
         },
+        resolveDeferredUIMoveRequest(details) {
+            const state = getInternalState();
+            const deferredRequest = state.state.change.deferredUIMoveRequest;
+            assert(deferredRequest, 'No deferred UI move request to resolve');
+            const { sourceSquare, destination } = deferredRequest;
+            const moveRequest = {
+                from: sourceSquare,
+                to: destination.to,
+                ...(destination.capturedSquare !== undefined && {
+                    capturedSquare: destination.capturedSquare
+                }),
+                ...(destination.secondary !== undefined && { secondary: destination.secondary }),
+                promotedTo: details.promotedTo
+            };
+            const mutationSession = state.mutation.getSession();
+            const move = state.state.board.move(moveRequest, mutationSession);
+            state.state.change.setDeferredUIMoveRequest(null, mutationSession);
+            mutationSession.addMutation('runtime.interaction.resolveDeferredUIMoveRequest', true);
+            runtimeRunMutationPipeline(state);
+            return move;
+        },
+        cancelDeferredUIMoveRequest() {
+            const state = getInternalState();
+            assert(state.state.change.deferredUIMoveRequest, 'No deferred UI move request to cancel');
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.change.setDeferredUIMoveRequest(null, mutationSession);
+            mutationSession.addMutation('runtime.interaction.cancelDeferredUIMoveRequest', changed);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
         getSnapshot() {
             const state = getInternalState();
             return {
@@ -139,11 +177,13 @@ export function createRuntime(options) {
         return internalState;
     }
     // Create RuntimeExtensionSurface to pass to the extension system for initialization of extension instances
-    const extensionSurface = createExtensionRuntimeSurfaceCommands(getInternalState);
+    const extensionSurfaceCommands = createExtensionRuntimeSurfaceCommandsInternalSurface(getInternalState);
+    const extensionSurfaceEvents = createExtensionRuntimeSurfaceEvents(getInternalState);
     // Now construct the internal state
     const optionsInternal = {
         ...options,
-        extensionRuntimeSurfaceCommands: extensionSurface,
+        extensionRuntimeSurfaceCommands: extensionSurfaceCommands,
+        extensionRuntimeSurfaceEvents: extensionSurfaceEvents,
         getInternalState
     };
     internalState = createRuntimeInternal(optionsInternal);
@@ -174,7 +214,7 @@ export function createRuntime(options) {
             internalStatus = 'destroyed';
             internalState = null;
         },
-        ...extensionSurface,
+        ...extensionSurfaceCommands,
         getExtensionsPublicRecord() {
             return getInternalState().extensionSystem.getPublicRecord();
         }

package/dist/runtime/input/adapter/event.d.ts

@@ -0,0 +1,3 @@
+import { InputAdapterInternal } from './types.js';
+export declare function eventHandler(state: InputAdapterInternal, e: Event): void;
+export declare function eventDestroy(state: InputAdapterInternal): void;

package/dist/runtime/input/adapter/event.js

@@ -0,0 +1,19 @@
+import { ALL_SCENE_POINTER_EVENT_TYPES } from '../../../extensions/types/basic/events.js';
+import { pointerEventDestroy, pointerEventHandler } from './pointer.js';
+export function eventHandler(state, e) {
+    let context = null;
+    if (ALL_SCENE_POINTER_EVENT_TYPES.has(e.type)) {
+        context = pointerEventHandler(state, e);
+    }
+    if (!context) {
+        context = {
+            rawEvent: e,
+            sceneEvent: null
+        };
+    }
+    // Pass to controller for extension handling
+    state.controller.onEvent(context);
+}
+export function eventDestroy(state) {
+    pointerEventDestroy(state);
+}

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

@@ -1,2 +1,2 @@
-import { InputAdapter, InputAdapterInitOptions } from './types';
+import { InputAdapter, InputAdapterInitOptions } from './types.js';
 export declare function createInputAdapter(options: InputAdapterInitOptions): InputAdapter;

package/dist/runtime/input/adapter/factory.js

@@ -1,55 +1,36 @@
-import { isPointerRelevantEvent, onPointerCancel, onPointerDown, onPointerLeave, onPointerMove, onPointerUp, releaseCapture } from './pointer';
+import assert from '@ktarmyshov/assert';
+import { eventDestroy, eventHandler } from './event.js';
+import { NEED_EVENT_TYPES } from './types.js';
 function createInputAdapterInternal(options) {
     return {
         container: options.container,
-        getGeometry: options.getGeometry,
+        getRenderGeometry: options.getRenderGeometry,
         controller: options.controller,
         activePointerId: null
     };
 }
 export function createInputAdapter(options) {
     const internalState = createInputAdapterInternal(options);
-    const onPointerDownHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerDown(internalState, e);
-    };
-    const onPointerMoveHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerMove(internalState, e);
-    };
-    const onPointerUpHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerUp(internalState, e);
-    };
-    const onPointerCancelHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerCancel(internalState, e);
-    };
-    const onPointerLeaveHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerLeave(internalState, e);
+    const onEventHander = (e) => {
+        eventHandler(internalState, e);
     };
     const inputAdapter = {
+        subscribeEvent(type) {
+            internalState.container.addEventListener(type, onEventHander);
+        },
+        unsubscribeEvent(type) {
+            assert(NEED_EVENT_TYPES.has(type), `Unsubscribe for event type ${type} is not supported. This is required event type for the board to function properly.`);
+            internalState.container.removeEventListener(type, onEventHander);
+        },
         destroy() {
-            if (internalState.activePointerId !== null) {
-                releaseCapture(internalState);
+            for (const type of NEED_EVENT_TYPES) {
+                internalState.container.removeEventListener(type, onEventHander);
             }
-            internalState.container.removeEventListener('pointerdown', onPointerDownHandler);
-            internalState.container.removeEventListener('pointermove', onPointerMoveHandler);
-            internalState.container.removeEventListener('pointerup', onPointerUpHandler);
-            internalState.container.removeEventListener('pointercancel', onPointerCancelHandler);
-            internalState.container.removeEventListener('pointerleave', onPointerLeaveHandler);
+            eventDestroy(internalState);
         }
     };
-    internalState.container.addEventListener('pointerdown', onPointerDownHandler);
-    internalState.container.addEventListener('pointermove', onPointerMoveHandler);
-    internalState.container.addEventListener('pointerup', onPointerUpHandler);
-    internalState.container.addEventListener('pointercancel', onPointerCancelHandler);
-    internalState.container.addEventListener('pointerleave', onPointerLeaveHandler);
+    for (const type of NEED_EVENT_TYPES) {
+        internalState.container.addEventListener(type, onEventHander);
+    }
     return inputAdapter;
 }