@mirasen/chessboard 0.1.1 → 1.0.0-rc.0

package/dist/runtime/input/controller/pointer.js

@@ -1,38 +1,42 @@
 import assert from '@ktarmyshov/assert';
 import { isEmptyPieceCode, isNonEmptyPieceCode } from '../../../state/board/check.js';
 import { fromPieceCode } from '../../../state/board/piece.js';
+import { isDragSessionCoreOwned } from '../../../state/interaction/helpers.js';
 import { canMoveTo } from './helpers.js';
-export function handlePointerDown(state, event) {
-    assert(event.type === 'pointerdown', 'handlePointerDown should only be called for pointerdown events');
-    if (event.button !== 0) {
+export function handlePointerDown(state, context) {
+    assert(context.rawEvent.type === 'pointerdown', 'handlePointerDown should only be called for pointerdown events');
+    const rawEvent = context.rawEvent;
+    if (rawEvent.button !== 0) {
         // Only handle left-click for now
         return;
     }
+    const sceneEvent = context.sceneEvent;
+    assert(sceneEvent, 'Scene event should be present for pointer events');
     const interaction = state.surface.getInteractionStateSnapshot();
     if (interaction.dragSession) {
         // Ignore pointer down events if there's already an active drag session
         return;
     }
-    if (event.target !== null) {
+    if (sceneEvent.targetSquare !== null) {
         /**
          * If piece is already selected, and we have a valid target square event.target
          * AND it's a different square AND (it's empty OR (has an opponent piece AND is a legal move target))
          * THEN start a release-targeting drag session
          */
-        if (interaction.selected && event.target !== interaction.selected.square) {
+        if (interaction.selected && sceneEvent.targetSquare !== interaction.selected.square) {
             const selectedPieceCode = interaction.selected.pieceCode;
             assert(isNonEmptyPieceCode(selectedPieceCode), 'Selected piece code must be non-zero');
-            const targetPieceCode = state.surface.getPieceCodeAt(event.target);
+            const targetPieceCode = state.surface.getPieceCodeAt(sceneEvent.targetSquare);
             if (isEmptyPieceCode(targetPieceCode)) {
-                state.surface.startReleaseTargetingDrag(interaction.selected.square, event.target);
+                state.surface.startReleaseTargetingDrag(interaction.selected.square, sceneEvent.targetSquare);
                 return;
             }
             const isLegalMoveTarget = interaction.movability.mode === 1 /* MovabilityModeCode.Free */ ||
                 (interaction.movability.mode === 2 /* MovabilityModeCode.Strict */ &&
-                    interaction.activeDestinations.has(event.target));
+                    interaction.activeDestinations.has(sceneEvent.targetSquare));
             if (fromPieceCode(targetPieceCode).color !== fromPieceCode(selectedPieceCode).color &&
                 isLegalMoveTarget) {
-                state.surface.startReleaseTargetingDrag(interaction.selected.square, event.target);
+                state.surface.startReleaseTargetingDrag(interaction.selected.square, sceneEvent.targetSquare);
                 return;
             }
         }
@@ -40,53 +44,57 @@ export function handlePointerDown(state, event) {
          * If we are here, then it's not release-targeting.
          * So it's either a new lift or re-lift of the same piece. In either case, we can just start a lifted drag session if the target is valid.
          */
-        const pieceCode = state.surface.getPieceCodeAt(event.target);
+        const pieceCode = state.surface.getPieceCodeAt(sceneEvent.targetSquare);
         if (!isEmptyPieceCode(pieceCode)) {
-            state.surface.startLiftedDrag(event.target, event.target);
+            state.surface.startLiftedDrag(sceneEvent.targetSquare, sceneEvent.targetSquare);
         }
     }
 }
-export function handlePointerMove(state, event) {
-    assert(event.type === 'pointermove', 'handlePointerMove should only be called for pointermove events');
+export function handlePointerMove(state, context) {
+    assert(context.rawEvent.type === 'pointermove', 'handlePointerMove should only be called for pointermove events');
     const interaction = state.surface.getInteractionStateSnapshot();
     if (interaction.dragSession) {
-        state.surface.updateDragSessionCurrentTarget(event.target);
+        state.surface.updateDragSessionCurrentTarget(context.sceneEvent?.targetSquare ?? null);
     }
 }
-export function handlePointerUp(state, event) {
-    assert(event.type === 'pointerup', 'handlePointerUp should only be called for pointerup events');
+export function handlePointerUp(state, context) {
+    assert(context.rawEvent.type === 'pointerup', 'handlePointerUp should only be called for pointerup events');
     const interaction = state.surface.getInteractionStateSnapshot();
-    if (!interaction.dragSession) {
+    const dragSession = interaction.dragSession;
+    if (!dragSession) {
         // No active drag session, so nothing to do on pointer up
         return;
     }
+    const sceneEvent = context.sceneEvent;
+    assert(sceneEvent, 'Scene event should be present for pointer events');
+    if (!isDragSessionCoreOwned(dragSession)) {
+        // For extension-owned drag sessions, we simply end the session without attempting to make a move,
+        // since the runtime doesn't have enough information about the semantics of the drag session.
+        state.surface.completeExtensionDrag(sceneEvent.targetSquare);
+        return;
+    }
     // Check if the square is the same as the source square of the drag session.
     // If it is, then we can end the drag session without making a move.
-    if (event.target === interaction.dragSession.sourceSquare) {
+    if (sceneEvent.targetSquare === dragSession.sourceSquare) {
         state.surface.cancelActiveInteraction();
         return;
     }
     // Check if the target square is a valid destination for the selected piece.
-    if (event.target !== null && canMoveTo(interaction, event.target)) {
-        if (interaction.dragSession.type === 'lifted-piece-drag') {
-            state.surface.dropTo(event.target);
-        }
-        else {
-            state.surface.releaseTo(event.target);
-        }
+    if (sceneEvent.targetSquare !== null && canMoveTo(interaction, sceneEvent.targetSquare)) {
+        state.surface.completeCoreDragTo(sceneEvent.targetSquare);
         return;
     }
     // Invalid target: piece returns to source for lifted drag (selection preserved),
     // or selection is cleared for release targeting.
-    if (interaction.dragSession.type === 'lifted-piece-drag') {
+    if (dragSession.type === 'lifted-piece-drag') {
         state.surface.cancelActiveInteraction();
     }
     else {
         state.surface.cancelInteraction();
     }
 }
-export function handlePointerCancel(state, event) {
-    assert(event.type === 'pointercancel', 'handlePointerCancel should only be called for pointercancel events');
+export function handlePointerCancel(state, context) {
+    assert(context.rawEvent.type === 'pointercancel', 'handlePointerCancel should only be called for pointercancel events');
     const interaction = state.surface.getInteractionStateSnapshot();
     if (!interaction.dragSession) {
         // No active drag session, so nothing to do on pointer cancel
@@ -95,10 +103,3 @@ export function handlePointerCancel(state, event) {
     // Cancel the active interaction on pointer cancel
     state.surface.cancelActiveInteraction();
 }
-export function handlePointerLeave(state, event) {
-    assert(event.type === 'pointerleave', 'handlePointerLeave should only be called for pointerleave events');
-    const interaction = state.surface.getInteractionStateSnapshot();
-    if (interaction.dragSession) {
-        state.surface.updateDragSessionCurrentTarget(event.target);
-    }
-}

package/dist/runtime/input/controller/transient-visuals.d.ts

@@ -1,3 +1,3 @@
-import { SceneEvent } from '../../../extensions/types/basic/events.js';
+import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
 import { InteractionControllerInternal } from './types.js';
-export declare function transmitTransientInput(state: InteractionControllerInternal, event: SceneEvent): void;
+export declare function transmitTransientInput(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;

package/dist/runtime/input/controller/transient-visuals.js

@@ -1,12 +1,19 @@
 function isPointerEvent(event) {
     return event.type.startsWith('pointer');
 }
-export function transmitTransientInput(state, event) {
-    if (isPointerEvent(event) && event.rawPoint && event.clampedPoint) {
+function isRawPointerEvent(event) {
+    return event instanceof PointerEvent;
+}
+export function transmitTransientInput(state, context) {
+    if (context.sceneEvent &&
+        isPointerEvent(context.sceneEvent) &&
+        isRawPointerEvent(context.rawEvent) &&
+        context.sceneEvent.boardClampedPoint) {
         state.surface.transientInput({
-            target: event.target,
-            rawPoint: event.rawPoint,
-            clampedPoint: event.clampedPoint
+            target: context.sceneEvent.targetSquare,
+            point: context.sceneEvent.point,
+            clampedPoint: context.sceneEvent.clampedPoint,
+            boardClampedPoint: context.sceneEvent.boardClampedPoint
         });
     }
 }

package/dist/runtime/input/controller/types.d.ts

@@ -1,18 +1,19 @@
-import { SceneEvent } from '../../../extensions/types/basic/events.js';
 import { TransientInput } from '../../../extensions/types/basic/transient-visuals.js';
+import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
 import { PieceCode, Square } from '../../../state/board/types/internal.js';
 import { InteractionStateSnapshot } from '../../../state/interaction/types/main.js';
 export interface RuntimeInteractionSurface {
     getInteractionStateSnapshot(): InteractionStateSnapshot;
     getPieceCodeAt(square: Square): PieceCode;
     startLiftedDrag(source: Square, target: Square): void;
-    dropTo(target: Square): void;
     startReleaseTargetingDrag(source: Square, target: Square): void;
-    releaseTo(target: Square): void;
+    completeCoreDragTo(target: Square): void;
+    completeExtensionDrag(target: Square | null): void;
     updateDragSessionCurrentTarget(target: Square | null): void;
     cancelActiveInteraction(): void;
     cancelInteraction(): void;
     transientInput(input: TransientInput): void;
+    onEvent(context: ExtensionOnEventContext): void;
 }
 export interface InteractionControllerInternal {
     readonly surface: RuntimeInteractionSurface;
@@ -21,5 +22,5 @@ export interface InteractionControllerInitOptions {
     surface: RuntimeInteractionSurface;
 }
 export interface InteractionController {
-    onEvent(event: SceneEvent): void;
+    onEvent(context: ExtensionOnEventContext): void;
 }

package/dist/runtime/lifecycle.js

@@ -16,18 +16,18 @@ export function runtimeValidateIsNotMounted(state) {
 }
 export function runtimeMount(state, container) {
     runtimeValidateIsNotMounted(state);
+    assert(state.inputAdapter === null, 'Input adapter should not be initialized before mounting');
+    state.inputAdapter = createInputAdapter({
+        container,
+        getRenderGeometry: () => state.layout.geometry,
+        controller: state.interactionController
+    });
     state.renderSystem.mount(container);
     state.resizeObserver = new ResizeObserver(() => {
         runtimeRefreshGeometry(state);
     });
     // Observe will cause immediate first callback!
     state.resizeObserver.observe(container);
-    assert(state.inputAdapter === null, 'Input adapter should not be initialized before mounting');
-    state.inputAdapter = createInputAdapter({
-        container,
-        getGeometry: () => state.layout.geometry,
-        controller: state.interactionController
-    });
 }
 export function runtimeUnmount(state) {
     runtimeValidateIsMounted(state);

package/dist/runtime/mutation/interaction.js

@@ -4,11 +4,7 @@ export const reconcileInteractionSelectionAfterBoardStateChange = (context, muta
     const { current } = context;
     if (!mutationSession.hasMutation({ prefixes: ['state.board.'] }) ||
         mutationSession.hasMutation({
-            causes: [
-                'state.interaction.clear',
-                'runtime.interaction.dropTo',
-                'runtime.interaction.releaseTo'
-            ]
+            causes: ['state.interaction.clear', 'runtime.interaction.completeDragTo']
         })) {
         return;
     }

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

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

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

@@ -1,5 +1,6 @@
 import { AnyExtensionDefinition } from '../../extensions/types/extension.js';
 import { ExtensionRuntimeSurfaceCommands } from '../../extensions/types/surface/commands.js';
+import { ExtensionRuntimeSurfaceEvents } from '../../extensions/types/surface/events.js';
 import { RuntimeStateInitOptions } from '../../state/types.js';
 import { InputAdapter } from '../input/adapter/types.js';
 import { InteractionController } from '../input/controller/types.js';
@@ -19,6 +20,7 @@ export interface RuntimeInitOptions {
 }
 export interface RuntimeInitOptionsInternal extends RuntimeInitOptions {
     extensionRuntimeSurfaceCommands: ExtensionRuntimeSurfaceCommands;
+    extensionRuntimeSurfaceEvents: ExtensionRuntimeSurfaceEvents;
     getInternalState: GetInternalState;
 }
 /**

package/dist/state/change/{factory.d.ts → factory/main.d.ts}

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

package/dist/state/change/{factory.js → factory/main.js}

@@ -1,9 +1,9 @@
 import { cloneDeep } from 'es-toolkit/object';
-import { changeStateSetDeferredUIMoveRequestContext, changeStateSetLastMove } from './reducers.js';
+import { changeStateSetDeferredUIMoveRequest, changeStateSetLastMove } from '../reducers.js';
 function createChangeStateInternal() {
     return {
         lastMove: null,
-        deferredUIMoveRequestContext: null
+        deferredUIMoveRequest: null
     };
 }
 export function createChangeState() {
@@ -12,17 +12,20 @@ export function createChangeState() {
         get lastMove() {
             return cloneDeep(internalState.lastMove);
         },
+        get deferredUIMoveRequest() {
+            return cloneDeep(internalState.deferredUIMoveRequest);
+        },
         setLastMove(move, mutationSession) {
             return mutationSession.addMutation('state.change.setLastMove', changeStateSetLastMove(internalState, move));
         },
         getSnapshot() {
             return {
                 ...cloneDeep(internalState),
-                deferredUIMoveRequestContext: internalState.deferredUIMoveRequestContext?.getSnapshot() ?? null
+                deferredUIMoveRequest: internalState.deferredUIMoveRequest?.getSnapshot() ?? null
             };
         },
-        setDeferredUIMoveRequestContext(context, mutationSession) {
-            return mutationSession.addMutation('state.change.setDeferredUIMoveRequestContext', changeStateSetDeferredUIMoveRequestContext(internalState, context));
+        setDeferredUIMoveRequest(request, mutationSession) {
+            return mutationSession.addMutation('state.change.setDeferredUIMoveRequest', changeStateSetDeferredUIMoveRequest(internalState, request));
         }
     };
 }

package/dist/state/change/factory/ui-move.d.ts

@@ -0,0 +1,4 @@
+import { Square } from '../../board/types/internal.js';
+import { MoveDestinationSnapshot } from '../../interaction/types/internal.js';
+import { PendingUIMoveRequest } from '../types/ui-move.js';
+export declare function createPendingUIMoveRequest(sourceSquare: Square, destination: MoveDestinationSnapshot): PendingUIMoveRequest;

package/dist/{runtime → state/change}/factory/ui-move.js

@@ -1,4 +1,4 @@
-function createMoveRequestContextInternal(sourceSquare, destination) {
+function createPendingUIMoveRequestInternal(sourceSquare, destination) {
     return {
         sourceSquare,
         destination,
@@ -6,7 +6,7 @@ function createMoveRequestContextInternal(sourceSquare, destination) {
         resolvedMoveRequest: null
     };
 }
-function moveRequestContextCanBeAutoResolved(state) {
+function pendingUIMoveRequestCanBeAutoResolved(state) {
     return (state.status === 'unresolved' &&
         (state.destination.promotedTo === undefined || state.destination.promotedTo.length <= 1));
 }
@@ -21,11 +21,11 @@ function assertCanBeResolved(state) {
     }
 }
 function assertCanBeAutoResolved(state) {
-    if (!moveRequestContextCanBeAutoResolved(state)) {
+    if (!pendingUIMoveRequestCanBeAutoResolved(state)) {
         throw new Error('Move request cannot be auto-resolved. Either it is already resolved or deferred, or it requires a promotion choice.');
     }
 }
-function moveRequestContextAutoResolve(state) {
+function pendingUIMoveRequestAutoResolve(state) {
     assertCanBeAutoResolved(state);
     const promotedTo = state.destination.promotedTo?.length === 1 ? state.destination.promotedTo[0] : undefined;
     state.status = 'resolved';
@@ -41,8 +41,8 @@ function moveRequestContextAutoResolve(state) {
         ...(promotedTo !== undefined ? { promotedTo } : {})
     };
 }
-export function createUIMoveRequestContext(sourceSquare, destination) {
-    const internalState = createMoveRequestContextInternal(sourceSquare, destination);
+export function createPendingUIMoveRequest(sourceSquare, destination) {
+    const internalState = createPendingUIMoveRequestInternal(sourceSquare, destination);
     return {
         get status() {
             return internalState.status;
@@ -54,7 +54,7 @@ export function createUIMoveRequestContext(sourceSquare, destination) {
             return internalState.destination;
         },
         get canBeAutoResolved() {
-            return moveRequestContextCanBeAutoResolved(internalState);
+            return pendingUIMoveRequestCanBeAutoResolved(internalState);
         },
         get resolvedMoveRequest() {
             return internalState.resolvedMoveRequest;
@@ -69,14 +69,14 @@ export function createUIMoveRequestContext(sourceSquare, destination) {
             internalState.resolvedMoveRequest = request;
         },
         autoresolve() {
-            moveRequestContextAutoResolve(internalState);
+            pendingUIMoveRequestAutoResolve(internalState);
         },
         getSnapshot() {
             return {
                 status: internalState.status,
                 sourceSquare: internalState.sourceSquare,
                 destination: internalState.destination,
-                canBeAutoResolved: moveRequestContextCanBeAutoResolved(internalState),
+                canBeAutoResolved: pendingUIMoveRequestCanBeAutoResolved(internalState),
                 resolvedMoveRequest: internalState.resolvedMoveRequest
             };
         }

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

@@ -1,8 +1,10 @@
-import { ExtensionUIMoveRequestContextSnapshot } from '../../extensions/types/context/ui-move.js';
 import type { MoveRequest, MoveRequestBase, MoveSnapshot } from '../board/types/internal.js';
 import { MoveDestinationSnapshot } from '../interaction/types/internal.js';
+import { ChangeStateSnapshot } from './types/main.js';
+import { PendingUIMoveRequestSnapshot } from './types/ui-move.js';
 export declare function movesEqual(moveA: MoveSnapshot | null, moveB: MoveSnapshot | null): boolean;
 export declare function moveRequestBasesEqual(requestA: MoveRequestBase | null, requestB: MoveRequestBase | null): boolean;
 export declare function moveRequestsEqual(requestA: MoveRequest | null, requestB: MoveRequest | null): boolean;
 export declare function moveDestinationsEqual(destA: MoveDestinationSnapshot | null, destB: MoveDestinationSnapshot | null): boolean;
-export declare function uiMoveRequestContextsEqual(contextA: ExtensionUIMoveRequestContextSnapshot | null, contextB: ExtensionUIMoveRequestContextSnapshot | null): boolean;
+export declare function pendingUIMoveRequestsEqual(contextA: PendingUIMoveRequestSnapshot | null, contextB: PendingUIMoveRequestSnapshot | null): boolean;
+export declare function changeStatesEqual(stateA: ChangeStateSnapshot | null, stateB: ChangeStateSnapshot | null): boolean;

package/dist/state/change/helpers.js

@@ -69,7 +69,7 @@ export function moveDestinationsEqual(destA, destB) {
         setsEqual(new Set(destA.promotedTo ?? []), new Set(destB.promotedTo ?? [])) &&
         moveRequestBasesEqual(destA.secondary ?? null, destB.secondary ?? null));
 }
-export function uiMoveRequestContextsEqual(contextA, contextB) {
+export function pendingUIMoveRequestsEqual(contextA, contextB) {
     if (contextA === null && contextB === null) {
         return true;
     }
@@ -84,3 +84,13 @@ export function uiMoveRequestContextsEqual(contextA, contextB) {
         contextA.canBeAutoResolved === contextB.canBeAutoResolved &&
         moveRequestsEqual(contextA.resolvedMoveRequest, contextB.resolvedMoveRequest));
 }
+export function changeStatesEqual(stateA, stateB) {
+    if (stateA === null && stateB === null) {
+        return true;
+    }
+    if (stateA === null || stateB === null) {
+        return false;
+    }
+    return (pendingUIMoveRequestsEqual(stateA.deferredUIMoveRequest, stateB.deferredUIMoveRequest) &&
+        movesEqual(stateA.lastMove, stateB.lastMove));
+}

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

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

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

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

package/dist/state/change/reducers.js

@@ -1,5 +1,5 @@
 import { cloneDeep } from 'es-toolkit/object';
-import { movesEqual, uiMoveRequestContextsEqual } from './helpers.js';
+import { movesEqual, pendingUIMoveRequestsEqual } from './helpers.js';
 export function changeStateSetLastMove(state, move) {
     if (movesEqual(state.lastMove, move)) {
         return false; // No change
@@ -7,10 +7,10 @@ export function changeStateSetLastMove(state, move) {
     state.lastMove = cloneDeep(move);
     return true;
 }
-export function changeStateSetDeferredUIMoveRequestContext(state, context) {
-    if (uiMoveRequestContextsEqual(state.deferredUIMoveRequestContext, context)) {
+export function changeStateSetDeferredUIMoveRequest(state, request) {
+    if (pendingUIMoveRequestsEqual(state.deferredUIMoveRequest, request)) {
         return false; // No change
     }
-    state.deferredUIMoveRequestContext = context;
+    state.deferredUIMoveRequest = request;
     return true;
 }

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

@@ -0,0 +1,18 @@
+import type { ReadonlyDeep } from 'type-fest';
+import { MoveSnapshot } from '../../board/types/internal.js';
+import type { ChangeStateMutationSession } from '../mutation.js';
+import { PendingUIMoveRequest, PendingUIMoveRequestSnapshot } from './ui-move.js';
+export interface ChangeStateInternal {
+    lastMove: MoveSnapshot | null;
+    deferredUIMoveRequest: PendingUIMoveRequest | null;
+}
+export type ChangeStateSnapshot = ReadonlyDeep<Omit<ChangeStateInternal, 'deferredUIMoveRequest'>> & {
+    deferredUIMoveRequest: PendingUIMoveRequestSnapshot | null;
+};
+export interface ChangeState {
+    readonly lastMove: MoveSnapshot | null;
+    readonly deferredUIMoveRequest: PendingUIMoveRequest | null;
+    setLastMove(move: MoveSnapshot | null, mutationSession: ChangeStateMutationSession): boolean;
+    setDeferredUIMoveRequest(request: PendingUIMoveRequest | null, mutationSession: ChangeStateMutationSession): boolean;
+    getSnapshot(): ChangeStateSnapshot;
+}

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

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

package/dist/state/change/types/ui-move.d.ts

@@ -0,0 +1,25 @@
+import { MoveRequest, RolePromotionCode, Square } from '../../board/types/internal.js';
+import { MoveDestinationSnapshot } from '../../interaction/types/internal.js';
+export type PendingUIMoveRequestStatus = 'unresolved' | 'deferred' | 'resolved';
+export interface PendingUIMoveRequestSnapshot {
+    readonly status: PendingUIMoveRequestStatus;
+    readonly sourceSquare: Square;
+    readonly destination: MoveDestinationSnapshot;
+    readonly canBeAutoResolved: boolean;
+    readonly resolvedMoveRequest: MoveRequest | null;
+}
+export interface PendingUIMoveRequest extends PendingUIMoveRequestSnapshot {
+    defer(): void;
+    resolve(request: MoveRequest): void;
+    autoresolve(): void;
+    getSnapshot(): PendingUIMoveRequestSnapshot;
+}
+export interface PendingUIMoveRequestInternal {
+    readonly sourceSquare: Square;
+    readonly destination: MoveDestinationSnapshot;
+    status: PendingUIMoveRequestStatus;
+    resolvedMoveRequest: MoveRequest | null;
+}
+export interface DeferredUIMoveResolutionDetails {
+    readonly promotedTo: RolePromotionCode;
+}

package/dist/state/change/types/ui-move.js

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

package/dist/state/factory.js

@@ -1,5 +1,5 @@
 import { createBoardState } from './board/factory.js';
-import { createChangeState } from './change/factory.js';
+import { createChangeState } from './change/factory/main.js';
 import { createInteractionState } from './interaction/factory.js';
 import { createViewState } from './view/factory.js';
 function createRuntimeStateInternal(options) {

package/dist/state/interaction/factory.js

@@ -51,8 +51,10 @@ export function createInteractionState(options) {
             return internalState.dragSession ? { ...internalState.dragSession } : null;
         },
         setDragSession(session, mutationSession) {
-            // Assert that the selected is the same as the source of the drag session when setting a lifted-piece-drag session
-            if (session) {
+            // assert that there is no active session when setting a new session.
+            assert(session === null || internalState.dragSession === null, 'Cannot set a new drag session while another session is active');
+            if (session && session.owner === 'core') {
+                // Assert that the selected is the same as the source of the drag session when setting a lifted-piece-drag session
                 assert(internalState.selected, 'There must be a selected piece to start a drag session');
                 if (session.type === 'lifted-piece-drag') {
                     assert(internalState.selected, 'There must be a selected piece to start a lifted-piece-drag session');

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

@@ -1,4 +1,6 @@
 import { InteractionStateMutationSession } from './mutation.js';
+import { DragSessionCoreOwnedSnapshot, DragSessionSnapshot } from './types/internal.js';
 import { InteractionStateInternal, InteractionStateSelected } from './types/main.js';
 export declare function selectedEqual(a: InteractionStateSelected | null, b: InteractionStateSelected | null): boolean;
 export declare function updateActiveDestinations(state: InteractionStateInternal, mutationSession: InteractionStateMutationSession): boolean;
+export declare function isDragSessionCoreOwned(session: DragSessionSnapshot): session is DragSessionCoreOwnedSnapshot;

package/dist/state/interaction/helpers.js

@@ -14,3 +14,6 @@ export function updateActiveDestinations(state, mutationSession) {
     const activeDests = getActiveDestinations(state, state.selected.square);
     return mutationSession.addMutation('state.interaction.updateActiveDestinations', interactionSetActiveDestinations(state, activeDests));
 }
+export function isDragSessionCoreOwned(session) {
+    return session.owner === 'core';
+}

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

@@ -1,11 +1,19 @@
 import type { ReadonlyDeep } from 'type-fest';
+import type { ExtensionDragSession, ExtensionDragSessionBase } from '../../../extensions/types/basic/interaction.js';
 import type { MoveRequest, PieceCode, RolePromotionCode, Square } from '../../board/types/internal.js';
-export interface DragSession {
+export type DragSessionExtensionOwned = ExtensionDragSession & {
+    owner: string;
+};
+export type DragSessionExtensionOwnedSnapshot = ReadonlyDeep<DragSessionExtensionOwned>;
+export interface DragSessionCoreOwned extends ExtensionDragSessionBase {
+    owner: 'core';
     type: 'lifted-piece-drag' | 'release-targeting';
     sourceSquare: Square;
     sourcePieceCode: PieceCode;
     targetSquare: Square | null;
 }
+export type DragSessionCoreOwnedSnapshot = ReadonlyDeep<DragSessionCoreOwned>;
+export type DragSession = DragSessionCoreOwned | DragSessionExtensionOwned;
 export type DragSessionSnapshot = ReadonlyDeep<DragSession>;
 export interface MoveDestination extends Omit<MoveRequest, 'from' | 'promotedTo'> {
     promotedTo?: RolePromotionCode[];

package/dist/state/types.d.ts

@@ -1,6 +1,6 @@
 import { PositionInput } from './board/types/input.js';
 import { BoardState, BoardStateSnapshot } from './board/types/main.js';
-import type { ChangeState, ChangeStateSnapshot } from './change/types.js';
+import type { ChangeState, ChangeStateSnapshot } from './change/types/main.js';
 import { InteractionState, InteractionStateInitOptions, InteractionStateSnapshot } from './interaction/types/main.js';
 import { ViewStateSnapshot } from './view/types/internal.js';
 import { ViewState, ViewStateInitOptions } from './view/types/main.js';