@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/liquid-line/definition.js

@@ -1,111 +1,4 @@
-import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
-import { buildLiquidLineFloorplan } from './floorplan.js';
-import { buildLiquidLineGeometry } from './geometry.js';
-import { liquidLineParametrics } from './parametrics.js';
-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 const liquidLineDefinition = {
-    kind: 'liquid-line',
-    schemaVersion: 1,
-    schema: LiquidLineNode,
-    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],
-        ],
-        diameter: 0.375,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-    },
-    parametrics: liquidLineParametrics,
-    geometry: buildLiquidLineGeometry,
-    geometryKey: (n) => JSON.stringify([n.path, n.diameter]),
-    // 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.diameter;
-        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: buildLiquidLineFloorplan,
-    // 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' },
-    ],
-    presentation: {
-        label: 'Liquid Line',
-        description: 'Standalone refrigerant liquid line — a thin bare-copper run; Follow mode traces an existing lineset.',
-        icon: { kind: 'url', src: '/icons/lineset.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 94,
-    },
-    mcp: {
-        description: 'A standalone refrigerant liquid line defined as a polyline of thin bare copper. Snaps onto refrigerant service ports; can be traced alongside an existing lineset.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { liquidLineEditContribution } from './definition.edit.js';
+import { liquidLineRenderDefinition } from './definition.render.js';
+export const liquidLineDefinition = composeNodeDefinition(liquidLineRenderDefinition, liquidLineEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/liquid-line/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEzC,eAAO,MAAM,0BAA0B,EAAE,oBAAoB,CAAC,OAAO,cAAc,CAAC,GAAG;IACrF,IAAI,EAAE,aAAa,CAAA;CAwEpB,CAAA"}

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

@@ -0,0 +1,70 @@
+import { buildLiquidLineGeometry } from './geometry.js';
+import { LiquidLineNode } from './schema.js';
+export const liquidLineRenderDefinition = {
+    kind: 'liquid-line',
+    schemaVersion: 1,
+    schema: LiquidLineNode,
+    category: 'utility',
+    distributionRole: 'run',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        path: [
+            [0, 0, 0],
+            [2, 0, 0],
+        ],
+        diameter: 0.375,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+    },
+    geometry: buildLiquidLineGeometry,
+    geometryKey: (n) => JSON.stringify([n.path, n.diameter]),
+    // 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.diameter;
+        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',
+            },
+        ];
+    },
+    presentation: {
+        label: 'Liquid Line',
+        description: 'Standalone refrigerant liquid line — a thin bare-copper run; Follow mode traces an existing lineset.',
+        icon: { kind: 'url', src: '/icons/lineset.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 94,
+    },
+    mcp: {
+        description: 'A standalone refrigerant liquid line defined as a polyline of thin bare copper. Snaps onto refrigerant service ports; can be traced alongside an existing lineset.',
+    },
+};

package/dist/liquid-line/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';
 /**
  * Floor-plan representation of a liquid line: a single thin copper polyline at

package/dist/liquid-line/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';
 const UP = new Vector3(0, 1, 0);

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/liquid-line/tool.tsx"],"names":[],"mappings":"AAyQA,QAAA,MAAM,cAAc,0CAqWnB,CAAA;eA8Bc,cAAc"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/liquid-line/tool.tsx"],"names":[],"mappings":"AA0QA,QAAA,MAAM,cAAc,0CA4WnB,CAAA;eA8Bc,cAAc"}

package/dist/liquid-line/tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, LiquidLineNode, useScene, } from '@pascal-app/core';
+import { emitter, LiquidLineNode, usePascalI18n, useScene, } from '@pascal-app/core';
 import { CursorSphere, DimensionPill, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, isTypingTarget, markToolCancelConsumed, triggerSFX, useEditor, usePathDraftPreview, } from '@pascal-app/editor';
 import { alignDrawPoint, clearDrawAlignment, collectScenePorts, findNearestPortXZ, } from '@pascal-app/editor/distribution';
 import { useViewer } from '@pascal-app/viewer';
@@ -217,6 +217,7 @@ function tracePath(target) {
     return traced.length >= 2 ? traced : null;
 }
 const LiquidLineTool = () => {
+    const i18n = usePascalI18n();
     const activeLevelId = useViewer((s) => s.selection.levelId);
     const unit = useViewer((s) => s.unit);
     const follow = useLiquidLineToolOptions((s) => s.follow);
@@ -505,8 +506,14 @@ const LiquidLineTool = () => {
                                     padding: '3px 7px',
                                     whiteSpace: 'nowrap',
                                 }, children: followTargetRef.current
-                                    ? 'Click to trace this lineset run'
-                                    : 'Follow: hover a lineset' }) }) })) : (pillParts && (_jsx("group", { position: cursorPos, children: _jsx(Html, { center: true, position: [0, 1.45, 0], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsx(DimensionPill, { parts: pillParts, primary: pillPrimary, unit: unit }) }) })))] })), snapTarget && (_jsxs("mesh", { layers: EDITOR_LAYER, position: snapTarget, children: [_jsx("sphereGeometry", { args: [0.1, 24, 16] }), _jsx("meshBasicMaterial", { color: PREVIEW_COLOR, depthTest: false, opacity: 0.35, transparent: true })] })), draftPoints.map((p, i) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: p, children: [_jsx("sphereGeometry", { args: [0.05, 16, 12] }), _jsx("meshBasicMaterial", { color: PREVIEW_COLOR, depthTest: false })] }, `pt-${i}`))), previewSegments.map((seg, i) => (_jsx(PreviewSegment, { a: seg.a, b: seg.b }, `seg-${i}`))), traceSegments.map((seg, i) => (_jsx(PreviewSegment, { a: seg.a, b: seg.b }, `trace-${i}`)))] }));
+                                    ? i18n._({
+                                        id: 'node.liquidLine.tool.clickToTraceThisLinesetRun',
+                                        message: 'Click to trace this lineset run',
+                                    })
+                                    : i18n._({
+                                        id: 'node.liquidLine.tool.followHoverALineset',
+                                        message: 'Follow: hover a lineset',
+                                    }) }) }) })) : (pillParts && (_jsx("group", { position: cursorPos, children: _jsx(Html, { center: true, position: [0, 1.45, 0], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsx(DimensionPill, { parts: pillParts, primary: pillPrimary, unit: unit }) }) })))] })), snapTarget && (_jsxs("mesh", { layers: EDITOR_LAYER, position: snapTarget, children: [_jsx("sphereGeometry", { args: [0.1, 24, 16] }), _jsx("meshBasicMaterial", { color: PREVIEW_COLOR, depthTest: false, opacity: 0.35, transparent: true })] })), draftPoints.map((p, i) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: p, children: [_jsx("sphereGeometry", { args: [0.05, 16, 12] }), _jsx("meshBasicMaterial", { color: PREVIEW_COLOR, depthTest: false })] }, `pt-${i}`))), previewSegments.map((seg, i) => (_jsx(PreviewSegment, { a: seg.a, b: seg.b }, `seg-${i}`))), traceSegments.map((seg, i) => (_jsx(PreviewSegment, { a: seg.a, b: seg.b }, `trace-${i}`)))] }));
 };
 function PreviewSegment({ a, b }) {
     const start = new Vector3(...a);

package/dist/measurement/definition.d.ts

@@ -1,4 +1,127 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { MeasurementNode } from './schema.js';
-export declare const measurementDefinition: NodeDefinition<typeof MeasurementNode>;
+export declare const measurementDefinition: 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<`measurement_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"measurement">>;
+    measurement: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"distance">;
+        points: import("zod").ZodTuple<[import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"feature">;
+            reference: import("zod").ZodObject<{
+                nodeId: import("zod").ZodString;
+                featureId: import("zod").ZodString;
+                parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+            }, import("zod/v4/core").$strip>;
+            fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>]>, import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"feature">;
+            reference: import("zod").ZodObject<{
+                nodeId: import("zod").ZodString;
+                featureId: import("zod").ZodString;
+                parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+            }, import("zod/v4/core").$strip>;
+            fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>]>], null>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"angle">;
+        points: import("zod").ZodTuple<[import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"feature">;
+            reference: import("zod").ZodObject<{
+                nodeId: import("zod").ZodString;
+                featureId: import("zod").ZodString;
+                parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+            }, import("zod/v4/core").$strip>;
+            fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>]>, import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"feature">;
+            reference: import("zod").ZodObject<{
+                nodeId: import("zod").ZodString;
+                featureId: import("zod").ZodString;
+                parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+            }, import("zod/v4/core").$strip>;
+            fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>]>, import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"feature">;
+            reference: import("zod").ZodObject<{
+                nodeId: import("zod").ZodString;
+                featureId: import("zod").ZodString;
+                parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+            }, import("zod/v4/core").$strip>;
+            fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>]>], null>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"area">;
+        base: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"feature">;
+            reference: import("zod").ZodObject<{
+                nodeId: import("zod").ZodString;
+                featureId: import("zod").ZodString;
+                parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+            }, import("zod/v4/core").$strip>;
+            fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"perimeter">;
+        base: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"feature">;
+            reference: import("zod").ZodObject<{
+                nodeId: import("zod").ZodString;
+                featureId: import("zod").ZodString;
+                parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+            }, import("zod/v4/core").$strip>;
+            fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"volume">;
+        base: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"feature">;
+            reference: import("zod").ZodObject<{
+                nodeId: import("zod").ZodString;
+                featureId: import("zod").ZodString;
+                parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+            }, import("zod/v4/core").$strip>;
+            fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>]>>;
+        extrusion: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+    }, import("zod/v4/core").$strip>], "kind">;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/measurement/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAInF,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAqExE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/measurement/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGjC,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/measurement/definition.edit.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAsBpF,CAAA"}

package/dist/measurement/definition.edit.js

@@ -0,0 +1,26 @@
+import { measurementReferenceNodeIds } from '@pascal-app/core';
+import { buildMeasurementFloorplan } from './floorplan.js';
+import { measurementMoveVertexAffordance } from './floorplan-affordance.js';
+export const measurementEditContribution = {
+    snapProfile: 'structural',
+    floorplan: buildMeasurementFloorplan,
+    floorplanDependencies: (node) => measurementReferenceNodeIds(node.measurement),
+    extensions: {
+        'pascal:editor/floorplan': {
+            referencedSelectionAnnotationRole: 'measurement',
+        },
+    },
+    floorplanAffordances: {
+        'move-measurement-vertex': measurementMoveVertexAffordance,
+    },
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+    },
+    tool: () => import('./tool-router.js'),
+    toolHints: [
+        { key: 'Left click', label: 'Place measurement point' },
+        { key: 'Enter', label: 'Finish measurement' },
+        { key: 'Backspace', label: 'Remove last point' },
+        { key: 'Esc', label: 'Finish and continue' },
+    ],
+};

package/dist/measurement/definition.js

@@ -1,67 +1,4 @@
-import { measurementReferenceNodeIds } from '@pascal-app/core';
-import { buildMeasurementFloorplan } from './floorplan.js';
-import { measurementMoveVertexAffordance } from './floorplan-affordance.js';
-import { MeasurementNode } from './schema.js';
-export const measurementDefinition = {
-    kind: 'measurement',
-    bake: 'strip',
-    snapProfile: 'structural',
-    schemaVersion: 2,
-    schema: MeasurementNode,
-    category: 'analysis',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        measurement: {
-            kind: 'distance',
-            points: [
-                [0, 0, 0],
-                [1, 0, 0],
-            ],
-        },
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        deletable: true,
-        duplicable: true,
-        presettable: false,
-    },
-    dirtyTracking: false,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    floorplan: buildMeasurementFloorplan,
-    floorplanDependencies: (node) => measurementReferenceNodeIds(node.measurement),
-    extensions: {
-        'pascal:editor/floorplan': {
-            referencedSelectionAnnotationRole: 'measurement',
-        },
-    },
-    floorplanAffordances: {
-        'move-measurement-vertex': measurementMoveVertexAffordance,
-    },
-    affordanceTools: {
-        selection: () => import('./selection.js'),
-    },
-    tool: () => import('./tool-router.js'),
-    toolHints: [
-        { key: 'Left click', label: 'Place measurement point' },
-        { key: 'Enter', label: 'Finish measurement' },
-        { key: 'Backspace', label: 'Remove last point' },
-        { key: 'Esc', label: 'Finish and continue' },
-    ],
-    presentation: {
-        label: 'Measurement',
-        description: 'A persistent distance, angle, area, perimeter, or volume annotation.',
-        icon: { kind: 'url', src: '/icons/measure.webp' },
-        hidden: true,
-        actionMenu: false,
-    },
-    mcp: {
-        description: 'A persistent level-local distance, angle, area, perimeter, or volume measurement.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { measurementEditContribution } from './definition.edit.js';
+import { measurementRenderDefinition } from './definition.render.js';
+export const measurementDefinition = composeNodeDefinition(measurementRenderDefinition, measurementEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/measurement/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,aAAa,CAAA;CA2CpB,CAAA"}

package/dist/measurement/definition.render.js

@@ -0,0 +1,43 @@
+import { MeasurementNode } from './schema.js';
+export const measurementRenderDefinition = {
+    kind: 'measurement',
+    bake: 'strip',
+    schemaVersion: 2,
+    schema: MeasurementNode,
+    category: 'analysis',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        measurement: {
+            kind: 'distance',
+            points: [
+                [0, 0, 0],
+                [1, 0, 0],
+            ],
+        },
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+        duplicable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Measurement',
+        description: 'A persistent distance, angle, area, perimeter, or volume annotation.',
+        icon: { kind: 'url', src: '/icons/measure.webp' },
+        hidden: true,
+        actionMenu: false,
+    },
+    mcp: {
+        description: 'A persistent level-local distance, angle, area, perimeter, or volume measurement.',
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/measurement/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EACpB,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AA+BzB,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA4M1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/measurement/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EAOtB,KAAK,eAAe,EACpB,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AA0BzB,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA4M1B"}

package/dist/measurement/floorplan.js

@@ -1,5 +1,6 @@
-import { measurementAngle, measurementArea, measurementDistance, measurementPerimeter, measurementPrismVolume, } from '@pascal-app/core';
-import { buildMeasurementAngleArcPoints, formatAngleRadians, formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, measurementFloorplanPresentationColor, measurementPolygonLabelAnchor, readFloorplanContext, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
+import { buildMeasurementAngleArcPoints, formatAngleRadians, formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, measurementAngle, measurementArea, measurementDistance, measurementPerimeter, measurementPrismVolume, } from '@pascal-app/core';
+import { measurementFloorplanPresentationColor, readFloorplanContext, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
+import { measurementPolygonLabelAnchor } from '@pascal-app/viewer';
 import { measurementResolvedEditPoints } from './edit.js';
 import { resolveMeasurementNode } from './resolve.js';
 const projectPoint = (point) => [point[0], point[2]];

package/dist/measurement/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/measurement/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EAWrB,MAAM,kBAAkB,CAAA;AAezB,OAAO,EAML,KAAK,QAAQ,EAKd,MAAM,OAAO,CAAA;AAiRd,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAO/E;AAED,eAAO,MAAM,mBAAmB,aAAc;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,gCA0ItE,CAAA;eAEc,mBAAmB"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/measurement/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,eAAe,EAWrB,MAAM,kBAAkB,CAAA;AAYzB,OAAO,EAML,KAAK,QAAQ,EAKd,MAAM,OAAO,CAAA;AAiRd,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAO/E;AAED,eAAO,MAAM,mBAAmB,aAAc;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,gCA0ItE,CAAA;eAEc,mBAAmB"}

package/dist/measurement/renderer.js

@@ -1,8 +1,7 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { measurementAngle, measurementArea, measurementDistance, measurementNormal, measurementPerimeter, measurementPrismVolume, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { buildMeasurementAngleArcPoints, formatAngleRadians, formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, measurementPolygonLabelAnchor, measurementPresentationColor, triangulateMeasurementPolygon, } from '@pascal-app/editor';
-import { OVERLAY_LAYER, useNodeEvents, useViewer } from '@pascal-app/viewer';
+import { buildMeasurementAngleArcPoints, formatAngleRadians, formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, measurementAngle, measurementArea, measurementDistance, measurementNormal, measurementPerimeter, measurementPrismVolume, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { measurementPolygonLabelAnchor, measurementPresentationColor, OVERLAY_LAYER, triangulateMeasurementPolygon, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';

package/dist/measurement/selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/measurement/selection.tsx"],"names":[],"mappings":"AA+XA,QAAA,MAAM,8BAA8B,0CAiCnC,CAAA;eAEc,8BAA8B"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/measurement/selection.tsx"],"names":[],"mappings":"AA8XA,QAAA,MAAM,8BAA8B,0CAiCnC,CAAA;eAEc,8BAA8B"}

package/dist/measurement/selection.js

@@ -1,8 +1,8 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { collectAlignmentAnchors, emitter, MeasurementNode, resolveLevelId, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { boundaryReshapeScope, EDITOR_LAYER, isAlignmentGuideActive, MEASUREMENT_ACTIVE_COLOR, swallowNextClick, useInteractionScope, } from '@pascal-app/editor';
-import { useViewer } from '@pascal-app/viewer';
+import { boundaryReshapeScope, EDITOR_LAYER, isAlignmentGuideActive, swallowNextClick, useInteractionScope, } from '@pascal-app/editor';
+import { MEASUREMENT_ACTIVE_COLOR, useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { createPortal, useFrame, useThree } from '@react-three/fiber';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';

package/dist/measurement/tool.d.ts

@@ -1,5 +1,5 @@
-import { type AlignmentAnchor, type MeasurementFeatureAnchor, type MeasurementSnapKind } from '@pascal-app/core';
-import { type LinearUnit, type MeasurementAxis, type MeasurementAxisGuide, type MeasurementKind, type MeasurementPoint } from '@pascal-app/editor';
+import { type AlignmentAnchor, type LinearUnit, type MeasurementFeatureAnchor, type MeasurementSnapKind } from '@pascal-app/core';
+import { type MeasurementAxis, type MeasurementAxisGuide, type MeasurementKind, type MeasurementPoint } from '@pascal-app/editor';
 import { type FC } from 'react';
 import { type Camera, type Intersection, type Object3D, Raycaster, Vector2, Vector3 } from 'three';
 import { type MeasurementSurfacePreference } from './surface-query.js';
@@ -59,7 +59,7 @@ export declare function associateSurfaceHit(hit: LocalSurfaceHit, maxDistance?:
     };
 };
 export declare function closestMeasurementExtrusionHeight(rayOrigin: MeasurementPoint, rayDirection: MeasurementPoint, axisOrigin: MeasurementPoint, axisDirection: MeasurementPoint): number | null;
-export declare function parseMeasurementExtrusionHeight(value: string, unit: LinearUnit): number | null;
+export declare function parseMeasurementExtrusionHeight(value: string, unit: LinearUnit, locale?: string): number | null;
 export declare function localNormalToPreviewFrame(levelObject: Object3D, buildingObject: Object3D | null, normal: MeasurementPoint): Vector3;
 export declare function buildMeasurementDraftLinePositions(points: readonly Vector3[], dashSize?: number, gapSize?: number): number[];
 export declare const MeasurementTool: FC;