@mirasen/chessboard 0.1.0 → 1.0.0-rc.0

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

@@ -1,5 +1,3 @@
-import { ScenePoint } from '../../../extensions/types/basic/transient-visuals';
-import { RenderGeometry } from '../../../layout/geometry/types';
-import { Square } from '../../../state/board/types/internal';
-export declare function mapBoardPointToSquare(x: number, y: number, geometry: RenderGeometry): Square | null;
-export declare function clampBoardPoint(point: ScenePoint, geometry: RenderGeometry): ScenePoint;
+import { ScenePointerEvent } from '../../../extensions/types/basic/events.js';
+import { InputAdapterInternal } from './types.js';
+export declare function makeScenePointerEvent(state: InputAdapterInternal, e: PointerEvent): ScenePointerEvent;

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

@@ -1,12 +1,67 @@
-export function mapBoardPointToSquare(x, y, geometry) {
+export function makeScenePointerEvent(state, e) {
+    const containerRect = state.container.getBoundingClientRect();
+    const sceneRect = makeSceneRectFromDOMRect(containerRect);
+    const point = toScenePoint(e, containerRect);
+    const clampedPoint = clampToSceneRect(point, sceneRect);
+    let clampedToBoardPoint = null;
+    let targetSquare = null;
+    const geometry = state.getRenderGeometry();
+    if (geometry) {
+        const sceneBoardRect = geometry.boardRect;
+        clampedToBoardPoint = clampToSceneRect(point, sceneBoardRect);
+        targetSquare = mapScenePointToSquare(point, geometry);
+    }
+    return {
+        // DOM part
+        type: e.type,
+        // scene part
+        point,
+        clampedPoint,
+        boardClampedPoint: clampedToBoardPoint,
+        // board part
+        targetSquare
+    };
+}
+function toScenePoint(e, inRect) {
+    return {
+        x: e.clientX - inRect.x,
+        y: e.clientY - inRect.y
+    };
+}
+function makeSceneRectFromDOMRect(domRect) {
+    return {
+        x: 0,
+        y: 0,
+        width: domRect.width,
+        height: domRect.height
+    };
+}
+function clampToSceneRect(point, boundRect) {
+    // X cannot go below boundRect.x, cannot go above boundRect.x + boundRect.width
+    // Y cannot go below boundRect.y, cannot go above boundRect.y + boundRect.height
+    return {
+        x: Math.max(boundRect.x, Math.min(point.x, boundRect.x + boundRect.width)),
+        y: Math.max(boundRect.y, Math.min(point.y, boundRect.y + boundRect.height))
+    };
+}
+function mapScenePointToSquare(point, geometry) {
+    const { x, y } = point;
     if (!Number.isFinite(x) || !Number.isFinite(y))
         return null;
-    const { boardSize, squareSize, orientation } = geometry;
-    if (x < 0 || x >= boardSize || y < 0 || y >= boardSize)
+    const orientation = geometry.orientation;
+    const boardRect = geometry.boardRect;
+    const boardSize = boardRect.width;
+    const squareSize = geometry.squareSize;
+    if (x < boardRect.x ||
+        x >= boardRect.x + boardSize ||
+        y < boardRect.y ||
+        y >= boardRect.y + boardSize)
         return null;
     // Grid cell indices, each in [0, 7].
-    const xIndex = Math.floor(x / squareSize);
-    const yIndex = Math.floor(y / squareSize);
+    const xIndex = Math.floor((x - boardRect.x) / squareSize);
+    const yIndex = Math.floor((y - boardRect.y) / squareSize);
+    if (xIndex < 0 || xIndex > 7 || yIndex < 0 || yIndex > 7)
+        return null;
     // Invert the orientation mapping used by geometry.squareRect:
     //   white: xIndex = file,     yIndex = 7 - rank  →  file = xIndex,     rank = 7 - yIndex
     //   black: xIndex = 7 - file, yIndex = rank       →  file = 7 - xIndex, rank = yIndex
@@ -14,10 +69,3 @@ export function mapBoardPointToSquare(x, y, geometry) {
     const rank = orientation === 0 /* ColorCode.White */ ? 7 - yIndex : yIndex;
     return (rank * 8 + file);
 }
-export function clampBoardPoint(point, geometry) {
-    const { boardSize } = geometry;
-    return {
-        x: Math.min(Math.max(point.x, 0), boardSize),
-        y: Math.min(Math.max(point.y, 0), boardSize)
-    };
-}

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

@@ -1,13 +1,9 @@
-import { ScenePointerEventType } from '../../../extensions/types/basic/events';
-import { InputAdapterInternal } from './types';
-export type PointerRelevantEvent = PointerEvent & {
-    type: ScenePointerEventType;
-};
-export declare function isPointerRelevantEvent(e: PointerEvent): e is PointerRelevantEvent;
+import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
+import { InputAdapterInternal } from './types.js';
+export declare function pointerEventHandler(state: InputAdapterInternal, e: PointerEvent): ExtensionOnEventContext;
 /** Release capture for the currently tracked pointer and clear tracking state. */
 export declare function releaseCapture(state: InputAdapterInternal): void;
-export declare function onPointerDown(state: InputAdapterInternal, e: PointerRelevantEvent): void;
-export declare function onPointerMove(state: InputAdapterInternal, e: PointerRelevantEvent): void;
-export declare function onPointerUp(state: InputAdapterInternal, e: PointerRelevantEvent): void;
-export declare function onPointerCancel(state: InputAdapterInternal, e: PointerRelevantEvent): void;
-export declare function onPointerLeave(state: InputAdapterInternal, e: PointerRelevantEvent): void;
+export declare function adapterOnPointerDown(state: InputAdapterInternal, e: PointerEvent): void;
+export declare function adapterOnPointerUp(state: InputAdapterInternal, e: PointerEvent): void;
+export declare function adapterOnPointerCancel(state: InputAdapterInternal, e: PointerEvent): void;
+export declare function pointerEventDestroy(state: InputAdapterInternal): void;

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

@@ -1,9 +1,30 @@
 import assert from '@ktarmyshov/assert';
-import { SCENE_POINTER_EVENT_TYPES } from '../../../extensions/types/basic/events';
-import { clampBoardPoint, mapBoardPointToSquare } from './helpers';
-const validPointerEventTypes = new Set(SCENE_POINTER_EVENT_TYPES);
-export function isPointerRelevantEvent(e) {
-    return e instanceof PointerEvent && validPointerEventTypes.has(e.type);
+import { ALL_SCENE_POINTER_EVENT_TYPES } from '../../../extensions/types/basic/events.js';
+import { makeScenePointerEvent } from './helpers.js';
+export function pointerEventHandler(state, e) {
+    assert(ALL_SCENE_POINTER_EVENT_TYPES.has(e.type), `Unexpected pointer event type: ${e.type}`);
+    // First convert to scene event for controller
+    const sceneEvent = makeScenePointerEvent(state, e);
+    // Then handle pointer event within the adapter logic (e.g. tracking active pointer, capturing, etc.)
+    pointerEventAdapterHandler(state, e);
+    // Then create context and pass to controller for extension handling
+    return {
+        rawEvent: e,
+        sceneEvent
+    };
+}
+function pointerEventAdapterHandler(state, e) {
+    switch (e.type) {
+        case 'pointerdown':
+            adapterOnPointerDown(state, e);
+            break;
+        case 'pointerup':
+            adapterOnPointerUp(state, e);
+            break;
+        case 'pointercancel':
+            adapterOnPointerCancel(state, e);
+            break;
+    }
 }
 /** Release capture for the currently tracked pointer and clear tracking state. */
 export function releaseCapture(state) {
@@ -14,84 +35,30 @@ export function releaseCapture(state) {
     }
     state.activePointerId = null;
 }
-function resolvePointerTarget(state, e) {
-    const geometry = state.getGeometry();
-    if (!geometry)
-        return { target: null, rawPoint: null, clampedPoint: null };
-    const rect = state.container.getBoundingClientRect();
-    const x = e.clientX - rect.left;
-    const y = e.clientY - rect.top;
-    const target = mapBoardPointToSquare(x, y, geometry);
-    const point = { x, y };
-    return { target, rawPoint: point, clampedPoint: clampBoardPoint(point, geometry) };
-}
-function makeBoardPointerEvent(e, pointerTarget) {
-    assert(e.defaultPrevented === false, 'Expected event to be unhandled before making BoardPointerEvent');
-    let defaultPrevented = false;
-    return {
-        type: e.type,
-        // DOM part
-        pointerId: e.pointerId,
-        isPrimary: e.isPrimary,
-        button: e.button,
-        buttons: e.buttons,
-        ctrlKey: e.ctrlKey,
-        altKey: e.altKey,
-        shiftKey: e.shiftKey,
-        metaKey: e.metaKey,
-        // Board part
-        rawPoint: pointerTarget.rawPoint,
-        clampedPoint: pointerTarget.clampedPoint,
-        target: pointerTarget.target,
-        // Mechanics
-        get defaultPrevented() {
-            return defaultPrevented;
-        },
-        preventDefault() {
-            defaultPrevented = true;
-        }
-    };
-}
-export function onPointerDown(state, e) {
+export function adapterOnPointerDown(state, e) {
+    assert(e.type === 'pointerdown', `Expected pointerdown event, got ${e.type}`);
     if (!e.isPrimary)
         return; // ignore non-primary pointers
     if (state.activePointerId !== null)
         return; // already tracking
     state.activePointerId = e.pointerId;
     state.container.setPointerCapture(e.pointerId);
-    const pointerTarget = resolvePointerTarget(state, e);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    e.preventDefault(); // prevent native text selection during drag
-    state.controller.onEvent(boardEvent);
 }
-export function onPointerMove(state, e) {
+export function adapterOnPointerUp(state, e) {
+    assert(e.type === 'pointerup', `Expected pointerup event, got ${e.type}`);
     if (e.pointerId !== state.activePointerId)
         return;
-    const pointerTarget = resolvePointerTarget(state, e);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    e.preventDefault(); // prevent native text selection during drag
-    state.controller.onEvent(boardEvent);
-}
-export function onPointerUp(state, e) {
-    if (e.pointerId !== state.activePointerId)
-        return;
-    const pointerTarget = resolvePointerTarget(state, e); // resolve before releasing capture
     releaseCapture(state);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    state.controller.onEvent(boardEvent);
 }
-export function onPointerCancel(state, e) {
+export function adapterOnPointerCancel(state, e) {
+    assert(e.type === 'pointercancel', `Expected pointercancel event, got ${e.type}`);
     if (e.pointerId !== state.activePointerId)
         return;
-    const pointerTarget = resolvePointerTarget(state, e); // resolve before releasing capture
     releaseCapture(state);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    state.controller.onEvent(boardEvent);
 }
-export function onPointerLeave(state, e) {
-    if (e.pointerId !== state.activePointerId)
-        return;
-    const pointerTarget = resolvePointerTarget(state, e);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    state.controller.onEvent(boardEvent);
+export function pointerEventDestroy(state) {
+    if (state.activePointerId !== null) {
+        releaseCapture(state);
+    }
+    state.activePointerId = null;
 }

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

@@ -1,16 +1,19 @@
-import { RenderGeometry } from '../../../layout/geometry/types';
-import { InteractionController } from '../controller/types';
+import { SceneRenderGeometry } from '../../../layout/geometry/types.js';
+import { InteractionController } from '../controller/types.js';
 export interface InputAdapterInitOptions {
     container: HTMLElement;
-    getGeometry: () => RenderGeometry | null;
+    getRenderGeometry: () => SceneRenderGeometry | null;
     controller: InteractionController;
 }
 export interface InputAdapterInternal {
     readonly container: HTMLElement;
-    readonly getGeometry: () => RenderGeometry | null;
+    readonly getRenderGeometry: () => SceneRenderGeometry | null;
     readonly controller: InteractionController;
     activePointerId: number | null;
 }
 export interface InputAdapter {
+    subscribeEvent<K extends keyof HTMLElementEventMap>(type: K): void;
+    unsubscribeEvent<K extends keyof HTMLElementEventMap>(type: K): void;
     destroy(): void;
 }
+export declare const NEED_EVENT_TYPES: Set<string>;

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

@@ -1 +1,6 @@
-export {};
+export const NEED_EVENT_TYPES = new Set([
+    'pointerdown',
+    'pointermove',
+    'pointerup',
+    'pointercancel'
+]);

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

@@ -1,2 +1,2 @@
-import { InteractionController, InteractionControllerInitOptions } from './types';
+import { InteractionController, InteractionControllerInitOptions } from './types.js';
 export declare function createInteractionController(options: InteractionControllerInitOptions): InteractionController;

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

@@ -1,5 +1,5 @@
-import { handlePointerCancel, handlePointerDown, handlePointerLeave, handlePointerMove, handlePointerUp } from './pointer';
-import { transmitTransientInput } from './transient-visuals';
+import { handlePointerCancel, handlePointerDown, handlePointerMove, handlePointerUp } from './pointer.js';
+import { transmitTransientInput } from './transient-visuals.js';
 function createInteractionControllerInternal(options) {
     return {
         surface: options.surface
@@ -8,25 +8,26 @@ function createInteractionControllerInternal(options) {
 export function createInteractionController(options) {
     const internalState = createInteractionControllerInternal(options);
     return {
-        onEvent(event) {
-            switch (event.type) {
+        onEvent(context) {
+            internalState.surface.onEvent(context);
+            if (context.rawEvent.defaultPrevented) {
+                return; // The event has been handled by the surface (extensions)
+            }
+            switch (context.rawEvent.type) {
                 case 'pointerdown':
-                    handlePointerDown(internalState, event);
+                    handlePointerDown(internalState, context);
                     break;
                 case 'pointermove':
-                    handlePointerMove(internalState, event);
+                    handlePointerMove(internalState, context);
                     break;
                 case 'pointerup':
-                    handlePointerUp(internalState, event);
+                    handlePointerUp(internalState, context);
                     break;
                 case 'pointercancel':
-                    handlePointerCancel(internalState, event);
-                    break;
-                case 'pointerleave':
-                    handlePointerLeave(internalState, event);
+                    handlePointerCancel(internalState, context);
                     break;
             }
-            transmitTransientInput(internalState, event);
+            transmitTransientInput(internalState, context);
         }
     };
 }

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

@@ -1,3 +1,3 @@
-import type { Square } from '../../../state/board/types/internal';
-import { InteractionStateSnapshot } from '../../../state/interaction/types/main';
+import type { Square } from '../../../state/board/types/internal.js';
+import { InteractionStateSnapshot } from '../../../state/interaction/types/main.js';
 export declare function canMoveTo(snapshot: InteractionStateSnapshot, target: Square): boolean;

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

@@ -1,7 +1,6 @@
-import { ScenePointerEvent } from '../../../extensions/types/basic/events';
-import { InteractionControllerInternal } from './types';
-export declare function handlePointerDown(state: InteractionControllerInternal, event: ScenePointerEvent): void;
-export declare function handlePointerMove(state: InteractionControllerInternal, event: ScenePointerEvent): void;
-export declare function handlePointerUp(state: InteractionControllerInternal, event: ScenePointerEvent): void;
-export declare function handlePointerCancel(state: InteractionControllerInternal, event: ScenePointerEvent): void;
-export declare function handlePointerLeave(state: InteractionControllerInternal, event: ScenePointerEvent): void;
+import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
+import { InteractionControllerInternal } from './types.js';
+export declare function handlePointerDown(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;
+export declare function handlePointerMove(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;
+export declare function handlePointerUp(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;
+export declare function handlePointerCancel(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;

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

@@ -1,38 +1,42 @@
 import assert from '@ktarmyshov/assert';
-import { isEmptyPieceCode, isNonEmptyPieceCode } from '../../../state/board/check';
-import { fromPieceCode } from '../../../state/board/piece';
-import { canMoveTo } from './helpers';
-export function handlePointerDown(state, event) {
-    assert(event.type === 'pointerdown', 'handlePointerDown should only be called for pointerdown events');
-    if (event.button !== 0) {
+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, 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';
-import { InteractionControllerInternal } from './types';
-export declare function transmitTransientInput(state: InteractionControllerInternal, event: SceneEvent): void;
+import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
+import { InteractionControllerInternal } from './types.js';
+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';
-import { TransientInput } from '../../../extensions/types/basic/transient-visuals';
-import { PieceCode, Square } from '../../../state/board/types/internal';
-import { InteractionStateSnapshot } from '../../../state/interaction/types/main';
+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/layout.d.ts

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

package/dist/runtime/layout.js

@@ -1,5 +1,5 @@
-import { runtimeValidateIsMounted } from './lifecycle';
-import { runtimeRunMutationPipeline } from './mutation/run';
+import { runtimeValidateIsMounted } from './lifecycle.js';
+import { runtimeRunMutationPipeline } from './mutation/run.js';
 export function runtimeRefreshGeometry(state) {
     runtimeValidateIsMounted(state);
     state.layout.refreshGeometry({

package/dist/runtime/lifecycle.d.ts

@@ -1,5 +1,5 @@
-import { RenderSystem } from '../render/types';
-import { RuntimeInternal } from './types/main';
+import { RenderSystem } from '../render/types.js';
+import { RuntimeInternal } from './types/main.js';
 export declare function runtimeIsMounted(state: RuntimeInternal): boolean;
 export declare function runtimeValidateIsMounted(state: RuntimeInternal): asserts state is RuntimeInternal & {
     readonly renderSystem: RuntimeInternal['renderSystem'] & {

package/dist/runtime/lifecycle.js

@@ -1,6 +1,6 @@
 import assert from '@ktarmyshov/assert';
-import { createInputAdapter } from './input/adapter/factory';
-import { runtimeRefreshGeometry } from './layout';
+import { createInputAdapter } from './input/adapter/factory.js';
+import { runtimeRefreshGeometry } from './layout.js';
 export function runtimeIsMounted(state) {
     return state.renderSystem.isMounted;
 }
@@ -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/extension-update.d.ts

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

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

@@ -1,2 +1,2 @@
-import { RuntimeMutationPipeline } from './pipeline';
+import { RuntimeMutationPipeline } from './pipeline.js';
 export declare function createRuntimeMutationPipeline(): RuntimeMutationPipeline;