@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/item/definition.edit.js

@@ -0,0 +1,203 @@
+import { getEffectiveCutterNode, getScaledDimensions, resolveCutterHost, toggleMechanism, } from '@pascal-app/core';
+import { itemHasLights, itemMechanism, toggleItemLights } from '../shared/item-interactions.js';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
+import { buildItemContextualDimensions } from './floorplan.js';
+import { itemFloorplanMoveTarget } from './floorplan-move.js';
+import { itemPaint } from './paint.js';
+import { itemParametrics } from './parametrics.js';
+import { itemPlacementNotice } from './placement-notice.js';
+// The two floor gizmos flank the item at mid-height so they never overlap,
+// even on small items: move sits past the left edge, rotate past the right
+// edge, both floated the same distance in front of the item. Mirrors the
+// wall-item layout below (WALL_SIDE_OFFSET / WALL_GIZMO_LIFT). The guide ring
+// traces a circle slightly outside the footprint's bounding circle.
+const GIZMO_SIDE_OFFSET = 0.3;
+const GIZMO_FRONT_OFFSET = 0.3;
+const ROTATE_RING_OFFSET = 0.06;
+// Whole-item rotation handle — the two-headed curved arrow. `arc-resize`
+// does the angular drag math (raycasts a horizontal plane at the gizmo's
+// Y, measures cursor bearing around the item's local origin, returns the
+// delta). Rotation snaps to 15° increments by default; holding Shift
+// bypasses that snap (handled generically in node-arrow-handles for any
+// `shape: 'rotate'`), matching the R/T rotate step for placed items. Item
+// rotation is stored as `[x, y, z]`; only the Y component turns.
+function itemRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        // Negate the cursor delta to match three.js Y-rotation handedness
+        // (positive Ry takes +X → −Z, while atan2(z, x) increases +X → +Z).
+        apply: (initial, delta) => {
+            const [rx, ry, rz] = initial.rotation ?? [0, 0, 0];
+            return { rotation: [rx, ry - delta, rz] };
+        },
+        placement: {
+            // Past the item's right edge at mid-height, floated in front. The
+            // registered item mesh carries position + rotation only (scale lives on
+            // an inner mesh), so the scaled footprint maps straight to world.
+            position: (n) => {
+                const [w, h, d] = getScaledDimensions(n);
+                return [w / 2 + GIZMO_SIDE_OFFSET, h / 2, d / 2 + GIZMO_FRONT_OFFSET];
+            },
+            // Fixed −45° tilt leans the curve toward the item's front face.
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (n) => {
+                const [w, , d] = getScaledDimensions(n);
+                return Math.hypot(w / 2, d / 2) + ROTATE_RING_OFFSET;
+            },
+            y: (n) => getScaledDimensions(n)[1] / 2,
+        },
+    };
+}
+// The 4-way move cross, just past the item's left edge. Press-drag hands the
+// item to its placement coordinator (showing the bounding box, dimension labels
+// and grid-snap ticker) and commits on release — press-drag-release motion with
+// the full placement feedback.
+function itemMoveHandle() {
+    return {
+        kind: 'tap-action',
+        shape: 'move-cross',
+        cursor: 'move',
+        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
+        placement: {
+            // Past the item's left edge at mid-height, mirroring the rotate grip on
+            // the right so the two never overlap on small items.
+            position: (n) => {
+                const [w, h, d] = getScaledDimensions(n);
+                return [-(w / 2 + GIZMO_SIDE_OFFSET), h / 2, d / 2 + GIZMO_FRONT_OFFSET];
+            },
+        },
+    };
+}
+// ---- Wall-mounted items (attachTo 'wall' / 'wall-side') ----
+// These live in the wall's local frame: position is [along-wall, up, depth]
+// and the item faces along the wall normal (its local +Z). Both gizmos use
+// `portal: 'grandparent'` so they render in the wall frame like door / window
+// handles, and sit a little off the wall surface (+Z) so they're grabbable.
+// How far off the wall surface (along the normal) the wall gizmos float, and
+// how far to either side of the item they sit.
+const WALL_GIZMO_LIFT = 0.12;
+const WALL_SIDE_OFFSET = 0.3;
+// Spin the item flat against the wall — rotation about its local +Z (the wall
+// normal), written to rotation[2]. Sits just past the item's right edge.
+function itemWallRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        rotationPlane: 'node-normal',
+        portal: 'grandparent',
+        apply: (initial, delta) => {
+            const [rx, ry, rz] = initial.rotation ?? [0, 0, 0];
+            return { rotation: [rx, ry, rz + delta] };
+        },
+        placement: {
+            position: (n) => {
+                const [w] = getScaledDimensions(n);
+                return [w / 2 + WALL_SIDE_OFFSET, 0, WALL_GIZMO_LIFT];
+            },
+        },
+    };
+}
+// Move cross past the item's left edge on the wall face. Tap to hand the item
+// to its placement coordinator (`engageMove`) — same feedback as the floating
+// move button, and the coordinator handles the wall ↔ floor ↔ ceiling
+// transitions the generic translate drag couldn't. `plane: 'node-normal'`
+// stands the cross up against the wall face.
+function itemWallMoveHandle() {
+    return {
+        kind: 'tap-action',
+        shape: 'move-cross',
+        plane: 'node-normal',
+        portal: 'grandparent',
+        cursor: 'move',
+        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
+        placement: {
+            position: (n) => {
+                const [w] = getScaledDimensions(n);
+                return [-(w / 2 + WALL_SIDE_OFFSET), 0, WALL_GIZMO_LIFT];
+            },
+        },
+    };
+}
+export const itemEditContribution = {
+    snapProfile: 'item',
+    facingIndicator: true,
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildItemContextualDimensions,
+            actionMenu: { actions: () => import('../shared/item-interaction-actions.js') },
+        },
+    },
+    capabilities: {
+        paint: itemPaint,
+    },
+    parametrics: itemParametrics,
+    // In-world rotate + move gizmos for selected items.
+    //  - Floor items: world-Y rotate + free floor-plane move cross.
+    //  - Wall items: wall-normal rotate (spin flat against the wall) + a move
+    //    cross constrained to the wall face. Both ride the wall frame.
+    //  - Ceiling items: no gizmos yet (move via the move tool).
+    handles: (node) => {
+        const attachTo = node.asset.attachTo;
+        if (attachTo === 'wall' || attachTo === 'wall-side') {
+            return [itemWallRotateHandle(), itemWallMoveHandle()];
+        }
+        if (attachTo)
+            return [];
+        return [itemRotateHandle(), itemMoveHandle()];
+    },
+    preview: () => import('./renderer.js').then(({ ItemPreview }) => ({ default: ItemPreview })),
+    // Catalog placement tool — mounted when `useEditor.tool === 'item'`.
+    // Wraps the same placement coordinator the move-tool uses (surface
+    // strategies for floor / wall / ceiling / item-surface). Replaces
+    // the legacy `editor/src/components/tools/item/item-tool.tsx`.
+    tool: () => import('./tool.js'),
+    // Stage D — 3D move-tool (registry-driven). Adopts the moving node
+    // and runs the placement coordinator with surface strategies for
+    // floor / wall / ceiling / item-surface, including attachTo
+    // *transitions* (drop a wall item on a ceiling and have it switch).
+    // Replaces the legacy `MoveItemContent` in editor's dispatcher; the
+    // `getRegistryAffordanceTool('item', 'move')` lookup picks this up.
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    floorplanAffectedIds: (args) => {
+        const ids = [...restingFloorplanAffectedIds(args)];
+        for (const node of [args.node, getEffectiveCutterNode(args.node)]) {
+            if (node.type !== 'item')
+                continue;
+            for (const cutter of node.source?.manifest.cutters ?? []) {
+                const host = resolveCutterHost(node, cutter.host === 'mounted' ? 'cutout' : `cut:${cutter.host}`, args.nodes);
+                if (host)
+                    ids.push(host.id);
+            }
+        }
+        return ids;
+    },
+    // 2D move-on-floorplan handler. Branches on `asset.attachTo`:
+    // wall items snap to walls (like door / window), ceiling items
+    // snap to ceiling polygons, floor items snap to slabs. attachTo
+    // *transitions* (drop a wall item on a ceiling) remain canonical
+    // in the 3D path; 2D only re-anchors within the same family.
+    floorplanMoveTarget: itemFloorplanMoveTarget,
+    placementNotice: itemPlacementNotice,
+    keyboardActions: {
+        e: {
+            appliesTo: (node) => itemMechanism.has(node) || itemHasLights(node),
+            // Same as the action bar: mechanisms when the item has them, otherwise its light.
+            run: (node) => itemMechanism.has(node) ? toggleMechanism(itemMechanism, node) : toggleItemLights(node),
+        },
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place item' },
+        { key: 'R / T', label: 'Rotate' },
+        { key: 'Shift', label: 'Cycle snapping mode' },
+        { key: 'Alt', label: 'Force place' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/item/definition.js

@@ -1,356 +1,4 @@
-import { getEffectiveCutterNode, getScaledDimensions, resolveCutterHost, toggleMechanism, } from '@pascal-app/core';
-import { itemHasLights, itemMechanism, toggleItemLights } from '../shared/item-interactions.js';
-import { itemBatchable } from '../shared/node-batch/batchable.js';
-import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
-import { authoredItemFaceHost } from './authored-face-host.js';
-import { buildItemContextualDimensions, buildItemFloorplan } from './floorplan.js';
-import { itemFloorplanMoveTarget } from './floorplan-move.js';
-import { itemPaint } from './paint.js';
-import { itemParametrics } from './parametrics.js';
-import { itemPlacementNotice } from './placement-notice.js';
-import { ItemNode } from './schema.js';
-// The two floor gizmos flank the item at mid-height so they never overlap,
-// even on small items: move sits past the left edge, rotate past the right
-// edge, both floated the same distance in front of the item. Mirrors the
-// wall-item layout below (WALL_SIDE_OFFSET / WALL_GIZMO_LIFT). The guide ring
-// traces a circle slightly outside the footprint's bounding circle.
-const GIZMO_SIDE_OFFSET = 0.3;
-const GIZMO_FRONT_OFFSET = 0.3;
-const ROTATE_RING_OFFSET = 0.06;
-// Whole-item rotation handle — the two-headed curved arrow. `arc-resize`
-// does the angular drag math (raycasts a horizontal plane at the gizmo's
-// Y, measures cursor bearing around the item's local origin, returns the
-// delta). Rotation snaps to 15° increments by default; holding Shift
-// bypasses that snap (handled generically in node-arrow-handles for any
-// `shape: 'rotate'`), matching the R/T rotate step for placed items. Item
-// rotation is stored as `[x, y, z]`; only the Y component turns.
-function itemRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        // Negate the cursor delta to match three.js Y-rotation handedness
-        // (positive Ry takes +X → −Z, while atan2(z, x) increases +X → +Z).
-        apply: (initial, delta) => {
-            const [rx, ry, rz] = initial.rotation ?? [0, 0, 0];
-            return { rotation: [rx, ry - delta, rz] };
-        },
-        placement: {
-            // Past the item's right edge at mid-height, floated in front. The
-            // registered item mesh carries position + rotation only (scale lives on
-            // an inner mesh), so the scaled footprint maps straight to world.
-            position: (n) => {
-                const [w, h, d] = getScaledDimensions(n);
-                return [w / 2 + GIZMO_SIDE_OFFSET, h / 2, d / 2 + GIZMO_FRONT_OFFSET];
-            },
-            // Fixed −45° tilt leans the curve toward the item's front face.
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            radius: (n) => {
-                const [w, , d] = getScaledDimensions(n);
-                return Math.hypot(w / 2, d / 2) + ROTATE_RING_OFFSET;
-            },
-            y: (n) => getScaledDimensions(n)[1] / 2,
-        },
-    };
-}
-// The 4-way move cross, just past the item's left edge. Press-drag hands the
-// item to its placement coordinator (showing the bounding box, dimension labels
-// and grid-snap ticker) and commits on release — press-drag-release motion with
-// the full placement feedback.
-function itemMoveHandle() {
-    return {
-        kind: 'tap-action',
-        shape: 'move-cross',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
-        placement: {
-            // Past the item's left edge at mid-height, mirroring the rotate grip on
-            // the right so the two never overlap on small items.
-            position: (n) => {
-                const [w, h, d] = getScaledDimensions(n);
-                return [-(w / 2 + GIZMO_SIDE_OFFSET), h / 2, d / 2 + GIZMO_FRONT_OFFSET];
-            },
-        },
-    };
-}
-// ---- Wall-mounted items (attachTo 'wall' / 'wall-side') ----
-// These live in the wall's local frame: position is [along-wall, up, depth]
-// and the item faces along the wall normal (its local +Z). Both gizmos use
-// `portal: 'grandparent'` so they render in the wall frame like door / window
-// handles, and sit a little off the wall surface (+Z) so they're grabbable.
-// How far off the wall surface (along the normal) the wall gizmos float, and
-// how far to either side of the item they sit.
-const WALL_GIZMO_LIFT = 0.12;
-const WALL_SIDE_OFFSET = 0.3;
-// Spin the item flat against the wall — rotation about its local +Z (the wall
-// normal), written to rotation[2]. Sits just past the item's right edge.
-function itemWallRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        rotationPlane: 'node-normal',
-        portal: 'grandparent',
-        apply: (initial, delta) => {
-            const [rx, ry, rz] = initial.rotation ?? [0, 0, 0];
-            return { rotation: [rx, ry, rz + delta] };
-        },
-        placement: {
-            position: (n) => {
-                const [w] = getScaledDimensions(n);
-                return [w / 2 + WALL_SIDE_OFFSET, 0, WALL_GIZMO_LIFT];
-            },
-        },
-    };
-}
-// Move cross past the item's left edge on the wall face. Tap to hand the item
-// to its placement coordinator (`engageMove`) — same feedback as the floating
-// move button, and the coordinator handles the wall ↔ floor ↔ ceiling
-// transitions the generic translate drag couldn't. `plane: 'node-normal'`
-// stands the cross up against the wall face.
-function itemWallMoveHandle() {
-    return {
-        kind: 'tap-action',
-        shape: 'move-cross',
-        plane: 'node-normal',
-        portal: 'grandparent',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
-        placement: {
-            position: (n) => {
-                const [w] = getScaledDimensions(n);
-                return [-(w / 2 + WALL_SIDE_OFFSET), 0, WALL_GIZMO_LIFT];
-            },
-        },
-    };
-}
-/**
- * Item — Phase 5 batch kind. Catalog-backed, GLB-rendered, multi-host.
- *
- * Demonstrates the **custom `def.renderer` escape hatch** ("Opting out of a
- * generic path" in wiki/architecture/node-definitions.md): items use `useGLTF` from drei to
- * load CDN assets, plus a non-trivial interactive-widget layer inside
- * the rendered scene. Not expressible as a pure `def.geometry`. The
- * registry mounts the custom React renderer as-is.
- *
- * Capabilities:
- *  - **No `movable`**: item's move is bespoke `MoveItemContent` —
- *    handles attachTo transitions mid-drag (floor ↔ wall ↔ ceiling),
- *    asset.attachTo lookups, scale-preserving Y math for surface
- *    placement. The smooth generic mover can't express that. Legacy
- *    mover keeps running via capability-driven dispatch.
- *  - `selectable`, `duplicable`, `deletable` standard.
- *
- * Stages:
- *  - A: registered.
- *  - B: N/A — def.renderer escape hatch (GLB / useGLTF).
- *  - C: `def.floorplan` resolves parent chain via `ctx.resolve`,
- *    returns a rotated rectangle (width × depth). Mirrors the legacy
- *    `getItemFloorplanTransform` math. Legacy `floorplanItemEntries`
- *    short-circuits when item is registered.
- *
- * `toolHints`: matches the legacy ItemHelper UI (mouse / R / T / Shift /
- * Esc) — registry-driven placement panel.
- */
-export const itemDefinition = {
-    kind: 'item',
-    snapProfile: 'item',
-    facingIndicator: true,
-    schemaVersion: 2,
-    schema: ItemNode,
-    category: 'furnish',
-    surfaceRole: 'furnishing',
-    extensions: {
-        'pascal:editor/floorplan': {
-            contextualDimensions: buildItemContextualDimensions,
-            actionMenu: { actions: () => import('../shared/item-interaction-actions.js') },
-        },
-    },
-    // Defaults shape is cast: the schema requires a fully-typed `asset`
-    // field, but in practice items are always created from the catalog
-    // (the asset is supplied at placement time). `createNode` re-parses
-    // through the schema, so any missing zod defaults fill at runtime.
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        children: [],
-        position: [0, 0, 0],
-        rotation: [0, 0, 0],
-        scale: [1, 1, 1],
-        asset: {
-            id: 'placeholder',
-            category: 'misc',
-            name: 'Item',
-            thumbnail: '',
-            src: 'asset:placeholder',
-            dimensions: [1, 1, 1],
-            source: 'library',
-        },
-    }),
-    capabilities: {
-        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
-        revealOnEdit: ['scale'],
-        batchable: itemBatchable,
-        selectable: { hitVolume: 'bbox' },
-        // Authored objects host ceiling items on their undersides; catalog items do not.
-        faceHost: authoredItemFaceHost,
-        surfaces: {
-            top: {
-                height: (node) => {
-                    const item = node;
-                    return (item.asset.surface?.height ?? item.asset.dimensions[1]) * item.scale[1];
-                },
-            },
-        },
-        duplicable: { subtree: 'with-children' },
-        deletable: true,
-        paint: itemPaint,
-        mechanism: itemMechanism,
-        // Items participate in compositions — e.g. "table-with-plants",
-        // "shelf-with-books-on-top" — so they're presettable in their own
-        // right (and as descendants of presettable parents). The GLB-kind
-        // catalog still exists alongside; preset-flavoured items become
-        // siblings of GLB items inside the unified `items` table.
-        //
-        // Items can be hosted on walls (assets with `attachTo: 'wall'`)
-        // via `wallId` + `wallT`, or on a roof-segment wall face via
-        // `roofSegmentId`. When a composition that includes a wall-hosted
-        // item is saved as a preset (a sconce, a hanging shelf, etc.), the
-        // host app strips these via `getHostRefFields(def)` so the
-        // descendant re-attaches against the new host geometry at
-        // placement time.
-        hostRefFields: ['wallId', 'wallT', 'roofSegmentId', 'roofFace', 'blockFaceId'],
-        // Floor items get lifted by slabs underneath via the generic
-        // `<FloorElevationSystem>`. Wall- / ceiling-attached items live in
-        // their parent's local frame and skip the lift via `applies`.
-        floorPlaced: {
-            footprint: (node) => {
-                const item = node;
-                return { dimensions: getScaledDimensions(item), rotation: item.rotation };
-            },
-            applies: (node) => !node.asset.attachTo,
-            collides: true,
-        },
-        // Recessed ceiling fixtures cut a hole in their host ceiling. The viewer's
-        // CeilingSystem queries this capability on each child of a ceiling so it
-        // never needs to branch on `node.type`.
-        ceilingCut: {
-            buildCeilingHole(rawNode) {
-                const node = rawNode;
-                if (!node.asset.recessed || node.asset.attachTo !== 'ceiling')
-                    return null;
-                // Inset slightly so the fixture's trim (widest part, sitting in the
-                // ceiling plane) overlaps the solid ceiling around the opening and hides
-                // the cut edge. Same constant the old ceiling-system used.
-                const INSET = 0.82;
-                const [width, , depth] = getScaledDimensions(node);
-                const halfW = (width / 2) * INSET;
-                const halfD = (depth / 2) * INSET;
-                const cx = node.position[0];
-                const cz = node.position[2];
-                const yaw = node.rotation?.[1] ?? 0;
-                const cos = Math.cos(yaw);
-                const sin = Math.sin(yaw);
-                // Rotate the (inset) footprint corners about Y and translate to the
-                // item's plan position. Y-rotation of (dx, dz): (dx·cos + dz·sin, −dx·sin + dz·cos).
-                return [
-                    [-halfW, -halfD],
-                    [halfW, -halfD],
-                    [halfW, halfD],
-                    [-halfW, halfD],
-                ].map(([dx, dz]) => [cx + dx * cos + dz * sin, cz - dx * sin + dz * cos]);
-            },
-        },
-    },
-    parametrics: itemParametrics,
-    // In-world rotate + move gizmos for selected items.
-    //  - Floor items: world-Y rotate + free floor-plane move cross.
-    //  - Wall items: wall-normal rotate (spin flat against the wall) + a move
-    //    cross constrained to the wall face. Both ride the wall frame.
-    //  - Ceiling items: no gizmos yet (move via the move tool).
-    handles: (node) => {
-        const attachTo = node.asset.attachTo;
-        if (attachTo === 'wall' || attachTo === 'wall-side') {
-            return [itemWallRotateHandle(), itemWallMoveHandle()];
-        }
-        if (attachTo)
-            return [];
-        return [itemRotateHandle(), itemMoveHandle()];
-    },
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./renderer.js').then(({ ItemPreview }) => ({ default: ItemPreview })),
-    system: {
-        module: () => import('./system.js'),
-        // Same priority as the legacy ItemSystem.
-        priority: 2,
-    },
-    // Catalog placement tool — mounted when `useEditor.tool === 'item'`.
-    // Wraps the same placement coordinator the move-tool uses (surface
-    // strategies for floor / wall / ceiling / item-surface). Replaces
-    // the legacy `editor/src/components/tools/item/item-tool.tsx`.
-    tool: () => import('./tool.js'),
-    // Stage D — 3D move-tool (registry-driven). Adopts the moving node
-    // and runs the placement coordinator with surface strategies for
-    // floor / wall / ceiling / item-surface, including attachTo
-    // *transitions* (drop a wall item on a ceiling and have it switch).
-    // Replaces the legacy `MoveItemContent` in editor's dispatcher; the
-    // `getRegistryAffordanceTool('item', 'move')` lookup picks this up.
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    // Stage C: floor-plan polygon. ctx.resolve walks the parent chain
-    // (wall / nested item / level) to compute the world-space transform.
-    floorplan: buildItemFloorplan,
-    floorplanAffectedIds: (args) => {
-        const ids = [...restingFloorplanAffectedIds(args)];
-        for (const node of [args.node, getEffectiveCutterNode(args.node)]) {
-            if (node.type !== 'item')
-                continue;
-            for (const cutter of node.source?.manifest.cutters ?? []) {
-                const host = resolveCutterHost(node, cutter.host === 'mounted' ? 'cutout' : `cut:${cutter.host}`, args.nodes);
-                if (host)
-                    ids.push(host.id);
-            }
-        }
-        return ids;
-    },
-    // 2D move-on-floorplan handler. Branches on `asset.attachTo`:
-    // wall items snap to walls (like door / window), ceiling items
-    // snap to ceiling polygons, floor items snap to slabs. attachTo
-    // *transitions* (drop a wall item on a ceiling) remain canonical
-    // in the 3D path; 2D only re-anchors within the same family.
-    floorplanMoveTarget: itemFloorplanMoveTarget,
-    placementNotice: itemPlacementNotice,
-    keyboardActions: {
-        e: {
-            appliesTo: (node) => itemMechanism.has(node) || itemHasLights(node),
-            // Same as the action bar: mechanisms when the item has them, otherwise its light.
-            run: (node) => itemMechanism.has(node) ? toggleMechanism(itemMechanism, node) : toggleItemLights(node),
-        },
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place item' },
-        { key: 'R / T', label: 'Rotate' },
-        { key: 'Shift', label: 'Cycle snapping mode' },
-        { key: 'Alt', label: 'Force place' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Item',
-        description: 'A catalog-backed item (furniture, fixtures, decorations).',
-        icon: { kind: 'url', src: '/icons/item.webp' },
-        paletteSection: 'furnish',
-        paletteOrder: 10,
-    },
-    mcp: {
-        description: 'A catalog-backed item with asset reference, transforms, and optional attachTo for wall/ceiling mounting.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { itemEditContribution } from './definition.edit.js';
+import { itemRenderDefinition } from './definition.render.js';
+export const itemDefinition = composeNodeDefinition(itemRenderDefinition, itemEditContribution);

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

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

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

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