@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/shelf/definition.d.ts

@@ -1,4 +1,109 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { ShelfNode } from './schema.js';
-export declare const shelfDefinition: NodeDefinition<typeof ShelfNode>;
+export declare const shelfDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`shelf_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"shelf">>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    thickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    style: import("zod").ZodDefault<import("zod").ZodEnum<{
+        bookshelf: "bookshelf";
+        cubby: "cubby";
+        "open-rack": "open-rack";
+        "wall-shelf": "wall-shelf";
+    }>>;
+    rows: import("zod").ZodDefault<import("zod").ZodNumber>;
+    columns: import("zod").ZodDefault<import("zod").ZodNumber>;
+    withBack: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    withSides: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    withBottom: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    bracketStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        hidden: "hidden";
+        industrial: "industrial";
+        minimal: "minimal";
+    }>>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAWpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA2HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA4J5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAsE,CAAA"}

package/dist/shelf/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { ShelfNode } from './schema.js';
+export declare const shelfEditContribution: NodeEditContribution<typeof ShelfNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/shelf/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAOvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAkIzC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAgCxE,CAAA"}

package/dist/shelf/definition.edit.js

@@ -0,0 +1,153 @@
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
+import { sanitizeShelfDimensions } from './dimensions.js';
+import { shelfResizeAffordance, shelfRotateAffordance } from './floorplan-affordances.js';
+import { shelfFloorplanMoveTarget } from './floorplan-move.js';
+import { shelfPaint } from './paint.js';
+import { shelfParametrics } from './parametrics.js';
+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 shelfEditContribution = {
+    snapProfile: 'item',
+    facingIndicator: true,
+    capabilities: {
+        paint: shelfPaint,
+    },
+    parametrics: shelfParametrics,
+    handles: shelfHandles,
+    floorplanAffectedIds: restingFloorplanAffectedIds,
+    // 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.js'),
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Left click', label: 'Place shelf' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/shelf/definition.js

@@ -1,272 +1,4 @@
-import { shelfSlots } from '@pascal-app/core';
-import { staticBatchable } from '../shared/node-batch/batchable.js';
-import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
-import { sanitizeShelfDimensions } from './dimensions.js';
-import { buildShelfFloorplan } from './floorplan.js';
-import { shelfResizeAffordance, shelfRotateAffordance } from './floorplan-affordances.js';
-import { shelfFloorplanMoveTarget } from './floorplan-move.js';
-import { buildShelfGeometry, shelfRowSurfaceYs } from './geometry.js';
-import { shelfPaint } from './paint.js';
-import { shelfParametrics } from './parametrics.js';
-import { ShelfNode } from './schema.js';
-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: {
-        batchable: staticBatchable,
-        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
-        revealOnEdit: ['width', 'depth', 'height', 'thickness', 'rows', 'columns', 'style'],
-        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: { subtree: 'with-children' },
-        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', 'procedural-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.
-    geometryChildTypes: [],
-    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,
-    floorplanAffectedIds: restingFloorplanAffectedIds,
-    // 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.js'),
-    tool: () => import('./tool.js'),
-    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.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { shelfEditContribution } from './definition.edit.js';
+import { shelfRenderDefinition } from './definition.render.js';
+export const shelfDefinition = composeNodeDefinition(shelfRenderDefinition, shelfEditContribution);

package/dist/shelf/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { ShelfNode } from './schema.js';
+export declare const shelfRenderDefinition: NodeRenderDefinition<typeof ShelfNode> & {
+    kind: 'shelf';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/shelf/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAKvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAAC,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAuH3F,CAAA"}