@pascal-app/nodes 1.0.0 → 1.0.3

package/dist/lineset/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/lineset/tool.tsx"],"names":[],"mappings":"AAwFA,QAAA,MAAM,WAAW,0CA4QhB,CAAA;AAgCD,eAAe,WAAW,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/lineset/tool.tsx"],"names":[],"mappings":"AAwFA,QAAA,MAAM,WAAW,0CA6QhB,CAAA;AAgCD,eAAe,WAAW,CAAA"}

package/dist/lineset/tool.js

@@ -96,6 +96,7 @@ const LinesetTool = () => {
             // mitered polyline run.
             const lineset = LinesetNode.parse({
                 ...linesetDefinition.defaults(),
+                ...useEditor.getState().toolDefaults.lineset,
                 name: 'Lineset',
                 path: [start, end],
             });

package/dist/liquid-line/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/liquid-line/tool.tsx"],"names":[],"mappings":"AAmQA,QAAA,MAAM,cAAc,0CAkWnB,CAAA;AA8BD,eAAe,cAAc,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/liquid-line/tool.tsx"],"names":[],"mappings":"AAmQA,QAAA,MAAM,cAAc,0CAsWnB,CAAA;AA8BD,eAAe,cAAc,CAAA"}

package/dist/liquid-line/tool.js

@@ -262,6 +262,7 @@ const LiquidLineTool = () => {
             // rather than folding into one mitered polyline run.
             const line = LiquidLineNode.parse({
                 ...liquidLineDefinition.defaults(),
+                ...useEditor.getState().toolDefaults['liquid-line'],
                 name: 'Liquid Line',
                 path: [start, end],
             });
@@ -279,7 +280,10 @@ const LiquidLineTool = () => {
             const traced = tracePath(target);
             if (!traced)
                 return;
-            const defaults = liquidLineDefinition.defaults();
+            const defaults = {
+                ...liquidLineDefinition.defaults(),
+                ...useEditor.getState().toolDefaults['liquid-line'],
+            };
             const create = [];
             for (let i = 0; i < traced.length - 1; i++) {
                 const a = traced[i];

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/measurement/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAInF,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAoExE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/measurement/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAInF,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAqExE,CAAA"}

package/dist/measurement/definition.js

@@ -29,6 +29,7 @@ export const measurementDefinition = {
         presettable: false,
     },
     dirtyTracking: false,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/pipe-segment/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAmFxE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAqFxE,CAAA"}

package/dist/pipe-segment/parametrics.js

@@ -1,3 +1,4 @@
+import { findAutomaticRunEndCapIds } from '../shared/automatic-run-end-cap';
 import { fittingDeletionPlansForRun } from '../shared/fitting-deletion-cleanup';
 export const pipeSegmentParametrics = {
     derive: (next) => next.autoHangers
@@ -8,7 +9,10 @@ export const pipeSegmentParametrics = {
         }
         : {},
     onDelete: (pipe, nodes, _pendingDeleteIds, requestedDeleteIds) => fittingDeletionPlansForRun(pipe, nodes, requestedDeleteIds, true).flatMap((plan) => plan.updates),
-    onDeleteCascade: (pipe, nodes, _pendingDeleteIds, requestedDeleteIds) => fittingDeletionPlansForRun(pipe, nodes, requestedDeleteIds, false).flatMap((plan) => plan.deleteFitting ? [plan.fittingId, ...plan.cascadeDeleteIds] : []),
+    onDeleteCascade: (pipe, nodes, _pendingDeleteIds, requestedDeleteIds) => [
+        ...findAutomaticRunEndCapIds(pipe.id, nodes, 'pipe-fitting'),
+        ...fittingDeletionPlansForRun(pipe, nodes, requestedDeleteIds, false).flatMap((plan) => plan.deleteFitting ? [plan.fittingId, ...plan.cascadeDeleteIds] : []),
+    ],
     trailingSection: () => import('../shared/run-hanger-inspector'),
     groups: [
         {

package/dist/pipe-segment/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/tool.tsx"],"names":[],"mappings":"AA+DA,QAAA,MAAM,eAAe,0CA2bpB,CAAA;AA8BD,eAAe,eAAe,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/tool.tsx"],"names":[],"mappings":"AA+DA,QAAA,MAAM,eAAe,0CAucpB,CAAA;AA8BD,eAAe,eAAe,CAAA"}

package/dist/pipe-segment/tool.js

@@ -28,6 +28,7 @@ function getConnectionPorts(levelId, nodes) {
 }
 const PipeSegmentTool = () => {
     const { activeLevelId, sceneApi, unit } = useRegistryToolContext();
+    const toolDefaults = useEditor((s) => s.toolDefaults['pipe-segment']);
     const continuationSeedRef = useRef(currentPipeContinuationSeed());
     const continuationSeed = continuationSeedRef.current;
     const hangerDefaults = useEditor((state) => state.toolDefaults['pipe-segment']);
@@ -42,14 +43,14 @@ const PipeSegmentTool = () => {
     autoHangersRef.current = autoHangers;
     const pendingPromotionRef = useRef(continuationSeed?.promotedFitting ?? null);
     const defaults = pipeSegmentDefinition.defaults();
-    const [system, setSystem] = useState(continuationSeed?.pipe.system ?? defaults.system);
+    const [system, setSystem] = useState(continuationSeed?.pipe.system ?? toolDefaults?.system ?? defaults.system);
     const [sloped, setSloped] = useState(false);
     const slopePercent = 100 / 48;
     const slopeDirection = 1;
     const gradeRef = useRef(slopePercent / 100);
     gradeRef.current = (slopeDirection * slopePercent) / 100;
-    const [diameter, setDiameter] = useState(continuationSeed?.pipe.diameter ?? defaults.diameter);
-    const [pipeMaterial, setPipeMaterial] = useState(continuationSeed?.pipe.pipeMaterial ?? defaults.pipeMaterial);
+    const [diameter, setDiameter] = useState(continuationSeed?.pipe.diameter ?? toolDefaults?.diameter ?? defaults.diameter);
+    const [pipeMaterial, setPipeMaterial] = useState(continuationSeed?.pipe.pipeMaterial ?? toolDefaults?.pipeMaterial ?? defaults.pipeMaterial);
     const systemRef = useRef(system);
     systemRef.current = system;
     const slopedRef = useRef(sloped);
@@ -63,6 +64,16 @@ const PipeSegmentTool = () => {
         mode.setEnabled('pipe-segment', initialAutoHangersRef.current);
         return () => mode.setEnabled('pipe-segment', false);
     }, []);
+    useEffect(() => {
+        if (!toolDefaults)
+            return;
+        if (toolDefaults.system)
+            setSystem(toolDefaults.system);
+        if (typeof toolDefaults.diameter === 'number')
+            setDiameter(toolDefaults.diameter);
+        if (toolDefaults.pipeMaterial)
+            setPipeMaterial(toolDefaults.pipeMaterial);
+    }, [toolDefaults]);
     const commitSegment = ({ start: rawStart, end, startConnection, endConnection, surfaceTarget, previewOnly = false, }) => {
         if (!activeLevelId)
             return null;

package/dist/pipe-trap/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CAqHjB,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CAoHjB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/pipe-trap/tool.js

@@ -25,16 +25,14 @@ function snap(value, step) {
  */
 const PipeTrapTool = () => {
     const activeLevelId = useViewer((s) => s.selection.levelId);
+    const toolDefaults = useEditor((s) => s.toolDefaults['pipe-trap']);
     const [cursor, setCursor] = useState(null);
     const [yaw, setYaw] = useState(0);
-    const [diameter] = useState(pipeTrapDefinition.defaults().diameter);
     const yawRef = useRef(0);
-    const diameterRef = useRef(diameter);
-    diameterRef.current = diameter;
     const previewNode = useMemo(() => PipeTrapNode.parse({
         ...pipeTrapDefinition.defaults(),
-        diameter,
-    }), [diameter]);
+        ...toolDefaults,
+    }), [toolDefaults]);
     const ghost = useMemo(() => {
         const group = buildPipeTrapGeometry(previewNode);
         group.traverse((child) => {
@@ -56,7 +54,7 @@ const PipeTrapTool = () => {
                     applySnap: isMagneticSnapActive(),
                     bypass: !isMagneticSnapActive(),
                 }),
-                diameter: diameterRef.current,
+                diameter: previewNode.diameter,
             };
         };
         let lastEvent = null;
@@ -68,6 +66,7 @@ const PipeTrapTool = () => {
             const r = resolve(event);
             const trap = PipeTrapNode.parse({
                 ...pipeTrapDefinition.defaults(),
+                ...toolDefaults,
                 diameter: r.diameter,
                 position: r.position,
                 rotation: yawRef.current,
@@ -104,9 +103,9 @@ const PipeTrapTool = () => {
             window.removeEventListener('keydown', onKeyDown, true);
             clearDrawAlignment();
         };
-    }, [activeLevelId]);
+    }, [activeLevelId, previewNode.diameter, toolDefaults]);
     if (!activeLevelId || !cursor)
         return null;
-    return (_jsxs(LevelOffsetGroup, { children: [_jsx("group", { position: cursor, rotation: [0, yaw, 0], children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [cursor[0], cursor[1] + 0.5, cursor[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: [diameter, "\" Trap"] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" })] }) })] }));
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx("group", { position: cursor, rotation: [0, yaw, 0], children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [cursor[0], cursor[1] + 0.5, cursor[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: [previewNode.diameter, "\" Trap"] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" })] }) })] }));
 };
 export default PipeTrapTool;

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

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

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

@@ -0,0 +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;AAEpG,OAAO,EAKL,kBAAkB,EAWnB,MAAM,mCAAmC,CAAA;AA8D1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAqO9E,CAAA"}

package/dist/procedural-item/definition.js

@@ -0,0 +1,257 @@
+import { useScene } from '@pascal-app/core';
+import { boundsOf, boxCorners, evaluateRecipe, frame, ProceduralItemNode, parameterPatch, proceduralFootprint, proceduralSlotColor, queryProceduralItem, resolveProceduralWallPlacement, setProceduralMaterial, shelfRecipe, snapParameters, transformPoint, validateProceduralRelations, } from '@pascal-app/core/procedural-items';
+import { itemPaint } from '../item/paint';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
+import { proceduralFloorplanMoveTarget } from './move-session';
+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) => 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 } },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        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'],
+        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) => {
+            const node = n;
+            return node.recipe.slots.map((s) => ({ slotId: s.id, label: s.label, default: s.color }));
+        },
+        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),
+        },
+    },
+    relations: { hosts: ['item', 'procedural-item'], cascadeDelete: 'descendants' },
+    renderer: { kind: 'parametric', module: () => import('./renderer') },
+    parametrics: { groups: [], customPanel: () => import('@pascal-app/editor/procedural-items') },
+    affordanceTools: { move: () => import('./move-tool') },
+    floorplanMoveTarget: proceduralFloorplanMoveTarget,
+    floorplanAffectedIds: restingFloorplanAffectedIds,
+    keyboardActions: {
+        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.' },
+};

package/dist/procedural-item/geometry.d.ts

@@ -0,0 +1,31 @@
+import { type Evaluation, type ProceduralItemNode } from '@pascal-app/core/procedural-items';
+import { type BufferGeometry } from 'three';
+export type Batch = {
+    slot: string;
+    geometry: BufferGeometry;
+    ranges: {
+        end: number;
+        partId: string;
+        shapeId: string;
+    }[];
+};
+export type BuiltItem = {
+    batches: Batch[];
+    evaluation: Evaluation;
+    milliseconds: number;
+    triangles: number;
+};
+export declare const proceduralMetrics: {
+    builds: number;
+    cacheHits: number;
+    lastBuildMs: number;
+    liveEntries: number;
+};
+export declare const geometrySignature: (node: ProceduralItemNode) => string;
+export declare function buildProceduralGeometry(node: ProceduralItemNode): BuiltItem;
+export declare function acquireProceduralGeometry(node: ProceduralItemNode): {
+    value: BuiltItem;
+    release: () => void;
+};
+export declare function partAtFace(ranges: Batch['ranges'], face: number): string | null;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/procedural-item/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,OAAO,CAAA;AAGd,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,cAAc,CAAA;IACxB,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC3D,CAAA;AACD,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,KAAK,EAAE,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AACD,eAAO,MAAM,iBAAiB;;;;;CAA8D,CAAA;AAE5F,eAAO,MAAM,iBAAiB,GAAI,MAAM,kBAAkB,WACV,CAAA;AAChD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CA8D3E;AACD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,kBAAkB;;;EAwBjE;AACD,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,iBAE/D"}

package/dist/procedural-item/geometry.js

@@ -0,0 +1,88 @@
+import { evaluateRecipe, } from '@pascal-app/core/procedural-items';
+import { BoxGeometry, CylinderGeometry, Euler, Matrix4, Quaternion, Vector3, } from 'three';
+import { RoundedBoxGeometry } from 'three/addons/geometries/RoundedBoxGeometry.js';
+import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js';
+export const proceduralMetrics = { builds: 0, cacheHits: 0, lastBuildMs: 0, liveEntries: 0 };
+const cache = new Map();
+export const geometrySignature = (node) => JSON.stringify([node.recipe, node.parameters]);
+export function buildProceduralGeometry(node) {
+    const start = performance.now(), evaluation = evaluateRecipe(node.recipe, node.parameters);
+    const bySlot = new Map();
+    for (const shape of evaluation.shapes) {
+        const [w, h, d] = shape.size;
+        const source = shape.primitive === 'roundedBox'
+            ? new RoundedBoxGeometry(w, h, d, 2, shape.radius)
+            : shape.primitive === 'cylinder'
+                ? new CylinderGeometry(0.5, 0.5, 1, 24, 1)
+                : new BoxGeometry(w, h, d);
+        if (shape.primitive === 'cylinder')
+            source.scale(w, h, d);
+        const geometry = source.index ? source.toNonIndexed() : source;
+        if (geometry !== source)
+            source.dispose();
+        geometry.clearGroups();
+        const vertices = geometry.getAttribute('position'), normals = geometry.getAttribute('normal'), uv = geometry.getAttribute('uv');
+        for (let i = 0; i < vertices.count; i++) {
+            const x = vertices.getX(i), y = vertices.getY(i), z = vertices.getZ(i);
+            const nx = Math.abs(normals.getX(i)), ny = Math.abs(normals.getY(i)), nz = Math.abs(normals.getZ(i));
+            uv.setXY(i, nx > ny && nx > nz ? z : x, ny > nx && ny > nz ? z : y);
+        }
+        geometry.applyMatrix4(new Matrix4().compose(new Vector3(...shape.position), new Quaternion().setFromEuler(new Euler(...shape.rotation)), new Vector3(1, 1, 1)));
+        const entry = bySlot.get(shape.slot) ?? { geometries: [], ranges: [], faces: 0 };
+        entry.geometries.push(geometry);
+        entry.faces += geometry.getAttribute('position').count / 3;
+        entry.ranges.push({ end: entry.faces, partId: shape.partId, shapeId: shape.id });
+        bySlot.set(shape.slot, entry);
+    }
+    const batches = [];
+    for (const [slot, entry] of bySlot) {
+        const geometry = mergeGeometries(entry.geometries, false);
+        for (const g of entry.geometries)
+            g.dispose();
+        if (!geometry)
+            throw new Error('Unable to batch procedural geometry');
+        geometry.computeBoundingBox();
+        geometry.computeBoundingSphere();
+        batches.push({ slot, geometry, ranges: entry.ranges });
+    }
+    const milliseconds = performance.now() - start;
+    proceduralMetrics.builds++;
+    proceduralMetrics.lastBuildMs = milliseconds;
+    return {
+        batches,
+        evaluation,
+        milliseconds,
+        triangles: batches.reduce((n, b) => n + b.geometry.getAttribute('position').count / 3, 0),
+    };
+}
+export function acquireProceduralGeometry(node) {
+    const key = geometrySignature(node);
+    let entry = cache.get(key);
+    if (entry)
+        proceduralMetrics.cacheHits++;
+    else {
+        entry = { value: buildProceduralGeometry(node), users: 0 };
+        cache.set(key, entry);
+    }
+    entry.users++;
+    proceduralMetrics.liveEntries = cache.size;
+    let released = false;
+    return {
+        value: entry.value,
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            const current = cache.get(key);
+            if (current && --current.users === 0) {
+                for (const batch of current.value.batches)
+                    batch.geometry.dispose();
+                cache.delete(key);
+            }
+            proceduralMetrics.liveEntries = cache.size;
+        },
+    };
+}
+export function partAtFace(ranges, face) {
+    return ranges.find((r) => face < r.end)?.partId ?? null;
+}

package/dist/procedural-item/index.d.ts

@@ -0,0 +1,3 @@
+export { proceduralItemDefinition } from './definition';
+export { acquireProceduralGeometry, buildProceduralGeometry, geometrySignature, partAtFace, proceduralMetrics, } from './geometry';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/procedural-item/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EACV,iBAAiB,GAClB,MAAM,YAAY,CAAA"}

package/dist/procedural-item/index.js

@@ -0,0 +1,2 @@
+export { proceduralItemDefinition } from './definition';
+export { acquireProceduralGeometry, buildProceduralGeometry, geometrySignature, partAtFace, proceduralMetrics, } from './geometry';

package/dist/procedural-item/move-session.d.ts

@@ -0,0 +1,15 @@
+import { type AnyNodeId, type CeilingNode, type FloorplanMoveTarget, type FloorplanMoveTargetSession, type WallNode } from '@pascal-app/core';
+import { type ProceduralItemNode } from '@pascal-app/core/procedural-items';
+export declare const createProceduralWallMoveSession: typeof createProceduralMountedMoveSession;
+export declare const createProceduralCeilingMoveSession: typeof createProceduralMountedMoveSession;
+declare function createProceduralMountedMoveSession(node: ProceduralItemNode, levelId: AnyNodeId): FloorplanMoveTargetSession & {
+    wall(wall: WallNode, x: number, y: number, side: "front" | "back", alt: boolean): void;
+    ceiling(ceiling: CeilingNode, x: number, z: number, alt: boolean): void;
+    rotate(direction: number): void;
+    free(point: readonly [number, number]): void;
+    commit(): void;
+    readonly candidate: ProceduralItemNode | null;
+};
+export declare const proceduralFloorplanMoveTarget: FloorplanMoveTarget<ProceduralItemNode>;
+export {};
+//# sourceMappingURL=move-session.d.ts.map

package/dist/procedural-item/move-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-session.d.ts","sourceRoot":"","sources":["../../src/procedural-item/move-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAI/B,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAML,KAAK,kBAAkB,EAOxB,MAAM,mCAAmC,CAAA;AA0B1C,eAAO,MAAM,+BAA+B,2CAAqC,CAAA;AACjF,eAAO,MAAM,kCAAkC,2CAAqC,CAAA;AAEpF,iBAAS,kCAAkC,CAAC,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,SAAS;eA4BzE,QAAQ,KAAK,MAAM,KAAK,MAAM,QAAQ,OAAO,GAAG,MAAM,OAAO,OAAO,GAAG,IAAI;qBACrE,WAAW,KAAK,MAAM,KAAK,MAAM,OAAO,OAAO,GAAG,IAAI;sBACrD,MAAM,GAAG,IAAI;gBACnB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;cAClC,IAAI;wBACM,kBAAkB,GAAG,IAAI;EAiKhD;AAED,eAAO,MAAM,6BAA6B,EAAE,mBAAmB,CAAC,kBAAkB,CAqBjF,CAAA"}