@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/pipe-segment/floorplan.js

@@ -1,6 +1,6 @@
-import { INCHES_TO_METERS } from '../duct-segment/geometry';
-import { runHangerFloorplan } from '../shared/run-hangers';
-import { pipeContinuationHandlePlan, pipeEndpointPort } from './continuation';
+import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { runHangerFloorplan } from '../shared/run-hangers.js';
+import { pipeContinuationHandlePlan, pipeEndpointPort } from './continuation.js';
 const WASTE_COLOR = '#57534e';
 const VENT_COLOR = '#78716c';
 /**

package/dist/pipe-segment/geometry.d.ts

@@ -1,6 +1,6 @@
 import type { GeometryContext } from '@pascal-app/core';
 import { Group, MeshStandardMaterial } from 'three';
-import type { PipeSegmentNode } from './schema';
+import type { PipeSegmentNode } from './schema.js';
 type PipeAppearance = {
     pipeMaterial: 'pvc' | 'abs' | 'cast-iron';
     system: 'waste' | 'vent';

package/dist/pipe-segment/geometry.js

@@ -1,6 +1,6 @@
 import { Group, Mesh, MeshStandardMaterial, SphereGeometry, Vector3 } from 'three';
-import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry';
-import { buildRunHangers } from '../shared/run-hangers';
+import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { buildRunHangers } from '../shared/run-hangers.js';
 const PVC_COLOR = '#f5f5f5';
 const ABS_COLOR = '#3a3a3a';
 const CAST_IRON_COLOR = '#54575c';

package/dist/pipe-segment/index.d.ts

@@ -1,4 +1,4 @@
-export { pipeSegmentDefinition } from './definition';
-export { buildPipeSegmentGeometry } from './geometry';
-export { PipeSegmentNode } from './schema';
+export { pipeSegmentDefinition } from './definition.js';
+export { buildPipeSegmentGeometry } from './geometry.js';
+export { PipeSegmentNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/pipe-segment/index.js

@@ -1,3 +1,3 @@
-export { pipeSegmentDefinition } from './definition';
-export { buildPipeSegmentGeometry } from './geometry';
-export { PipeSegmentNode } from './schema';
+export { pipeSegmentDefinition } from './definition.js';
+export { buildPipeSegmentGeometry } from './geometry.js';
+export { PipeSegmentNode } from './schema.js';

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;eAiCc,mBAAmB"}

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

@@ -1,13 +1,13 @@
 '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';
-import { collectGhostAlignmentCandidates, resolveGhostAlignment, } from '../shared/ghost-alignment';
-import { startRunMoveConnectivity } from '../shared/run-move-connectivity';
-import { translateWallRun } from '../shared/wall-run-move';
+import { collectGhostAlignmentCandidates, resolveGhostAlignment, } from '../shared/ghost-alignment.js';
+import { startRunMoveConnectivity } from '../shared/run-move-connectivity.js';
+import { translateWallRun } from '../shared/wall-run-move.js';
 const GHOST_COLOR = '#818cf8';
 const GHOST_OPACITY = 0.5;
 const IN_TO_M = 0.0254;
@@ -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/parametrics.d.ts

@@ -1,4 +1,4 @@
 import type { ParametricDescriptor } from '@pascal-app/core';
-import type { PipeSegmentNode } from './schema';
+import type { PipeSegmentNode } from './schema.js';
 export declare const pipeSegmentParametrics: ParametricDescriptor<PipeSegmentNode>;
 //# sourceMappingURL=parametrics.d.ts.map

package/dist/pipe-segment/parametrics.js

@@ -1,5 +1,5 @@
-import { findAutomaticRunEndCapIds } from '../shared/automatic-run-end-cap';
-import { fittingDeletionPlansForRun } from '../shared/fitting-deletion-cleanup';
+import { findAutomaticRunEndCapIds } from '../shared/automatic-run-end-cap.js';
+import { fittingDeletionPlansForRun } from '../shared/fitting-deletion-cleanup.js';
 export const pipeSegmentParametrics = {
     derive: (next) => next.autoHangers
         ? {
@@ -13,7 +13,7 @@ export const pipeSegmentParametrics = {
         ...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'),
+    trailingSection: () => import('../shared/run-hanger-inspector.js'),
     groups: [
         {
             label: 'Hangers',

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

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/selection.tsx"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,QAAA,MAAM,8BAA8B,0CA+BnC,CAAA;AAs7BD,eAAe,8BAA8B,CAAA"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/selection.tsx"],"names":[],"mappings":"AAiFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,QAAA,MAAM,8BAA8B,0CA+BnC,CAAA;eAs7Bc,8BAA8B"}

package/dist/pipe-segment/selection.js

@@ -2,20 +2,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { analyzePortConnectivity, PipeSegmentNode, pauseSceneHistory, resolveConnectivityUpdates, resumeSceneHistory, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { clearPlacementSurface, DimensionPill, isGridSnapActive, swallowNextClick, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { collectScenePorts, findNearestPortXZ } from '@pascal-app/editor/distribution';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { createPortal, useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { Plane, Raycaster, Vector2, Vector3 } from 'three';
-import { planRunEndCapFollowUpdates } from '../shared/automatic-run-end-cap';
-import { detectFittingEndpoint, planFittingEndpointReaim, } from '../shared/fitting-endpoint-reaim';
-import { PipeFittingGhost, PipeSegmentGhost } from '../shared/mep-ghost';
-import { planPipeRunTranslationOffsets } from '../shared/pipe-run-translation-offset';
-import { planVerticalOffsets } from '../shared/pipe-vertical-offset';
-import { collectScenePorts, DWV_PORT_SYSTEMS, findNearestPortXZ } from '../shared/ports';
-import { ContinuePlusHandle, HandleCube, MoveChevron } from '../shared/selection-handles';
-import { refreshWallRunAttachment } from '../shared/wall-run-move';
-import { activatePipeContinuation, pipeContinuationHandlePlan, } from './continuation';
+import { planRunEndCapFollowUpdates } from '../shared/automatic-run-end-cap.js';
+import { detectFittingEndpoint, planFittingEndpointReaim, } from '../shared/fitting-endpoint-reaim.js';
+import { PipeFittingGhost, PipeSegmentGhost } from '../shared/mep-ghost.js';
+import { planPipeRunTranslationOffsets } from '../shared/pipe-run-translation-offset.js';
+import { planVerticalOffsets } from '../shared/pipe-vertical-offset.js';
+import { DWV_PORT_SYSTEMS } from '../shared/port-systems.js';
+import { ContinuePlusHandle, HandleCube, MoveChevron } from '../shared/selection-handles.js';
+import { refreshWallRunAttachment } from '../shared/wall-run-move.js';
+import { activatePipeContinuation, pipeContinuationHandlePlan, } from './continuation.js';
 /** Port-snap radius for dragged run endpoints (meters, XZ). */
 const PORT_SNAP_RADIUS_M = 0.4;
 const CENTER_ARROW_GAP = 0.28;

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,0CAucpB,CAAA;AA8BD,eAAe,eAAe,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/tool.tsx"],"names":[],"mappings":"AA6DA,QAAA,MAAM,eAAe,0CAucpB,CAAA;eA8Bc,eAAe"}

package/dist/pipe-segment/tool.js

@@ -2,22 +2,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { PipeSegmentNode } from '@pascal-app/core';
 import { EDITOR_LAYER, triggerSFX, useEditor, usePathDraftPreview, useRegistryToolContext, } from '@pascal-app/editor';
+import { collectScenePorts, createRunWallAttachment, DistributionRunCursor, findNearestRunBody3D, findRunBodyCrossingSurface, RUN_PREVIEW_OPACITY, runDistanceSquared, stepNominalRunSize, useDistributionRunTool, } from '@pascal-app/editor/distribution';
 import { useEffect, useRef, useState } from 'react';
 import { Vector3 } from 'three';
-import { planPipeBranchTap, planPipeCrossAtRunBody, planPipeElbowAtPort, } from '../shared/auto-fitting';
-import { createPipeRunEndCap, findMatedRunEndCapIds, isRunEndCapPort, } from '../shared/automatic-run-end-cap';
-import { ConnectionFeedback } from '../shared/connection-feedback';
-import { createRunWallAttachment } from '../shared/distribution-run-contract';
-import { DistributionRunCursor, RUN_PREVIEW_OPACITY, runDistanceSquared, runSectionHalfSizeM, stepNominalRunSize, useDistributionRunTool, } from '../shared/distribution-run-tool';
-import { FITTING_CLEARANCE_MESSAGE, hasFittingClearance } from '../shared/fitting-clearance';
-import { LevelOffsetGroup } from '../shared/level-offset-group';
-import { PipeFittingGhost } from '../shared/mep-ghost';
-import { collectScenePorts, DWV_PORT_SYSTEMS, findNearestRunBody3D, findRunBodyCrossingSurface, } from '../shared/ports';
-import { RunHangerPreview } from '../shared/run-hanger-controls';
-import { useRunHangerMode } from '../shared/run-hanger-mode';
-import { currentPipeContinuationSeed, pipeEndpointPort } from './continuation';
-import { pipeSegmentDefinition } from './definition';
-import { applyPipeGrade } from './slope';
+import { planPipeBranchTap, planPipeCrossAtRunBody, planPipeElbowAtPort, } from '../shared/auto-fitting.js';
+import { createPipeRunEndCap, findMatedRunEndCapIds, isRunEndCapPort, } from '../shared/automatic-run-end-cap.js';
+import { ConnectionFeedback } from '../shared/connection-feedback.js';
+import { FITTING_CLEARANCE_MESSAGE, hasFittingClearance } from '../shared/fitting-clearance.js';
+import { LevelOffsetGroup } from '../shared/level-offset-group.js';
+import { PipeFittingGhost } from '../shared/mep-ghost.js';
+import { DWV_PORT_SYSTEMS, runSectionHalfSizeM } from '../shared/port-systems.js';
+import { RunHangerPreview } from '../shared/run-hanger-controls.js';
+import { useRunHangerMode } from '../shared/run-hanger-mode.js';
+import { currentPipeContinuationSeed, pipeEndpointPort } from './continuation.js';
+import { pipeSegmentDefinition } from './definition.js';
+import { applyPipeGrade } from './slope.js';
 const PIPE_DIAMETERS_IN = [1.25, 1.5, 2, 3, 4, 6];
 const BODY_SNAP_RADIUS_M = 0.3;
 function getConnectionPorts(levelId, nodes) {

package/dist/pipe-trap/definition.d.ts

@@ -1,5 +1,5 @@
 import type { NodeDefinition } from '@pascal-app/core';
-import { PipeTrapNode } from './schema';
+import { PipeTrapNode } from './schema.js';
 /**
  * DWV P-trap — the water-seal fitting on the waste line. Placed by its
  * own click tool; the pipe tool then draws the trap arm off the outlet.

package/dist/pipe-trap/definition.js

@@ -1,8 +1,8 @@
-import { buildPipeTrapFloorplan } from './floorplan';
-import { buildPipeTrapGeometry } from './geometry';
-import { pipeTrapParametrics } from './parametrics';
-import { getPipeTrapPorts } from './ports';
-import { PipeTrapNode } from './schema';
+import { buildPipeTrapFloorplan } from './floorplan.js';
+import { buildPipeTrapGeometry } from './geometry.js';
+import { pipeTrapParametrics } from './parametrics.js';
+import { getPipeTrapPorts } from './ports.js';
+import { PipeTrapNode } from './schema.js';
 /**
  * DWV P-trap — the water-seal fitting on the waste line. Placed by its
  * own click tool; the pipe tool then draws the trap arm off the outlet.
@@ -40,7 +40,7 @@ export const pipeTrapDefinition = {
     geometryKey: (n) => JSON.stringify([n.diameter, n.pipeMaterial, n.armLengthM]),
     ports: getPipeTrapPorts,
     floorplan: buildPipeTrapFloorplan,
-    tool: () => import('./tool'),
+    tool: () => import('./tool.js'),
     toolHints: [
         { key: 'Click', label: 'Place trap' },
         { key: 'R / T', label: 'Rotate ±45°' },

package/dist/pipe-trap/floorplan.d.ts

@@ -1,5 +1,5 @@
 import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
-import type { PipeTrapNode } from './schema';
+import type { PipeTrapNode } from './schema.js';
 /**
  * Floor-plan symbol — the conventional trap glyph: a short stub at the
  * inlet (the fixture drop, drawn as a dot since it's vertical) and a

package/dist/pipe-trap/floorplan.js

@@ -1,4 +1,4 @@
-import { getPipeTrapPorts } from './ports';
+import { getPipeTrapPorts } from './ports.js';
 const PIPE_STROKE = '#57534e';
 /**
  * Floor-plan symbol — the conventional trap glyph: a short stub at the

package/dist/pipe-trap/geometry.d.ts

@@ -1,5 +1,5 @@
 import { Group, Vector3 } from 'three';
-import type { PipeTrapNode } from './schema';
+import type { PipeTrapNode } from './schema.js';
 /**
  * P-trap geometry in the LOCAL frame (origin at the trap weir, the low
  * point of the U). Inlet stub rises +Y to the fixture tailpiece; a

package/dist/pipe-trap/geometry.js

@@ -1,6 +1,6 @@
 import { DoubleSide, Group, Mesh, SphereGeometry, TorusGeometry, Vector3 } from 'three';
-import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry';
-import { createPipeMaterial } from '../pipe-segment/geometry';
+import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { createPipeMaterial } from '../pipe-segment/geometry.js';
 const BEND_SEGMENTS = 24;
 const RADIAL_SEGMENTS = 20;
 /** Sphere hubs filling the U-bend → stub joints read as a coupling and,

package/dist/pipe-trap/index.d.ts

@@ -1,5 +1,5 @@
-export { pipeTrapDefinition } from './definition';
-export { buildPipeTrapGeometry } from './geometry';
-export { getPipeTrapPorts } from './ports';
-export { PipeTrapNode } from './schema';
+export { pipeTrapDefinition } from './definition.js';
+export { buildPipeTrapGeometry } from './geometry.js';
+export { getPipeTrapPorts } from './ports.js';
+export { PipeTrapNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/pipe-trap/index.js

@@ -1,4 +1,4 @@
-export { pipeTrapDefinition } from './definition';
-export { buildPipeTrapGeometry } from './geometry';
-export { getPipeTrapPorts } from './ports';
-export { PipeTrapNode } from './schema';
+export { pipeTrapDefinition } from './definition.js';
+export { buildPipeTrapGeometry } from './geometry.js';
+export { getPipeTrapPorts } from './ports.js';
+export { PipeTrapNode } from './schema.js';

package/dist/pipe-trap/parametrics.d.ts

@@ -1,4 +1,4 @@
 import type { ParametricDescriptor } from '@pascal-app/core';
-import type { PipeTrapNode } from './schema';
+import type { PipeTrapNode } from './schema.js';
 export declare const pipeTrapParametrics: ParametricDescriptor<PipeTrapNode>;
 //# sourceMappingURL=parametrics.d.ts.map

package/dist/pipe-trap/ports.d.ts

@@ -1,5 +1,5 @@
 import type { NodePort } from '@pascal-app/core';
-import type { PipeTrapNode } from './schema';
+import type { PipeTrapNode } from './schema.js';
 /**
  * `def.ports` — the trap's inlet (up, to the fixture) and outlet (the
  * trap arm, toward the vented waste line), transformed by position +

package/dist/pipe-trap/ports.js

@@ -1,5 +1,5 @@
 import { Vector3 } from 'three';
-import { localTrapPorts } from './geometry';
+import { localTrapPorts } from './geometry.js';
 /**
  * `def.ports` — the trap's inlet (up, to the fixture) and outlet (the
  * trap arm, toward the vented waste line), transformed by position +

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,0CAoHjB,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AA2BA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CAmHjB,CAAA;eAEc,YAAY"}

package/dist/pipe-trap/tool.js

@@ -1,15 +1,15 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, PipeTrapNode, useScene } from '@pascal-app/core';
-import { isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor } from '@pascal-app/editor';
+import { isGridSnapActive, isMagneticSnapActive, isTypingTarget, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { alignDrawPoint, clearDrawAlignment } from '@pascal-app/editor/distribution';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { subscribeAccessorySnapping } from '../shared/accessory-snapping';
-import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
-import { LevelOffsetGroup } from '../shared/level-offset-group';
-import { pipeTrapDefinition } from './definition';
-import { buildPipeTrapGeometry } from './geometry';
+import { subscribeAccessorySnapping } from '../shared/accessory-snapping.js';
+import { LevelOffsetGroup } from '../shared/level-offset-group.js';
+import { pipeTrapDefinition } from './definition.js';
+import { buildPipeTrapGeometry } from './geometry.js';
 const PREVIEW_OPACITY = 0.55;
 const ROTATE_STEP_RAD = Math.PI / 4;
 function snap(value, step) {
@@ -76,8 +76,7 @@ const PipeTrapTool = () => {
             triggerSFX('sfx:item-place');
         };
         const onKeyDown = (e) => {
-            const tag = e.target?.tagName;
-            if (tag === 'INPUT' || tag === 'TEXTAREA')
+            if (isTypingTarget(e.target))
                 return;
             const key = e.key;
             if (key === 'r' || key === 'R' || key === 't' || key === 'T') {

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,WAAY,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;AA8D1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAqO9E,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,CAiS9E,CAAA"}

package/dist/procedural-item/definition.js

@@ -1,8 +1,12 @@
-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';
+import { getEffectiveNode, proceduralItemSlots, toggleMechanism, useInteractive, useScene, } from '@pascal-app/core';
+import { boundsOf, boxCorners, evaluateRecipe, frame, operableParts, ProceduralItemNode, parameterPatch, proceduralCeilingHole, proceduralFootprint, proceduralSlotColor, queryProceduralItem, resolveProceduralWallPlacement, setProceduralMaterial, shelfRecipe, snapParameters, transformPoint, validateProceduralRelations, } from '@pascal-app/core/procedural-items';
+import { usePlacementPreview } from '@pascal-app/editor';
+import { decorateProceduralEmission } from '@pascal-app/viewer';
+import { itemPaint } from '../item/paint.js';
+import { proceduralMechanism, toggleItemLights } from '../shared/item-interactions.js';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
+import { bakeProceduralAnimationClips, isProceduralMotionPlaying } from './animation.js';
+import { proceduralFloorplanMoveTarget } from './move-session.js';
 const GIZMO_SIDE_OFFSET = 0.3;
 const GIZMO_FRONT_OFFSET = 0.3;
 const ROTATE_RING_OFFSET = 0.06;
@@ -10,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() {
@@ -70,9 +80,24 @@ export const proceduralItemDefinition = {
         position: [0, 0, 0],
         rotation: [0, 0, 0],
     }),
-    extensions: { 'pascal:editor/floorplan': { directDrag: true } },
+    extensions: {
+        'pascal:editor/floorplan': {
+            directDrag: true,
+            actionMenu: { actions: () => import('../shared/item-interaction-actions.js') },
+        },
+    },
     capabilities: {
+        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
+        revealOnEdit: ['recipe'],
+        batchable: {
+            scope: 'level',
+            // Part lights clone their emissive slot per node, and a playing motion
+            // moves meshes under the static copy.
+            excluded: (n) => n.recipe.parts.some((part) => part.light) ||
+                isProceduralMotionPlaying(n.id),
+        },
         selectable: { hitVolume: 'bbox' },
+        mechanism: proceduralMechanism,
         dragBounds: (n) => {
             const node = n;
             const e = evaluateRecipe(node.recipe, node.parameters);
@@ -86,6 +111,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,
@@ -95,10 +143,7 @@ export const proceduralItemDefinition = {
         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 }));
-        },
+        slots: (n) => proceduralItemSlots(n),
         surfaces: {
             custom: (n) => evaluateRecipe(n.recipe, n.parameters).surfaces.map((s) => ({
                 id: s.id,
@@ -111,15 +156,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') },
+    renderer: { kind: 'parametric', module: () => import('./renderer.js') },
+    exportAnimation: ({ node, object }) => bakeProceduralAnimationClips(node, object),
     parametrics: { groups: [], customPanel: () => import('@pascal-app/editor/procedural-items') },
-    affordanceTools: { move: () => import('./move-tool') },
+    affordanceTools: { move: () => import('./move-tool.js') },
     floorplanMoveTarget: proceduralFloorplanMoveTarget,
     floorplanAffectedIds: restingFloorplanAffectedIds,
     keyboardActions: {
+        e: {
+            appliesTo: (n) => {
+                const recipe = n.recipe;
+                return operableParts(recipe).length > 0 || recipe.parts.some((part) => part.light);
+            },
+            run: (n) => proceduralMechanism.has(n) ? toggleMechanism(proceduralMechanism, n) : toggleItemLights(n),
+        },
         r: {
             appliesTo: (n) => Boolean(n.wallId),
             run: (n) => {