@mirasen/chessboard 0.1.1 → 1.0.0-rc.0

package/dist/extensions/first-party/main-renderer/pieces/render.js

@@ -14,13 +14,13 @@ export function rendererPiecesRender(state, context, layer) {
         const suppressed = state.suppressedSquares.has(sq);
         if (isNonEmptyPieceCode(pieceCode) && !suppressed) {
             const url = state.config[pieceCode];
-            const r = geometry.squareRect(sq);
+            const r = geometry.getSquareRect(sq);
             if (existing !== null) {
                 updateElementAttributes(existing.root, {
                     x: r.x.toString(),
                     y: r.y.toString(),
-                    width: r.size.toString(),
-                    height: r.size.toString(),
+                    width: r.width.toString(),
+                    height: r.height.toString(),
                     href: url
                 });
             }
@@ -31,8 +31,8 @@ export function rendererPiecesRender(state, context, layer) {
                         href: url,
                         x: r.x.toString(),
                         y: r.y.toString(),
-                        width: r.size.toString(),
-                        height: r.size.toString()
+                        width: r.width.toString(),
+                        height: r.height.toString()
                     })
                 });
             }

package/dist/extensions/first-party/main-renderer/pieces/suppress.js

@@ -1,9 +1,14 @@
 export function calculateSuppressedSquares(_state, context, animationSuppressedSquares) {
     const dragSession = context.currentFrame.state.interaction.dragSession;
-    const dragSquare = dragSession?.type === 'lifted-piece-drag' ? dragSession.sourceSquare : undefined;
+    const dragSquare = dragSession?.type === 'lifted-piece-drag' ? dragSession.sourceSquare : null;
     const result = new Set(animationSuppressedSquares);
-    if (dragSquare !== undefined) {
+    if (dragSquare !== null) {
         result.add(dragSquare);
     }
+    const pendingMoveRequest = context.currentFrame.state.change.deferredUIMoveRequest;
+    if (pendingMoveRequest) {
+        result.add(pendingMoveRequest.sourceSquare);
+        result.add(pendingMoveRequest.destination.to);
+    }
     return result;
 }

package/dist/extensions/first-party/main-renderer/types/extension.d.ts

@@ -3,7 +3,7 @@ import { MainRendererConfigInput } from './input.js';
 export type MainRendererInitOptions = Partial<MainRendererConfigInput>;
 export declare const EXTENSION_SLOTS: readonly ["board", "coordinates", "pieces", "animation", "drag"];
 export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
-export declare const EXTENSION_ID: "main-renderer";
+export declare const EXTENSION_ID: "renderer";
 export type MainRendererDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
 export type MainRendererInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
 export declare enum DirtyLayer {

package/dist/extensions/first-party/main-renderer/types/extension.js

@@ -1,5 +1,5 @@
 export const EXTENSION_SLOTS = ['board', 'coordinates', 'pieces', 'animation', 'drag'];
-export const EXTENSION_ID = 'main-renderer';
+export const EXTENSION_ID = 'renderer';
 export var DirtyLayer;
 (function (DirtyLayer) {
     DirtyLayer[DirtyLayer["Board"] = 1] = "Board";

package/dist/extensions/first-party/promotion/factory.d.ts

@@ -0,0 +1,3 @@
+import { PromotionInitConfig } from './types/input.js';
+import { PromotionDefinition } from './types/main.js';
+export declare function createPromotion(config?: PromotionInitConfig): PromotionDefinition;

package/dist/extensions/first-party/promotion/factory.js

@@ -0,0 +1,219 @@
+import assert from '@ktarmyshov/assert';
+import { createSvgElement, updateElementAttributes } from '../../../render/svg/helpers.js';
+import { fileOf, rankOf, squareOf } from '../../../state/board/coords.js';
+import { toPieceCode } from '../../../state/board/piece.js';
+import { isUpdateContextRenderable } from '../../types/context/update.js';
+import { extensionCreateInternalBase, extensionDestroy, extensionMount, extensionUnmount } from '../common/helpers.js';
+import { normalizePromotionConfig } from './normalize.js';
+import { EXTENSION_ID, EXTENSION_SLOTS } from './types/main.js';
+export function createPromotion(config = {}) {
+    const mergedConfig = normalizePromotionConfig(config);
+    return {
+        id: EXTENSION_ID,
+        slots: EXTENSION_SLOTS,
+        createInstance(options) {
+            return createPromotionInstance(options, mergedConfig);
+        }
+    };
+}
+function createPromotionInternal(options, config) {
+    return {
+        ...extensionCreateInternalBase(),
+        svgPromotionPieces: new Map(),
+        activePromotionSquares: new Map(),
+        svgHoverRect: null,
+        config,
+        runtimeSurface: options.runtimeSurface
+    };
+}
+function extensionCleanPieceNode(state, roleCode) {
+    const pieceNode = state.svgPromotionPieces.get(roleCode);
+    if (pieceNode) {
+        pieceNode.svg.remove();
+        pieceNode.rect.remove();
+        state.svgPromotionPieces.delete(roleCode);
+    }
+}
+function extensionCleanPieceNodes(state) {
+    for (const pieceNode of state.svgPromotionPieces.values()) {
+        pieceNode.svg.remove();
+        pieceNode.rect.remove();
+    }
+    state.svgPromotionPieces.clear();
+}
+function extensionCleanHoverRect(state) {
+    if (state.svgHoverRect) {
+        state.svgHoverRect.remove();
+        state.svgHoverRect = null;
+    }
+}
+function extensionClean(state) {
+    extensionCleanPieceNodes(state);
+    extensionCleanHoverRect(state);
+    state.activePromotionSquares.clear();
+}
+function createPromotionInstance(options, config) {
+    const internalState = createPromotionInternal(options, config);
+    return {
+        id: EXTENSION_ID,
+        mount(env) {
+            extensionMount(internalState, env.slotRoots);
+        },
+        onUIMoveRequest(context) {
+            const request = context.request;
+            if (request.status !== 'unresolved')
+                return; // no-op if the request is already resolved or deferred
+            if (request.canBeAutoResolved)
+                return; // no-op, core will auto-resolve
+            // OK! now this one is our request!
+            request.defer(); // defer the request until the user selects a piece to promote to
+        },
+        onUpdate(context) {
+            const needsRender = context.mutation.hasMutation({
+                causes: ['state.change.setDeferredUIMoveRequest', 'layout.refreshGeometry']
+            }) && isUpdateContextRenderable(context);
+            if (!needsRender) {
+                return; // no-op
+            }
+            const request = context.currentFrame.state.change.deferredUIMoveRequest;
+            if (request !== null) {
+                internalState.runtimeSurface.transientVisuals.subscribe();
+                internalState.runtimeSurface.events.subscribeEvent('pointerdown');
+            }
+            else {
+                internalState.runtimeSurface.transientVisuals.unsubscribe();
+                internalState.runtimeSurface.events.unsubscribeEvent('pointerdown');
+            }
+            context.invalidation.markDirty(1 /* DirtyLayer.Promotion */);
+        },
+        render(context) {
+            assert(context.invalidation.dirtyLayers !== 0, 'Render should only be called when there are dirty layers');
+            const deferredRequest = context.currentFrame.state.change.deferredUIMoveRequest;
+            if (deferredRequest === null) {
+                // No deferred request, so we can clean up any existing promotion piece nodes and highlights
+                extensionClean(internalState);
+                return;
+            }
+            const targetSquare = deferredRequest.destination.to;
+            const targetFile = fileOf(targetSquare);
+            const targetRank = rankOf(targetSquare);
+            const promotedTo = deferredRequest.destination.promotedTo;
+            assert(promotedTo && promotedTo.length > 1 && promotedTo.length <= 4, 'PromotedTo should be available in a deferred promotion request and have between 2 and 4 roles');
+            const promotedToSorted = promotedTo.toSorted((a, b) => b - a); // Descending order to render queen on top
+            const geometry = context.currentFrame.layout.geometry;
+            // Determine piece color from target rank
+            const isWhitePromotion = targetRank === 7;
+            const pieceColor = isWhitePromotion ? 0 /* ColorCode.White */ : 8 /* ColorCode.Black */;
+            // Direction: white pieces cascade downward (rank decreases), black upward (rank increases)
+            const rankStep = isWhitePromotion ? -1 : 1;
+            // Rebuild the active promotion squares set
+            internalState.activePromotionSquares.clear();
+            // Remove nodes for roles no longer in the desired set
+            const desiredRoles = new Set(promotedToSorted);
+            for (const [roleCode] of internalState.svgPromotionPieces) {
+                if (!desiredRoles.has(roleCode)) {
+                    extensionCleanPieceNode(internalState, roleCode);
+                }
+            }
+            // Create or update a node for each promotion role
+            assert(internalState.slotRoots, 'Slot roots should be available when render is called');
+            const layer = internalState.slotRoots.animation;
+            for (let i = 0; i < promotedToSorted.length; i++) {
+                const roleCode = promotedToSorted[i];
+                const displayRank = (targetRank + i * rankStep);
+                const displaySquare = squareOf(targetFile, displayRank);
+                const pieceCode = toPieceCode(roleCode, pieceColor);
+                const url = internalState.config.pieceUrls[pieceCode];
+                const r = geometry.getSquareRect(displaySquare);
+                const rectAttrs = {
+                    x: r.x.toString(),
+                    y: r.y.toString(),
+                    width: r.width.toString(),
+                    height: r.height.toString(),
+                    fill: internalState.config.squareColor.color,
+                    'fill-opacity': internalState.config.squareColor.opacity.toString(),
+                    'shape-rendering': 'crispEdges'
+                };
+                const imageAttrs = {
+                    href: url,
+                    x: r.x.toString(),
+                    y: r.y.toString(),
+                    width: r.width.toString(),
+                    height: r.height.toString()
+                };
+                internalState.activePromotionSquares.set(displaySquare, roleCode);
+                const existing = internalState.svgPromotionPieces.get(roleCode) ?? null;
+                if (existing !== null) {
+                    updateElementAttributes(existing.rect, rectAttrs);
+                    updateElementAttributes(existing.svg, imageAttrs);
+                }
+                else {
+                    const rect = createSvgElement(layer, 'rect', {
+                        'data-chessboard-id': `promotion-bg-${roleCode}`,
+                        ...rectAttrs
+                    });
+                    const svg = createSvgElement(layer, 'image', {
+                        'data-chessboard-id': `promotion-piece-${roleCode}`,
+                        ...imageAttrs
+                    });
+                    internalState.svgPromotionPieces.set(roleCode, { svg, rect });
+                }
+            }
+        },
+        renderTransientVisuals(context) {
+            const target = context.transientInput.target;
+            if (target !== null && internalState.activePromotionSquares.has(target)) {
+                // Hover is over one of the promotion squares
+                const geometry = context.currentFrame.layout.geometry;
+                const r = geometry.getSquareRect(target);
+                const attrs = {
+                    x: r.x.toString(),
+                    y: r.y.toString(),
+                    width: r.width.toString(),
+                    height: r.height.toString(),
+                    fill: internalState.config.hoverColor.color,
+                    'fill-opacity': internalState.config.hoverColor.opacity.toString(),
+                    'shape-rendering': 'crispEdges'
+                };
+                if (internalState.svgHoverRect) {
+                    updateElementAttributes(internalState.svgHoverRect, attrs);
+                }
+                else {
+                    assert(internalState.slotRoots, 'Slot roots should be available when renderTransientVisuals is called');
+                    const layer = internalState.slotRoots.animation;
+                    internalState.svgHoverRect = createSvgElement(layer, 'rect', {
+                        'data-chessboard-id': 'promotion-hover',
+                        ...attrs
+                    });
+                }
+            }
+            else {
+                // Not hovering over a promotion square — remove hover rect
+                extensionCleanHoverRect(internalState);
+            }
+        },
+        onEvent(context) {
+            assert(context.rawEvent.type === 'pointerdown', 'Only pointerdown events should be subscribed to');
+            const targetSquare = context.sceneEvent?.targetSquare ?? null;
+            if (targetSquare !== null) {
+                const roleCode = internalState.activePromotionSquares.get(targetSquare);
+                if (roleCode !== undefined) {
+                    context.rawEvent.preventDefault(); // Prevent focus change and other side effects if it is our promotion square
+                    internalState.runtimeSurface.commands.resolveDeferredUIMoveRequest({
+                        promotedTo: roleCode
+                    });
+                    return;
+                }
+            }
+            internalState.runtimeSurface.commands.cancelDeferredUIMoveRequest();
+        },
+        unmount() {
+            extensionUnmount(internalState);
+            extensionClean(internalState);
+        },
+        destroy() {
+            extensionDestroy(internalState);
+            extensionClean(internalState);
+        }
+    };
+}

package/dist/extensions/first-party/promotion/normalize.d.ts

@@ -0,0 +1,3 @@
+import { PromotionInitConfig } from './types/input.js';
+import { PromotionConfig } from './types/internal.js';
+export declare function normalizePromotionConfig(config: PromotionInitConfig): PromotionConfig;

package/dist/extensions/first-party/promotion/normalize.js

@@ -0,0 +1,37 @@
+import assert from '@ktarmyshov/assert';
+import { normalizePiece } from '../../../state/board/normalize.js';
+import { ALL_NON_EMPTY_PROMOTION_PIECE_CODES, DEFAULT_CONFIG } from './types/internal.js';
+function assertPieceUrlsComplete(pieceUrls) {
+    for (const pieceCode of ALL_NON_EMPTY_PROMOTION_PIECE_CODES) {
+        assert(pieceCode in pieceUrls, `Missing URL for piece code: ${pieceCode}`);
+    }
+}
+function assertPieceCodeIsPromotionPieceCode(pieceCode) {
+    assert(pieceCode === 5 /* PieceCode.WhiteQueen */ ||
+        pieceCode === 4 /* PieceCode.WhiteRook */ ||
+        pieceCode === 3 /* PieceCode.WhiteBishop */ ||
+        pieceCode === 2 /* PieceCode.WhiteKnight */ ||
+        pieceCode === 13 /* PieceCode.BlackQueen */ ||
+        pieceCode === 12 /* PieceCode.BlackRook */ ||
+        pieceCode === 11 /* PieceCode.BlackBishop */ ||
+        pieceCode === 10 /* PieceCode.BlackKnight */, `Invalid promotion piece code: ${pieceCode}`);
+}
+function normalizePromotionPieceUrls(input) {
+    const normalized = {};
+    for (const [key, url] of Object.entries(input)) {
+        const pieceCode = normalizePiece(key);
+        assertPieceCodeIsPromotionPieceCode(pieceCode);
+        normalized[pieceCode] = url;
+    }
+    assertPieceUrlsComplete(normalized);
+    return normalized;
+}
+export function normalizePromotionConfig(config) {
+    return {
+        squareColor: config.squareColor ?? DEFAULT_CONFIG.squareColor,
+        hoverColor: config.hoverColor ?? DEFAULT_CONFIG.hoverColor,
+        pieceUrls: config.pieceUrls
+            ? normalizePromotionPieceUrls(config.pieceUrls)
+            : DEFAULT_CONFIG.pieceUrls
+    };
+}

package/dist/extensions/first-party/promotion/types/input.d.ts

@@ -0,0 +1,10 @@
+import { ColorShort, RolePromotionShort } from '../../../../state/board/types/input.js';
+import { OpaqueColor } from '../../common/types.js';
+import { PieceUrlsInput } from '../../main-renderer/types/input.js';
+export type PromotionPieceString = `${ColorShort}${RolePromotionShort}`;
+export type PromotionPieceUrlsInput = Pick<PieceUrlsInput, PromotionPieceString>;
+export interface PromotionInitConfig {
+    squareColor?: OpaqueColor;
+    hoverColor?: OpaqueColor;
+    pieceUrls?: PromotionPieceUrlsInput;
+}

package/dist/extensions/first-party/promotion/types/internal.d.ts

@@ -0,0 +1,12 @@
+import { NonEmptyPieceCode, PieceCode } from '../../../../state/board/types/internal.js';
+import { OpaqueColor } from '../../common/types.js';
+export type PromotionPieceCode = Exclude<NonEmptyPieceCode, PieceCode.WhitePawn | PieceCode.BlackPawn | PieceCode.BlackKing | PieceCode.WhiteKing>;
+export type PromotionPieceUrls = Record<PromotionPieceCode, string>;
+export interface PromotionConfig {
+    squareColor: OpaqueColor;
+    hoverColor: OpaqueColor;
+    pieceUrls: PromotionPieceUrls;
+}
+export declare const PROMOTION_CHESSNUT_PIECE_URLS: PromotionPieceUrls;
+export declare const ALL_NON_EMPTY_PROMOTION_PIECE_CODES: PromotionPieceCode[];
+export declare const DEFAULT_CONFIG: PromotionConfig;

package/dist/extensions/first-party/promotion/types/internal.js

@@ -0,0 +1,22 @@
+export const PROMOTION_CHESSNUT_PIECE_URLS = {
+    [5 /* PieceCode.WhiteQueen */]: new URL('../../../../../assets/pieces/chessnut/wQ.svg', import.meta.url).toString(),
+    [4 /* PieceCode.WhiteRook */]: new URL('../../../../../assets/pieces/chessnut/wR.svg', import.meta.url).toString(),
+    [3 /* PieceCode.WhiteBishop */]: new URL('../../../../../assets/pieces/chessnut/wB.svg', import.meta.url).toString(),
+    [2 /* PieceCode.WhiteKnight */]: new URL('../../../../../assets/pieces/chessnut/wN.svg', import.meta.url).toString(),
+    [13 /* PieceCode.BlackQueen */]: new URL('../../../../../assets/pieces/chessnut/bQ.svg', import.meta.url).toString(),
+    [12 /* PieceCode.BlackRook */]: new URL('../../../../../assets/pieces/chessnut/bR.svg', import.meta.url).toString(),
+    [11 /* PieceCode.BlackBishop */]: new URL('../../../../../assets/pieces/chessnut/bB.svg', import.meta.url).toString(),
+    [10 /* PieceCode.BlackKnight */]: new URL('../../../../../assets/pieces/chessnut/bN.svg', import.meta.url).toString()
+};
+export const ALL_NON_EMPTY_PROMOTION_PIECE_CODES = Object.keys(PROMOTION_CHESSNUT_PIECE_URLS).map((code) => Number(code));
+export const DEFAULT_CONFIG = {
+    squareColor: {
+        color: 'rgba(255, 255, 255)',
+        opacity: 1
+    },
+    hoverColor: {
+        color: '#000000',
+        opacity: 0.15
+    },
+    pieceUrls: PROMOTION_CHESSNUT_PIECE_URLS
+};

package/dist/extensions/first-party/promotion/types/main.d.ts

@@ -0,0 +1,24 @@
+import { RolePromotionCode, Square } from '../../../../state/board/types/internal.js';
+import { ExtensionDefinition, ExtensionInstance } from '../../../types/extension.js';
+import { ExtensionRuntimeSurface } from '../../../types/surface/main.js';
+import { ExtensionInternal } from '../../common/types.js';
+import { PromotionConfig } from './internal.js';
+export declare const EXTENSION_SLOTS: readonly ["animation"];
+export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
+export declare const EXTENSION_ID: "promotion";
+export type PromotionDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
+export type PromotionInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
+export interface PromotionPieceNode {
+    readonly svg: SVGImageElement;
+    readonly rect: SVGRectElement;
+}
+export interface PromotionInstanceInternal extends ExtensionInternal<ExtensionSlotsType> {
+    readonly config: PromotionConfig;
+    readonly svgPromotionPieces: Map<RolePromotionCode, PromotionPieceNode>;
+    readonly activePromotionSquares: Map<Square, RolePromotionCode>;
+    svgHoverRect: SVGRectElement | null;
+    readonly runtimeSurface: ExtensionRuntimeSurface;
+}
+export declare const enum DirtyLayer {
+    Promotion = 1
+}

package/dist/extensions/first-party/promotion/types/main.js

@@ -0,0 +1,2 @@
+export const EXTENSION_SLOTS = ['animation'];
+export const EXTENSION_ID = 'promotion';

package/dist/extensions/first-party/selected-square/factory.js

@@ -55,12 +55,12 @@ function createSelectedSquareInstance(config) {
                 return;
             }
             const geometry = context.currentFrame.layout.geometry;
-            const r = geometry.squareRect(selectedSquare);
+            const r = geometry.getSquareRect(selectedSquare);
             const rectAttributes = {
                 x: r.x.toString(),
                 y: r.y.toString(),
-                width: r.size.toString(),
-                height: r.size.toString(),
+                width: r.width.toString(),
+                height: r.height.toString(),
                 fill: internalState.config.color,
                 'fill-opacity': internalState.config.opacity.toString(),
                 'shape-rendering': 'crispEdges'

package/dist/extensions/index.d.ts

@@ -5,4 +5,4 @@ export { createLegalMoves } from './first-party/legal-moves/factory.js';
 export { createMainRenderer } from './first-party/main-renderer/factory.js';
 export { createSelectedSquare } from './first-party/selected-square/factory.js';
 export type { AnyExtensionDefinition, ExtensionDefinitionId, ExtensionDefinitionPublicApi } from './types/extension.js';
-export type { BuiltInExtensionId, DefaultBuiltinChessboardExtensions } from './types/wrapper.js';
+export type { builtInExtensionFactoryMap, BuiltInExtensionId } from './types/wrapper.js';

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

@@ -1,34 +1,11 @@
 import { Square } from '../../../state/board/types/internal.js';
 import { ScenePoint } from '../basic/transient-visuals.js';
-interface SceneEventBase {
-    readonly defaultPrevented: boolean;
-    preventDefault(): void;
+export interface ScenePointerEvent {
+    readonly type: 'pointercancel' | 'pointerdown' | 'pointerenter' | 'pointerleave' | 'pointermove' | 'pointerout' | 'pointerover' | 'pointerrawupdate' | 'pointerup';
+    readonly point: ScenePoint;
+    readonly clampedPoint: ScenePoint;
+    readonly boardClampedPoint: ScenePoint | null;
+    readonly targetSquare: Square | null;
 }
-export interface ScenePointerEvent extends SceneEventBase {
-    readonly type: 'pointerdown' | 'pointermove' | 'pointerup' | 'pointercancel' | 'pointerleave';
-    readonly pointerId: number;
-    readonly isPrimary: boolean;
-    readonly button: number;
-    readonly buttons: number;
-    readonly ctrlKey: boolean;
-    readonly altKey: boolean;
-    readonly shiftKey: boolean;
-    readonly metaKey: boolean;
-    readonly rawPoint: ScenePoint | null;
-    readonly clampedPoint: ScenePoint | null;
-    readonly target: Square | null;
-}
-export type ScenePointerEventType = ScenePointerEvent['type'];
-export declare const SCENE_POINTER_EVENT_TYPES: ScenePointerEventType[];
-export interface SceneKeyboardEvent extends SceneEventBase {
-    readonly type: 'keydown' | 'keyup';
-    readonly key: string;
-    readonly repeat: boolean;
-    readonly ctrlKey: boolean;
-    readonly altKey: boolean;
-    readonly shiftKey: boolean;
-    readonly metaKey: boolean;
-}
-export type SceneEvent = ScenePointerEvent | SceneKeyboardEvent;
-export type SceneEventType = SceneEvent['type'];
-export {};
+export declare const ALL_SCENE_POINTER_EVENT_TYPES: ReadonlySet<string>;
+export type SceneEvent = ScenePointerEvent;

package/dist/extensions/types/basic/events.js

@@ -1,7 +1,11 @@
-export const SCENE_POINTER_EVENT_TYPES = [
+export const ALL_SCENE_POINTER_EVENT_TYPES = new Set([
+    'pointercancel',
     'pointerdown',
+    'pointerenter',
+    'pointerleave',
     'pointermove',
-    'pointerup',
-    'pointercancel',
-    'pointerleave'
-];
+    'pointerout',
+    'pointerover',
+    'pointerrawupdate',
+    'pointerup'
+]);

package/dist/extensions/types/basic/interaction.d.ts

@@ -0,0 +1,21 @@
+import { ReadonlyDeep } from 'type-fest';
+import type { PieceCode, Square } from '../../../state/board/types/internal.js';
+export interface ExtensionDragSessionBase {
+    sourceSquare: Square | null;
+    sourcePieceCode: PieceCode | null;
+    targetSquare: Square | null;
+}
+export interface ExtensionDragSessionLiftedPiece extends ExtensionDragSessionBase {
+    type: 'lifted-piece-drag';
+    sourcePieceCode: PieceCode;
+}
+export interface ExtensionDragSessionReleaseTargeting extends ExtensionDragSessionBase {
+    type: 'release-targeting';
+}
+type ExtensionCustomDragSessionType = `ext:${string}`;
+export interface ExtensionDragSessionCustom extends ExtensionDragSessionBase {
+    type: ExtensionCustomDragSessionType;
+}
+export type ExtensionDragSession = ExtensionDragSessionLiftedPiece | ExtensionDragSessionReleaseTargeting | ExtensionDragSessionCustom;
+export type ExtensionDragSessionSnapshot = ReadonlyDeep<ExtensionDragSession>;
+export {};

package/dist/extensions/types/basic/transient-visuals.d.ts

@@ -5,6 +5,7 @@ export interface ScenePoint {
 }
 export interface TransientInput {
     target: Square | null;
-    rawPoint: ScenePoint;
+    point: ScenePoint;
     clampedPoint: ScenePoint;
+    boardClampedPoint: ScenePoint;
 }

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

@@ -0,0 +1,5 @@
+import { SceneEvent } from '../basic/events.js';
+export interface ExtensionOnEventContext {
+    rawEvent: Event;
+    sceneEvent: SceneEvent | null;
+}

package/dist/extensions/types/context/events.js

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

package/dist/extensions/types/context/ui-move.d.ts

@@ -1,16 +1,4 @@
-import { MoveRequest, Square } from '../../../state/board/types/internal.js';
-import { MoveDestinationSnapshot } from '../../../state/interaction/types/internal.js';
-export type ExtensionUIMoveRequestStatus = 'unresolved' | 'deferred' | 'resolved';
-export interface ExtensionUIMoveRequestContextSnapshot {
-    readonly status: ExtensionUIMoveRequestStatus;
-    readonly sourceSquare: Square;
-    readonly destination: MoveDestinationSnapshot;
-    readonly canBeAutoResolved: boolean;
-    readonly resolvedMoveRequest: MoveRequest | null;
-}
-export interface ExtensionUIMoveRequestContext extends ExtensionUIMoveRequestContextSnapshot {
-    defer(): void;
-    resolve(request: MoveRequest): void;
-    autoresolve(): void;
-    getSnapshot(): ExtensionUIMoveRequestContextSnapshot;
+import { PendingUIMoveRequest } from '../../../state/change/types/ui-move.js';
+export interface ExtensionPendingUIMoveRequestContext {
+    readonly request: PendingUIMoveRequest;
 }

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

@@ -1,25 +1,27 @@
-import { SceneEvent } from './basic/events.js';
+import { ExtensionDragSessionSnapshot } from './basic/interaction.js';
 import { ExtensionInstanceMountOptions, ExtensionSlotName } from './basic/mount.js';
 import { ExtensionAnimationFinishedContext, ExtensionCleanAnimationContext, ExtensionPrepareAnimationContext, ExtensionRenderAnimationContext } from './context/animation.js';
+import { ExtensionOnEventContext } from './context/events.js';
 import { ExtensionRenderContext } from './context/render.js';
 import { ExtensionRenderTransientVisualsContext } from './context/transient-visuals.js';
-import { ExtensionUIMoveRequestContext } from './context/ui-move.js';
+import { ExtensionPendingUIMoveRequestContext } from './context/ui-move.js';
 import { ExtensionUpdateContext } from './context/update.js';
 import { ExtensionRuntimeSurface } from './surface/main.js';
 interface ExtensionInstanceBase<TId extends string, TSlots extends readonly ExtensionSlotName[]> {
     readonly id: TId;
-    mount(env: ExtensionInstanceMountOptions<TSlots>): void;
-    unmount(): void;
-    destroy(): void;
-    onUpdate(context: ExtensionUpdateContext): void;
-    onUIMoveRequest?(context: ExtensionUIMoveRequestContext): void;
+    mount?(env: ExtensionInstanceMountOptions<TSlots>): void;
+    unmount?(): void;
+    destroy?(): void;
+    onUpdate?(context: ExtensionUpdateContext): void;
     render?(context: ExtensionRenderContext): void;
     prepareAnimation?(context: ExtensionPrepareAnimationContext): void;
     renderAnimation?(context: ExtensionRenderAnimationContext): void;
     onAnimationFinished?(context: ExtensionAnimationFinishedContext): void;
     cleanAnimation?(context: ExtensionCleanAnimationContext): void;
+    completeDrag?(session: ExtensionDragSessionSnapshot): void;
     renderTransientVisuals?(context: ExtensionRenderTransientVisualsContext): void;
-    onEvent?(event: SceneEvent): void;
+    onUIMoveRequest?(context: ExtensionPendingUIMoveRequestContext): void;
+    onEvent?(context: ExtensionOnEventContext): void;
 }
 type ExtensionInstancePublicPart<TPublic> = [TPublic] extends [never] ? Record<never, never> : {
     getPublic(): TPublic;

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

@@ -1,11 +1,13 @@
 import { RuntimeReadonlyMutationSession } from '../../runtime/mutation/types.js';
+import { DragSessionExtensionOwned } from '../../state/interaction/types/internal.js';
 import { ExtensionInvalidationState } from '../invalidation/types.js';
 import { ExtensionAnimationControllerInternalSurface } from './basic/animation.js';
-import { SceneEventType } from './basic/events.js';
 import { UpdateFrameSnapshot } from './basic/update.js';
-import { ExtensionUIMoveRequestContext } from './context/ui-move.js';
+import { ExtensionOnEventContext } from './context/events.js';
+import { ExtensionPendingUIMoveRequestContext } from './context/ui-move.js';
 import { AnyExtensionDefinition, AnyExtensionInstance } from './extension.js';
-import { ExtensionRuntimeSurfaceCommands } from './surface/commands.js';
+import { ExtensionRuntimeSurfaceCommandsInternalSurface } from './surface/commands.js';
+import { ExtensionRuntimeSurfaceEvents } from './surface/events.js';
 export interface ExtensionSystemExtensionRecord {
     readonly id: string;
     readonly definition: AnyExtensionDefinition;
@@ -14,13 +16,14 @@ export interface ExtensionSystemExtensionRecord {
     readonly animation: ExtensionAnimationControllerInternalSurface;
 }
 export interface ExtensionSystemInitOptions {
-    extensionRuntimeSurfaceCommands: ExtensionRuntimeSurfaceCommands;
+    extensionRuntimeSurfaceCommands: ExtensionRuntimeSurfaceCommandsInternalSurface;
+    extensionRuntimeSurfaceEvents: ExtensionRuntimeSurfaceEvents;
     extensions?: readonly AnyExtensionDefinition[];
 }
 export interface ExtensionSystemInternal {
     readonly extensions: Map<string, ExtensionSystemExtensionRecord>;
     readonly transientVisualsSubscribers: Set<string>;
-    readonly eventSubscribers: Map<string, Set<SceneEventType>>;
+    readonly eventSubscribers: Map<string, Set<string>>;
     currentFrame: UpdateFrameSnapshot | null;
 }
 export interface ExtensionSystemUpdateRequest {
@@ -37,7 +40,9 @@ export interface ExtensionSystem {
     getPublicRecord(): Readonly<Record<string, unknown>>;
     getSharedDataForRenderSystem(): ExtensionSystemSharedDataForRenderSystem;
     onUpdate(request: ExtensionSystemUpdateRequest): void;
-    onUIMoveRequest(context: ExtensionUIMoveRequestContext): void;
+    onUIMoveRequest(context: ExtensionPendingUIMoveRequestContext): void;
+    onEvent(context: ExtensionOnEventContext): void;
+    completeDrag(session: DragSessionExtensionOwned): void;
     onUnmount(): void;
     onDestroy(): void;
 }