@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/level/definition.render.js

@@ -0,0 +1,53 @@
+import { DEFAULT_LEVEL_HEIGHT, LevelNode as LevelNodeSchema } from '@pascal-app/core';
+import { LevelNode } from './schema.js';
+export const levelRenderDefinition = {
+    kind: 'level',
+    schemaVersion: 2,
+    schema: LevelNode,
+    category: 'site',
+    defaults: () => {
+        const stub = LevelNodeSchema.parse({
+            id: 'level_default',
+            type: 'level',
+            height: DEFAULT_LEVEL_HEIGHT,
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: false,
+        // Level is a container — selection happens via the sidebar tree
+        // and the floating level switcher, never via 3D click. Declaring
+        // `selectable` here would make `getSelectableKinds()` add the
+        // kind to `SelectionManager`'s subscription list, and the event
+        // would fire on every wall/slab/ceiling click that bubbled to the
+        // level group — selecting the level instead of the actual node
+        // hit. Legacy `allTypes` deliberately omitted containers; we
+        // mirror that.
+        duplicable: false,
+        deletable: true,
+        // Container kind — saving a level as a standalone preset has no
+        // meaning (its contents make sense only inside a building).
+        presettable: false,
+    },
+    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
+    dirtyTracking: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 1,
+    },
+    presentation: {
+        label: 'Level',
+        description: 'A single floor of a building, holding walls / slabs / ceilings / items.',
+        icon: { kind: 'url', src: '/icons/level.webp' },
+        paletteSection: 'site',
+        paletteOrder: 7,
+    },
+    mcp: {
+        description: 'A level (floor) container under a building.',
+    },
+};

package/dist/lineset/definition.d.ts

@@ -1,15 +1,50 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { LinesetNode } from './schema.js';
-/**
- * Refrigerant lineset — the copper suction + liquid pair joining a split
- * system's outdoor condenser to its indoor coil. The refrigerant-side
- * sibling of `duct-segment`: same polyline model and draw tool, but it
- * snaps onto refrigerant service ports instead of duct collars.
- *
- * Composition: `def.geometry` only, plus a selection-time path-handle
- * system shared in spirit with the duct segment. The framework's
- * `<ParametricNodeRenderer>` mounts an empty group; `<GeometrySystem>`
- * fills it via `buildLinesetGeometry` on dirty.
- */
-export declare const linesetDefinition: NodeDefinition<typeof LinesetNode>;
+export declare const linesetDefinition: 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<`lineset_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"lineset">>;
+    path: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    suctionDiameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    liquidDiameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    insulated: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lineset/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAqHhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lineset/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG7B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/lineset/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,OAAO,WAAW,CAiC5E,CAAA"}

package/dist/lineset/definition.edit.js

@@ -0,0 +1,36 @@
+import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
+import { linesetParametrics } from './parametrics.js';
+export const linesetEditContribution = {
+    drafting: { cancelOnHistoryJump: true },
+    // Directional run: like a wall, drafting sets a direction, so it takes the
+    // structural snapping context (grid / lines / angles / off) with a 45° angle
+    // lock available as a cyclable mode.
+    snapProfile: 'structural',
+    parametrics: linesetParametrics,
+    // 2D selection-time path-point handles — the floor-plan twin of the 3D
+    // `affordanceTools.selection` handles. The builder emits an
+    // `endpoint-handle` per path vertex; this drags the matching point.
+    floorplanAffordances: {
+        'move-path-point': createPathPointMoveAffordance('lineset'),
+    },
+    // Selection-time path-point handles (drag to edit a committed run).
+    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
+    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
+    // which the viewer package mounts for the read-only route.
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+        // Ghost-preview duplicate / move (the refrigerant-loop sibling of
+        // duct-segment's mover). Duplicate is pure drag-to-place: a translucent
+        // copy of the run, wrapped in a footprint bounding box, follows the
+        // cursor and only lands on the commit click — nothing is inserted into
+        // the scene before that.
+        move: () => import('./move-tool.js'),
+    },
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Click', label: 'Start lineset' },
+        { key: 'Click again', label: 'Place it (locked to 45°)' },
+        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
+        { key: 'Esc', label: 'Cancel start point' },
+    ],
+};

package/dist/lineset/definition.js

@@ -1,119 +1,4 @@
-import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
-import { buildLinesetFloorplan } from './floorplan.js';
-import { buildLinesetGeometry } from './geometry.js';
-import { linesetParametrics } from './parametrics.js';
-import { LinesetNode } from './schema.js';
-/**
- * Refrigerant lineset — the copper suction + liquid pair joining a split
- * system's outdoor condenser to its indoor coil. The refrigerant-side
- * sibling of `duct-segment`: same polyline model and draw tool, but it
- * snaps onto refrigerant service ports instead of duct collars.
- *
- * Composition: `def.geometry` only, plus a selection-time path-handle
- * system shared in spirit with the duct segment. The framework's
- * `<ParametricNodeRenderer>` mounts an empty group; `<GeometrySystem>`
- * fills it via `buildLinesetGeometry` on dirty.
- */
-export const linesetDefinition = {
-    kind: 'lineset',
-    schemaVersion: 1,
-    schema: LinesetNode,
-    category: 'utility',
-    distributionRole: 'run',
-    drafting: { cancelOnHistoryJump: true },
-    // Directional run: like a wall, drafting sets a direction, so it takes the
-    // structural snapping context (grid / lines / angles / off) with a 45° angle
-    // lock available as a cyclable mode.
-    snapProfile: 'structural',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        path: [
-            [0, 0, 0],
-            [2, 0, 0],
-        ],
-        suctionDiameter: 0.875,
-        liquidDiameter: 0.375,
-        insulated: true,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-    },
-    parametrics: linesetParametrics,
-    geometry: buildLinesetGeometry,
-    geometryKey: (n) => JSON.stringify([n.path, n.suctionDiameter, n.liquidDiameter, n.insulated]),
-    // Open run ends as typed refrigerant ports — directions point outward
-    // along the path tangent so they mate flush onto a service valve. Path
-    // coords are already level-local, so no transform is needed.
-    ports: (n) => {
-        if (n.path.length < 2)
-            return [];
-        const diameter = n.suctionDiameter;
-        const unit = (a, b) => {
-            const d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-            const len = Math.hypot(d[0], d[1], d[2]);
-            return len < 1e-9 ? [1, 0, 0] : [d[0] / len, d[1] / len, d[2] / len];
-        };
-        const first = n.path[0];
-        const second = n.path[1];
-        const last = n.path[n.path.length - 1];
-        const prev = n.path[n.path.length - 2];
-        return [
-            {
-                id: 'start',
-                position: first,
-                direction: unit(first, second),
-                diameter,
-                system: 'refrigerant',
-            },
-            {
-                id: 'end',
-                position: last,
-                direction: unit(last, prev),
-                diameter,
-                system: 'refrigerant',
-            },
-        ];
-    },
-    floorplan: buildLinesetFloorplan,
-    // 2D selection-time path-point handles — the floor-plan twin of the 3D
-    // `affordanceTools.selection` handles. The builder emits an
-    // `endpoint-handle` per path vertex; this drags the matching point.
-    floorplanAffordances: {
-        'move-path-point': createPathPointMoveAffordance('lineset'),
-    },
-    // Selection-time path-point handles (drag to edit a committed run).
-    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
-    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
-    // which the viewer package mounts for the read-only route.
-    affordanceTools: {
-        selection: () => import('./selection.js'),
-        // Ghost-preview duplicate / move (the refrigerant-loop sibling of
-        // duct-segment's mover). Duplicate is pure drag-to-place: a translucent
-        // copy of the run, wrapped in a footprint bounding box, follows the
-        // cursor and only lands on the commit click — nothing is inserted into
-        // the scene before that.
-        move: () => import('./move-tool.js'),
-    },
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Start lineset' },
-        { key: 'Click again', label: 'Place it (locked to 45°)' },
-        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
-        { key: 'Esc', label: 'Cancel start point' },
-    ],
-    presentation: {
-        label: 'Lineset',
-        description: 'Refrigerant lineset — copper suction + liquid pair joining a condenser to the indoor coil.',
-        icon: { kind: 'url', src: '/icons/lineset.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 93,
-    },
-    mcp: {
-        description: 'A refrigerant lineset defined as a polyline: an insulated suction line plus a bare liquid line, joining an HVAC condenser to its indoor coil. Snaps onto refrigerant service ports.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { linesetEditContribution } from './definition.edit.js';
+import { linesetRenderDefinition } from './definition.render.js';
+export const linesetDefinition = composeNodeDefinition(linesetRenderDefinition, linesetEditContribution);

package/dist/lineset/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { LinesetNode } from './schema.js';
+export declare const linesetRenderDefinition: NodeRenderDefinition<typeof LinesetNode> & {
+    kind: 'lineset';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/lineset/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/lineset/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,OAAO,WAAW,CAAC,GAAG;IAC/E,IAAI,EAAE,SAAS,CAAA;CA2EhB,CAAA"}

package/dist/lineset/definition.render.js

@@ -0,0 +1,74 @@
+import { buildLinesetFloorplan } from './floorplan.js';
+import { buildLinesetGeometry } from './geometry.js';
+import { LinesetNode } from './schema.js';
+export const linesetRenderDefinition = {
+    kind: 'lineset',
+    schemaVersion: 1,
+    schema: LinesetNode,
+    category: 'utility',
+    distributionRole: 'run',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        path: [
+            [0, 0, 0],
+            [2, 0, 0],
+        ],
+        suctionDiameter: 0.875,
+        liquidDiameter: 0.375,
+        insulated: true,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+    },
+    geometry: buildLinesetGeometry,
+    geometryKey: (n) => JSON.stringify([n.path, n.suctionDiameter, n.liquidDiameter, n.insulated]),
+    // Open run ends as typed refrigerant ports — directions point outward
+    // along the path tangent so they mate flush onto a service valve. Path
+    // coords are already level-local, so no transform is needed.
+    ports: (n) => {
+        if (n.path.length < 2)
+            return [];
+        const diameter = n.suctionDiameter;
+        const unit = (a, b) => {
+            const d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+            const len = Math.hypot(d[0], d[1], d[2]);
+            return len < 1e-9 ? [1, 0, 0] : [d[0] / len, d[1] / len, d[2] / len];
+        };
+        const first = n.path[0];
+        const second = n.path[1];
+        const last = n.path[n.path.length - 1];
+        const prev = n.path[n.path.length - 2];
+        return [
+            {
+                id: 'start',
+                position: first,
+                direction: unit(first, second),
+                diameter,
+                system: 'refrigerant',
+            },
+            {
+                id: 'end',
+                position: last,
+                direction: unit(last, prev),
+                diameter,
+                system: 'refrigerant',
+            },
+        ];
+    },
+    floorplan: buildLinesetFloorplan,
+    presentation: {
+        label: 'Lineset',
+        description: 'Refrigerant lineset — copper suction + liquid pair joining a condenser to the indoor coil.',
+        icon: { kind: 'url', src: '/icons/lineset.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 93,
+    },
+    mcp: {
+        description: 'A refrigerant lineset defined as a polyline: an insulated suction line plus a bare liquid line, joining an HVAC condenser to its indoor coil. Snaps onto refrigerant service ports.',
+    },
+};

package/dist/lineset/floorplan.js

@@ -1,4 +1,4 @@
-import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 const COPPER_LINE = '#b06b3f';
 const BODY_COLOR = '#9ca3af';
 /**

package/dist/lineset/geometry.js

@@ -1,5 +1,5 @@
 import { CylinderGeometry, Group, Mesh, MeshStandardMaterial, SphereGeometry, Vector3 } from 'three';
-import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 const RADIAL_SEGMENTS = 16;
 const COPPER_COLOR = '#b06b3f';
 // Light foam sleeve. Real Armaflex is black, but a light jacket reads

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/lineset/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AAqEzB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA2MvD,CAAA;eAiCc,eAAe"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/lineset/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AAqEzB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAkNvD,CAAA;eAiCc,eAAe"}

package/dist/lineset/move-tool.js

@@ -145,10 +145,12 @@ export const MoveLinesetTool = ({ node }) => {
                 triggerSFX('sfx:grid-snap');
             }
             prevSnapRef.current = cur;
-            hasMovedRef.current = true;
             const nextPath = originalPath.map(([x, y, z]) => [x + dx, y, z + dz]);
+            // Connected joints that cannot follow hold the last shown frame.
+            if (connectivity && !connectivity.preview({ path: nextPath }))
+                return;
+            hasMovedRef.current = true;
             setPreview(nextPath);
-            connectivity?.preview({ path: nextPath });
         };
         const commit = (event) => {
             if (committed)
@@ -161,11 +163,19 @@ export const MoveLinesetTool = ({ node }) => {
                 event.nativeEvent?.stopPropagation?.();
                 return;
             }
-            committed = true;
             const finalPath = previewPathRef.current;
+            const creating = isNew && !useScene.getState().nodes[nodeId];
+            // Fold connected-fitting / sibling-run follow-updates into the SAME
+            // batch as the moved run so the whole joint is one undo step.
+            const followUpdates = creating || !connectivity ? [] : connectivity.commitUpdates({ path: finalPath });
+            if (!followUpdates) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
             useScene.temporal.getState().resume();
             let selectId = nodeId;
-            if (isNew && !useScene.getState().nodes[nodeId]) {
+            if (creating) {
                 const created = LinesetNode.parse({
                     ...node,
                     path: finalPath,
@@ -182,9 +192,6 @@ export const MoveLinesetTool = ({ node }) => {
                 selectId = created.id;
             }
             else {
-                // Fold connected-fitting / sibling-run follow-updates into the SAME
-                // batch as the moved run so the whole joint is one undo step.
-                const followUpdates = connectivity?.commitUpdates({ path: finalPath }) ?? [];
                 useScene
                     .getState()
                     .updateNodes([

package/dist/liquid-line/definition.d.ts

@@ -1,16 +1,48 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { LiquidLineNode } from './schema.js';
-/**
- * Standalone refrigerant liquid line — the thin bare-copper line broken out of
- * the lineset so it can be drawn on its own. The refrigerant-side sibling of
- * `lineset`: same polyline model and draw tool, snapping onto refrigerant
- * service ports, but a single thin line. Its tool adds a Follow mode that
- * traces an existing lineset's path at an offset.
- *
- * Composition: `def.geometry` only, plus a selection-time path-handle system
- * shared in spirit with the lineset. The framework's `<ParametricNodeRenderer>`
- * mounts an empty group; `<GeometrySystem>` fills it via
- * `buildLiquidLineGeometry` on dirty.
- */
-export declare const liquidLineDefinition: NodeDefinition<typeof LiquidLineNode>;
+export declare const liquidLineDefinition: 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<`liquid-line_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"liquid-line">>;
+    path: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/liquid-line/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CA4GtE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/liquid-line/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGhC,CAAA"}

package/dist/liquid-line/definition.edit.d.ts

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

package/dist/liquid-line/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/liquid-line/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE9C,eAAO,MAAM,0BAA0B,EAAE,oBAAoB,CAAC,OAAO,cAAc,CA0BlF,CAAA"}

package/dist/liquid-line/definition.edit.js

@@ -0,0 +1,29 @@
+import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
+import { liquidLineParametrics } from './parametrics.js';
+export const liquidLineEditContribution = {
+    drafting: { cancelOnHistoryJump: true },
+    // Directional run: like a wall, drafting sets a direction, so it takes the
+    // structural snapping context (grid / lines / angles / off) with a 45° angle
+    // lock available as a cyclable mode.
+    snapProfile: 'structural',
+    parametrics: liquidLineParametrics,
+    // 2D selection-time path-point handles — the floor-plan twin of the 3D
+    // `affordanceTools.selection` handles.
+    floorplanAffordances: {
+        'move-path-point': createPathPointMoveAffordance('liquid-line'),
+    },
+    // Selection-time path-point handles (drag to edit a committed run) and the
+    // ghost-preview duplicate / move tool (drag-to-place a translucent copy).
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+        move: () => import('./move-tool.js'),
+    },
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Click', label: 'Start liquid line' },
+        { key: 'Click again', label: 'Place it (locked to 45°)' },
+        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
+        { key: 'F', label: 'Follow: trace a lineset' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};