@pascal-app/nodes 0.1.1

package/dist/shelf/definition.js

@@ -0,0 +1,265 @@
+import { sanitizeShelfDimensions } from './dimensions';
+import { buildShelfFloorplan } from './floorplan';
+import { shelfResizeAffordance, shelfRotateAffordance } from './floorplan-affordances';
+import { shelfFloorplanMoveTarget } from './floorplan-move';
+import { buildShelfGeometry, shelfRowSurfaceYs } from './geometry';
+import { shelfPaint } from './paint';
+import { shelfParametrics } from './parametrics';
+import { ShelfNode } from './schema';
+import { shelfSlots } from './slots';
+const SIDE_HANDLE_OFFSET = 0.18;
+const HEIGHT_HANDLE_OFFSET = 0.22;
+const ROTATE_CORNER_OFFSET = 0.32;
+const ROTATE_RING_OFFSET = 0.04;
+const MOVE_FRONT_OFFSET = 0.35;
+const MIN_SHELF_WIDTH = 0.3;
+const MIN_SHELF_DEPTH = 0.1;
+const MIN_SHELF_HEIGHT = 0.05;
+// Width arrow — anchor='center' so dragging the +X side grows the full
+// width symmetrically (both edges move ±delta), matching the column /
+// elevator pattern.
+function shelfWidthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'center',
+        min: MIN_SHELF_WIDTH,
+        currentValue: (n) => n.width,
+        apply: (_n, newValue) => ({ width: newValue }),
+        placement: {
+            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, n.height / 2, 0],
+        },
+    };
+}
+// Depth arrow — symmetric on the +Z side.
+function shelfDepthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'center',
+        min: MIN_SHELF_DEPTH,
+        currentValue: (n) => n.depth,
+        apply: (_n, newValue) => ({ depth: newValue }),
+        placement: {
+            position: (n) => [0, n.height / 2, n.depth / 2 + SIDE_HANDLE_OFFSET],
+        },
+    };
+}
+// Height arrow — anchor='min' so the base stays on the floor and the
+// top edge follows the cursor.
+function shelfHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_SHELF_HEIGHT,
+        currentValue: (n) => n.height,
+        apply: (_n, newValue) => ({ height: newValue }),
+        placement: {
+            position: (n) => [0, n.height + HEIGHT_HANDLE_OFFSET, 0],
+        },
+    };
+}
+// Whole-shelf rotation gizmo — curved two-headed arrow at the front of
+// the footprint, guide ring traces the corner-diagonal radius on hover
+// / drag. Same pattern as the elevator / column rotate gizmo; differs
+// only because shelf stores rotation as a `[x, y, z]` tuple, so the
+// apply patch writes back the whole tuple with Y mutated.
+function shelfRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => {
+            const r = initial.rotation ?? [0, 0, 0];
+            // Negate to match three.js Y-rotation handedness (cursor atan2
+            // ticks opposite-handed from `rotation-y`).
+            return { rotation: [r[0], (r[1] ?? 0) - delta, r[2]] };
+        },
+        placement: {
+            position: (n) => {
+                const halfZ = n.depth / 2;
+                const yMid = Math.max(n.height, MIN_SHELF_HEIGHT) / 2;
+                return [n.width / 2, yMid, halfZ + ROTATE_CORNER_OFFSET];
+            },
+            // Tilt the curve toward the shelf's front face.
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(n.width / 2, n.depth / 2) + ROTATE_RING_OFFSET,
+            y: (n) => Math.max(n.height, MIN_SHELF_HEIGHT) / 2,
+        },
+    };
+}
+function shelfMoveHandle() {
+    return {
+        kind: 'translate',
+        placement: {
+            // Low to the floor at the front edge (matches the item move grip) so it
+            // reads as a floor-move grip and stays clear of the body resize / rotate
+            // handles that sit at mid-height.
+            position: (n) => {
+                const shelf = sanitizeShelfDimensions(n);
+                return [0, 0.02, shelf.depth / 2 + MOVE_FRONT_OFFSET];
+            },
+        },
+        apply: (_n, pos) => ({ position: [pos[0], pos[1], pos[2]] }),
+        snapExtents: (n) => {
+            const shelf = sanitizeShelfDimensions(n);
+            const swap = Math.abs(Math.sin(shelf.rotation[1] ?? 0)) > 0.9;
+            return [swap ? shelf.depth : shelf.width, swap ? shelf.width : shelf.depth];
+        },
+    };
+}
+function shelfHandles(_node) {
+    return [
+        shelfWidthHandle(),
+        shelfDepthHandle(),
+        shelfHeightHandle(),
+        shelfRotateHandle(),
+        shelfMoveHandle(),
+    ];
+}
+export const shelfDefinition = {
+    kind: 'shelf',
+    snapProfile: 'item',
+    facingIndicator: true,
+    schemaVersion: 2,
+    schema: ShelfNode,
+    category: 'furnish',
+    surfaceRole: 'joinery',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        width: 1,
+        depth: 0.5,
+        thickness: 0.05,
+        height: 1.8,
+        style: 'cubby',
+        rows: 3,
+        columns: 2,
+        withBack: true,
+        withSides: true,
+        withBottom: true,
+        bracketStyle: 'minimal',
+        // material / materialPreset left undefined — geometry falls back to
+        // the per-slot off-white default, and slot paint mode writes chosen
+        // catalog materials into `slots`.
+    }),
+    capabilities: {
+        movable: { axes: ['x', 'z'], gridSnap: true },
+        rotatable: {
+            axes: ['y'],
+            snapAngles: [0, Math.PI / 4, Math.PI / 2, (3 * Math.PI) / 4, Math.PI],
+        },
+        // Multi-row hosting: each row's top board exposes a surface so items
+        // can stack on whichever row the cursor targets. `surfaces.top`
+        // points at the topmost board (legacy compatibility — code that
+        // assumes a single surface still works). `surfaces.custom` emits
+        // one `SurfacePoint` per row centered on (0, rowY, 0) — the
+        // placement coordinator's shelf strategy picks the closest by
+        // cursor local-Y and snaps there.
+        surfaces: {
+            top: { height: (n) => shelfRowSurfaceYs(n).at(-1) ?? 0 },
+            custom: (n) => shelfRowSurfaceYs(n).map((y) => ({
+                position: [0, y, 0],
+                normal: [0, 1, 0],
+            })),
+        },
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        paint: shelfPaint,
+        slots: (n) => shelfSlots(n),
+        // Slab elevation lift via the generic `<FloorElevationSystem>` — a
+        // shelf sitting over a raised slab visually rests on top of it.
+        floorPlaced: {
+            footprint: (node) => {
+                const shelf = sanitizeShelfDimensions(node);
+                return {
+                    dimensions: [shelf.width, shelf.height, shelf.depth],
+                    rotation: shelf.rotation,
+                };
+            },
+            collides: true,
+        },
+    },
+    // Items host on shelves the same way they host on slabs / other items —
+    // declared here so the placement coordinator's shelf strategy can
+    // confirm parent-kind compatibility before reparenting.
+    relations: {
+        hosts: ['item'],
+        cascadeDelete: 'descendants',
+    },
+    parametrics: shelfParametrics,
+    handles: shelfHandles,
+    // Three-checkbox composition: shelf needs only pure builder functions.
+    // The framework's <ParametricNodeRenderer> + <GeometrySystem> handle 3D
+    // mount and rebuild on dirty; the <FloorplanRegistryLayer> calls
+    // buildShelfFloorplan for the 2D top-down view. No renderer.tsx, no
+    // system.tsx, no inline floor-plan SVG — see
+    // `wiki/architecture/node-definitions.md`.
+    geometry: buildShelfGeometry,
+    // Boards/posts/back depend only on these fields — never on hosted
+    // `children`. Lets <GeometrySystem> skip the dispose+rebuild (and the
+    // pointer enter/leave churn it causes) when an item reparents onto a row.
+    geometryKey: (n) => {
+        const s = sanitizeShelfDimensions(n);
+        return JSON.stringify([
+            s.style,
+            s.width,
+            s.depth,
+            s.thickness,
+            s.height,
+            s.rows,
+            s.columns,
+            s.withBack,
+            s.withSides,
+            s.withBottom,
+            s.bracketStyle,
+            s.material,
+            s.materialPreset,
+            JSON.stringify(s.slots ?? null),
+        ]);
+    },
+    floorplan: buildShelfFloorplan,
+    // 2D move handler — Path 1 in `FloorplanRegistryMoveOverlay`. Without
+    // this the overlay falls through to Path 2 which stomps the SVG
+    // entry's `transform` attribute (set by the floor-plan layer to
+    // position the shelf at `node.position`), producing the "ultra slow,
+    // wrong place" symptom the user observed. Path 1 writes live
+    // transforms during drag for real-time 3D sync and commits via a
+    // single tracked `updateNode`.
+    floorplanMoveTarget: shelfFloorplanMoveTarget,
+    // 2D drag affordances for the resize chevrons + rotate-arrow emitted
+    // when the shelf is selected. `shelf-resize` handles width / depth
+    // (the payload's `dim` discriminator); `shelf-rotate` is the corner
+    // arc-arrow that drives `rotation[1]`. Body move stays on the
+    // action-menu Move button → `shelfFloorplanMoveTarget` above.
+    floorplanAffordances: {
+        'shelf-resize': shelfResizeAffordance,
+        'shelf-rotate': shelfRotateAffordance,
+    },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Left click', label: 'Place shelf' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Shelf',
+        description: 'A configurable shelving unit. Items host on each row.',
+        icon: { kind: 'url', src: '/icons/shelf.webp' },
+        paletteSection: 'furnish',
+        paletteOrder: 30,
+    },
+    mcp: {
+        description: 'A parametric shelving unit. Four styles (wall-shelf / bookshelf / open-rack / cubby) with configurable rows, columns, sides, and back. Items host on each row.',
+    },
+};

package/dist/shelf/dimensions.d.ts

@@ -0,0 +1,3 @@
+import type { ShelfNode } from './schema';
+export declare function sanitizeShelfDimensions(node: ShelfNode): ShelfNode;
+//# sourceMappingURL=dimensions.d.ts.map

package/dist/shelf/dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensions.d.ts","sourceRoot":"","sources":["../../src/shelf/dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAOzC,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAUlE"}

package/dist/shelf/dimensions.js

@@ -0,0 +1,15 @@
+function clampShelfDim(value, lo, hi, fallback) {
+    const v = typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+    return Math.min(Math.max(v, lo), hi);
+}
+export function sanitizeShelfDimensions(node) {
+    return {
+        ...node,
+        width: clampShelfDim(node.width, 0.3, 3.0, 1.2),
+        depth: clampShelfDim(node.depth, 0.1, 1.0, 0.3),
+        thickness: clampShelfDim(node.thickness, 0.01, 0.1, 0.04),
+        height: clampShelfDim(node.height, 0.05, 2.5, 0.9),
+        rows: Math.round(clampShelfDim(node.rows, 1, 8, 1)),
+        columns: Math.round(clampShelfDim(node.columns, 1, 6, 1)),
+    };
+}

package/dist/shelf/floorplan-affordances.d.ts

@@ -0,0 +1,26 @@
+import { type FloorplanAffordance, type ShelfNode } from '@pascal-app/core';
+export type ShelfResizePayload = {
+    dim: 'width' | 'depth';
+    planAxis: [number, number];
+};
+/**
+ * Single drag handler for both shelf size arrows. Mirrors the 3D
+ * `shelfWidthHandle` / `shelfDepthHandle` (`anchor: 'center'` — cursor
+ * delta `d` along the outward axis grows the dimension by `2·d` so both
+ * faces move ±d and the centre stays put).
+ */
+export declare const shelfResizeAffordance: FloorplanAffordance<ShelfNode>;
+/**
+ * Whole-shelf rotation drag (floor-plan). Sister to the 3D
+ * `shelfRotateHandle` (arc-resize). Cursor angle around the shelf
+ * centre drives `rotation[1]` (Y axis). Shelf stores rotation as a
+ * `[x, y, z]` tuple — the patch preserves the X / Z slots.
+ *
+ * Same `- delta` convention as the 3D handle: the floor-plan builder
+ * plots the footprint at `-rotation[1]` (see `buildShelfFloorplan`'s
+ * `planRy`), so the 2D view rotates the same direction as 3D for the
+ * same `rotation` value and the same cursor gesture writes the same
+ * sign in both views.
+ */
+export declare const shelfRotateAffordance: FloorplanAffordance<ShelfNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/shelf/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAQzB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,OAAO,GAAG,OAAO,CAAA;IAGtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAiChE,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CA+BhE,CAAA"}

package/dist/shelf/floorplan-affordances.js

@@ -0,0 +1,88 @@
+import { useScene, } from '@pascal-app/core';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+// Mirror the 3D handles in `shelf/definition.ts` so a drag can't push a
+// value past what the renderer / geometry builder accepts.
+const MIN_SHELF_WIDTH = 0.3;
+const MIN_SHELF_DEPTH = 0.1;
+/**
+ * Single drag handler for both shelf size arrows. Mirrors the 3D
+ * `shelfWidthHandle` / `shelfDepthHandle` (`anchor: 'center'` — cursor
+ * delta `d` along the outward axis grows the dimension by `2·d` so both
+ * faces move ±d and the centre stays put).
+ */
+export const shelfResizeAffordance = {
+    start({ node, payload, initialPlanPoint }) {
+        const { dim, planAxis } = payload;
+        const shelfId = node.id;
+        const [ax, ay] = planAxis;
+        const initialProj = initialPlanPoint[0] * ax + initialPlanPoint[1] * ay;
+        const initialWidth = node.width;
+        const initialDepth = node.depth;
+        let lastPatch = {};
+        return {
+            affectedIds: [shelfId],
+            apply({ planPoint }) {
+                const currentProj = planPoint[0] * ax + planPoint[1] * ay;
+                const projDelta = currentProj - initialProj;
+                if (dim === 'width') {
+                    lastPatch = { width: Math.max(MIN_SHELF_WIDTH, initialWidth + 2 * projDelta) };
+                }
+                else {
+                    lastPatch = { depth: Math.max(MIN_SHELF_DEPTH, initialDepth + 2 * projDelta) };
+                }
+                useScene.getState().updateNode(shelfId, lastPatch);
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                if (Object.keys(lastPatch).length > 0) {
+                    useScene.getState().updateNode(shelfId, lastPatch);
+                }
+            },
+        };
+    },
+};
+/**
+ * Whole-shelf rotation drag (floor-plan). Sister to the 3D
+ * `shelfRotateHandle` (arc-resize). Cursor angle around the shelf
+ * centre drives `rotation[1]` (Y axis). Shelf stores rotation as a
+ * `[x, y, z]` tuple — the patch preserves the X / Z slots.
+ *
+ * Same `- delta` convention as the 3D handle: the floor-plan builder
+ * plots the footprint at `-rotation[1]` (see `buildShelfFloorplan`'s
+ * `planRy`), so the 2D view rotates the same direction as 3D for the
+ * same `rotation` value and the same cursor gesture writes the same
+ * sign in both views.
+ */
+export const shelfRotateAffordance = {
+    start({ node, initialPlanPoint }) {
+        const shelfId = node.id;
+        const r = node.rotation ?? [0, 0, 0];
+        const initialRotationY = r[1] ?? 0;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        let lastRotation = [r[0], initialRotationY, r[2]];
+        return {
+            affectedIds: [shelfId],
+            apply({ planPoint, modifiers }) {
+                const delta = rotateAffordanceDelta({
+                    center: [cx, cz],
+                    initialAngle,
+                    planPoint,
+                    free: modifiers.shiftKey,
+                });
+                const newRotationY = initialRotationY - delta;
+                lastRotation = [r[0], newRotationY, r[2]];
+                useScene.getState().updateNode(shelfId, { rotation: lastRotation });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(shelfId, { rotation: lastRotation });
+            },
+        };
+    },
+};

package/dist/shelf/floorplan-move.d.ts

@@ -0,0 +1,25 @@
+import { type FloorplanMoveTarget, type ShelfNode } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for shelf — mirrors `itemFloorplanMoveTarget`,
+ * because shelf is a `position`-field kind (it carries its location in
+ * `node.position`, not in polygon vertices):
+ *
+ *   - Each pointermove writes the absolute world-plan position straight
+ *     to `useScene` (history is paused by the overlay). This is the single
+ *     source of truth: the 2D `FloorplanRegistryLayer` and the 3D
+ *     `ParametricNodeRenderer` group transform both follow it reactively,
+ *     so 2D and 3D can never diverge.
+ *   - On commit, the overlay's snapshot-diff reverts to baseline, resumes
+ *     history, and re-applies the final position as one undoable step.
+ *     `canCommit` only validates.
+ *
+ * Earlier this used the `useLiveTransforms` + imperative-mesh pattern that
+ * `slab` / `ceiling` use. That works for polygon kinds because their commit
+ * rebuilds geometry (the vertices change), which forces the 3D group to
+ * reconcile. Shelf's `geometryKey` excludes `position`, so its commit
+ * `markDirty` is a no-op and nothing reconciled the 3D group off the cleared
+ * live transform — the 2D SVG moved but the 3D mesh stayed put. Writing the
+ * scene directly removes that second source of truth entirely.
+ */
+export declare const shelfFloorplanMoveTarget: FloorplanMoveTarget<ShelfNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

package/dist/shelf/floorplan-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAWzB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CA2EnE,CAAA"}

package/dist/shelf/floorplan-move.js

@@ -0,0 +1,90 @@
+import { collectAlignmentAnchors, movingFootprintAnchors, useScene, } from '@pascal-app/core';
+import { applyFloorplanAlignment, getFloorStackPreviewPosition, isMagneticSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+/**
+ * 2D floor-plan move handler for shelf — mirrors `itemFloorplanMoveTarget`,
+ * because shelf is a `position`-field kind (it carries its location in
+ * `node.position`, not in polygon vertices):
+ *
+ *   - Each pointermove writes the absolute world-plan position straight
+ *     to `useScene` (history is paused by the overlay). This is the single
+ *     source of truth: the 2D `FloorplanRegistryLayer` and the 3D
+ *     `ParametricNodeRenderer` group transform both follow it reactively,
+ *     so 2D and 3D can never diverge.
+ *   - On commit, the overlay's snapshot-diff reverts to baseline, resumes
+ *     history, and re-applies the final position as one undoable step.
+ *     `canCommit` only validates.
+ *
+ * Earlier this used the `useLiveTransforms` + imperative-mesh pattern that
+ * `slab` / `ceiling` use. That works for polygon kinds because their commit
+ * rebuilds geometry (the vertices change), which forces the 3D group to
+ * reconcile. Shelf's `geometryKey` excludes `position`, so its commit
+ * `markDirty` is a no-op and nothing reconciled the 3D group off the cleared
+ * live transform — the 2D SVG moved but the 3D mesh stayed put. Writing the
+ * scene directly removes that second source of truth entirely.
+ */
+export const shelfFloorplanMoveTarget = ({ node, nodes }) => {
+    const shelfId = node.id;
+    const originalPosition = [...node.position];
+    const originalRotationY = node.rotation[1] ?? 0;
+    const resolveCursor = createFloorplanCursorResolver({
+        original: [originalPosition[0], originalPosition[2]],
+        metadata: node.metadata,
+    });
+    let lastPosition = originalPosition;
+    let lastSnapKey = null;
+    // Alignment candidates — corner/edge/segment anchors of every OTHER node
+    // (incl. wall faces). Gathered once: the scene is stable during the drag
+    // (only the shelf moves), so re-collecting per tick is wasted work.
+    const candidates = collectAlignmentAnchors(nodes, shelfId);
+    const session = {
+        affectedIds: [shelfId],
+        apply({ planPoint, modifiers }) {
+            const snap = (value) => {
+                if (modifiers.shiftKey)
+                    return value;
+                const step = useEditor.getState().gridSnapStep;
+                return Math.round(value / step) * step;
+            };
+            const gridSnapped = resolveCursor(planPoint, { snap });
+            // Figma-style alignment layered on the grid snap — the shelf footprint
+            // edges snap to neighbours / wall faces and a guide is published. Alt
+            // bypasses alignment; Shift bypasses all snap.
+            const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], originalRotationY), candidates, { applySnap: isMagneticSnapActive(), bypass: modifiers.altKey || modifiers.shiftKey });
+            const next = [snapped[0], originalPosition[1], snapped[1]];
+            lastPosition = next;
+            // Grid-snap SFX on cell crossings — matches the 3D `MoveSlabTool`
+            // and the placement coordinators. Item / slab / wall flows fire
+            // the same cue, so the shelf following along is the expected UX.
+            const snapKey = `${snapped[0]},${snapped[1]}`;
+            if (!modifiers.shiftKey && snapKey !== lastSnapKey) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapKey = snapKey;
+            }
+            const visualPosition = getFloorStackPreviewPosition({
+                node,
+                position: next,
+                rotation: node.rotation,
+                levelId: node.parentId ?? null,
+            });
+            // Single source of truth — write the absolute position straight to
+            // the scene (history is paused by the overlay). Both the 2D SVG and
+            // the 3D group transform read `node.position` reactively, so they
+            // stay in lockstep. The overlay's snapshot-diff turns the whole drag
+            // into one undoable step on commit.
+            useScene.getState().updateNodes([
+                {
+                    id: shelfId,
+                    data: { position: visualPosition },
+                },
+            ]);
+        },
+        canCommit() {
+            const live = useScene.getState().nodes[shelfId];
+            if (live?.type !== 'shelf')
+                return false;
+            return !(lastPosition[0] === originalPosition[0] && lastPosition[2] === originalPosition[2]);
+        },
+    };
+    return session;
+};

package/dist/shelf/floorplan.d.ts

@@ -0,0 +1,20 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { ShelfNode } from './schema';
+/**
+ * 2D floor-plan representation of a shelf. The unit's outer footprint
+ * projects to a rectangle of `width × depth` centered on the shelf's
+ * position, rotated by its Y angle. For `bookshelf` / `cubby` with
+ * columns > 1, vertical column dividers project as thin lines so the
+ * grid is legible from above.
+ *
+ * Brackets / posts / individual boards are intentionally omitted — they
+ * stack vertically under the topmost board from a top-down view and
+ * adding them clutters the plan without conveying useful information.
+ *
+ * When selected, emits resize chevrons matching the 3D handle set
+ * (width on +X, depth on +Z) plus a rotate-arrow at the front-right
+ * corner. Body move continues to flow through `shelfFloorplanMoveTarget`
+ * (engaged from the action-menu Move button, not from these arrows).
+ */
+export declare function buildShelfFloorplan(node: ShelfNode, ctx?: GeometryContext): FloorplanGeometry;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/shelf/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAG1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAQzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,iBAAiB,CAmH7F"}