@mirasen/chessboard 0.1.1 → 1.0.0-rc.0

package/dist/animation/render/move.js

@@ -1,6 +1,6 @@
 import { createSvgElement, updateElementAttributes } from '../../render/svg/helpers.js';
 export function prepareMoveTrack(track, geometry, pieceUrls, layer) {
-    const r = geometry.squareRect(track.fromSq);
+    const r = geometry.getSquareRect(track.fromSq);
     const url = pieceUrls[track.pieceCode];
     const root = createSvgElement(layer, 'image', {
         'data-chessboard-id': `animation-move-${track.id}`,
@@ -8,14 +8,14 @@ export function prepareMoveTrack(track, geometry, pieceUrls, 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()
     });
     return { ...track, root };
 }
 export function renderMoveTrack(node, geometry, progress) {
-    const from = geometry.squareRect(node.fromSq);
-    const to = geometry.squareRect(node.toSq);
+    const from = geometry.getSquareRect(node.fromSq);
+    const to = geometry.getSquareRect(node.toSq);
     const x = from.x + (to.x - from.x) * progress;
     const y = from.y + (to.y - from.y) * progress;
     updateElementAttributes(node.root, {

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

@@ -1,13 +1,13 @@
 import type { PieceUrls } from '../../extensions/first-party/main-renderer/types/internal.js';
-import type { RenderGeometry } from '../../layout/geometry/types.js';
+import type { SceneRenderGeometry } from '../../layout/geometry/types.js';
 import type { AnimationPlan } from '../types.js';
 import type { PreparedNodeMap } from './types.js';
 /**
  * Prepare all tracks in the plan — creates SVG nodes in `layer` for each track.
  * Returns a map keyed by track id for use in render/clean passes.
  */
-export declare function prepareAnimationPlan(plan: AnimationPlan, geometry: RenderGeometry, pieceUrls: PieceUrls, layer: SVGElement): PreparedNodeMap;
-export declare function renderAnimationPlan(nodes: PreparedNodeMap, geometry: RenderGeometry, progress: number): void;
+export declare function prepareAnimationPlan(plan: AnimationPlan, geometry: SceneRenderGeometry, pieceUrls: PieceUrls, layer: SVGElement): PreparedNodeMap;
+export declare function renderAnimationPlan(nodes: PreparedNodeMap, geometry: SceneRenderGeometry, progress: number): void;
 /**
  * Clean up all track nodes — removes SVG elements from the DOM.
  */

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

@@ -1,7 +1,7 @@
 import type { PieceUrls } from '../../extensions/first-party/main-renderer/types/internal.js';
-import type { RenderGeometry } from '../../layout/geometry/types.js';
+import type { SceneRenderGeometry } from '../../layout/geometry/types.js';
 import type { AnimationTrackStatic } from '../types.js';
 import type { PreparedStaticNode } from './types.js';
-export declare function prepareStaticTrack(track: AnimationTrackStatic, geometry: RenderGeometry, pieceUrls: PieceUrls, layer: SVGElement): PreparedStaticNode;
+export declare function prepareStaticTrack(track: AnimationTrackStatic, geometry: SceneRenderGeometry, pieceUrls: PieceUrls, layer: SVGElement): PreparedStaticNode;
 export declare function renderStaticTrack(_node: PreparedStaticNode): void;
 export declare function cleanStaticTrack(node: PreparedStaticNode): void;

package/dist/animation/render/static.js

@@ -1,6 +1,6 @@
 import { createSvgElement } from '../../render/svg/helpers.js';
 export function prepareStaticTrack(track, geometry, pieceUrls, layer) {
-    const r = geometry.squareRect(track.sq);
+    const r = geometry.getSquareRect(track.sq);
     const url = pieceUrls[track.pieceCode];
     const root = createSvgElement(layer, 'image', {
         'data-chessboard-id': `animation-static-${track.id}`,
@@ -8,8 +8,8 @@ export function prepareStaticTrack(track, geometry, pieceUrls, 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()
     });
     return { ...track, root };
 }

package/dist/animation/types.d.ts

@@ -1,5 +1,8 @@
 import { ReadonlyDeep } from 'type-fest';
 import type { NonEmptyPieceCode, Square } from '../state/board/types/internal.js';
+import { BoardStateSnapshot } from '../state/board/types/main.js';
+import { ChangeStateSnapshot } from '../state/change/types/main.js';
+import { InteractionStateSnapshot } from '../state/interaction/types/main.js';
 export interface AnimationTrackMove {
     id: number;
     pieceCode: NonEmptyPieceCode;
@@ -20,27 +23,23 @@ export interface AnimationTrackStatic {
     effect: 'static';
 }
 export type AnimationTrack = AnimationTrackMove | AnimationTrackFade | AnimationTrackStatic;
-export interface AnimationPlan {
-    sessionId: number;
-    tracks: AnimationTrack[];
-}
 export interface AnimationSession {
     id: number;
-    tracks: AnimationTrack[];
+    plan: AnimationPlan;
     startTime: number;
     duration: number;
 }
 export type AnimationSessionSnapshot = ReadonlyDeep<AnimationSession>;
-export interface AnimationTrackMoveExclude {
-    fromSq: Square;
-    toSq: Square;
+export interface AnimationPlanningSnapshot {
+    readonly board: BoardStateSnapshot;
+    readonly change: ChangeStateSnapshot;
+    readonly interaction: InteractionStateSnapshot;
 }
-export interface AnimationTrackSquareExclude {
-    sq: Square;
+export interface AnimationPlanningInput {
+    previous: AnimationPlanningSnapshot;
+    current: AnimationPlanningSnapshot;
 }
-export type AnimationTrackExclude = AnimationTrackMoveExclude | AnimationTrackSquareExclude;
-export declare function isMoveExclude(e: AnimationTrackExclude): e is AnimationTrackMoveExclude;
-export declare function isSquareExclude(e: AnimationTrackExclude): e is AnimationTrackSquareExclude;
-export interface CalculateAnimationTracksOptions {
-    exclude?: AnimationTrackExclude[];
+export interface AnimationPlan {
+    readonly tracks: readonly AnimationTrack[];
+    readonly suppressedSquares: ReadonlySet<Square>;
 }

package/dist/animation/types.js

@@ -1,6 +1 @@
-export function isMoveExclude(e) {
-    return 'fromSq' in e && 'toSq' in e;
-}
-export function isSquareExclude(e) {
-    return 'sq' in e && !('fromSq' in e) && !('toSq' in e);
-}
+export {};

package/dist/extensions/factory/main.js

@@ -1,3 +1,4 @@
+import assert from '@ktarmyshov/assert';
 import { createExtensionAnimationController } from '../animation/factory.js';
 import { createExtensionInvalidationState } from '../invalidation/factory.js';
 import { extensionSystemUpdateState, extensionSystemUpdateUIMoveRequest } from '../update.js';
@@ -6,11 +7,14 @@ function createExtensionSystemInternal(getInternalState, options) {
     const extensions = new Map();
     const extensionsArray = options.extensions ?? [];
     for (const extensionDef of extensionsArray) {
+        if (extensionDef.id === 'core') {
+            throw new Error('Extension id "core" is reserved and cannot be used by extensions');
+        }
         if (extensions.has(extensionDef.id)) {
             throw new Error(`Duplicate extension id found: ${extensionDef.id}`);
         }
         const instance = extensionDef.createInstance({
-            runtimeSurface: createExtensionRuntimeSurface(getInternalState, options.extensionRuntimeSurfaceCommands, extensionDef)
+            runtimeSurface: createExtensionRuntimeSurface(getInternalState, options.extensionRuntimeSurfaceCommands, options.extensionRuntimeSurfaceEvents, extensionDef)
         });
         const record = {
             id: extensionDef.id,
@@ -72,6 +76,23 @@ export function createExtensionSystem(options) {
         onUIMoveRequest(context) {
             extensionSystemUpdateUIMoveRequest(internalState, context);
         },
+        onEvent(context) {
+            const subscribers = internalState.eventSubscribers.get(context.rawEvent.type);
+            if (subscribers) {
+                for (const extensionId of subscribers) {
+                    const extensionRec = internalState.extensions.get(extensionId);
+                    if (extensionRec) {
+                        extensionRec.instance.onEvent?.(context);
+                    }
+                }
+            }
+        },
+        completeDrag(session) {
+            const extensionRec = internalState.extensions.get(session.owner);
+            assert(extensionRec, `Extension record not found for completing drag session with owner ${session.owner}`);
+            assert(extensionRec.instance.completeDrag, `Extension instance does not have a completeDrag handler for completing drag session with owner ${session.owner}`);
+            extensionRec.instance.completeDrag(session);
+        },
         onUnmount() {
             internalState.transientVisualsSubscribers.clear();
             internalState.eventSubscribers.clear();
@@ -84,7 +105,7 @@ export function createExtensionSystem(options) {
         onDestroy() {
             // We assume that the onUnmout was already called by runtime, but let's still validate
             for (const extensionRec of internalState.extensions.values()) {
-                extensionRec.instance.destroy();
+                extensionRec.instance.destroy?.();
                 const onUnmountCalled = [
                     extensionRec.invalidation.dirtyLayers === 0,
                     extensionRec.animation.getAll().length === 0

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

@@ -1,5 +1,6 @@
 import type { AnyExtensionDefinition } from '../types/extension.js';
 import type { GetInternalState } from '../types/main.js';
 import type { ExtensionRuntimeSurfaceCommands } from '../types/surface/commands.js';
+import { ExtensionRuntimeSurfaceEvents } from '../types/surface/events.js';
 import type { ExtensionRuntimeSurface } from '../types/surface/main.js';
-export declare function createExtensionRuntimeSurface(getInternalState: GetInternalState, commands: ExtensionRuntimeSurfaceCommands, extensionDef: AnyExtensionDefinition): ExtensionRuntimeSurface;
+export declare function createExtensionRuntimeSurface(getInternalState: GetInternalState, commands: ExtensionRuntimeSurfaceCommands, events: ExtensionRuntimeSurfaceEvents, extensionDef: AnyExtensionDefinition): ExtensionRuntimeSurface;

package/dist/extensions/factory/runtime.js

@@ -33,11 +33,55 @@ function createExtensionRuntimeSurfaceAnimation(getInternalState, extensionDef)
         }
     };
 }
-export function createExtensionRuntimeSurface(getInternalState, commands, extensionDef) {
-    // @ts-expect-error We will implement events later, for now we just return empty object for it to satisfy the interface
+function createExtensionRuntimeSurfaceEvents(getInternalState, runtimeSurfaceEvents, extensionDef) {
     return {
-        commands,
+        subscribeEvent(type) {
+            const internalState = getInternalState();
+            const extensionRec = internalState.extensions.get(extensionDef.id);
+            assert(extensionRec, 'Extension record not found for subscribing to events');
+            assert(extensionRec.instance.onEvent, 'Extension instance does not have an onEvent handler for subscribing to events');
+            let subscribers = internalState.eventSubscribers.get(type);
+            if (!subscribers) {
+                subscribers = new Set();
+                internalState.eventSubscribers.set(type, subscribers);
+            }
+            subscribers.add(extensionDef.id);
+            runtimeSurfaceEvents.subscribeEvent(type);
+        },
+        unsubscribeEvent(type) {
+            const internalState = getInternalState();
+            const subscribers = internalState.eventSubscribers.get(type);
+            if (subscribers) {
+                subscribers.delete(extensionDef.id);
+                if (subscribers.size === 0) {
+                    internalState.eventSubscribers.delete(type);
+                    runtimeSurfaceEvents.unsubscribeEvent(type);
+                }
+            }
+        }
+    };
+}
+function createExtensionRuntimeSurfaceCommands(getInternalState, runtimeSurfaceCommands, extensionDef) {
+    return {
+        ...runtimeSurfaceCommands,
+        startDrag(session) {
+            const internalState = getInternalState();
+            const extensionRec = internalState.extensions.get(extensionDef.id);
+            assert(extensionRec, 'Extension record not found for starting drag session');
+            assert(extensionRec.instance.completeDrag, 'Extension instance does not have a completeDrag handler for starting drag session');
+            const extSession = {
+                owner: extensionDef.id,
+                ...session
+            };
+            return runtimeSurfaceCommands.startDrag(extSession);
+        }
+    };
+}
+export function createExtensionRuntimeSurface(getInternalState, commands, events, extensionDef) {
+    return {
+        commands: createExtensionRuntimeSurfaceCommands(getInternalState, commands, extensionDef),
         animation: createExtensionRuntimeSurfaceAnimation(getInternalState, extensionDef),
-        transientVisuals: createExtensionRuntimeSurfaceTransientVisuals(getInternalState, extensionDef)
+        transientVisuals: createExtensionRuntimeSurfaceTransientVisuals(getInternalState, extensionDef),
+        events: createExtensionRuntimeSurfaceEvents(getInternalState, events, extensionDef)
     };
 }

package/dist/extensions/first-party/active-target/factory.js

@@ -60,19 +60,19 @@ function createActiveTargetInstance(config) {
                 return;
             }
             const geometry = context.currentFrame.layout.geometry;
-            const r = geometry.squareRect(square);
+            const r = geometry.getSquareRect(square);
             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.squareColor.color,
                 'fill-opacity': internalState.config.squareColor.opacity.toString(),
                 'shape-rendering': 'crispEdges'
             };
             const radius = geometry.squareSize * internalState.config.halo.radiusRatio;
-            const centerX = r.x + r.size / 2;
-            const centerY = r.y + r.size / 2;
+            const centerX = r.x + r.width / 2;
+            const centerY = r.y + r.height / 2;
             const haloAttributes = {
                 cx: centerX.toString(),
                 cy: centerY.toString(),

package/dist/extensions/first-party/auto-promote/factory.d.ts

@@ -0,0 +1,2 @@
+import { AutoPromoteDefinition } from './types.js';
+export declare function createAutoPromote(): AutoPromoteDefinition;

package/dist/extensions/first-party/auto-promote/factory.js

@@ -0,0 +1,51 @@
+import { extensionCreateInternalBase } from '../common/helpers.js';
+import { EXTENSION_ID, EXTENSION_SLOTS } from './types.js';
+export function createAutoPromote() {
+    return {
+        id: EXTENSION_ID,
+        slots: EXTENSION_SLOTS,
+        createInstance() {
+            return createAutoPromoteInstance();
+        }
+    };
+}
+function createAutoPromoteInternal() {
+    return {
+        ...extensionCreateInternalBase(),
+        toQueen: false
+    };
+}
+function createAutoPromoteInstancePublic(state) {
+    return {
+        get toQueen() {
+            return state.toQueen;
+        },
+        set toQueen(value) {
+            state.toQueen = value;
+        }
+    };
+}
+function createAutoPromoteInstance() {
+    const internalState = createAutoPromoteInternal();
+    const publicInterface = createAutoPromoteInstancePublic(internalState);
+    return {
+        id: EXTENSION_ID,
+        onUIMoveRequest(context) {
+            if (!internalState.toQueen)
+                return;
+            // Check if we can promote to queen
+            const pendingRequest = context.request;
+            const activeDestination = pendingRequest.destination;
+            if (activeDestination.promotedTo?.includes(5 /* RoleCode.Queen */)) {
+                pendingRequest.resolve({
+                    from: pendingRequest.sourceSquare,
+                    to: activeDestination.to,
+                    promotedTo: 5 /* RoleCode.Queen */
+                });
+            }
+        },
+        getPublic() {
+            return publicInterface;
+        }
+    };
+}

package/dist/extensions/first-party/auto-promote/types.d.ts

@@ -0,0 +1,14 @@
+import { ExtensionSlotSvgRoots } from '../../types/basic/mount.js';
+import { ExtensionDefinition, ExtensionInstance } from '../../types/extension.js';
+export declare const EXTENSION_SLOTS: readonly [];
+export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
+export declare const EXTENSION_ID: "autoPromote";
+export type AutoPromoteDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, AutoPromotePublic>;
+export interface AutoPromotePublic {
+    toQueen: boolean;
+}
+export type AutoPromoteInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, AutoPromotePublic>;
+export type AutoPromoteSlotRoots = ExtensionSlotSvgRoots<typeof EXTENSION_SLOTS>;
+export interface AutoPromoteInstanceInternal {
+    toQueen: boolean;
+}

package/dist/extensions/first-party/auto-promote/types.js

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

package/dist/extensions/first-party/board-events/factory.js

@@ -1,5 +1,5 @@
 import { denormalizeMove } from '../../../state/board/denormalize.js';
-import { extensionCreateInternalBase, extensionDestroy, extensionMount, extensionUnmount } from '../common/helpers.js';
+import { extensionCreateInternalBase } from '../common/helpers.js';
 import { EXTENSION_ID, EXTENSION_SLOTS } from './types.js';
 export function createBoardEvents() {
     return {
@@ -17,10 +17,6 @@ function createBoardEventsInternal() {
         onRawUpdate: null
     };
 }
-function extensionClean(state) {
-    state.onUIMove = null;
-    state.onRawUpdate = null;
-}
 function createBoardEventsInstancePublic(state) {
     return {
         setOnUIMove(callback) {
@@ -36,9 +32,6 @@ function createBoardEventsInstance() {
     const publicInterface = createBoardEventsInstancePublic(internalState);
     return {
         id: EXTENSION_ID,
-        mount(env) {
-            extensionMount(internalState, env.slotRoots);
-        },
         onUpdate(context) {
             if (internalState.onRawUpdate) {
                 internalState.onRawUpdate({
@@ -54,14 +47,6 @@ function createBoardEventsInstance() {
         },
         getPublic() {
             return publicInterface;
-        },
-        unmount() {
-            extensionUnmount(internalState);
-            extensionClean(internalState);
-        },
-        destroy() {
-            extensionDestroy(internalState);
-            extensionClean(internalState);
         }
     };
 }

package/dist/extensions/first-party/board-events/types.d.ts

@@ -3,7 +3,6 @@ import { MoveOutput } from '../../../state/board/types/output.js';
 import { ExtensionSlotSvgRoots } from '../../types/basic/mount.js';
 import { UpdateFrameSnapshot } from '../../types/basic/update.js';
 import { ExtensionDefinition, ExtensionInstance } from '../../types/extension.js';
-import { ExtensionInternal } from '../common/types.js';
 export declare const EXTENSION_SLOTS: readonly [];
 export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
 export declare const EXTENSION_ID: "events";
@@ -21,7 +20,7 @@ export interface BoardEventsPublic {
 }
 export type BoardEventsInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, BoardEventsPublic>;
 export type BoardEventsSlotRoots = ExtensionSlotSvgRoots<typeof EXTENSION_SLOTS>;
-export interface BoardEventsInstanceInternal extends ExtensionInternal<ExtensionSlotsType> {
+export interface BoardEventsInstanceInternal {
     onUIMove: OnUIMoveCallback | null;
     onRawUpdate: OnRawUpdateCallback | null;
 }

package/dist/extensions/first-party/last-move/factory.js

@@ -57,13 +57,13 @@ function createLastMoveInstance(config) {
                 return;
             }
             const geometry = context.currentFrame.layout.geometry;
-            const rFrom = geometry.squareRect(fromSq);
-            const rTo = geometry.squareRect(toSq);
+            const rFrom = geometry.getSquareRect(fromSq);
+            const rTo = geometry.getSquareRect(toSq);
             const rectFromAttributes = {
                 x: rFrom.x.toString(),
                 y: rFrom.y.toString(),
-                width: rFrom.size.toString(),
-                height: rFrom.size.toString(),
+                width: rFrom.width.toString(),
+                height: rFrom.height.toString(),
                 fill: internalState.config.color,
                 'fill-opacity': internalState.config.opacity.toString(),
                 'shape-rendering': 'crispEdges'
@@ -71,8 +71,8 @@ function createLastMoveInstance(config) {
             const rectToAttributes = {
                 x: rTo.x.toString(),
                 y: rTo.y.toString(),
-                width: rTo.size.toString(),
-                height: rTo.size.toString(),
+                width: rTo.width.toString(),
+                height: rTo.height.toString(),
                 fill: internalState.config.color,
                 'fill-opacity': internalState.config.opacity.toString(),
                 'shape-rendering': 'crispEdges'

package/dist/extensions/first-party/legal-moves/factory.js

@@ -70,7 +70,7 @@ function createLegalMovesInstance(config) {
                 fill: 'none'
             }; // TODO: Remove, this is just for visual test
             for (const [square, destination] of interaction.activeDestinations) {
-                const rect = geometry.squareRect(square);
+                const rect = geometry.getSquareRect(square);
                 const circleX = rect.x + geometry.squareSize / 2;
                 const circleY = rect.y + geometry.squareSize / 2;
                 const selectedPieceCode = context.currentFrame.state.board.pieces[interaction.selected.square];

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

@@ -1,4 +1,3 @@
-import { collectSuppressedSquares } from '../../../../animation/planner.js';
 import { cleanAnimationPlan, prepareAnimationPlan, renderAnimationPlan } from '../../../../animation/render/plan.js';
 const EMPTY_SQUARES = new Set();
 export function rendererAnimationPrepare(state, context, layer) {
@@ -38,7 +37,7 @@ export function getAnimationSuppressedSquares(state) {
         const entry = state.entries.get(session.id);
         if (!entry)
             continue;
-        for (const sq of collectSuppressedSquares(entry.plan.tracks)) {
+        for (const sq of entry.plan.suppressedSquares) {
             result.add(sq);
         }
     }

package/dist/extensions/first-party/main-renderer/animation/update.js

@@ -1,40 +1,26 @@
 import { calculateAnimationPlan } from '../../../../animation/planner.js';
 import { piecePositionsEqual } from '../../../../state/board/check.js';
+import { changeStatesEqual } from '../../../../state/change/helpers.js';
 import { isUpdateContextRenderable } from '../../../types/context/update.js';
 const DEFAULT_ANIMATION_DURATION_MS = 180;
 export function rendererAnimationOnUpdate(state, context) {
     if (!isUpdateContextRenderable(context) ||
-        !context.mutation.hasMutation({ prefixes: ['state.board.'] }) ||
+        !context.mutation.hasMutation({ prefixes: ['state.board.', 'state.change.'] }) ||
         !context.previousFrame) {
         return;
     }
-    const previousBoard = context.previousFrame.state.board;
-    const currentBoard = context.currentFrame.state.board;
-    if (piecePositionsEqual(previousBoard, currentBoard))
+    if (piecePositionsEqual(context.previousFrame.state.board, context.currentFrame.state.board) &&
+        changeStatesEqual(context.previousFrame.state.change, context.currentFrame.state.change))
         return;
-    // On DropTo exclude the move that user did from the animation plan
-    const exclude = [];
-    if (context.mutation.hasMutation({ causes: ['runtime.interaction.dropTo'] }) &&
-        context.currentFrame.state.change.lastMove) {
-        exclude.push({
-            fromSq: context.currentFrame.state.change.lastMove.from,
-            toSq: context.currentFrame.state.change.lastMove.to
-        });
-        exclude.push({
-            sq: context.currentFrame.state.change.lastMove.from
-        });
-        exclude.push({
-            sq: context.currentFrame.state.change.lastMove.to
-        });
-    }
-    const plan = calculateAnimationPlan(previousBoard, currentBoard, 0 /* placeholder session id for draft plan */, {
-        exclude
+    // Pass raw snapshots to the planner — it normalizes internally
+    const plan = calculateAnimationPlan({
+        previous: context.previousFrame.state,
+        current: context.currentFrame.state
     });
     if (plan.tracks.length === 0)
         return;
     const session = state.runtimeSurface.animation.submit({
         duration: DEFAULT_ANIMATION_DURATION_MS
     });
-    plan.sessionId = session.id;
-    state.entries.set(plan.sessionId, { plan, nodes: null });
+    state.entries.set(session.id, { plan, nodes: null });
 }

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

@@ -10,13 +10,13 @@ export function rendererBoardRender(state, context, layer) {
     clearElementChildren(layer);
     const { light, dark } = state.config;
     for (let sq = 0; sq < SQUARE_COUNT; sq++) {
-        const r = geometry.squareRect(sq);
+        const r = geometry.getSquareRect(sq);
         createSvgElement(layer, 'rect', {
             'data-chessboard-id': `square-${sq}`,
             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: isLightSquare(sq) ? light : dark,
             'shape-rendering': 'crispEdges'
         });

package/dist/extensions/first-party/main-renderer/board/update.js

@@ -1,3 +1,4 @@
+import { sceneRectsEqual } from '../../../../layout/geometry/helpers.js';
 import { isFrameRenderable } from '../../../types/basic/update.js';
 import { isUpdateContextRenderable } from '../../../types/context/update.js';
 import { DirtyLayer } from '../types/extension.js';
@@ -12,14 +13,15 @@ export function rendererBoardOnUpdate(_state, context) {
     }
     // Ok geometry changed, let's check the board size
     const currentGeometry = context.currentFrame.layout.geometry;
-    const currentBoardSize = currentGeometry.boardSize;
+    const currentBoardRect = currentGeometry.boardRect;
     const currentOrientation = currentGeometry.orientation;
     const previousGeometry = context.previousFrame && isFrameRenderable(context.previousFrame)
         ? context.previousFrame.layout.geometry
         : null;
-    const previousBoardSize = previousGeometry?.boardSize;
+    const previousBoardRect = previousGeometry?.boardRect ?? null;
     const previousOrientation = previousGeometry?.orientation;
-    const needsRender = currentBoardSize !== previousBoardSize || currentOrientation !== previousOrientation;
+    const needsRender = sceneRectsEqual(currentBoardRect, previousBoardRect) === false ||
+        currentOrientation !== previousOrientation;
     if (!needsRender) {
         return; // no-op
     }

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

@@ -19,7 +19,7 @@ export function rendererCoordinatesRender(state, context, layer) {
         const logicalRank = (geometry.orientation === 0 /* ColorCode.White */ ? 7 - visualRank : visualRank);
         const sq = squareOf(rankFile, logicalRank);
         const label = geometry.orientation === 0 /* ColorCode.White */ ? String(8 - visualRank) : String(1 + visualRank);
-        const r = geometry.squareRect(sq);
+        const r = geometry.getSquareRect(sq);
         const color = labelColorForSquare(sq, coords);
         const text = createSvgElement(layer, 'text', {
             'data-chessboard-id': `coord-rank-${label}`,
@@ -42,12 +42,12 @@ export function rendererCoordinatesRender(state, context, layer) {
         const label = geometry.orientation === 0 /* ColorCode.White */
             ? String.fromCharCode('a'.charCodeAt(0) + visualFile)
             : String.fromCharCode('h'.charCodeAt(0) - visualFile);
-        const r = geometry.squareRect(sq);
+        const r = geometry.getSquareRect(sq);
         const color = labelColorForSquare(sq, coords);
         const text = createSvgElement(layer, 'text', {
             'data-chessboard-id': `coord-file-${label}`,
-            x: (r.x + r.size - offset).toString(),
-            y: (r.y + r.size - offset).toString(),
+            x: (r.x + r.width - offset).toString(),
+            y: (r.y + r.height - offset).toString(),
             'font-size': fontSize.toString(),
             'font-family': 'sans-serif',
             'font-weight': 'bold',

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

@@ -1,7 +1,7 @@
 import { createSvgElement, updateElementAttributes } from '../../../../render/svg/helpers.js';
 export function rendererDragRenderTransientVisuals(state, context, layer) {
     const geometry = context.currentFrame.layout.geometry;
-    const point = context.transientInput.clampedPoint;
+    const point = context.transientInput.boardClampedPoint;
     const squareSize = geometry.squareSize.toString();
     const x = (point.x - geometry.squareSize / 2).toString();
     const y = (point.y - geometry.squareSize / 2).toString();

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

@@ -1,4 +1,3 @@
-import { MainRendererConfigInput, PieceUrlsInput } from './types/input.js';
-import { MainRendererConfig, PieceUrls } from './types/internal.js';
-export declare function normalizePieceUrls(input: PieceUrlsInput): PieceUrls;
+import { MainRendererConfigInput } from './types/input.js';
+import { MainRendererConfig } from './types/internal.js';
 export declare function normalizeMainRendererConfig(input: Partial<MainRendererConfigInput>): MainRendererConfig;

package/dist/extensions/first-party/main-renderer/normalize.js

@@ -7,7 +7,7 @@ function assertPieceUrlsComplete(pieceUrls) {
         assert(pieceCode in pieceUrls, `Missing URL for piece code: ${pieceCode}`);
     }
 }
-export function normalizePieceUrls(input) {
+function normalizePieceUrls(input) {
     const normalized = {};
     for (const [key, url] of Object.entries(input)) {
         const pieceCode = normalizePiece(key);