@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/procedural-item/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgD,cAAc,EAAE,MAAM,kBAAkB,CAAA;AASpG,OAAO,EAML,kBAAkB,EAYnB,MAAM,mCAAmC,CAAA;AA6E1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAiS9E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGpC,CAAA"}

package/dist/procedural-item/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import { type ProceduralItemNode } from '@pascal-app/core/procedural-items';
+import type { NodeEditContribution } from '../definition-contributions.js';
+export declare const proceduralItemEditContribution: NodeEditContribution<typeof ProceduralItemNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/procedural-item/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.edit.ts"],"names":[],"mappings":"AAUA,OAAO,EAML,KAAK,kBAAkB,EAUxB,MAAM,mCAAmC,CAAA;AAK1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AA4EvE,eAAO,MAAM,8BAA8B,EAAE,oBAAoB,CAAC,OAAO,kBAAkB,CAuN1F,CAAA"}

package/dist/procedural-item/definition.edit.js

@@ -0,0 +1,255 @@
+import { getEffectiveNode, toggleMechanism, useInteractive, useScene, } from '@pascal-app/core';
+import { boundsOf, boxCorners, evaluateRecipe, frame, operableParts, parameterPatch, proceduralCeilingHole, proceduralSlotColor, queryProceduralItem, resolveProceduralWallPlacement, setProceduralMaterial, snapParameters, transformPoint, validateProceduralRelations, } from '@pascal-app/core/procedural-items';
+import { usePlacementPreview } from '@pascal-app/editor';
+import { decorateProceduralEmission } from '@pascal-app/viewer';
+import { itemPaint } from '../item/paint.js';
+import { proceduralMechanism, toggleItemLights } from '../shared/item-interactions.js';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
+import { proceduralFloorplanMoveTarget } from './move-session.js';
+const GIZMO_SIDE_OFFSET = 0.3;
+const GIZMO_FRONT_OFFSET = 0.3;
+const ROTATE_RING_OFFSET = 0.06;
+function handleBounds(node, part) {
+    const e = evaluateRecipe(node.recipe, node.parameters);
+    const shapes = part ? e.shapes.filter((shape) => shape.partId === part) : [];
+    return shapes.length
+        ? boundsOf(shapes.flatMap((shape) => shape.primitive === 'ellipsoid'
+            ? (() => {
+                const axes = frame(shape.position, shape.rotation).axes;
+                const extent = [0, 1, 2].map((i) => Math.hypot(...axes.map((axis, j) => (axis[i] * shape.size[j]) / 2)));
+                return boxCorners(shape.position.map((v, i) => v - extent[i]), shape.position.map((v, i) => v + extent[i]));
+            })()
+            : boxCorners(shape.size.map((v) => -v / 2), shape.size.map((v) => v / 2)).map((point) => transformPoint(frame(shape.position, shape.rotation), point))))
+        : e;
+}
+function proceduralRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => {
+            const [rx, ry, rz] = initial.rotation;
+            return { rotation: [rx, ry - delta, rz] };
+        },
+        placement: {
+            position: (n) => {
+                const b = evaluateRecipe(n.recipe, n.parameters);
+                return [
+                    b.max[0] + GIZMO_SIDE_OFFSET,
+                    (b.min[1] + b.max[1]) / 2,
+                    b.max[2] + GIZMO_FRONT_OFFSET,
+                ];
+            },
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            center: (n) => {
+                const b = evaluateRecipe(n.recipe, n.parameters);
+                return b.min.map((v, i) => (v + b.max[i]) / 2);
+            },
+            radius: (n) => {
+                const b = evaluateRecipe(n.recipe, n.parameters);
+                return Math.hypot(b.dimensions[0] / 2, b.dimensions[2] / 2) + ROTATE_RING_OFFSET;
+            },
+            y: (n) => {
+                const b = evaluateRecipe(n.recipe, n.parameters);
+                return (b.min[1] + b.max[1]) / 2;
+            },
+        },
+    };
+}
+export const proceduralItemEditContribution = {
+    snapProfile: 'item',
+    extensions: {
+        'pascal:editor/floorplan': {
+            directDrag: true,
+            actionMenu: { actions: () => import('../shared/item-interaction-actions.js') },
+        },
+    },
+    capabilities: {
+        // A v2 ceiling design with `cuts` opens its host ceiling (CeilingSystem dispatch).
+        ceilingCut: {
+            // Follows the live gesture (R2): a move preview cuts where it sits; handle and slider
+            // overrides cut at their live values; a hidden design (the move's source) cuts nothing.
+            buildCeilingHole: (n) => {
+                const preview = usePlacementPreview.getState().node;
+                if (preview?.id === n.id && preview.type === 'procedural-item')
+                    return preview.parentId === n.parentId ? proceduralCeilingHole(preview) : null;
+                const node = getEffectiveNode(n);
+                return node.visible === false ? null : proceduralCeilingHole(node);
+            },
+            // A design being moved onto another ceiling cuts it before it becomes its child.
+            holesFor: (ceiling) => {
+                const preview = usePlacementPreview.getState().node;
+                if (preview?.type !== 'procedural-item' || preview.parentId !== ceiling.id)
+                    return [];
+                const moving = useScene.getState().nodes[preview.id];
+                if (!moving || moving.parentId === ceiling.id)
+                    return [];
+                const hole = proceduralCeilingHole(preview);
+                return hole ? [hole] : [];
+            },
+        },
+        paint: {
+            ...itemPaint,
+            commit: ({ node, role, material, materialPreset }) => setProceduralMaterial(node.id, role, materialPreset, material),
+            applyPreview: (args) => {
+                const restore = itemPaint.applyPreview?.(args);
+                if (!restore)
+                    return restore;
+                const node = args.node;
+                if (node?.type !== 'procedural-item')
+                    return restore;
+                const lights = evaluateRecipe(node.recipe, node.parameters).lights;
+                const restoreEmission = decorateProceduralEmission(args.root, lights, useInteractive.getState().procedural[node.id]?.lightsOn ??
+                    useInteractive.getState().lampDefault);
+                return () => {
+                    restoreEmission();
+                    restore();
+                };
+            },
+        },
+    },
+    parametrics: { groups: [], customPanel: () => import('@pascal-app/editor/procedural-items') },
+    affordanceTools: { move: () => import('./move-tool.js') },
+    floorplanMoveTarget: proceduralFloorplanMoveTarget,
+    floorplanAffectedIds: restingFloorplanAffectedIds,
+    keyboardActions: {
+        e: {
+            appliesTo: (n) => {
+                const recipe = n.recipe;
+                return operableParts(recipe).length > 0 || recipe.parts.some((part) => part.light);
+            },
+            run: (n) => proceduralMechanism.has(n) ? toggleMechanism(proceduralMechanism, n) : toggleItemLights(n),
+        },
+        r: {
+            appliesTo: (n) => Boolean(n.wallId),
+            run: (n) => {
+                const node = n;
+                const nodes = useScene.getState().nodes;
+                const wall = nodes[node.wallId];
+                if (wall?.type !== 'wall')
+                    return;
+                const next = resolveProceduralWallPlacement(node, wall, node.position[0], node.position[1], node.side === 'back' ? 'front' : 'back', nodes);
+                if (next)
+                    useScene.getState().updateNode(node.id, {
+                        side: next.side,
+                        position: [next.position[0], next.position[1], node.position[2]],
+                    });
+            },
+        },
+    },
+    handles: (node) => {
+        const result = [];
+        for (const p of node.recipe.parameters) {
+            if (!p.axis)
+                continue;
+            const axis = p.axis, index = axis === 'x' ? 0 : axis === 'y' ? 1 : 2;
+            const downward = axis === 'y' && node.recipe.mounting?.attachTo === 'ceiling';
+            result.push({
+                kind: 'linear-resize',
+                latchGroup: p.part,
+                faceNormal: Boolean(node.wallId),
+                portal: node.recipe.mounting ? 'grandparent' : 'self',
+                axis,
+                direction: downward ? -1 : undefined,
+                anchor: axis === 'y' ? (downward ? 'max' : 'min') : 'center',
+                min: p.min,
+                max: p.max,
+                currentValue: (n) => n.parameters[p.id] ?? p.default,
+                apply: (n, v, scene) => {
+                    const patch = parameterPatch(n, p.id, Math.min(p.max, Math.max(p.min, v)));
+                    if (!patch)
+                        return {};
+                    try {
+                        validateProceduralRelations({ ...n, ...patch }, scene.nodes());
+                        validateProceduralRelations({ ...n, parameters: snapParameters(n.recipe, patch.parameters) }, scene.nodes());
+                        return patch;
+                    }
+                    catch {
+                        return {};
+                    }
+                },
+                commit: (n, patch, scene) => {
+                    const parameters = snapParameters(n.recipe, patch.parameters ?? n.parameters);
+                    validateProceduralRelations({ ...n, parameters }, scene.nodes());
+                    scene.update(n.id, { parameters });
+                },
+                placement: {
+                    clearance: {
+                        edge: (n) => handleBounds(n, p.part)[downward ? 'min' : 'max'][index],
+                        distance: 0.4,
+                    },
+                    position: (n) => {
+                        const b = handleBounds(n, p.part);
+                        const pos = b.max.map((v, i) => (i === index ? v + 0.15 : (b.min[i] + v) / 2));
+                        if (downward)
+                            pos[index] = b.min[index] - 0.15;
+                        return pos;
+                    },
+                },
+            });
+        }
+        if (node.recipe.mounting?.attachTo !== 'wall-side')
+            result.push({
+                ...proceduralRotateHandle(),
+                portal: node.recipe.mounting ? 'grandparent' : 'self',
+            });
+        return result;
+    },
+    floorplan: (node, ctx) => {
+        const chain = { [node.id]: node };
+        let current = node.parentId, depth = 0;
+        while (current && depth++ < 32) {
+            const parent = ctx.resolve(current);
+            if (!parent)
+                break;
+            chain[current] = parent;
+            current = parent.parentId;
+        }
+        const q = queryProceduralItem(node, chain), b = q.levelBounds;
+        const floorPlanUrl = node.metadata.floorPlanUrl;
+        if (typeof floorPlanUrl === 'string' && floorPlanUrl.trim()) {
+            const local = q.localBounds;
+            const center = transformPoint(q.frame, local.min.map((v, i) => (v + local.max[i]) / 2));
+            const points = [
+                [local.min[0], local.min[2]],
+                [local.max[0], local.min[2]],
+                [local.max[0], local.max[2]],
+                [local.min[0], local.max[2]],
+            ].map(([x, z]) => {
+                const point = transformPoint(q.frame, [x, 0, z]);
+                return [point[0], point[2]];
+            });
+            const selected = ctx.viewState?.selected || ctx.viewState?.highlighted;
+            const stroke = selected ? (ctx.viewState?.palette?.selectedStroke ?? '#3b82f6') : '#92400e';
+            const strokeWidth = selected ? 0.035 : 0.012;
+            const children = [
+                { kind: 'polygon', points, fill: 'transparent', stroke, strokeWidth, opacity: 0.85 },
+                {
+                    kind: 'image',
+                    url: floorPlanUrl,
+                    center: [center[0], center[2]],
+                    width: local.dimensions[0],
+                    height: local.dimensions[2],
+                    rotation: Math.atan2(q.frame.axes[0][2], q.frame.axes[0][0]),
+                },
+            ];
+            if (selected)
+                children.push({ kind: 'polygon', points, fill: 'none', stroke, strokeWidth });
+            return { kind: 'group', children };
+        }
+        return {
+            kind: 'rect',
+            x: b.min[0],
+            y: b.min[2],
+            width: b.dimensions[0],
+            height: b.dimensions[2],
+            fill: proceduralSlotColor(node.slots[node.recipe.slots[0].id], node.recipe.slots[0].color, ctx.materials ?? {}),
+            stroke: '#44403c',
+            strokeWidth: 0.01,
+        };
+    },
+    renderer: { kind: 'parametric', module: () => import('./renderer.edit.js') },
+};

package/dist/procedural-item/definition.js

@@ -1,325 +1,4 @@
-import { getEffectiveNode, proceduralItemSlots, toggleMechanism, useInteractive, useScene, } from '@pascal-app/core';
-import { boundsOf, boxCorners, evaluateRecipe, frame, operableParts, ProceduralItemNode, parameterPatch, proceduralCeilingHole, proceduralFootprint, proceduralSlotColor, queryProceduralItem, resolveProceduralWallPlacement, setProceduralMaterial, shelfRecipe, snapParameters, transformPoint, validateProceduralRelations, } from '@pascal-app/core/procedural-items';
-import { usePlacementPreview } from '@pascal-app/editor';
-import { decorateProceduralEmission } from '@pascal-app/viewer';
-import { itemPaint } from '../item/paint.js';
-import { proceduralMechanism, toggleItemLights } from '../shared/item-interactions.js';
-import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
-import { bakeProceduralAnimationClips, isProceduralMotionPlaying } from './animation.js';
-import { proceduralFloorplanMoveTarget } from './move-session.js';
-const GIZMO_SIDE_OFFSET = 0.3;
-const GIZMO_FRONT_OFFSET = 0.3;
-const ROTATE_RING_OFFSET = 0.06;
-function handleBounds(node, part) {
-    const e = evaluateRecipe(node.recipe, node.parameters);
-    const shapes = part ? e.shapes.filter((shape) => shape.partId === part) : [];
-    return shapes.length
-        ? boundsOf(shapes.flatMap((shape) => shape.primitive === 'ellipsoid'
-            ? (() => {
-                const axes = frame(shape.position, shape.rotation).axes;
-                const extent = [0, 1, 2].map((i) => Math.hypot(...axes.map((axis, j) => (axis[i] * shape.size[j]) / 2)));
-                return boxCorners(shape.position.map((v, i) => v - extent[i]), shape.position.map((v, i) => v + extent[i]));
-            })()
-            : boxCorners(shape.size.map((v) => -v / 2), shape.size.map((v) => v / 2)).map((point) => transformPoint(frame(shape.position, shape.rotation), point))))
-        : e;
-}
-function proceduralRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta) => {
-            const [rx, ry, rz] = initial.rotation;
-            return { rotation: [rx, ry - delta, rz] };
-        },
-        placement: {
-            position: (n) => {
-                const b = evaluateRecipe(n.recipe, n.parameters);
-                return [
-                    b.max[0] + GIZMO_SIDE_OFFSET,
-                    (b.min[1] + b.max[1]) / 2,
-                    b.max[2] + GIZMO_FRONT_OFFSET,
-                ];
-            },
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            center: (n) => {
-                const b = evaluateRecipe(n.recipe, n.parameters);
-                return b.min.map((v, i) => (v + b.max[i]) / 2);
-            },
-            radius: (n) => {
-                const b = evaluateRecipe(n.recipe, n.parameters);
-                return Math.hypot(b.dimensions[0] / 2, b.dimensions[2] / 2) + ROTATE_RING_OFFSET;
-            },
-            y: (n) => {
-                const b = evaluateRecipe(n.recipe, n.parameters);
-                return (b.min[1] + b.max[1]) / 2;
-            },
-        },
-    };
-}
-export const proceduralItemDefinition = {
-    kind: 'procedural-item',
-    schemaVersion: 1,
-    schema: ProceduralItemNode,
-    category: 'furnish',
-    snapProfile: 'item',
-    surfaceRole: 'furnishing',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        recipe: shelfRecipe,
-        parameters: {},
-        slots: {},
-        children: [],
-        attachments: {},
-        position: [0, 0, 0],
-        rotation: [0, 0, 0],
-    }),
-    extensions: {
-        'pascal:editor/floorplan': {
-            directDrag: true,
-            actionMenu: { actions: () => import('../shared/item-interaction-actions.js') },
-        },
-    },
-    capabilities: {
-        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
-        revealOnEdit: ['recipe'],
-        batchable: {
-            scope: 'level',
-            // Part lights clone their emissive slot per node, and a playing motion
-            // moves meshes under the static copy.
-            excluded: (n) => n.recipe.parts.some((part) => part.light) ||
-                isProceduralMotionPlaying(n.id),
-        },
-        selectable: { hitVolume: 'bbox' },
-        mechanism: proceduralMechanism,
-        dragBounds: (n) => {
-            const node = n;
-            const e = evaluateRecipe(node.recipe, node.parameters);
-            return {
-                size: e.dimensions,
-                center: e.min.map((v, i) => (v + e.max[i]) / 2),
-            };
-        },
-        hostable: {
-            parents: ['level', 'wall', 'ceiling', 'procedural-item', 'item', 'shelf'],
-            align: 'face',
-        },
-        hostRefFields: ['wallId', 'side', 'supportSlabId'],
-        // A v2 ceiling design with `cuts` opens its host ceiling (CeilingSystem dispatch).
-        ceilingCut: {
-            // Follows the live gesture (R2): a move preview cuts where it sits; handle and slider
-            // overrides cut at their live values; a hidden design (the move's source) cuts nothing.
-            buildCeilingHole: (n) => {
-                const preview = usePlacementPreview.getState().node;
-                if (preview?.id === n.id && preview.type === 'procedural-item')
-                    return preview.parentId === n.parentId ? proceduralCeilingHole(preview) : null;
-                const node = getEffectiveNode(n);
-                return node.visible === false ? null : proceduralCeilingHole(node);
-            },
-            // A design being moved onto another ceiling cuts it before it becomes its child.
-            holesFor: (ceiling) => {
-                const preview = usePlacementPreview.getState().node;
-                if (preview?.type !== 'procedural-item' || preview.parentId !== ceiling.id)
-                    return [];
-                const moving = useScene.getState().nodes[preview.id];
-                if (!moving || moving.parentId === ceiling.id)
-                    return [];
-                const hole = proceduralCeilingHole(preview);
-                return hole ? [hole] : [];
-            },
-        },
-        floorPlaced: {
-            footprint: (n) => proceduralFootprint(n),
-            applies: (n) => !n.recipe.mounting,
-            collides: true,
-        },
-        movable: { axes: ['x', 'z'], gridSnap: true },
-        rotatable: { axes: ['y'], snapAngles: [0, Math.PI / 4, Math.PI / 2, Math.PI] },
-        duplicable: { subtree: 'with-children' },
-        deletable: true,
-        slots: (n) => proceduralItemSlots(n),
-        surfaces: {
-            custom: (n) => evaluateRecipe(n.recipe, n.parameters).surfaces.map((s) => ({
-                id: s.id,
-                position: s.position,
-                normal: s.normal,
-                rotation: s.rotation,
-                size: s.size,
-            })),
-        },
-        paint: {
-            ...itemPaint,
-            commit: ({ node, role, material, materialPreset }) => setProceduralMaterial(node.id, role, materialPreset, material),
-            applyPreview: (args) => {
-                const restore = itemPaint.applyPreview?.(args);
-                if (!restore)
-                    return restore;
-                const node = args.node;
-                if (node?.type !== 'procedural-item')
-                    return restore;
-                const lights = evaluateRecipe(node.recipe, node.parameters).lights;
-                const restoreEmission = decorateProceduralEmission(args.root, lights, useInteractive.getState().procedural[node.id]?.lightsOn ??
-                    useInteractive.getState().lampDefault);
-                return () => {
-                    restoreEmission();
-                    restore();
-                };
-            },
-        },
-    },
-    relations: { hosts: ['item', 'procedural-item'], cascadeDelete: 'descendants' },
-    renderer: { kind: 'parametric', module: () => import('./renderer.js') },
-    exportAnimation: ({ node, object }) => bakeProceduralAnimationClips(node, object),
-    parametrics: { groups: [], customPanel: () => import('@pascal-app/editor/procedural-items') },
-    affordanceTools: { move: () => import('./move-tool.js') },
-    floorplanMoveTarget: proceduralFloorplanMoveTarget,
-    floorplanAffectedIds: restingFloorplanAffectedIds,
-    keyboardActions: {
-        e: {
-            appliesTo: (n) => {
-                const recipe = n.recipe;
-                return operableParts(recipe).length > 0 || recipe.parts.some((part) => part.light);
-            },
-            run: (n) => proceduralMechanism.has(n) ? toggleMechanism(proceduralMechanism, n) : toggleItemLights(n),
-        },
-        r: {
-            appliesTo: (n) => Boolean(n.wallId),
-            run: (n) => {
-                const node = n;
-                const nodes = useScene.getState().nodes;
-                const wall = nodes[node.wallId];
-                if (wall?.type !== 'wall')
-                    return;
-                const next = resolveProceduralWallPlacement(node, wall, node.position[0], node.position[1], node.side === 'back' ? 'front' : 'back', nodes);
-                if (next)
-                    useScene.getState().updateNode(node.id, {
-                        side: next.side,
-                        position: [next.position[0], next.position[1], node.position[2]],
-                    });
-            },
-        },
-    },
-    handles: (node) => {
-        const result = [];
-        for (const p of node.recipe.parameters) {
-            if (!p.axis)
-                continue;
-            const axis = p.axis, index = axis === 'x' ? 0 : axis === 'y' ? 1 : 2;
-            const downward = axis === 'y' && node.recipe.mounting?.attachTo === 'ceiling';
-            result.push({
-                kind: 'linear-resize',
-                latchGroup: p.part,
-                faceNormal: Boolean(node.wallId),
-                portal: node.recipe.mounting ? 'grandparent' : 'self',
-                axis,
-                direction: downward ? -1 : undefined,
-                anchor: axis === 'y' ? (downward ? 'max' : 'min') : 'center',
-                min: p.min,
-                max: p.max,
-                currentValue: (n) => n.parameters[p.id] ?? p.default,
-                apply: (n, v, scene) => {
-                    const patch = parameterPatch(n, p.id, Math.min(p.max, Math.max(p.min, v)));
-                    if (!patch)
-                        return {};
-                    try {
-                        validateProceduralRelations({ ...n, ...patch }, scene.nodes());
-                        validateProceduralRelations({ ...n, parameters: snapParameters(n.recipe, patch.parameters) }, scene.nodes());
-                        return patch;
-                    }
-                    catch {
-                        return {};
-                    }
-                },
-                commit: (n, patch, scene) => {
-                    const parameters = snapParameters(n.recipe, patch.parameters ?? n.parameters);
-                    validateProceduralRelations({ ...n, parameters }, scene.nodes());
-                    scene.update(n.id, { parameters });
-                },
-                placement: {
-                    clearance: {
-                        edge: (n) => handleBounds(n, p.part)[downward ? 'min' : 'max'][index],
-                        distance: 0.4,
-                    },
-                    position: (n) => {
-                        const b = handleBounds(n, p.part);
-                        const pos = b.max.map((v, i) => (i === index ? v + 0.15 : (b.min[i] + v) / 2));
-                        if (downward)
-                            pos[index] = b.min[index] - 0.15;
-                        return pos;
-                    },
-                },
-            });
-        }
-        if (node.recipe.mounting?.attachTo !== 'wall-side')
-            result.push({
-                ...proceduralRotateHandle(),
-                portal: node.recipe.mounting ? 'grandparent' : 'self',
-            });
-        return result;
-    },
-    floorplan: (node, ctx) => {
-        const chain = { [node.id]: node };
-        let current = node.parentId, depth = 0;
-        while (current && depth++ < 32) {
-            const parent = ctx.resolve(current);
-            if (!parent)
-                break;
-            chain[current] = parent;
-            current = parent.parentId;
-        }
-        const q = queryProceduralItem(node, chain), b = q.levelBounds;
-        const floorPlanUrl = node.metadata.floorPlanUrl;
-        if (typeof floorPlanUrl === 'string' && floorPlanUrl.trim()) {
-            const local = q.localBounds;
-            const center = transformPoint(q.frame, local.min.map((v, i) => (v + local.max[i]) / 2));
-            const points = [
-                [local.min[0], local.min[2]],
-                [local.max[0], local.min[2]],
-                [local.max[0], local.max[2]],
-                [local.min[0], local.max[2]],
-            ].map(([x, z]) => {
-                const point = transformPoint(q.frame, [x, 0, z]);
-                return [point[0], point[2]];
-            });
-            const selected = ctx.viewState?.selected || ctx.viewState?.highlighted;
-            const stroke = selected ? (ctx.viewState?.palette?.selectedStroke ?? '#3b82f6') : '#92400e';
-            const strokeWidth = selected ? 0.035 : 0.012;
-            const children = [
-                { kind: 'polygon', points, fill: 'transparent', stroke, strokeWidth, opacity: 0.85 },
-                {
-                    kind: 'image',
-                    url: floorPlanUrl,
-                    center: [center[0], center[2]],
-                    width: local.dimensions[0],
-                    height: local.dimensions[2],
-                    rotation: Math.atan2(q.frame.axes[0][2], q.frame.axes[0][0]),
-                },
-            ];
-            if (selected)
-                children.push({ kind: 'polygon', points, fill: 'none', stroke, strokeWidth });
-            return { kind: 'group', children };
-        }
-        return {
-            kind: 'rect',
-            x: b.min[0],
-            y: b.min[2],
-            width: b.dimensions[0],
-            height: b.dimensions[2],
-            fill: proceduralSlotColor(node.slots[node.recipe.slots[0].id], node.recipe.slots[0].color, ctx.materials ?? {}),
-            stroke: '#44403c',
-            strokeWidth: 0.01,
-        };
-    },
-    presentation: {
-        label: 'Procedural item',
-        description: 'Experimental editable recipe',
-        icon: { kind: 'iconify', name: 'lucide:boxes' },
-    },
-    mcp: { description: 'Experimental procedural item with a validated recipe.' },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { proceduralItemEditContribution } from './definition.edit.js';
+import { proceduralItemRenderDefinition } from './definition.render.js';
+export const proceduralItemDefinition = composeNodeDefinition(proceduralItemRenderDefinition, proceduralItemEditContribution);

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

@@ -0,0 +1,6 @@
+import { ProceduralItemNode } from '@pascal-app/core/procedural-items';
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+export declare const proceduralItemRenderDefinition: NodeRenderDefinition<typeof ProceduralItemNode> & {
+    kind: 'procedural-item';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.render.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,kBAAkB,EAInB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,eAAO,MAAM,8BAA8B,EAAE,oBAAoB,CAAC,OAAO,kBAAkB,CAAC,GAAG;IAC7F,IAAI,EAAE,iBAAiB,CAAA;CAqFxB,CAAA"}