@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/shared/relative-roof-drag.js

@@ -1,9 +1,9 @@
 import { sceneRegistry, } from '@pascal-app/core';
+import { isGridSnapActive, useEditor } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import * as THREE from 'three';
 import { resolveRoofSegmentHit } from './roof-segment-hit.js';
 import { getSurfaceY } from './roof-surface.js';
-const ROOF_DRAG_SNAP_STEP_M = 0.05;
 export function roofSegmentLocalToBuildingLocal(segmentId, position) {
     const segmentObj = sceneRegistry.nodes.get(segmentId);
     if (!segmentObj)
@@ -68,10 +68,11 @@ export function createRelativeRoofDrag(original) {
     };
 }
 export function snapRelativeRoofDragTarget(target, bypass = false) {
-    if (bypass)
+    const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+    if (bypass || step <= 0)
         return target;
-    const localX = Math.round(target.localX / ROOF_DRAG_SNAP_STEP_M) * ROOF_DRAG_SNAP_STEP_M;
-    const localZ = Math.round(target.localZ / ROOF_DRAG_SNAP_STEP_M) * ROOF_DRAG_SNAP_STEP_M;
+    const localX = Math.round(target.localX / step) * step;
+    const localZ = Math.round(target.localZ / step) * step;
     const surfaceOffsetY = target.localY - getSurfaceY(target.localX, target.localZ, target.segment);
     const localY = getSurfaceY(localX, localZ, target.segment) + surfaceOffsetY;
     return {

package/dist/shared/roof-surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-surface.d.ts","sourceRoot":"","sources":["../../src/shared/roof-surface.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAEhF;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAEvF;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjD,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAC5C,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACpD,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;CACrD,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,qBAAqB,CAkBvB;AAyWD,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,eAAe,EACpB,GAAG,gBAAsB,GACxB,KAAK,CAAC,OAAO,CA2Hf;AAOD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,UAAU,oBAqBjF;AAQD,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAIpF"}
+{"version":3,"file":"roof-surface.d.ts","sourceRoot":"","sources":["../../src/shared/roof-surface.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAEhF;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAEvF;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjD,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAC5C,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACpD,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;CACrD,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,qBAAqB,CAkBvB;AA2WD,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,eAAe,EACpB,GAAG,gBAAsB,GACxB,KAAK,CAAC,OAAO,CA2Hf;AAOD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,UAAU,oBAqBjF;AAQD,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAIpF"}

package/dist/shared/roof-surface.js

@@ -75,6 +75,8 @@ function roofSurfaceFaceCacheKey(segment) {
         segment.dutchHipWidthRatio ?? ROOF_SHAPE_DEFAULTS.dutchHipWidthRatio,
         segment.dutchHipHeightRatio ?? ROOF_SHAPE_DEFAULTS.dutchHipHeightRatio,
         segment.dutchWaistLengthRatio ?? ROOF_SHAPE_DEFAULTS.dutchWaistLengthRatio,
+        segment.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake,
+        segment.dutchTopRakeThickness ?? ROOF_SHAPE_DEFAULTS.dutchTopRakeThickness,
     ].join('|');
 }
 function buildRoofSurfaceFaces(segment) {

package/dist/shared/run-hangers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-hangers.d.ts","sourceRoot":"","sources":["../../src/shared/run-hangers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAMpB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,eAAe,EACf,KAAK,EAOL,OAAO,EACR,MAAM,OAAO,CAAA;AAId,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,eAAe,CAAA;AAC5D,MAAM,MAAM,SAAS,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAEnG,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAqBlF;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,SAAS,GAAG,IAAI,CAAA;CACzB,CAAA;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,aAAa,EAAE,CA6EjB;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,CAEhG;AA0CD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,GAAG,eAAe,CAQ1E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CA+B7F;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,KAAK,CAsC/E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,EAAE,CAqC/F"}
+{"version":3,"file":"run-hangers.d.ts","sourceRoot":"","sources":["../../src/shared/run-hangers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAMpB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,eAAe,EACf,KAAK,EAOL,OAAO,EACR,MAAM,OAAO,CAAA;AAId,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,eAAe,CAAA;AAC5D,MAAM,MAAM,SAAS,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAEnG,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAqBlF;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,SAAS,GAAG,IAAI,CAAA;CACzB,CAAA;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,aAAa,EAAE,CA8EjB;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,CAEhG;AA0CD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,GAAG,eAAe,CAQ1E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CA+B7F;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,KAAK,CAsC/E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,EAAE,CAqC/F"}

package/dist/shared/run-hangers.js

@@ -1,6 +1,6 @@
 import { getWallBaseElevationForNodes, getWallCurveFrameAt, getWallEffectiveHeightForNodes, getWallLocalFaceZ, getWallThickness, pointInPolygon, resolveCeilingHeight, } from '@pascal-app/core';
 import { BoxGeometry, CylinderGeometry, ExtrudeGeometry, Group, Matrix4, Mesh, MeshStandardMaterial, Path, Shape, Vector2, Vector3, } from 'three';
-import { rectSectionAxes } from '../duct-segment/geometry.js';
+import { rectSectionAxes } from '../duct-segment/profile.js';
 import { hasWallChildOverlap, resolveWallAttachmentAtPlanPoint } from './wall-attach-target.js';
 export function hangerSceneNodes(ctx) {
     if (ctx?.sceneNodes)
@@ -72,7 +72,7 @@ export function planRunHangerSlots(run, nodes) {
                     if (!hit)
                         continue;
                     const base = getWallBaseElevationForNodes(host, nodes);
-                    const top = base + getWallEffectiveHeightForNodes(host, nodes);
+                    const top = base + getWallEffectiveHeightForNodes(host, nodes, hit.localX / hit.wallLength);
                     if (center.y < base || center.y > top)
                         continue;
                     if (hasWallChildOverlap(host.id, nodes, hit.localX, center.y - base, 0.08, 0.08))

package/dist/shared/run-move-connectivity.d.ts

@@ -25,7 +25,9 @@ type MovedTransform = {
  * through `useLiveNodeOverrides` (transient — no history churn;
  * `getEffectiveNode` merges overrides so the connected geometry rebuilds at
  * pointer rate), then fold into the commit's single tracked `updateNodes`
- * batch.
+ * batch. A transform the followers cannot follow without pulling a joint
+ * apart resolves to `null`: the tool holds its last shown frame, so release
+ * commits what is on screen.
  *
  * Returns `null` when nothing is connected, so callers skip all the work.
  */
@@ -35,15 +37,22 @@ export declare class RunMoveConnectivity {
     private readonly connectivity;
     private overriddenIds;
     constructor(node: AnyNode, connectivity: PortConnectivity);
-    /** Patches that keep the connected nodes attached for a given live transform. */
+    /** Patches that keep the connected nodes attached for a given live transform,
+     *  or null when they cannot all stay attached. */
     private updatesFor;
-    /** Live-preview the followers for the moved node's current drag transform. */
-    preview(transform: MovedTransform): void;
-    /** Follower patches to fold into the commit `updateNodes` batch. */
+    /** Live-preview the followers for the moved node's current drag transform,
+     *  returning the follower patches it shows. Null leaves the previous preview
+     *  in place: the followers cannot follow this transform. */
+    preview(transform: MovedTransform): {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[] | null;
+    /** Follower patches to fold into the commit `updateNodes` batch, or null when
+     *  they cannot follow `transform`. */
     commitUpdates(transform: MovedTransform): {
         id: AnyNodeId;
         data: Partial<AnyNode>;
-    }[];
+    }[] | null;
     /** Drop all live overrides (commit clears them once the scene write lands;
      *  cancel / unmount clears them to reveal the unchanged followers). */
     clear(): void;

package/dist/shared/run-move-connectivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-move-connectivity.d.ts","sourceRoot":"","sources":["../../src/shared/run-move-connectivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,gBAAgB,EAItB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpC;gEACgE;AAChE,KAAK,cAAc,GAAG;IAAE,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CAIlF;AAED,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJ/B,OAAO,CAAC,aAAa,CAAkB;IAEvC,YACmB,IAAI,EAAE,OAAO,EACb,YAAY,EAAE,gBAAgB,EAC7C;IAEJ,iFAAiF;IACjF,OAAO,CAAC,UAAU;IAOlB,8EAA8E;IAC9E,OAAO,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI,CAmBvC;IAED,oEAAoE;IACpE,aAAa,CAAC,SAAS,EAAE,cAAc,GAAG;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,CAEpF;IAED;2EACuE;IACvE,KAAK,IAAI,IAAI,CAOZ;CACF"}
+{"version":3,"file":"run-move-connectivity.d.ts","sourceRoot":"","sources":["../../src/shared/run-move-connectivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,gBAAgB,EAItB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpC;gEACgE;AAChE,KAAK,cAAc,GAAG;IAAE,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CAIlF;AAED,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJ/B,OAAO,CAAC,aAAa,CAAkB;IAEvC,YACmB,IAAI,EAAE,OAAO,EACb,YAAY,EAAE,gBAAgB,EAC7C;IAEJ;sDACkD;IAClD,OAAO,CAAC,UAAU;IAWlB;;gEAE4D;IAC5D,OAAO,CAAC,SAAS,EAAE,cAAc,GAAG;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,GAAG,IAAI,CAqBrF;IAED;0CACsC;IACtC,aAAa,CAAC,SAAS,EAAE,cAAc,GAAG;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,GAAG,IAAI,CAE3F;IAED;2EACuE;IACvE,KAAK,IAAI,IAAI,CAOZ;CACF"}

package/dist/shared/run-move-connectivity.js

@@ -18,7 +18,9 @@ import { analyzePortConnectivity, resolveConnectivityUpdates, useLiveNodeOverrid
  * through `useLiveNodeOverrides` (transient — no history churn;
  * `getEffectiveNode` merges overrides so the connected geometry rebuilds at
  * pointer rate), then fold into the commit's single tracked `updateNodes`
- * batch.
+ * batch. A transform the followers cannot follow without pulling a joint
+ * apart resolves to `null`: the tool holds its last shown frame, so release
+ * commits what is on screen.
  *
  * Returns `null` when nothing is connected, so callers skip all the work.
  */
@@ -36,14 +38,19 @@ export class RunMoveConnectivity {
         this.node = node;
         this.connectivity = connectivity;
     }
-    /** Patches that keep the connected nodes attached for a given live transform. */
+    /** Patches that keep the connected nodes attached for a given live transform,
+     *  or null when they cannot all stay attached. */
     updatesFor(transform) {
         const preview = { ...this.node, ...transform };
-        return resolveConnectivityUpdates(this.connectivity, preview).filter((u) => useScene.getState().nodes[u.id]);
+        return (resolveConnectivityUpdates(this.connectivity, preview)?.filter((u) => useScene.getState().nodes[u.id]) ?? null);
     }
-    /** Live-preview the followers for the moved node's current drag transform. */
+    /** Live-preview the followers for the moved node's current drag transform,
+     *  returning the follower patches it shows. Null leaves the previous preview
+     *  in place: the followers cannot follow this transform. */
     preview(transform) {
         const updates = this.updatesFor(transform);
+        if (!updates)
+            return null;
         const overrides = useLiveNodeOverrides.getState();
         const nextIds = updates.map((u) => u.id);
         // Drop overrides on nodes that fell out of this frame's update set (e.g. a
@@ -63,8 +70,10 @@ export class RunMoveConnectivity {
             }
         }
         this.overriddenIds = nextIds;
+        return updates;
     }
-    /** Follower patches to fold into the commit `updateNodes` batch. */
+    /** Follower patches to fold into the commit `updateNodes` batch, or null when
+     *  they cannot follow `transform`. */
     commitUpdates(transform) {
         return this.updatesFor(transform);
     }

package/dist/shared/run-tool-options.d.ts

@@ -0,0 +1,8 @@
+import type { ToolOption } from '@pascal-app/core';
+type RunKind = 'duct-segment' | 'pipe-segment';
+export declare function updateRunDefaults(kind: RunKind, patch: Record<string, unknown>): void;
+export declare function clearRunContinuation(kind: RunKind): void;
+export declare const ductRunToolOptions: ToolOption[];
+export declare const pipeRunToolOptions: ToolOption[];
+export {};
+//# sourceMappingURL=run-tool-options.d.ts.map

package/dist/shared/run-tool-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-tool-options.d.ts","sourceRoot":"","sources":["../../src/shared/run-tool-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAGlD,KAAK,OAAO,GAAG,cAAc,GAAG,cAAc,CAAA;AAE9C,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAGrF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAGxD;AA8GD,eAAO,MAAM,kBAAkB,EAAE,UAAU,EA0E1C,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,UAAU,EA4D1C,CAAA"}

package/dist/shared/run-tool-options.js

@@ -0,0 +1,166 @@
+import { useEditor } from '@pascal-app/editor';
+export function updateRunDefaults(kind, patch) {
+    const editor = useEditor.getState();
+    editor.setToolDefaults(kind, { ...editor.toolDefaults[kind], ...patch });
+}
+export function clearRunContinuation(kind) {
+    const { continuation: _continuation, ...settings } = useEditor.getState().toolDefaults[kind] ?? {};
+    useEditor.getState().setToolDefaults(kind, settings);
+}
+function choice(kind, key, label, values, fallback) {
+    return {
+        id: key,
+        label,
+        choices: values.map(([value, label, description]) => ({ value, label, description })),
+        subscribe: useEditor.subscribe,
+        value: () => String(useEditor.getState().toolDefaults[kind]?.[key] ?? fallback),
+        set: (value) => updateRunDefaults(kind, { [key]: value }),
+    };
+}
+function number(kind, key, label, fallback, input) {
+    return {
+        ...choice(kind, key, label, [], String(fallback)),
+        input,
+        set: (value) => {
+            const next = Number(value);
+            if (!Number.isFinite(next) ||
+                (input.min !== undefined && next < input.min) ||
+                (input.max !== undefined && next > input.max))
+                return;
+            updateRunDefaults(kind, { [key]: next });
+        },
+    };
+}
+function routing(kind) {
+    return [
+        choice(kind, 'routingMode', 'Route', [
+            ['surface', 'Follow surface', 'Follow the floor, wall, or ceiling under the pointer.'],
+            [
+                'horizontal',
+                kind === 'pipe-segment' ? 'Plan route' : 'Horizontal',
+                kind === 'pipe-segment'
+                    ? 'Follow a plan direction, applying the chosen fall from the start elevation.'
+                    : 'Keep the run at its starting elevation.',
+            ],
+            ['vertical', 'Vertical', 'Keep X and Z fixed. Enter the target elevation below.'],
+        ], 'surface'),
+        {
+            ...number(kind, 'elevation', 'Start elevation above level', 0, { unit: 'm', step: 0.01 }),
+            visible: {
+                subscribe: useEditor.subscribe,
+                value: () => ['horizontal', 'vertical'].includes(String(useEditor.getState().toolDefaults[kind]?.routingMode)),
+            },
+        },
+        {
+            ...number(kind, 'targetElevation', 'Target elevation above level', 3, {
+                unit: 'm',
+                step: 0.01,
+            }),
+            visible: {
+                subscribe: useEditor.subscribe,
+                value: () => useEditor.getState().toolDefaults[kind]?.routingMode === 'vertical',
+            },
+        },
+        choice(kind, 'crossingMode', 'Crossing another run', [
+            ['connect', 'Connect', 'Insert a fitting where runs meet.'],
+            [
+                'cross',
+                'Cross without joining',
+                'Keep the runs separate. This does not provide physical clearance.',
+            ],
+        ], 'connect'),
+    ];
+}
+const ductProfile = (round) => ({
+    subscribe: useEditor.subscribe,
+    value: () => (useEditor.getState().toolDefaults['duct-segment']?.shape === 'round') === round,
+});
+const ductPresets = {
+    trunk: { shape: 'rect', width: 14, height: 8, ductMaterial: 'sheet-metal', system: 'supply' },
+    branch: { shape: 'round', diameter: 6, ductMaterial: 'spiral', system: 'supply' },
+    flex: { shape: 'round', diameter: 6, ductMaterial: 'flex', system: 'supply' },
+    return: { shape: 'rect', width: 20, height: 10, ductMaterial: 'sheet-metal', system: 'return' },
+};
+export const ductRunToolOptions = [
+    {
+        ...choice('duct-segment', 'preset', 'Starting profile', [
+            ['custom', 'Custom'],
+            ['trunk', 'Supply trunk · 14 × 8 in'],
+            ['branch', 'Round branch · 6 in'],
+            ['flex', 'Flex connection · 6 in'],
+            ['return', 'Return trunk · 20 × 10 in'],
+        ], 'custom'),
+        value: () => {
+            const current = useEditor.getState().toolDefaults['duct-segment'] ?? {};
+            return (Object.entries(ductPresets).find(([, preset]) => Object.entries(preset).every(([key, value]) => current[key] === value))?.[0] ?? 'custom');
+        },
+        set: (value) => {
+            const preset = ductPresets[value];
+            if (preset)
+                updateRunDefaults('duct-segment', preset);
+        },
+    },
+    choice('duct-segment', 'system', 'System', [
+        ['supply', 'Supply'],
+        ['return', 'Return'],
+    ], 'supply'),
+    choice('duct-segment', 'shape', 'Profile', [
+        ['round', 'Round'],
+        ['rect', 'Rectangular'],
+        ['oval', 'Oval'],
+    ], 'rect'),
+    {
+        ...number('duct-segment', 'diameter', 'Diameter', 6, { min: 2, max: 48, unit: 'in' }),
+        visible: ductProfile(true),
+    },
+    {
+        ...number('duct-segment', 'width', 'Width', 14, { min: 4, max: 60, unit: 'in' }),
+        visible: ductProfile(false),
+    },
+    {
+        ...number('duct-segment', 'height', 'Height', 8, { min: 3, max: 40, unit: 'in' }),
+        visible: ductProfile(false),
+    },
+    choice('duct-segment', 'ductMaterial', 'Material', [
+        ['flex', 'Flex'],
+        ['sheet-metal', 'Sheet metal'],
+        ['spiral', 'Spiral'],
+        ['duct-board', 'Ductboard'],
+    ], 'flex'),
+    ...routing('duct-segment'),
+];
+export const pipeRunToolOptions = [
+    choice('pipe-segment', 'system', 'System', [
+        ['waste', 'Waste'],
+        ['vent', 'Vent'],
+    ], 'waste'),
+    number('pipe-segment', 'diameter', 'Diameter', 2, { min: 1.25, max: 8, unit: 'in' }),
+    choice('pipe-segment', 'pipeMaterial', 'Material', [
+        ['pvc', 'PVC'],
+        ['abs', 'ABS'],
+        ['cast-iron', 'Cast iron'],
+    ], 'pvc'),
+    {
+        ...choice('pipe-segment', 'fall', 'Fall', [
+            ['level', 'Level'],
+            ['sloped', 'Graded', 'Apply the grade and flow direction below.'],
+        ], 'level'),
+        visible: {
+            subscribe: useEditor.subscribe,
+            value: () => (useEditor.getState().toolDefaults['pipe-segment']?.system ?? 'waste') === 'waste',
+        },
+    },
+    {
+        ...number('pipe-segment', 'gradePercent', 'Grade', 100 / 48, { min: 0, step: 0.1, unit: '%' }),
+        visible: {
+            subscribe: useEditor.subscribe,
+            value: () => useEditor.getState().toolDefaults['pipe-segment']?.fall === 'sloped' &&
+                (useEditor.getState().toolDefaults['pipe-segment']?.system ?? 'waste') === 'waste',
+        },
+    },
+    choice('pipe-segment', 'flowDirection', 'Downhill flow', [
+        ['forward', 'Start → end'],
+        ['reverse', 'End → start'],
+    ], 'forward'),
+    ...routing('pipe-segment'),
+];

package/dist/shared/system-checks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-checks.d.ts","sourceRoot":"","sources":["../../src/shared/system-checks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAUf,MAAM,kBAAkB,CAAA;AAKzB,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B,CAAA;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,aAAa,EAAE,CAqI3F"}
+{"version":3,"file":"system-checks.d.ts","sourceRoot":"","sources":["../../src/shared/system-checks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAUf,MAAM,kBAAkB,CAAA;AAKzB,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B,CAAA;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,aAAa,EAAE,CA0I3F"}

package/dist/shared/system-checks.js

@@ -93,7 +93,8 @@ export function checkDistributionSystems(nodes) {
         if (wall.type !== 'wall')
             continue;
         const base = getWallBaseElevationForNodes(wall, nodes);
-        const top = base + getWallEffectiveHeightForNodes(wall, nodes);
+        const top = base +
+            Math.max(getWallEffectiveHeightForNodes(wall, nodes, 0), getWallEffectiveHeightForNodes(wall, nodes, 1));
         const points = [];
         for (let i = 0; i <= 16; i++) {
             const frame = getWallCurveFrameAt(wall, i / 16);

package/dist/shared/vertical-offset.js

@@ -1,7 +1,7 @@
 import { DuctSegmentNode, } from '@pascal-app/core';
 import { Vector3 } from 'three';
 import { fittingLegLength, getDuctFittingPorts } from '../duct-fitting/ports.js';
-import { rollToContinueAcrossElbow } from '../duct-segment/geometry.js';
+import { rollToContinueAcrossElbow } from '../duct-segment/profile.js';
 import { planElbowAtPort, planElbowRealign, profileDiameterIn, } from './auto-fitting.js';
 /** Joint-coincidence epsilon (m), matching core's port connectivity. */
 const COINCIDENT_EPS_M = 0.05;

package/dist/shared/wall-opening-ceiling.d.ts

@@ -17,4 +17,10 @@ export { resolveWallOpeningCeiling };
  * openings clamp elsewhere.
  */
 export declare function readHostWallCeiling(wallId: string | null | undefined, scene: WallCeilingSceneReader, opening?: Pick<DoorNode, 'position' | 'width' | 'height'>): number;
+/**
+ * Width cap for a wall-hosted opening's side handle: how far the moving edge can travel from
+ * `anchorS` (in direction `growSign`) before a sloped top drops below the opening's top `topY`,
+ * capped at `maxLength`. Zero when the top is already below `topY` at the anchor.
+ */
+export declare function readHostWallCeilingMaxWidth(wallId: string | null | undefined, scene: WallCeilingSceneReader, anchorS: number, growSign: number, topY: number, maxLength: number, opening?: Pick<DoorNode, 'position' | 'width' | 'height'>): number;
 //# sourceMappingURL=wall-opening-ceiling.d.ts.map

package/dist/shared/wall-opening-ceiling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-opening-ceiling.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-ceiling.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAErE;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAA;IAC/B,KAAK,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD,CAAA;AAED,kFAAkF;AAClF,OAAO,EAAE,yBAAyB,EAAE,CAAA;AAEpC;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,GACxD,MAAM,CASR"}
+{"version":3,"file":"wall-opening-ceiling.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-ceiling.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,QAAQ,EAOd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,yBAAyB,EAA0B,MAAM,2BAA2B,CAAA;AAE7F;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAA;IAC/B,KAAK,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD,CAAA;AAED,kFAAkF;AAClF,OAAO,EAAE,yBAAyB,EAAE,CAAA;AAEpC;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,GACxD,MAAM,CASR;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,sBAAsB,EAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,GACxD,MAAM,CAgBR"}

package/dist/shared/wall-opening-ceiling.js

@@ -1,5 +1,5 @@
-import { getOpeningFloorDatum, wallSupportForNodes, } from '@pascal-app/core';
-import { resolveWallOpeningCeiling } from '@pascal-app/core/building';
+import { getOpeningFloorDatum, getWallChordFractionAt, getWallCurveLength, getWallStationAtChordFraction, wallSupportForNodes, } from '@pascal-app/core';
+import { resolveWallOpeningCeiling, wallOpeningCeilingOver } from '@pascal-app/core/building';
 /** The ceiling an opening's top edge must stay under: the shared rule in core. */
 export { resolveWallOpeningCeiling };
 /**
@@ -11,11 +11,40 @@ export function readHostWallCeiling(wallId, scene, opening) {
     if (!wallId)
         return Number.POSITIVE_INFINITY;
     const wall = scene.get(wallId);
-    if (!wall)
+    if (wall?.type !== 'wall')
         return Number.POSITIVE_INFINITY;
     const nodes = scene.nodes();
-    const lift = opening
-        ? getOpeningFloorDatum(wall, opening, nodes) - wallSupportForNodes(wall, nodes).elevation
-        : 0;
-    return resolveWallOpeningCeiling(wall, nodes) - lift;
+    if (!opening)
+        return wallOpeningCeilingOver(wall, nodes, 0, getWallCurveLength(wall));
+    const left = opening.position[0] - opening.width / 2;
+    const right = opening.position[0] + opening.width / 2;
+    return wallOpeningCeilingOver(wall, nodes, left, right) - openingLift(wall, opening, nodes);
+}
+/**
+ * Width cap for a wall-hosted opening's side handle: how far the moving edge can travel from
+ * `anchorS` (in direction `growSign`) before a sloped top drops below the opening's top `topY`,
+ * capped at `maxLength`. Zero when the top is already below `topY` at the anchor.
+ */
+export function readHostWallCeilingMaxWidth(wallId, scene, anchorS, growSign, topY, maxLength, opening) {
+    if (!wallId)
+        return maxLength;
+    const wall = scene.get(wallId);
+    if (wall?.type !== 'wall')
+        return maxLength;
+    if (getWallCurveLength(wall) < 1e-4)
+        return 0;
+    const nodes = scene.nodes();
+    const lift = opening ? openingLift(wall, opening, nodes) : 0;
+    const startHeight = resolveWallOpeningCeiling(wall, nodes, 0) - lift;
+    const rise = resolveWallOpeningCeiling(wall, nodes, 1) - lift - startHeight;
+    if (startHeight + rise * getWallChordFractionAt(wall, anchorS) < topY - 1e-4)
+        return 0;
+    if (rise * growSign >= -1e-6)
+        return maxLength;
+    const limitS = getWallStationAtChordFraction(wall, (topY - startHeight) / rise);
+    return Math.max(0, Math.min(maxLength, (limitS - anchorS) / growSign));
+}
+/** How far the opening's floor datum sits above the wall's elected base. */
+function openingLift(wall, opening, nodes) {
+    return getOpeningFloorDatum(wall, opening, nodes) - wallSupportForNodes(wall, nodes).elevation;
 }

package/dist/shelf/definition.d.ts

@@ -1,4 +1,109 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { ShelfNode } from './schema.js';
-export declare const shelfDefinition: NodeDefinition<typeof ShelfNode>;
+export declare const shelfDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`shelf_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"shelf">>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    thickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    style: import("zod").ZodDefault<import("zod").ZodEnum<{
+        bookshelf: "bookshelf";
+        cubby: "cubby";
+        "open-rack": "open-rack";
+        "wall-shelf": "wall-shelf";
+    }>>;
+    rows: import("zod").ZodDefault<import("zod").ZodNumber>;
+    columns: import("zod").ZodDefault<import("zod").ZodNumber>;
+    withBack: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    withSides: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    withBottom: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    bracketStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        hidden: "hidden";
+        industrial: "industrial";
+        minimal: "minimal";
+    }>>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAWpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA2HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA4J5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAsE,CAAA"}

package/dist/shelf/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { ShelfNode } from './schema.js';
+export declare const shelfEditContribution: NodeEditContribution<typeof ShelfNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/shelf/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAQvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAkIzC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAiCxE,CAAA"}