@pascal-app/nodes 1.0.0 → 1.0.1

package/dist/imported-mesh/floorplan.js

@@ -0,0 +1,34 @@
+/** A compact plan proxy for imported geometry, derived from its XZ bounds. */
+export function buildImportedMeshFloorplan(node, ctx) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const primitive of node.primitives) {
+        for (let i = 0; i + 2 < primitive.positions.length; i += 3) {
+            minX = Math.min(minX, primitive.positions[i]);
+            maxX = Math.max(maxX, primitive.positions[i]);
+            minZ = Math.min(minZ, primitive.positions[i + 2]);
+            maxZ = Math.max(maxZ, primitive.positions[i + 2]);
+        }
+    }
+    if (![minX, maxX, minZ, maxZ].every(Number.isFinite))
+        return null;
+    const yaw = node.rotation[1];
+    const cos = Math.cos(-yaw);
+    const sin = Math.sin(-yaw);
+    const toPlan = (x, z) => [
+        node.position[0] + x * cos - z * sin,
+        node.position[2] + x * sin + z * cos,
+    ];
+    const selected = Boolean(ctx.viewState?.selected || ctx.viewState?.highlighted);
+    return {
+        kind: 'polygon',
+        points: [toPlan(minX, minZ), toPlan(maxX, minZ), toPlan(maxX, maxZ), toPlan(minX, maxZ)],
+        fill: '#94a3b8',
+        fillOpacity: selected ? 0.28 : 0.14,
+        stroke: selected ? (ctx.viewState?.palette?.selectedStroke ?? '#f97316') : '#64748b',
+        strokeWidth: selected ? 0.04 : 0.025,
+        vectorEffect: 'non-scaling-stroke',
+    };
+}

package/dist/imported-mesh/geometry.d.ts

@@ -0,0 +1,5 @@
+import type { ImportedMeshNode } from '@pascal-app/core';
+import { Group } from 'three';
+/** Build serialized imported triangle buffers without source-format coupling. */
+export declare function buildImportedMeshGeometry(node: ImportedMeshNode): Group;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/imported-mesh/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/imported-mesh/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,EAIL,KAAK,EAGN,MAAM,OAAO,CAAA;AAEd,iFAAiF;AACjF,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,gBAAgB,GAAG,KAAK,CA6BvE"}

package/dist/imported-mesh/geometry.js

@@ -0,0 +1,34 @@
+import { BufferGeometry, Float32BufferAttribute, FrontSide, Group, Mesh, MeshStandardMaterial, } from 'three';
+/** Build serialized imported triangle buffers without source-format coupling. */
+export function buildImportedMeshGeometry(node) {
+    const group = new Group();
+    for (const [primitiveIndex, primitive] of node.primitives.entries()) {
+        if (primitive.positions.length < 9)
+            continue;
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new Float32BufferAttribute(primitive.positions, 3));
+        if (primitive.normals?.length === primitive.positions.length) {
+            geometry.setAttribute('normal', new Float32BufferAttribute(primitive.normals, 3));
+        }
+        else {
+            geometry.computeVertexNormals();
+        }
+        if (primitive.indices.length >= 3)
+            geometry.setIndex(primitive.indices);
+        geometry.computeBoundingBox();
+        geometry.computeBoundingSphere();
+        const material = new MeshStandardMaterial({
+            color: primitive.color,
+            opacity: primitive.opacity,
+            transparent: primitive.opacity < 1,
+            depthWrite: primitive.opacity >= 1,
+            metalness: 0.05,
+            roughness: 0.8,
+            side: FrontSide,
+        });
+        const mesh = new Mesh(geometry, material);
+        mesh.name = `${node.name ?? 'Imported mesh'} primitive ${primitiveIndex + 1}`;
+        group.add(mesh);
+    }
+    return group;
+}

package/dist/imported-mesh/index.d.ts

@@ -0,0 +1,4 @@
+export { importedMeshDefinition } from './definition';
+export { buildImportedMeshGeometry } from './geometry';
+export { ImportedMeshNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/imported-mesh/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/imported-mesh/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA"}

package/dist/imported-mesh/index.js

@@ -0,0 +1,3 @@
+export { importedMeshDefinition } from './definition';
+export { buildImportedMeshGeometry } from './geometry';
+export { ImportedMeshNode } from './schema';

package/dist/imported-mesh/schema.d.ts

@@ -0,0 +1,2 @@
+export { ImportedMeshNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/imported-mesh/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/imported-mesh/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/imported-mesh/schema.js

@@ -0,0 +1 @@
+export { ImportedMeshNode } from '@pascal-app/core';

package/dist/index.d.ts

@@ -38,6 +38,7 @@ export { fenceDefinition } from './fence';
 export { guideDefinition } from './guide';
 export { gutterDefinition } from './gutter';
 export { hvacEquipmentDefinition } from './hvac-equipment';
+export { importedMeshDefinition } from './imported-mesh';
 export { itemDefinition } from './item';
 export { leanToExtensionDefinition } from './lean-to-extension';
 export { levelDefinition } from './level';
@@ -61,6 +62,7 @@ export { stairDefinition } from './stair';
 export { stairSegmentDefinition } from './stair-segment';
 export { structuralGridDefinition } from './structural-grid';
 export { turbineVentDefinition } from './turbine-vent';
+export { unitDefinition } from './unit';
 export { wallDefinition } from './wall';
 export { windowDefinition } from './window';
 export { zoneDefinition } from './zone';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -19,6 +19,7 @@ import { fenceDefinition } from './fence';
 import { guideDefinition } from './guide';
 import { gutterDefinition } from './gutter';
 import { hvacEquipmentDefinition } from './hvac-equipment';
+import { importedMeshDefinition } from './imported-mesh';
 import { itemDefinition } from './item';
 import { leanToExtensionDefinition } from './lean-to-extension';
 import { levelDefinition } from './level';
@@ -28,6 +29,7 @@ import { measurementDefinition } from './measurement';
 import { pipeFittingDefinition } from './pipe-fitting';
 import { pipeSegmentDefinition } from './pipe-segment';
 import { pipeTrapDefinition } from './pipe-trap';
+import { proceduralItemDefinition } from './procedural-item/definition';
 import { ridgeVentDefinition } from './ridge-vent';
 import { roofDefinition } from './roof';
 import { roofSegmentDefinition } from './roof-segment';
@@ -42,6 +44,7 @@ import { stairDefinition } from './stair';
 import { stairSegmentDefinition } from './stair-segment';
 import { structuralGridDefinition } from './structural-grid';
 import { turbineVentDefinition } from './turbine-vent';
+import { unitDefinition } from './unit';
 import { wallDefinition } from './wall';
 import { windowDefinition } from './window';
 import { zoneDefinition } from './zone';
@@ -79,10 +82,13 @@ export const builtinPlugin = {
         cabinetDefinition,
         cabinetModuleDefinition,
         itemDefinition,
+        proceduralItemDefinition,
+        importedMeshDefinition,
         // Stage A — wrap-exports the legacy renderer + system. Legacy
         // panels / move tools / floorplan branches still serve these.
         columnDefinition,
         elevatorDefinition,
+        unitDefinition,
         roofDefinition,
         roofSegmentDefinition,
         stairDefinition,
@@ -143,6 +149,7 @@ export { fenceDefinition } from './fence';
 export { guideDefinition } from './guide';
 export { gutterDefinition } from './gutter';
 export { hvacEquipmentDefinition } from './hvac-equipment';
+export { importedMeshDefinition } from './imported-mesh';
 export { itemDefinition } from './item';
 export { leanToExtensionDefinition } from './lean-to-extension';
 export { levelDefinition } from './level';
@@ -166,6 +173,7 @@ export { stairDefinition } from './stair';
 export { stairSegmentDefinition } from './stair-segment';
 export { structuralGridDefinition } from './structural-grid';
 export { turbineVentDefinition } from './turbine-vent';
+export { unitDefinition } from './unit';
 export { wallDefinition } from './wall';
 export { windowDefinition } from './window';
 export { zoneDefinition } from './zone';

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

@@ -1,3 +1,11 @@
-import { type FloorplanMoveTarget, type ItemNode } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type CeilingNode, type FloorplanMoveTarget, type ItemNode } from '@pascal-app/core';
 export declare const itemFloorplanMoveTarget: FloorplanMoveTarget<ItemNode>;
+/**
+ * Walk every ceiling under the level and return the first one whose
+ * polygon contains the pointer. Holes are honoured — a point inside a
+ * hole counts as not inside the surface. Slabs are intentionally NOT a
+ * valid target: floor items are parented to the level, not the slab,
+ * because slabs don't carry a `children` field on their schema.
+ */
+export declare function findContainingSurface(point: readonly [number, number], nodes: Record<AnyNodeId, AnyNode>, parentLevelId: AnyNodeId | null, targetKind: 'ceiling'): CeilingNode | null;
 //# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/item/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EAKxB,KAAK,QAAQ,EAMd,MAAM,kBAAkB,CAAA;AAsKzB,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA+BjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/item/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,WAAW,EAGhB,KAAK,mBAAmB,EAKxB,KAAK,QAAQ,EAQd,MAAM,kBAAkB,CAAA;AAkLzB,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA+BjE,CAAA;AAoOD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,UAAU,EAAE,SAAS,GACpB,WAAW,GAAG,IAAI,CAwBpB"}

package/dist/item/floorplan-move.js

@@ -1,6 +1,8 @@
-import { collectAlignmentAnchors, getBlockFaceFrame, getRoofWallFaceFrame, getScaledDimensions, movingFootprintAnchors, roofFacePointToSegment, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { collectAlignmentAnchors, createSceneApi, getBlockFaceFrame, getRoofWallFaceFrame, getScaledDimensions, movingFootprintAnchors, nodeRegistry, resolveSurfacePlacement, roofFacePointToSegment, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { boundsOf, boxCorners, frame, transformPoint } from '@pascal-app/core/procedural-items';
 import { applyFloorplanAlignment, isGridSnapActive, isMagneticSnapActive, useEditor, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { restingNodePlanFrame } from '../shared/resting-surface-plan';
 import { findClosestWallInPlan, snapLocalXToNeighbors } from '../shared/wall-attach-target';
 function rotateVec(x, z, rotationY) {
     const c = Math.cos(rotationY);
@@ -28,6 +30,15 @@ function resolveItemPlanTransform(item, nodes, cache = new Map()) {
             rotation: wallRotation + localRotation,
         };
     }
+    else if (parent?.type === 'cabinet' ||
+        parent?.type === 'cabinet-module' ||
+        parent?.type === 'procedural-item') {
+        const f = restingNodePlanFrame(item, (id) => nodes[id]);
+        result = {
+            point: [f.position[0], f.position[2]],
+            rotation: Math.atan2(f.axes[2][0], f.axes[2][2]),
+        };
+    }
     else if (parent?.type === 'shelf') {
         const shelf = parent;
         const [offsetX, offsetZ] = rotateVec(item.position[0], item.position[2], shelf.rotation[1] ?? 0);
@@ -219,6 +230,48 @@ function buildFloorItemSession(node, startLevelId, nodes) {
             // guides are DISPLAYED in every snapping mode; the magnetic pull onto them
             // is applied only in "lines" mode (`applySnap`).
             const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], rotationY), candidates, { applySnap: isMagneticSnapActive() });
+            const host = node.parentId ? nodes[node.parentId] : undefined;
+            if (host?.type === 'cabinet' || host?.type === 'shelf') {
+                const hostFrame = restingNodePlanFrame(host, (id) => useScene.getState().nodes[id]);
+                const dx = snapped[0] - hostFrame.position[0];
+                const dz = snapped[1] - hostFrame.position[2];
+                const local = [
+                    dx * hostFrame.axes[0][0] + dz * hostFrame.axes[0][2],
+                    node.position[1],
+                    dx * hostFrame.axes[2][0] + dz * hostFrame.axes[2][2],
+                ];
+                const bounds = nodeRegistry.get(node.type)?.capabilities.dragBounds?.(node, nodes);
+                const dimensions = bounds?.size ?? getScaledDimensions(node);
+                const center = bounds?.center;
+                const localBounds = center
+                    ? {
+                        min: center.map((v, i) => v - dimensions[i] / 2),
+                        max: center.map((v, i) => v + dimensions[i] / 2),
+                    }
+                    : undefined;
+                const projected = boundsOf(boxCorners(localBounds?.min ?? [-dimensions[0] / 2, 0, -dimensions[2] / 2], localBounds?.max ?? [dimensions[0] / 2, dimensions[1], dimensions[2] / 2]).map((p) => transformPoint(frame(local, node.rotation), p)));
+                const pose = resolveSurfacePlacement({
+                    host,
+                    childKind: node.type,
+                    childFootprint: { size: dimensions, rotationY, rotation: node.rotation, localBounds },
+                    hit: {
+                        point: [
+                            (projected.min[0] + projected.max[0]) / 2,
+                            projected.min[1],
+                            (projected.min[2] + projected.max[2]) / 2,
+                        ],
+                        normalWorldY: 1,
+                    },
+                    origin: local,
+                    scene: createSceneApi(useScene),
+                });
+                if (pose && Math.abs(pose.position[1] - node.position[1]) < 1e-5) {
+                    lastPatch = { parentId: host.id, position: [...pose.position], supportSlabId: undefined };
+                    useLiveNodeOverrides.getState().set(node.id, lastPatch);
+                    useScene.getState().markDirty(node.id);
+                    return;
+                }
+            }
             const sourceY = node.position[1];
             const nextPosition = [snapped[0], sourceY, snapped[1]];
             lastPatch = {
@@ -286,7 +339,7 @@ function buildSurfaceItemSession(node, startLevelId, targetKind) {
  * valid target: floor items are parented to the level, not the slab,
  * because slabs don't carry a `children` field on their schema.
  */
-function findContainingSurface(point, nodes, parentLevelId, targetKind) {
+export function findContainingSurface(point, nodes, parentLevelId, targetKind) {
     if (!parentLevelId)
         return null;
     const level = nodes[parentLevelId];

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AAsKzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmGjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AAkLzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmGjG"}

package/dist/item/floorplan.js

@@ -1,5 +1,6 @@
 import { getBlockFaceFrame, getRoofWallFaceFrame, getScaledDimensions, roofFacePointToSegment, useLiveTransforms, } from '@pascal-app/core';
 import { formatLinearMeasurement, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
+import { restingNodePlanFrame } from '../shared/resting-surface-plan';
 // Plan-space rotation convention used by the legacy `rotatePlanVector`
 // in `editor/src/lib/floorplan/geometry.ts`. This is a CLOCKWISE rotation
 // — the registry-side equivalent of the canonical floor-plan transform
@@ -47,6 +48,16 @@ function resolveItemTransform(item, ctx, cache = new Map()) {
             };
         }
     }
+    else if (parentNode?.type === 'cabinet' ||
+        parentNode?.type === 'cabinet-module' ||
+        parentNode?.type === 'procedural-item') {
+        const f = restingNodePlanFrame(item, ctx.resolve);
+        result = {
+            x: f.position[0],
+            y: f.position[2],
+            rotation: Math.atan2(f.axes[2][0], f.axes[2][2]),
+        };
+    }
     else if (parentNode?.type === 'shelf') {
         // Shelf-hosted item: `item.position` is in shelf-local coords. The
         // shelf has its own `position` + `rotation[1]` in its parent (level)

package/dist/item/move-tool.js

@@ -78,7 +78,7 @@ export function getInitialState(node, parent = node.parentId
     // handler — which preserves the grab offset — instead of a fresh `enter()`
     // that snaps the item's origin under the cursor. Without this the item
     // teleports the instant it's grabbed.
-    if (parent?.type === 'item') {
+    if (parent?.type === 'item' || parent?.type === 'cabinet' || parent?.type === 'procedural-item') {
         return {
             surface: 'item-surface',
             wallId: null,

package/dist/item/panel.js

@@ -78,7 +78,7 @@ export default function ItemPanel() {
     }, [selectedId, deleteNode, setSelection]);
     if (!(node && node.type === 'item' && selectedId))
         return null;
-    return (_jsxs(PanelWrapper, { icon: node.asset.thumbnail || '/icons/item.webp', onClose: handleClose, title: node.name || node.asset.name, width: 300, children: [_jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: Math.round(node.position[0] * 100) / 100 }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: Math.round(node.position[1] * 100) / 100 }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Z", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: Math.round(node.position[2] * 100) / 100 })] }), _jsxs(PanelSection, { title: "Rotation", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "rot" })] }), max: Math.round((node.rotation[1] * 180) / Math.PI) + 45, min: Math.round((node.rotation[1] * 180) / Math.PI) - 45, onChange: (degrees) => {
+    return (_jsxs(PanelWrapper, { icon: node.asset.thumbnail || '/icons/item.webp', onClose: handleClose, title: node.name || node.asset.name, width: 300, children: [_jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[0] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[1] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Z", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: node.position[2] })] }), _jsxs(PanelSection, { title: "Rotation", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "rot" })] }), max: Math.round((node.rotation[1] * 180) / Math.PI) + 45, min: Math.round((node.rotation[1] * 180) / Math.PI) - 45, onChange: (degrees) => {
                             const radians = (degrees * Math.PI) / 180;
                             handleUpdate({ rotation: [node.rotation[0], radians, node.rotation[2]] });
                         }, precision: 0, step: 1, unit: "\u00B0", value: Math.round((node.rotation[1] * 180) / Math.PI) }), _jsxs("div", { className: "flex gap-1.5 px-1 pt-2 pb-1", children: [_jsx(ActionButton, { label: "-45\u00B0", onClick: () => {

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/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;AA6D1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAmO9E,CAAA"}

package/dist/procedural-item/definition.js

@@ -0,0 +1,254 @@
+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 { 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],
+    }),
+    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: true,
+        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,
+    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.' },
+};