@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/pipe-fitting/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, PipeFittingNode, sceneRegistry, useScene, } from '@pascal-app/core';
-import { DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { copyCollectionIds, DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useState } from 'react';
 import { Box3, Euler, MeshBasicMaterial, Vector3 } from 'three';
@@ -251,7 +251,13 @@ export const MovePipeFittingTool = ({ node }) => {
                     metadata: stripPlacementMetadataFlags(node.metadata),
                     visible: true,
                 });
-                useScene.getState().createNode(created, node.parentId);
+                useScene.getState().createNodes([
+                    {
+                        node: created,
+                        parentId: node.parentId,
+                        collectionIds: copyCollectionIds(node),
+                    },
+                ]);
                 selectId = created.id;
             }
             else {

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AAqEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAwN3D,CAAA;AAiCD,eAAe,mBAAmB,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AAsEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA8N3D,CAAA;AAiCD,eAAe,mBAAmB,CAAA"}

package/dist/pipe-segment/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, PipeSegmentNode, sceneRegistry, useScene, } from '@pascal-app/core';
-import { DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { copyCollectionIds, DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useRef, useState } from 'react';
 import { Vector3 } from 'three';
@@ -186,7 +186,13 @@ export const MovePipeSegmentTool = ({ node }) => {
                     metadata: stripPlacementMetadataFlags(node.metadata),
                     visible: true,
                 });
-                useScene.getState().createNode(created, node.parentId);
+                useScene.getState().createNodes([
+                    {
+                        node: created,
+                        parentId: node.parentId,
+                        collectionIds: copyCollectionIds(node),
+                    },
+                ]);
                 selectId = created.id;
             }
             else {

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/animation.d.ts

@@ -0,0 +1,8 @@
+import { type ProceduralItemNode } from '@pascal-app/core/procedural-items';
+import * as THREE from 'three';
+/** Procedural items whose motion is playing draw their own meshes (node batch). */
+export declare const isProceduralMotionPlaying: (nodeId: string) => boolean;
+export declare function setProceduralMotionPlaying(nodeId: string, playing: boolean): boolean;
+export declare function poseProceduralMotionsAtRest(node: ProceduralItemNode, object: THREE.Object3D): void;
+export declare function bakeProceduralAnimationClips(node: ProceduralItemNode, object: THREE.Object3D): THREE.AnimationClip[];
+//# sourceMappingURL=animation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation.d.ts","sourceRoot":"","sources":["../../src/procedural-item/animation.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,mFAAmF;AACnF,eAAO,MAAM,yBAAyB,GAAI,QAAQ,MAAM,YAA+B,CAAA;AAEvF,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAKpF;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,KAAK,CAAC,QAAQ,GACrB,IAAI,CAQN;AAgBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,KAAK,CAAC,QAAQ,GACrB,KAAK,CAAC,aAAa,EAAE,CA6EvB"}

package/dist/procedural-item/animation.js

@@ -0,0 +1,116 @@
+import { evaluateRecipe, finitePoseFraction, motionAxis, motionRestOffset, motionTimeline, } from '@pascal-app/core/procedural-items';
+import * as THREE from 'three';
+const playingMotions = new Set();
+/** Procedural items whose motion is playing draw their own meshes (node batch). */
+export const isProceduralMotionPlaying = (nodeId) => playingMotions.has(nodeId);
+export function setProceduralMotionPlaying(nodeId, playing) {
+    if (playingMotions.has(nodeId) === playing)
+        return false;
+    if (playing)
+        playingMotions.add(nodeId);
+    else
+        playingMotions.delete(nodeId);
+    return true;
+}
+export function poseProceduralMotionsAtRest(node, object) {
+    const { motions } = evaluateRecipe(node.recipe, node.parameters);
+    for (const motion of motions) {
+        const group = object.getObjectByName(`${node.id}__motion__${motion.id}`);
+        if (!group)
+            continue;
+        group.position.set(...motionRestOffset(motion, motions));
+        group.quaternion.identity();
+    }
+}
+function axisVector(motion) {
+    return new THREE.Vector3(...motionAxis(motion));
+}
+// An export animates the joint groups, so it keeps them and drops the merged rest pose.
+function keepJointGroups(object) {
+    const rest = [];
+    object.traverse((child) => {
+        if (child.userData.pascalProceduralRest)
+            rest.push(child);
+        if (child.userData.pascalProceduralSplit)
+            child.visible = true;
+    });
+    for (const child of rest)
+        child.removeFromParent();
+}
+export function bakeProceduralAnimationClips(node, object) {
+    keepJointGroups(object);
+    const evaluation = evaluateRecipe(node.recipe, node.parameters);
+    const { T, perPart } = motionTimeline(evaluation);
+    poseProceduralMotionsAtRest(node, object);
+    const clips = [];
+    const finiteByPart = new Map();
+    const spinByPartAndPeriod = new Map();
+    for (const motion of evaluation.motions) {
+        const group = object.getObjectByName(`${node.id}__motion__${motion.id}`);
+        if (!group)
+            continue;
+        if (motion.kind === 'spin') {
+            const key = `${motion.partId}:${Math.abs(motion.amount)}`;
+            spinByPartAndPeriod.set(key, [...(spinByPartAndPeriod.get(key) ?? []), motion]);
+        }
+        else
+            finiteByPart.set(motion.partId, [...(finiteByPart.get(motion.partId) ?? []), motion]);
+    }
+    for (const [partId, motions] of finiteByPart) {
+        const tracks = [];
+        const clipName = `${node.id}:${partId}: open`;
+        for (const motion of motions) {
+            const group = object.getObjectByName(`${node.id}__motion__${motion.id}`);
+            const start = motion.delay;
+            const times = [
+                ...new Set([
+                    0,
+                    ...Array.from({ length: 33 }, (_, i) => start + (motion.duration * i) / 32),
+                    T,
+                ]),
+            ].sort((a, b) => a - b);
+            const values = times.flatMap((time) => {
+                const fraction = finitePoseFraction(motion, time);
+                if (motion.kind === 'slide')
+                    return new THREE.Vector3(...motionRestOffset(motion, evaluation.motions))
+                        .addScaledVector(axisVector(motion), motion.amount * fraction)
+                        .toArray();
+                return new THREE.Quaternion()
+                    .setFromAxisAngle(axisVector(motion), motion.amount * fraction)
+                    .toArray();
+            });
+            tracks.push(motion.kind === 'slide'
+                ? new THREE.VectorKeyframeTrack(`${group.uuid}.position`, times, values)
+                : new THREE.QuaternionKeyframeTrack(`${group.uuid}.quaternion`, times, values));
+            group.userData.proceduralMotion = {
+                ...group.userData.proceduralMotion,
+                clip: clipName,
+                activeWindow: [perPart[partId].A, perPart[partId].B],
+            };
+        }
+        const clip = new THREE.AnimationClip(clipName, T, tracks);
+        clip.userData = { loop: false };
+        clips.push(clip);
+    }
+    const spinCounts = new Map();
+    for (const motions of spinByPartAndPeriod.values()) {
+        const partId = motions[0].partId;
+        const ordinal = spinCounts.get(partId) ?? 0;
+        spinCounts.set(partId, ordinal + 1);
+        const clipName = `${node.id}:${partId}${ordinal ? `:${ordinal}` : ''}: loop`;
+        const duration = (2 * Math.PI) / Math.abs(motions[0].amount);
+        const times = [0, 0.25, 0.5, 0.75, 1].map((fraction) => fraction * duration);
+        const tracks = motions.map((motion) => {
+            const group = object.getObjectByName(`${node.id}__motion__${motion.id}`);
+            group.userData.proceduralMotion = { ...group.userData.proceduralMotion, clip: clipName };
+            const values = [0, 0.25, 0.5, 0.75, 1].flatMap((fraction) => new THREE.Quaternion()
+                .setFromAxisAngle(axisVector(motion), Math.sign(motion.amount) * 2 * Math.PI * fraction)
+                .toArray());
+            return new THREE.QuaternionKeyframeTrack(`${group.uuid}.quaternion`, times, values);
+        });
+        const clip = new THREE.AnimationClip(clipName, duration, tracks);
+        clip.userData = { loop: true };
+        clips.push(clip);
+    }
+    return clips;
+}

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;AAEpG,OAAO,EAKL,kBAAkB,EAWnB,MAAM,mCAAmC,CAAA;AA6D1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAmO9E,CAAA"}
+{"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,CA+R9E,CAAA"}

package/dist/procedural-item/definition.js

@@ -1,6 +1,11 @@
-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 { 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';
+import { proceduralMechanism, toggleItemLights } from '../shared/item-interactions';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
+import { bakeProceduralAnimationClips, isProceduralMotionPlaying } from './animation';
 import { proceduralFloorplanMoveTarget } from './move-session';
 const GIZMO_SIDE_OFFSET = 0.3;
 const GIZMO_FRONT_OFFSET = 0.3;
@@ -9,7 +14,13 @@ 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))))
+        ? 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() {
@@ -69,8 +80,22 @@ export const proceduralItemDefinition = {
         position: [0, 0, 0],
         rotation: [0, 0, 0],
     }),
+    extensions: {
+        'pascal:editor/floorplan': {
+            directDrag: true,
+            actionMenu: { actions: () => import('../shared/item-interaction-actions') },
+        },
+    },
     capabilities: {
+        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);
@@ -84,6 +109,29 @@ export const proceduralItemDefinition = {
             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,
@@ -91,12 +139,9 @@ export const proceduralItemDefinition = {
         },
         movable: { axes: ['x', 'z'], gridSnap: true },
         rotatable: { axes: ['y'], snapAngles: [0, Math.PI / 4, Math.PI / 2, Math.PI] },
-        duplicable: true,
+        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 }));
-        },
+        slots: (n) => proceduralItemSlots(n),
         surfaces: {
             custom: (n) => evaluateRecipe(n.recipe, n.parameters).surfaces.map((s) => ({
                 id: s.id,
@@ -109,14 +154,38 @@ export const proceduralItemDefinition = {
         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') },
+    exportAnimation: ({ node, object }) => bakeProceduralAnimationClips(node, object),
     parametrics: { groups: [], customPanel: () => import('@pascal-app/editor/procedural-items') },
     affordanceTools: { move: () => import('./move-tool') },
     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) => {

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

@@ -1,8 +1,10 @@
 import { type Evaluation, type ProceduralItemNode } from '@pascal-app/core/procedural-items';
-import { type BufferGeometry } from 'three';
+import { BufferGeometry } from 'three';
 export type Batch = {
     slot: string;
+    motionGroup?: string;
     geometry: BufferGeometry;
+    motionGeometry?: BufferGeometry;
     ranges: {
         end: number;
         partId: string;
@@ -11,6 +13,8 @@ export type Batch = {
 };
 export type BuiltItem = {
     batches: Batch[];
+    /** Part-tree designs: the whole rest pose merged per slot, drawn while no joint moves. */
+    rest?: Batch[];
     evaluation: Evaluation;
     milliseconds: number;
     triangles: number;

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

@@ -1 +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"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/procedural-item/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,kBAAkB,EAIxB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAEL,cAAc,EAaf,MAAM,OAAO,CAAA;AAGd,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,cAAc,CAAA;IACxB,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,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,0FAA0F;IAC1F,IAAI,CAAC,EAAE,KAAK,EAAE,CAAA;IACd,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAiMD,eAAO,MAAM,iBAAiB;;;;;CAA8D,CAAA;AAE5F,eAAO,MAAM,iBAAiB,GAAI,MAAM,kBAAkB,WACV,CAAA;AAChD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CA2G3E;AACD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,kBAAkB;;;EA2BjE;AACD,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,iBAE/D"}