@mirasen/chessboard 0.1.1 → 1.0.0-rc.0

package/dist/extensions/types/surface/commands.d.ts

@@ -1,8 +1,11 @@
 import { LayoutSnapshot } from '../../../layout/types.js';
 import { ColorInput, MoveRequestInput, PiecePositionInput, PositionInput, SquareString } from '../../../state/board/types/input.js';
 import { Move } from '../../../state/board/types/internal.js';
+import { DeferredUIMoveResolutionDetails } from '../../../state/change/types/ui-move.js';
 import { MovabilityInput } from '../../../state/interaction/types/input.js';
+import { DragSessionExtensionOwned } from '../../../state/interaction/types/internal.js';
 import { RuntimeStateSnapshot } from '../../../state/types.js';
+import { ExtensionDragSession } from '../basic/interaction.js';
 export interface ExtensionRuntimeSurfaceCommandsSnapshot {
     readonly state: RuntimeStateSnapshot;
     readonly layout: LayoutSnapshot;
@@ -19,8 +22,14 @@ export interface ExtensionRuntimeSurfaceCommands {
     setOrientation(orientation: ColorInput): boolean;
     setMovability(movability: MovabilityInput): boolean;
     select(square: SquareString | null): boolean;
+    startDrag(session: ExtensionDragSession): boolean;
     clearActiveInteraction(): boolean;
     clearInteraction(): boolean;
+    resolveDeferredUIMoveRequest(details: DeferredUIMoveResolutionDetails): Move;
+    cancelDeferredUIMoveRequest(): boolean;
     requestRender(request: ExtensionRuntimeSurfaceCommandsRenderRequest): void;
     getSnapshot(): ExtensionRuntimeSurfaceCommandsSnapshot;
 }
+export interface ExtensionRuntimeSurfaceCommandsInternalSurface extends ExtensionRuntimeSurfaceCommands {
+    startDrag(session: DragSessionExtensionOwned): boolean;
+}

package/dist/extensions/types/surface/events.d.ts

@@ -1,5 +1,4 @@
-import { SceneEventType } from '../basic/events.js';
 export interface ExtensionRuntimeSurfaceEvents {
-    subscribe(events: Iterable<SceneEventType>): void;
-    unsubscribe(events?: Iterable<SceneEventType>): void;
+    subscribeEvent<K extends keyof HTMLElementEventMap>(type: K): void;
+    unsubscribeEvent<K extends keyof HTMLElementEventMap>(type: K): void;
 }

package/dist/extensions/types/wrapper.d.ts

@@ -1,26 +1,27 @@
 /**
  * Public built-in extension ids accepted by createBoard({ extensions })
  */
-import { ActiveTargetDefinition } from '../first-party/active-target/types.js';
-import { BoardEventsDefinition } from '../first-party/board-events/types.js';
-import { LastMoveDefinition } from '../first-party/last-move/types.js';
-import { LegalMovesDefinition } from '../first-party/legal-moves/types.js';
-import { MainRendererDefinition } from '../first-party/main-renderer/types/extension.js';
-import { SelectedSquareDefinition } from '../first-party/selected-square/types.js';
-export declare const DefaultBuiltinChessboardExtensions: readonly ["mainRenderer", "events", "selectedSquare", "activeTarget", "legalMoves", "lastMove"];
-export type BuiltInExtensionId = (typeof DefaultBuiltinChessboardExtensions)[number];
-/**
- * Default built-in extensions used when createBoard(...) receives no extensions option
- */
+import { createActiveTarget } from '../first-party/active-target/factory.js';
+import { createAutoPromote } from '../first-party/auto-promote/factory.js';
+import { createBoardEvents } from '../first-party/board-events/factory.js';
+import { createLastMove } from '../first-party/last-move/factory.js';
+import { createLegalMoves } from '../first-party/legal-moves/factory.js';
+import { createMainRenderer } from '../first-party/main-renderer/factory.js';
+import { createPromotion } from '../first-party/promotion/factory.js';
+import { createSelectedSquare } from '../first-party/selected-square/factory.js';
+export declare const builtInExtensionFactoryMap: {
+    renderer: typeof createMainRenderer;
+    selectedSquare: typeof createSelectedSquare;
+    lastMove: typeof createLastMove;
+    activeTarget: typeof createActiveTarget;
+    legalMoves: typeof createLegalMoves;
+    events: typeof createBoardEvents;
+    autoPromote: typeof createAutoPromote;
+    promotion: typeof createPromotion;
+};
+export type BuiltInExtensionId = keyof typeof builtInExtensionFactoryMap;
+export type BuiltInExtensionDefinitionMap = {
+    [Id in BuiltInExtensionId]: ReturnType<(typeof builtInExtensionFactoryMap)[Id]>;
+};
+export declare const DefaultBuiltinChessboardExtensions: readonly ["renderer", "selectedSquare", "lastMove", "activeTarget", "legalMoves", "events", "autoPromote", "promotion"];
 export type DefaultBuiltinChessboardExtensions = typeof DefaultBuiltinChessboardExtensions;
-/**
- * Map built-in public ids -> concrete extension definition types
- */
-export interface BuiltInExtensionDefinitionMap {
-    mainRenderer: MainRendererDefinition;
-    events: BoardEventsDefinition;
-    selectedSquare: SelectedSquareDefinition;
-    activeTarget: ActiveTargetDefinition;
-    legalMoves: LegalMovesDefinition;
-    lastMove: LastMoveDefinition;
-}

package/dist/extensions/types/wrapper.js

@@ -1,11 +1,39 @@
 /**
  * Public built-in extension ids accepted by createBoard({ extensions })
  */
+import { createActiveTarget } from '../first-party/active-target/factory.js';
+import { EXTENSION_ID as EXTENSION_ID_ACTIVE_TARGET } from '../first-party/active-target/types.js';
+import { createAutoPromote } from '../first-party/auto-promote/factory.js';
+import { EXTENSION_ID as EXTENSION_ID_AUTO_PROMOTE } from '../first-party/auto-promote/types.js';
+import { createBoardEvents } from '../first-party/board-events/factory.js';
+import { EXTENSION_ID as EXTENSION_ID_BOARD_EVENTS } from '../first-party/board-events/types.js';
+import { createLastMove } from '../first-party/last-move/factory.js';
+import { EXTENSION_ID as EXTENSION_ID_LAST_MOVE } from '../first-party/last-move/types.js';
+import { createLegalMoves } from '../first-party/legal-moves/factory.js';
+import { EXTENSION_ID as EXTENSION_ID_LEGAL_MOVES } from '../first-party/legal-moves/types.js';
+import { createMainRenderer } from '../first-party/main-renderer/factory.js';
+import { EXTENSION_ID as EXTENSION_ID_RENDERER } from '../first-party/main-renderer/types/extension.js';
+import { createPromotion } from '../first-party/promotion/factory.js';
+import { EXTENSION_ID as EXTENSION_ID_PROMOTION } from '../first-party/promotion/types/main.js';
+import { createSelectedSquare } from '../first-party/selected-square/factory.js';
+import { EXTENSION_ID as EXTENSION_ID_SELECTED_SQUARE } from '../first-party/selected-square/types.js';
+export const builtInExtensionFactoryMap = {
+    [EXTENSION_ID_RENDERER]: createMainRenderer,
+    [EXTENSION_ID_SELECTED_SQUARE]: createSelectedSquare,
+    [EXTENSION_ID_LAST_MOVE]: createLastMove,
+    [EXTENSION_ID_ACTIVE_TARGET]: createActiveTarget,
+    [EXTENSION_ID_LEGAL_MOVES]: createLegalMoves,
+    [EXTENSION_ID_BOARD_EVENTS]: createBoardEvents,
+    [EXTENSION_ID_AUTO_PROMOTE]: createAutoPromote,
+    [EXTENSION_ID_PROMOTION]: createPromotion
+};
 export const DefaultBuiltinChessboardExtensions = [
-    'mainRenderer',
-    'events',
-    'selectedSquare',
-    'activeTarget',
-    'legalMoves',
-    'lastMove'
+    EXTENSION_ID_RENDERER,
+    EXTENSION_ID_SELECTED_SQUARE,
+    EXTENSION_ID_LAST_MOVE,
+    EXTENSION_ID_ACTIVE_TARGET,
+    EXTENSION_ID_LEGAL_MOVES,
+    EXTENSION_ID_BOARD_EVENTS,
+    EXTENSION_ID_AUTO_PROMOTE,
+    EXTENSION_ID_PROMOTION
 ];

package/dist/extensions/update.d.ts

@@ -1,4 +1,4 @@
-import { ExtensionUIMoveRequestContext } from './types/context/ui-move.js';
+import { ExtensionPendingUIMoveRequestContext } from './types/context/ui-move.js';
 import { ExtensionSystemInternal, ExtensionSystemUpdateRequest } from './types/main.js';
 export declare function extensionSystemUpdateState(state: ExtensionSystemInternal, request: ExtensionSystemUpdateRequest): void;
-export declare function extensionSystemUpdateUIMoveRequest(state: ExtensionSystemInternal, context: ExtensionUIMoveRequestContext): void;
+export declare function extensionSystemUpdateUIMoveRequest(state: ExtensionSystemInternal, context: ExtensionPendingUIMoveRequestContext): void;

package/dist/extensions/update.js

@@ -16,7 +16,7 @@ export function extensionSystemUpdateState(state, request) {
             : {
                 ...contextCommon
             };
-        extension.instance.onUpdate(context);
+        extension.instance.onUpdate?.(context);
     }
     state.currentFrame = request.state;
 }

package/dist/layout/factory.js

@@ -2,7 +2,7 @@ import { cloneDeep } from 'es-toolkit/object';
 import { layoutRefreshGeometry } from './reducers.js';
 function createLayoutInternal() {
     return {
-        boardSize: 0,
+        sceneSize: null,
         orientation: 0 /* ColorCode.White */,
         geometry: null,
         layoutEpoch: 0
@@ -11,8 +11,8 @@ function createLayoutInternal() {
 export function createLayout() {
     const internalState = createLayoutInternal();
     return {
-        get boardSize() {
-            return internalState.boardSize;
+        get sceneSize() {
+            return internalState.sceneSize;
         },
         get orientation() {
             return internalState.orientation;

package/dist/layout/geometry/factory.d.ts

@@ -1,12 +1,3 @@
 import { ColorCode } from '../../state/board/types/internal.js';
-import { RenderGeometry } from './types.js';
-/**
- * Create RenderGeometry for a given board size (in px) and orientation.
- * - Geometry uses an SVG-local coordinate system with origin at top-left.
- * - Orientation mapping:
- *   - 'white': files increase left→right (a..h), ranks increase bottom→top (1..8).
- *              yIndex = 7 - rank, xIndex = file
- *   - 'black': files increase right→left (a..h), ranks increase top→bottom (1..8).
- *              yIndex = rank, xIndex = 7 - file
- */
-export declare function createRenderGeometry(boardSize: number, orientation: ColorCode): RenderGeometry;
+import { SceneRenderGeometry, Size } from './types.js';
+export declare function createRenderGeometry(sceneSize: Size, orientation: ColorCode): SceneRenderGeometry;

package/dist/layout/geometry/factory.js

@@ -1,32 +1,31 @@
 import { fileOf, rankOf } from '../../state/board/coords.js';
-/**
- * Create RenderGeometry for a given board size (in px) and orientation.
- * - Geometry uses an SVG-local coordinate system with origin at top-left.
- * - Orientation mapping:
- *   - 'white': files increase left→right (a..h), ranks increase bottom→top (1..8).
- *              yIndex = 7 - rank, xIndex = file
- *   - 'black': files increase right→left (a..h), ranks increase top→bottom (1..8).
- *              yIndex = rank, xIndex = 7 - file
- */
-export function createRenderGeometry(boardSize, orientation) {
-    if (!(boardSize > 0 && Number.isFinite(boardSize))) {
-        throw new RangeError(`Invalid boardSize: ${boardSize}`);
+import { makeBoardRect, measureBoardSize } from './helpers.js';
+export function createRenderGeometry(sceneSize, orientation) {
+    if (!(sceneSize.height > 0 &&
+        Number.isFinite(sceneSize.height) &&
+        sceneSize.width > 0 &&
+        Number.isFinite(sceneSize.width))) {
+        throw new RangeError(`Invalid sceneSize: ${JSON.stringify(sceneSize)}`);
     }
+    const boardSize = measureBoardSize(sceneSize);
+    const boardRect = makeBoardRect(sceneSize);
     const squareSize = boardSize / 8;
     const white = orientation === 0 /* ColorCode.White */;
     return {
-        boardSize,
+        sceneSize: { ...sceneSize },
+        boardRect,
         squareSize,
         orientation,
-        squareRect(sq) {
+        getSquareRect(sq) {
             const f = fileOf(sq);
             const r = rankOf(sq);
             const xIndex = white ? f : 7 - f;
             const yIndex = white ? 7 - r : r;
             return {
-                x: xIndex * squareSize,
-                y: yIndex * squareSize,
-                size: squareSize
+                x: boardRect.x + xIndex * squareSize,
+                y: boardRect.y + yIndex * squareSize,
+                width: squareSize,
+                height: squareSize
             };
         }
     };

package/dist/layout/geometry/helpers.d.ts

@@ -0,0 +1,5 @@
+import { Rect, RectSnapshot, Size, SizeSnapshot } from './types.js';
+export declare function sceneRectsEqual(rect1: RectSnapshot | null, rect2: RectSnapshot | null): boolean;
+export declare function sceneSizesEqual(size1: SizeSnapshot | null, size2: SizeSnapshot | null): boolean;
+export declare function measureBoardSize(sceneSize: Size): number;
+export declare function makeBoardRect(sceneSize: Size): Rect;

package/dist/layout/geometry/helpers.js

@@ -0,0 +1,33 @@
+export function sceneRectsEqual(rect1, rect2) {
+    if (rect1 === null && rect2 === null) {
+        return true;
+    }
+    if (rect1 === null || rect2 === null) {
+        return false;
+    }
+    return (rect1.x === rect2.x &&
+        rect1.y === rect2.y &&
+        rect1.width === rect2.width &&
+        rect1.height === rect2.height);
+}
+export function sceneSizesEqual(size1, size2) {
+    if (size1 === null && size2 === null) {
+        return true;
+    }
+    if (size1 === null || size2 === null) {
+        return false;
+    }
+    return size1.width === size2.width && size1.height === size2.height;
+}
+export function measureBoardSize(sceneSize) {
+    return Math.min(sceneSize.width, sceneSize.height);
+}
+export function makeBoardRect(sceneSize) {
+    const boardSize = measureBoardSize(sceneSize);
+    return {
+        x: (sceneSize.width - boardSize) / 2,
+        y: (sceneSize.height - boardSize) / 2,
+        width: boardSize,
+        height: boardSize
+    };
+}

package/dist/layout/geometry/types.d.ts

@@ -1,20 +1,21 @@
 import { ReadonlyDeep } from 'type-fest';
 import { ColorCode, Square } from '../../state/board/types/internal.js';
-export interface SquareRect {
+export interface Size {
+    width: number;
+    height: number;
+}
+export type SizeSnapshot = ReadonlyDeep<Size>;
+export interface Rect {
     x: number;
     y: number;
-    size: number;
+    width: number;
+    height: number;
 }
-export type SquareRectSnapshot = ReadonlyDeep<SquareRect>;
-/**
- * RenderGeometry represents the derived geometry of the rendered chessboard.
- * It includes the board size, square size, orientation, and square rectangle mapping.
- *
- * It is computed from layout inputs and used by rendering and interaction code.
- */
-export interface RenderGeometry {
-    readonly boardSize: number;
+export type RectSnapshot = ReadonlyDeep<Rect>;
+export interface SceneRenderGeometry {
+    readonly sceneSize: SizeSnapshot;
+    readonly boardRect: RectSnapshot;
     readonly squareSize: number;
     readonly orientation: ColorCode;
-    squareRect(sq: Square): SquareRectSnapshot;
+    getSquareRect(sq: Square): RectSnapshot;
 }

package/dist/layout/helpers.d.ts

@@ -1,4 +1,3 @@
-/**
- * Measure board size from container (square board fits within host).
- */
-export declare function measureBoardSize(container: HTMLElement): number;
+import { Size } from './geometry/types.js';
+export declare function measureSceneSize(container: HTMLElement): Size;
+export declare function isSceneSizeValid(size: Size | null): boolean;

package/dist/layout/helpers.js

@@ -1,6 +1,6 @@
-/**
- * Measure board size from container (square board fits within host).
- */
-export function measureBoardSize(container) {
-    return Math.min(container.clientWidth, container.clientHeight);
+export function measureSceneSize(container) {
+    return { width: container.clientWidth, height: container.clientHeight };
+}
+export function isSceneSizeValid(size) {
+    return size !== null && size.width > 0 && size.height > 0;
 }

package/dist/layout/reducers.js

@@ -1,5 +1,6 @@
 import { createRenderGeometry } from './geometry/factory.js';
-import { measureBoardSize } from './helpers.js';
+import { sceneSizesEqual } from './geometry/helpers.js';
+import { isSceneSizeValid, measureSceneSize } from './helpers.js';
 export function layoutRefreshGeometry(state, options) {
     const orientation = options.orientation ?? state.orientation;
     if (orientation === null) {
@@ -7,23 +8,23 @@ export function layoutRefreshGeometry(state, options) {
         // For now we throw
         throw new Error('Orientation is expected to be provided on the first pass of layout.refreshGeometry');
     }
-    let boardSize = options.container ? measureBoardSize(options.container) : state.boardSize;
-    if (boardSize !== null && boardSize <= 0)
-        boardSize = null;
-    const changed = boardSize !== state.boardSize || orientation !== state.orientation;
+    let sceneSize = options.container ? measureSceneSize(options.container) : state.sceneSize;
+    if (sceneSize !== null && !isSceneSizeValid(sceneSize))
+        sceneSize = null;
+    const changed = !sceneSizesEqual(sceneSize, state.sceneSize) || orientation !== state.orientation;
     if (!changed) {
         return false; // no-op, no relevant changes
     }
     // Update the state
-    state.boardSize = boardSize;
+    state.sceneSize = sceneSize;
     state.orientation = orientation;
-    if (boardSize === null || orientation === null) {
+    if (sceneSize === null || orientation === null) {
         // General invalid-geometry rule. Orientation is currently guarded above,
         // but this branch stays explicit in case null orientation is allowed later.
         state.geometry = null;
     }
     else {
-        state.geometry = createRenderGeometry(boardSize, orientation);
+        state.geometry = createRenderGeometry(sceneSize, orientation);
     }
     state.layoutEpoch++;
     return true;

package/dist/layout/types.d.ts

@@ -1,11 +1,11 @@
 import { ReadonlyDeep } from 'type-fest';
 import { ColorCode } from '../state/board/types/internal.js';
-import { RenderGeometry } from './geometry/types.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/render/mount.js

@@ -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/state.js

@@ -1,3 +1,4 @@
+import { sceneSizesEqual } from '../../layout/geometry/helpers.js';
 import { updateElementAttributes } from '../svg/helpers.js';
 import { validateIsMounted } from './helpers.js';
 export function checkNeedsRender(state) {
@@ -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/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.js

@@ -1,9 +1,9 @@
 import assert from '@ktarmyshov/assert';
 import { isEmptyPieceCode } from '../../state/board/check.js';
+import { createPendingUIMoveRequest } from '../../state/change/factory/ui-move.js';
 import { canMoveTo } from '../input/controller/helpers.js';
-import { createUIMoveRequestContext } from './ui-move.js';
-function assertResolvedAfterAutoResolve(state) {
-    if (state.status !== 'resolved') {
+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.js

@@ -1,5 +1,6 @@
 import assert from '@ktarmyshov/assert';
 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) {
@@ -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);
         }
     };
 }