@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/roof-segment/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.render.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,cAAc,CAAA;CA8DrB,CAAA"}

package/dist/roof-segment/definition.render.js

@@ -0,0 +1,59 @@
+import { RoofSegmentNode as RoofSegmentNodeSchema, } from '@pascal-app/core';
+import { matchRoofSegmentMeasurementFeature, roofSegmentMeasurementFeatures } from './measurement.js';
+import { RoofSegmentNode } from './schema.js';
+import { roofSegmentSlots } from './slots.js';
+export const roofSegmentRenderDefinition = {
+    kind: 'roof-segment',
+    schemaVersion: 7,
+    schema: RoofSegmentNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = RoofSegmentNodeSchema.parse({
+            id: 'roof-segment_default',
+            type: 'roof-segment',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        revealOnEdit: [
+            'roofType',
+            'width',
+            'depth',
+            'wallHeight',
+            'pitch',
+            'overhang',
+            'wallThickness',
+            'deckThickness',
+            'barrelRise',
+            'barrelSegments',
+            'roofSystem',
+            'glazing',
+        ],
+        slots: (node) => roofSegmentSlots(node),
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    measurement: {
+        features: (node, ctx) => roofSegmentMeasurementFeatures(node, ctx.parent?.type === 'roof' ? ctx.parent : null),
+        match: (node, ctx, point, maxDistance) => matchRoofSegmentMeasurementFeature(node, ctx.parent?.type === 'roof' ? ctx.parent : null, point, maxDistance),
+    },
+    presentation: {
+        label: 'Roof Segment',
+        description: 'A single pitched plane of a parent roof.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 101,
+    },
+    mcp: {
+        description: 'A single roof segment with polygon footprint + pitch.',
+    },
+};

package/dist/roof-segment/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EAGxB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AA0DzB;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CAyG5E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA8B5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,eAAe,CAyEtE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EAIxB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AA0DzB;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CAyG5E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA8B5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,eAAe,CAyEtE,CAAA"}

package/dist/roof-segment/floorplan-affordances.js

@@ -1,10 +1,10 @@
-import { getRoofSegmentResizePatch, snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getRoofSegmentResizePatch, MIN_ROOF_SEGMENT_DIMENSION, snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { getSegmentGridStep, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, } from '@pascal-app/editor';
 import { commitSeatedRoofEdit } from '../roof/roof-level-target.js';
 import { bearingWallThickness, catchRoofOnWalls, catchRoofSideOnWalls, placeRoofOnWalls, roofCatchWalls, segmentWallLine, } from '../roof/wall-catch.js';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.js';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance.js';
-const MIN_ROOF_DIM = 1;
+const MIN_ROOF_DIM = MIN_ROOF_SEGMENT_DIMENSION;
 // Resolve world-space center + effective rotation of a roof segment by
 // composing the parent roof's position + rotation with the segment's
 // local position. Mirrors the floorplan builder's transform so handles

package/dist/roof-segment/paint.d.ts

@@ -2,5 +2,4 @@ import { type PaintCapability, type RoofSegmentNode, type RoofWallBand } from '@
 /** A heel or gable paints on its own: its own finish, cleared back to its fallback by the eraser. */
 export declare function wallBandPatch(band: RoofWallBand, material: RoofSegmentNode['material'], materialPreset: string | undefined): Partial<RoofSegmentNode>;
 export declare const roofSegmentPaint: PaintCapability;
-export { roofSegmentSlots } from '@pascal-app/core';
 //# sourceMappingURL=paint.d.ts.map

package/dist/roof-segment/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/roof-segment/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,YAAY,EAIlB,MAAM,kBAAkB,CAAA;AAiEzB,qGAAqG;AACrG,wBAAgB,aAAa,CAC3B,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,EACrC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED,eAAO,MAAM,gBAAgB,EAAE,eAoE9B,CAAA;AAED,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/roof-segment/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,YAAY,EAIlB,MAAM,kBAAkB,CAAA;AAiEzB,qGAAqG;AACrG,wBAAgB,aAAa,CAC3B,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,EACrC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED,eAAO,MAAM,gBAAgB,EAAE,eAoE9B,CAAA"}

package/dist/roof-segment/paint.js

@@ -130,4 +130,3 @@ export const roofSegmentPaint = {
         return { material: spec.material, materialPreset: spec.materialPreset };
     },
 };
-export { roofSegmentSlots } from '@pascal-app/core';

package/dist/roof-segment/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof-segment/panel.tsx"],"names":[],"mappings":"AAiJA,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCAgxBvC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof-segment/panel.tsx"],"names":[],"mappings":"AAkJA,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCAgyBvC"}

package/dist/roof-segment/panel.js

@@ -1,13 +1,15 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { createDefaultRidgeVentsForSegment, getConicalRoofCoverage, getRoofSegmentDeckReach, getSegmentSlopeFrame, isAutoGutterEnabled, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, isGlazedRoofSegment, normalizeRoofSegmentTrim, ROOF_SHAPE_DEFAULTS, roofBuildUpPatch, roofSegmentEaveProfile, roofTypeHasRakes, usePascalI18n, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, ToggleControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { createDefaultRidgeVentsForSegment, getConicalRoofCoverage, getRoofSegmentDeckReach, getSegmentSlopeFrame, isAutoGutterEnabled, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, isGlazedRoofSegment, MAX_ROOF_PITCH, MIN_ROOF_SEGMENT_DIMENSION, normalizeRoofSegmentTrim, ROOF_SHAPE_DEFAULTS, roofBuildUpPatch, roofSegmentEaveProfile, roofTypeHasRakes, usePascalI18n, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, ToggleControl, triggerSFX, useEditor, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Check, Copy, Move, Pencil, RotateCcw, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
 import { BarrelRoofPanel } from '../roof/barrel-panel.js';
+import { RoofGeometryNotice } from '../roof/geometry-notice.js';
 import { RoofGlazingPanel } from '../roof/glazing-panel.js';
 import { commitSeatedRoofEdit } from '../roof/roof-level-target.js';
+import { RoofTypeThumbnail } from '../roof/type-thumbnail.js';
 import { RoofBuildUpSection } from './build-up-section.js';
 const ROOF_TYPE_OPTIONS = [
     { label: /* i18n */ { id: 'node.roofSegment.panel.hip', message: 'Hip' }, value: 'hip' },
@@ -80,9 +82,6 @@ function roofLayerPlaneIds(children, nodes) {
 function hasSegmentTrim(node) {
     return Object.values(normalizeRoofSegmentTrim(node)).some((value) => value > 0);
 }
-function shouldShowTrimPlanes(metadata) {
-    return metadataRecord(metadata).showTrimPlanes === true;
-}
 function isManagedLeanToRoofSegment(metadata) {
     const record = metadataRecord(metadata);
     return record.managedByLeanTo !== undefined && record.leanToRole === 'roof-segment';
@@ -97,7 +96,7 @@ export default function RoofSegmentPanel() {
     const i18n = usePascalI18n();
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const setSelection = useViewer((s) => s.setSelection);
-    const updateNode = useScene((s) => s.updateNode);
+    const showTrimPlanes = useInteractionScope((s) => s.scope.kind === 'reshaping' && s.scope.reshape === 'trim' && s.scope.nodeId === selectedId);
     const setMovingNode = useEditor((s) => s.setMovingNode);
     const setRoofHostDragArmedId = useEditor((s) => s.setRoofHostDragArmedId);
     const unit = useViewer((s) => s.unit);
@@ -166,7 +165,6 @@ export default function RoofSegmentPanel() {
                     ...metadataRecord(node?.metadata),
                     autoGutter: false,
                     autoRidgeVent: false,
-                    showTrimPlanes: false,
                 },
             }
             : roofType === 'dutch'
@@ -181,24 +179,20 @@ export default function RoofSegmentPanel() {
                 : { roofType });
     }, [handleUpdate, node]);
     const handleClose = useCallback(() => {
-        if (node && shouldShowTrimPlanes(node.metadata)) {
-            updateNode(node.id, {
-                metadata: { ...metadataRecord(node.metadata), showTrimPlanes: false },
-            });
-        }
+        useInteractionScope
+            .getState()
+            .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'trim' && scope.nodeId === node?.id);
         setSelection({ selectedIds: [] });
-    }, [node, setSelection, updateNode]);
+    }, [node, setSelection]);
     const handleBack = useCallback(() => {
         if (node?.parentId) {
-            if (shouldShowTrimPlanes(node.metadata)) {
-                updateNode(node.id, {
-                    metadata: { ...metadataRecord(node.metadata), showTrimPlanes: false },
-                });
-            }
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'trim' && scope.nodeId === node?.id);
             setRoofHostDragArmedId(node.parentId);
             setSelection({ selectedIds: [node.parentId] });
         }
-    }, [node, setRoofHostDragArmedId, setSelection, updateNode]);
+    }, [node, setRoofHostDragArmedId, setSelection]);
     const handleDuplicate = useCallback(() => {
         if (node)
             duplicateNodeAndPickUp(node);
@@ -269,10 +263,12 @@ export default function RoofSegmentPanel() {
         if (!node)
             return;
         triggerSFX('sfx:item-pick');
-        handleUpdate({
-            metadata: { ...metadataRecord(node.metadata), showTrimPlanes: editing },
-        });
-    }, [handleUpdate, node]);
+        const interaction = useInteractionScope.getState();
+        if (editing)
+            interaction.begin({ kind: 'reshaping', reshape: 'trim', nodeId: node.id, driver: 'tool' });
+        else
+            interaction.endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'trim' && scope.nodeId === node.id);
+    }, [node]);
     const handleResetTrim = useCallback(() => {
         if (!node || !hasSegmentTrim(node))
             return;
@@ -281,19 +277,21 @@ export default function RoofSegmentPanel() {
     }, [handleUpdate, node]);
     if (!(node && node.type === 'roof-segment' && selectedId))
         return null;
-    const showTrimPlanes = shouldShowTrimPlanes(node.metadata);
     const managedLeanToRoofSegment = isManagedLeanToRoofSegment(node.metadata);
     const conicalCoverage = getConicalRoofCoverage(node);
     // both overhangs in plan, past the walls' outside faces; the node keeps the eaves' along the slope
     const reach = getRoofSegmentDeckReach(node);
     const halfWall = node.wallThickness / 2;
     const { cosTheta } = getSegmentSlopeFrame(node);
-    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: handleBack, onClose: handleClose, title: node.name || i18n._({ id: 'node.roofSegment.panel.roofSegment', message: 'Roof Segment' }), width: 300, children: [_jsx(RoofGlazingPanel, { segments: [node] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.roofType', message: 'Roof Type' }), children: [_jsx(SegmentedControl, { onChange: (v) => handleRoofTypeChange(v), options: ROOF_TYPE_OPTIONS.map((option) => ({ ...option, label: i18n._(option.label) })), value: node.roofType, disabled: managedLeanToRoofSegment }), _jsx(SegmentedControl, { onChange: (v) => handleRoofTypeChange(v), options: ROOF_TYPE_OPTIONS_2.map((option) => ({
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: handleBack, onClose: handleClose, title: node.name || i18n._({ id: 'node.roofSegment.panel.roofSegment', message: 'Roof Segment' }), width: 300, children: [_jsx(RoofGeometryNotice, { ids: [node.id, ...(node.parentId ? [node.parentId] : [])] }), _jsx(RoofGlazingPanel, { segments: [node] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.roofType', message: 'Roof Type' }), children: [_jsx(SegmentedControl, { onChange: (v) => handleRoofTypeChange(v), options: ROOF_TYPE_OPTIONS.map((option) => ({
+                            ...option,
+                            label: (_jsxs("span", { className: "flex flex-col items-center gap-1", children: [_jsx(RoofTypeThumbnail, { type: option.value }), _jsx("span", { children: i18n._(option.label) })] })),
+                        })), value: node.roofType, disabled: managedLeanToRoofSegment }), _jsx(SegmentedControl, { onChange: (v) => handleRoofTypeChange(v), options: ROOF_TYPE_OPTIONS_2.map((option) => ({
                             ...option,
-                            label: i18n._(option.label),
+                            label: (_jsxs("span", { className: "flex flex-col items-center gap-1", children: [_jsx(RoofTypeThumbnail, { type: option.value }), _jsx("span", { children: i18n._(option.label) })] })),
                         })), value: node.roofType, disabled: managedLeanToRoofSegment }), _jsx(SegmentedControl, { onChange: (v) => handleRoofTypeChange(v), options: ROOF_TYPE_OPTIONS_3.map((option) => ({
                             ...option,
-                            label: i18n._(option.label),
+                            label: (_jsxs("span", { className: "flex flex-col items-center gap-1", children: [_jsx(RoofTypeThumbnail, { type: option.value }), _jsx("span", { children: i18n._(option.label) })] })),
                         })), value: node.roofType, disabled: managedLeanToRoofSegment })] }), node.roofType !== 'conical' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.trim', message: 'Trim' }), children: [_jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: showTrimPlanes ? (_jsx(Check, { className: "h-3.5 w-3.5" })) : (_jsx(Pencil, { className: "h-3.5 w-3.5" })), label: showTrimPlanes
                                     ? i18n._({ id: 'node.roofSegment.panel.doneEditing', message: 'Done editing' })
                                     : i18n._({
@@ -302,28 +300,28 @@ export default function RoofSegmentPanel() {
                                     }), onClick: () => (showTrimPlanes ? handleBack() : handleTrimEditing(true)) }), _jsx(ActionButton, { className: "disabled:cursor-not-allowed disabled:opacity-40", disabled: !hasSegmentTrim(node), icon: _jsx(RotateCcw, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.roofSegment.panel.reset', message: 'Reset' }), onClick: handleResetTrim })] }), node.roofType !== 'shed' && node.roofType !== 'flat' && node.roofType !== 'barrel' && (_jsx(ToggleControl, { checked: autoRidgeVentEnabled, label: i18n._({
                             id: 'node.roofSegment.panel.autoRidgeVent',
                             message: 'Auto ridge vent',
-                        }), onChange: handleAutoRidgeVentToggle }))] })), node.roofType !== 'conical' && (_jsx(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.drainage', message: 'Drainage' }), children: _jsx(ToggleControl, { checked: autoGutterEnabled, label: i18n._({ id: 'node.roofSegment.panel.autoGutters', message: 'Auto gutters' }), onChange: handleAutoGutterToggle }) })), _jsx(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.footprint', message: 'Footprint' }), children: node.roofType === 'conical' ? (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.diameter', message: 'Diameter' }), max: 1000, min: 0.5, onChange: (v) => handleUpdate({ width: v, depth: v }), precision: 2, step: 0.5, unit: "m", value: node.width })) : (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: node.roofType === 'barrel'
+                        }), onChange: handleAutoRidgeVentToggle }))] })), node.roofType !== 'conical' && (_jsx(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.drainage', message: 'Drainage' }), children: _jsx(ToggleControl, { checked: autoGutterEnabled, label: i18n._({ id: 'node.roofSegment.panel.autoGutters', message: 'Auto gutters' }), onChange: handleAutoGutterToggle }) })), _jsx(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.footprint', message: 'Footprint' }), children: node.roofType === 'conical' ? (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.diameter', message: 'Diameter' }), min: MIN_ROOF_SEGMENT_DIMENSION, onChange: (v) => handleUpdate({ width: v, depth: v }), precision: 2, step: 0.5, unit: "m", value: node.width })) : (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: node.roofType === 'barrel'
                                 ? i18n._({ id: 'node.roofSegment.panel.length', message: 'Length' })
-                                : i18n._({ id: 'node.roofSegment.panel.width', message: 'Width' }), max: 1000, min: 0.5, onChange: (v) => handleUpdate({ width: v }), precision: 2, step: 0.5, unit: "m", value: node.width }), _jsx(SliderControl, { label: node.roofType === 'barrel'
+                                : i18n._({ id: 'node.roofSegment.panel.width', message: 'Width' }), min: MIN_ROOF_SEGMENT_DIMENSION, onChange: (v) => handleUpdate({ width: v }), precision: 2, step: 0.5, unit: "m", value: node.width }), _jsx(SliderControl, { label: node.roofType === 'barrel'
                                 ? i18n._({ id: 'node.roofSegment.panel.span', message: 'Span' })
-                                : i18n._({ id: 'node.roofSegment.panel.depth', message: 'Depth' }), max: 1000, min: 0.5, onChange: (v) => handleUpdate({ depth: v }), precision: 2, step: 0.5, unit: "m", value: node.depth })] })) }), node.roofType === 'conical' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.conicalShape', message: 'Conical Shape' }), children: [_jsx(ToggleControl, { checked: !conicalCoverage.fullCircle, label: i18n._({
+                                : i18n._({ id: 'node.roofSegment.panel.depth', message: 'Depth' }), min: MIN_ROOF_SEGMENT_DIMENSION, onChange: (v) => handleUpdate({ depth: v }), precision: 2, step: 0.5, unit: "m", value: node.depth })] })) }), node.roofType === 'conical' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.conicalShape', message: 'Conical Shape' }), children: [_jsx(ToggleControl, { checked: !conicalCoverage.fullCircle, label: i18n._({
                             id: 'node.roofSegment.panel.clippedVersion',
                             message: 'Clipped version',
                         }), onChange: (checked) => handleUpdate({ conicalFullCircle: !checked }) }), !conicalCoverage.fullCircle && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.startAngle', message: 'Start Angle' }), max: 180, min: -180, onChange: (degrees) => handleUpdate({ conicalStartAngle: (degrees * Math.PI) / 180 }), precision: 0, step: 1, unit: "\u00B0", value: Math.round((conicalCoverage.startAngle * 180) / Math.PI) }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.arc', message: 'Arc' }), max: 345, min: 15, onChange: (degrees) => handleUpdate({
                                     conicalSweepAngle: (Math.sign(conicalCoverage.sweepAngle) * degrees * Math.PI) / 180,
-                                }), precision: 0, step: 1, unit: "\u00B0", value: Math.round((Math.abs(conicalCoverage.sweepAngle) * 180) / Math.PI) })] }))] })), _jsx(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.wallHeight', message: 'Wall Height' }), children: _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.wall', message: 'Wall' }), max: 1000, min: 0, onChange: (v) => handleUpdate({ wallHeight: v }), precision: 2, step: 0.1, unit: "m", value: node.wallHeight }) }), node.roofType === 'barrel' ? (_jsx(BarrelRoofPanel, { node: node })) : (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.pitch', message: 'Pitch' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.angle', message: 'Angle' }), max: 60, min: 0, onChange: (v) => handleUpdate({ pitch: v }), precision: 0, step: 1, unit: "\u00B0", value: Math.round(node.pitch) }), _jsx("div", { className: "flex gap-1.5 px-1 pt-2 pb-1", children: PITCH_PRESETS.map((preset) => (_jsx(ActionButton, { label: preset.label, onClick: () => handleUpdate({ pitch: preset.deg }) }, preset.label))) })] })), node.roofType === 'gambrel' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.shape', message: 'Shape' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.kinkDepth', message: 'Kink Depth' }), max: 0.9, min: 0.1, onChange: (v) => handleUpdate({ gambrelLowerWidthRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.gambrelLowerWidthRatio * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.kinkHeight', message: 'Kink Height' }), max: 0.9, min: 0.1, onChange: (v) => handleUpdate({ gambrelLowerHeightRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.gambrelLowerHeightRatio * 100) / 100 })] })), node.roofType === 'mansard' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.shape', message: 'Shape' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistWidth', message: 'Waist Width' }), max: 0.45, min: 0.05, onChange: (v) => handleUpdate({ mansardSteepWidthRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.mansardSteepWidthRatio * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistHeight', message: 'Waist Height' }), max: 0.9, min: 0.1, onChange: (v) => handleUpdate({ mansardSteepHeightRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.mansardSteepHeightRatio * 100) / 100 })] })), node.roofType === 'dutch' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.shape', message: 'Shape' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistWidth', message: 'Waist Width' }), max: 0.45, min: 0.05, onChange: (v) => handleUpdate({ dutchHipWidthRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.dutchHipWidthRatio * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistHeight', message: 'Waist Height' }), max: 0.9, min: 0.1, onChange: (v) => handleUpdate({ dutchHipHeightRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.dutchHipHeightRatio * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistLength', message: 'Waist Length' }), max: 1, min: 0.1, onChange: (v) => handleUpdate({ dutchWaistLengthRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round((node.dutchWaistLengthRatio ?? ROOF_SHAPE_DEFAULTS.dutchWaistLengthRatio) * 100) / 100 }), _jsx(SliderControl, { label: i18n._({
+                                }), precision: 0, step: 1, unit: "\u00B0", value: Math.round((Math.abs(conicalCoverage.sweepAngle) * 180) / Math.PI) })] }))] })), _jsx(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.wallHeight', message: 'Wall Height' }), children: _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.wall', message: 'Wall' }), min: 0, onChange: (v) => handleUpdate({ wallHeight: v }), precision: 2, step: 0.1, unit: "m", value: node.wallHeight }) }), node.roofType === 'barrel' ? (_jsx(BarrelRoofPanel, { node: node })) : (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.pitch', message: 'Pitch' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.angle', message: 'Angle' }), max: MAX_ROOF_PITCH, min: 0, onChange: (v) => handleUpdate({ pitch: v }), precision: 0, step: 1, unit: "\u00B0", value: Math.round(node.pitch) }), _jsx("div", { className: "flex gap-1.5 px-1 pt-2 pb-1", children: PITCH_PRESETS.map((preset) => (_jsx(ActionButton, { label: preset.label, onClick: () => handleUpdate({ pitch: preset.deg }) }, preset.label))) })] })), node.roofType === 'gambrel' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.shape', message: 'Shape' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.kinkDepth', message: 'Kink Depth' }), max: 0.9, min: 0.1, onChange: (v) => handleUpdate({ gambrelLowerWidthRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.gambrelLowerWidthRatio * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.kinkHeight', message: 'Kink Height' }), max: 0.9, min: 0.1, onChange: (v) => handleUpdate({ gambrelLowerHeightRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.gambrelLowerHeightRatio * 100) / 100 })] })), node.roofType === 'mansard' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.shape', message: 'Shape' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistWidth', message: 'Waist Width' }), max: 0.45, min: 0.05, onChange: (v) => handleUpdate({ mansardSteepWidthRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.mansardSteepWidthRatio * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistHeight', message: 'Waist Height' }), max: 0.9, min: 0.1, onChange: (v) => handleUpdate({ mansardSteepHeightRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.mansardSteepHeightRatio * 100) / 100 })] })), node.roofType === 'dutch' && (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.shape', message: 'Shape' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistWidth', message: 'Waist Width' }), max: 0.45, min: 0.05, onChange: (v) => handleUpdate({ dutchHipWidthRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.dutchHipWidthRatio * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistHeight', message: 'Waist Height' }), max: 0.9, min: 0.1, onChange: (v) => handleUpdate({ dutchHipHeightRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round(node.dutchHipHeightRatio * 100) / 100 }), _jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.waistLength', message: 'Waist Length' }), max: 1, min: 0.1, onChange: (v) => handleUpdate({ dutchWaistLengthRatio: v }), precision: 2, step: 0.01, unit: "", value: Math.round((node.dutchWaistLengthRatio ?? ROOF_SHAPE_DEFAULTS.dutchWaistLengthRatio) * 100) / 100 }), _jsx(SliderControl, { label: i18n._({
                             id: 'node.roofSegment.panel.topRakeThick',
                             message: 'Top Rake Thick.',
                         }), max: 0.5, min: 0.01, onChange: (v) => handleUpdate({ dutchTopRakeThickness: v }), precision: 2, step: 0.01, unit: "m", value: node.dutchTopRakeThickness ?? ROOF_SHAPE_DEFAULTS.dutchTopRakeThickness }), _jsx(SliderControl, { label: i18n._({
                             id: 'node.roofSegment.panel.topRakeLength',
                             message: 'Top Rake Length',
-                        }), max: 3, min: 0, onChange: (v) => handleUpdate({ dutchGabletRake: v }), precision: 2, step: 0.01, unit: "m", value: node.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake })] })), _jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.structure', message: 'Structure' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.wallThick', message: 'Wall Thick.' }), max: 1, min: 0.05, onChange: (v) => handleUpdate({ wallThickness: v }), precision: 2, step: 0.05, unit: "m", value: node.wallThickness }), !(isGlazedRoofSegment(node) || node.buildUp) && (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.deckThick', message: 'Deck Thick.' }), max: 0.3, min: 0.04, onChange: (v) => handleUpdate({ deckThickness: v }), precision: 2, step: 0.01, unit: "m", value: node.deckThickness })), node.roofType === 'barrel' ? (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.endOverhang', message: 'End overhang' }), max: 1, min: 0, onChange: (v) => handleUpdate({ overhang: v }), precision: 2, step: 0.05, unit: "m", value: reach.x - halfWall })) : (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.eaveOverhang', message: 'Eave overhang' }), max: 1, min: 0, onChange: (v) => handleUpdate({ overhang: v / cosTheta }), precision: 2, step: 0.05, unit: "m", value: reach.z - halfWall })), roofTypeHasRakes(node.roofType) && (_jsx(SliderControl, { label: i18n._({
+                        }), max: 3, min: 0, onChange: (v) => handleUpdate({ dutchGabletRake: v }), precision: 2, step: 0.01, unit: "m", value: node.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake })] })), _jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.structure', message: 'Structure' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.wallThick', message: 'Wall Thick.' }), min: 0.05, onChange: (v) => handleUpdate({ wallThickness: v }), precision: 2, step: 0.05, unit: "m", value: node.wallThickness }), !(isGlazedRoofSegment(node) || node.buildUp) && (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.deckThick', message: 'Deck Thick.' }), min: 0.04, onChange: (v) => handleUpdate({ deckThickness: v }), precision: 2, step: 0.01, unit: "m", value: node.deckThickness })), node.roofType === 'barrel' ? (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.endOverhang', message: 'End overhang' }), min: 0, onChange: (v) => handleUpdate({ overhang: v }), precision: 2, step: 0.05, unit: "m", value: reach.x - halfWall })) : (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.eaveOverhang', message: 'Eave overhang' }), min: 0, onChange: (v) => handleUpdate({ overhang: v / cosTheta }), precision: 2, step: 0.05, unit: "m", value: reach.z - halfWall })), roofTypeHasRakes(node.roofType) && (_jsx(SliderControl, { label: i18n._({
                             id: 'node.roofSegment.panel.gableOverhang',
                             message: 'Gable overhang',
-                        }), max: 3, min: 0, onChange: (v) => handleUpdate({ gableOverhang: v }), precision: 2, step: 0.05, unit: "m", value: reach.x - halfWall })), !(isGlazedRoofSegment(node) || node.buildUp) && (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.shingleThick', message: 'Shingle Thick.' }), max: 0.3, min: 0.02, onChange: (v) => handleUpdate({ shingleThickness: v }), precision: 2, step: 0.01, unit: "m", value: node.shingleThickness })), EAVE_CUT_ROOF_TYPES.has(node.roofType) && node.pitch > 0 && (_jsxs("div", { children: [_jsx("div", { className: "px-1 pb-1 text-[10px] text-muted-foreground uppercase tracking-wide", children: i18n._({ id: 'node.roofSegment.panel.eaveCut', message: 'Eave cut' }) }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ eaveCut: v }), options: EAVE_CUT_OPTIONS.map((option) => ({
+                        }), min: 0, onChange: (v) => handleUpdate({ gableOverhang: v }), precision: 2, step: 0.05, unit: "m", value: reach.x - halfWall })), !(isGlazedRoofSegment(node) || node.buildUp) && (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.shingleThick', message: 'Shingle Thick.' }), min: 0.02, onChange: (v) => handleUpdate({ shingleThickness: v }), precision: 2, step: 0.01, unit: "m", value: node.shingleThickness })), EAVE_CUT_ROOF_TYPES.has(node.roofType) && node.pitch > 0 && (_jsxs("div", { children: [_jsx("div", { className: "px-1 pb-1 text-[10px] text-muted-foreground uppercase tracking-wide", children: i18n._({ id: 'node.roofSegment.panel.eaveCut', message: 'Eave cut' }) }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ eaveCut: v }), options: EAVE_CUT_OPTIONS.map((option) => ({
                                     ...option,
                                     label: i18n._(option.label),
-                                })), value: node.eaveCut ?? 'plumb' })] })), _jsx(ToggleControl, { checked: node.fascia ?? false, label: i18n._({ id: 'node.roofSegment.panel.fascia', message: 'Fascia' }), onChange: (checked) => handleUpdate({ fascia: checked }) }), node.fascia && (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.fasciaHeight', message: 'Fascia height' }), max: 0.6, min: 0.1, onChange: (v) => handleUpdate({ fasciaHeight: v }), precision: 2, step: 0.01, unit: "m", value: node.fasciaHeight ?? roofSegmentEaveProfile(node).fascia.height }))] }), !isGlazedRoofSegment(node) && (_jsx(RoofBuildUpSection, { node: node, onApplyToRoof: roofPlaneCount > 1 ? handleApplyToRoof : undefined, onUpdate: handleUpdate, unit: unit })), _jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.position', message: 'Position' }), children: [_jsx(SliderControl, { label: "X", onChange: (v) => {
+                                })), value: node.eaveCut ?? 'plumb' })] })), _jsx(ToggleControl, { checked: node.fascia ?? false, label: i18n._({ id: 'node.roofSegment.panel.fascia', message: 'Fascia' }), onChange: (checked) => handleUpdate({ fascia: checked }) }), node.fascia && (_jsx(SliderControl, { label: i18n._({ id: 'node.roofSegment.panel.fasciaHeight', message: 'Fascia height' }), min: 0.1, onChange: (v) => handleUpdate({ fasciaHeight: v }), precision: 2, step: 0.01, unit: "m", value: node.fasciaHeight ?? roofSegmentEaveProfile(node).fascia.height }))] }), !isGlazedRoofSegment(node) && (_jsx(RoofBuildUpSection, { node: node, onApplyToRoof: roofPlaneCount > 1 ? handleApplyToRoof : undefined, onUpdate: handleUpdate, unit: unit })), _jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.panel.position', message: 'Position' }), children: [_jsx(SliderControl, { label: "X", onChange: (v) => {
                             const pos = [...node.position];
                             pos[0] = v;
                             handleUpdate({ position: pos });

package/dist/roof-segment/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/roof-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,KAAK,eAAe,EAAoB,MAAM,kBAAkB,CAAA;AAEpG,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAiMxE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/roof-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAEzB,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAmMxE,CAAA"}

package/dist/roof-segment/parametrics.js

@@ -1,16 +1,15 @@
-import { roofTypeHasRakes } from '@pascal-app/core';
+import { MAX_ROOF_PITCH, MIN_ROOF_SEGMENT_DIMENSION, roofTypeHasRakes, } from '@pascal-app/core';
 export const roofSegmentParametrics = {
     groups: [
         {
             label: 'Footprint',
             fields: [
-                { key: 'width', kind: 'number', unit: 'm', min: 0.5, max: 1000, step: 0.5 },
+                { key: 'width', kind: 'number', unit: 'm', min: MIN_ROOF_SEGMENT_DIMENSION, step: 0.5 },
                 {
                     key: 'depth',
                     kind: 'number',
                     unit: 'm',
-                    min: 0.5,
-                    max: 1000,
+                    min: MIN_ROOF_SEGMENT_DIMENSION,
                     step: 0.5,
                     visibleIf: (node) => node.roofType !== 'conical',
                 },
@@ -25,10 +24,17 @@ export const roofSegmentParametrics = {
                     label: 'Wall',
                     unit: 'm',
                     min: 0,
-                    max: 1000,
                     step: 0.1,
                 },
-                { key: 'pitch', kind: 'number', label: 'Pitch', unit: '°', min: 0, max: 85, step: 1 },
+                {
+                    key: 'pitch',
+                    kind: 'number',
+                    label: 'Pitch',
+                    unit: '°',
+                    min: 0,
+                    max: MAX_ROOF_PITCH,
+                    step: 1,
+                },
                 {
                     key: 'conicalFullCircle',
                     kind: 'boolean',
@@ -129,7 +135,6 @@ export const roofSegmentParametrics = {
                     label: 'Wall thickness',
                     unit: 'm',
                     min: 0.05,
-                    max: 1,
                     step: 0.05,
                 },
                 {
@@ -138,19 +143,17 @@ export const roofSegmentParametrics = {
                     label: 'Deck thickness',
                     unit: 'm',
                     min: 0.04,
-                    max: 0.3,
                     step: 0.01,
                     // Layers set it: edited here it would part from them.
                     visibleIf: (node) => !node.buildUp,
                 },
-                { key: 'overhang', kind: 'number', unit: 'm', min: 0, max: 1, step: 0.05 },
+                { key: 'overhang', kind: 'number', unit: 'm', min: 0, step: 0.05 },
                 {
                     key: 'gableOverhang',
                     kind: 'number',
                     label: 'Gable overhang',
                     unit: 'm',
                     min: 0,
-                    max: 3,
                     step: 0.05,
                     visibleIf: (node) => roofTypeHasRakes(node.roofType),
                 },
@@ -160,7 +163,6 @@ export const roofSegmentParametrics = {
                     label: 'Shingle thickness',
                     unit: 'm',
                     min: 0.02,
-                    max: 0.3,
                     step: 0.01,
                     // Layers set it: edited here it would part from them.
                     visibleIf: (node) => !node.buildUp,

package/dist/roof-segment/slots.d.ts

@@ -0,0 +1,2 @@
+export { roofSegmentSlots } from '@pascal-app/core';
+//# sourceMappingURL=slots.d.ts.map

package/dist/roof-segment/slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/roof-segment/slots.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/roof-segment/slots.js

@@ -0,0 +1 @@
+export { roofSegmentSlots } from '@pascal-app/core';

package/dist/scan/definition.d.ts

@@ -1,8 +1,58 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { ScanNode } from './schema.js';
-/**
- * Scan — Stage A. Capture-session reference with an optional renderable
- * mesh. Raw sensor streams stay in the external session manifest.
- */
-export declare const scanDefinition: NodeDefinition<typeof ScanNode>;
+export declare const scanDefinition: 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<`scan_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"scan">>;
+    url: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    captureSession: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodObject<{
+        sessionId: import("zod").ZodString;
+        schemaVersion: import("zod").ZodOptional<import("zod").ZodNumber>;
+        revisionId: import("zod").ZodOptional<import("zod").ZodString>;
+        manifestUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>>;
+    layers: import("zod").ZodPipe<import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodBoolean>>, import("zod").ZodTransform<Record<string, boolean>, Record<string, boolean>>>;
+    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>>;
+    scale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/scan/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAElF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAkD1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/scan/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/scan/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAEtE,CAAA"}

package/dist/scan/definition.edit.js

@@ -0,0 +1,4 @@
+import { scanParametrics } from './parametrics.js';
+export const scanEditContribution = {
+    parametrics: scanParametrics,
+};

package/dist/scan/definition.js

@@ -1,52 +1,4 @@
-import { ScanNode as ScanNodeSchema } from '@pascal-app/core';
-import { scanParametrics } from './parametrics.js';
-import { ScanNode } from './schema.js';
-/**
- * Scan — Stage A. Capture-session reference with an optional renderable
- * mesh. Raw sensor streams stay in the external session manifest.
- */
-export const scanDefinition = {
-    kind: 'scan',
-    // Heavy LiDAR asset: stripped from the bake, re-added live from scene_graph
-    // in the viewer (see plans → Part D; glb-reference-nodes.tsx).
-    bake: 'strip',
-    schemaVersion: 4,
-    schema: ScanNode,
-    category: 'site',
-    defaults: () => {
-        const stub = ScanNodeSchema.parse({ id: 'scan_default', type: 'scan' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        movable: { axes: ['x', 'y', 'z'], gridSnap: true },
-        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
-        scalable: { axes: ['x', 'y', 'z'], min: 0.01, max: 10 },
-        duplicable: false,
-        deletable: true,
-        // Scans carry user-uploaded imagery — cataloging them as
-        // reusable presets is out of scope.
-        presettable: false,
-    },
-    parametrics: scanParametrics,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    system: {
-        module: () => import('./system.js'),
-        priority: 1,
-    },
-    presentation: {
-        label: 'Capture',
-        description: 'A captured session with optional mesh, motion, media, and sensor data.',
-        icon: { kind: 'url', src: '/icons/mesh.webp' },
-        paletteSection: 'site',
-        paletteOrder: 40,
-    },
-    mcp: {
-        description: 'A captured session reference with an optional renderable mesh.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { scanEditContribution } from './definition.edit.js';
+import { scanRenderDefinition } from './definition.render.js';
+export const scanDefinition = composeNodeDefinition(scanRenderDefinition, scanEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/scan/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CA2CxF,CAAA"}

package/dist/scan/definition.render.js

@@ -0,0 +1,46 @@
+import { ScanNode as ScanNodeSchema } from '@pascal-app/core';
+import { ScanNode } from './schema.js';
+export const scanRenderDefinition = {
+    kind: 'scan',
+    // Heavy LiDAR asset: stripped from the bake, re-added live from scene_graph
+    // in the viewer (see plans → Part D; glb-reference-nodes.tsx).
+    bake: 'strip',
+    schemaVersion: 4,
+    schema: ScanNode,
+    category: 'site',
+    defaults: () => {
+        const stub = ScanNodeSchema.parse({ id: 'scan_default', type: 'scan' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        movable: { axes: ['x', 'y', 'z'], gridSnap: true },
+        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
+        scalable: { axes: ['x', 'y', 'z'], min: 0.01, max: 10 },
+        duplicable: false,
+        deletable: true,
+        // Scans carry user-uploaded imagery — cataloging them as
+        // reusable presets is out of scope.
+        presettable: false,
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 1,
+    },
+    presentation: {
+        label: 'Capture',
+        description: 'A captured session with optional mesh, motion, media, and sensor data.',
+        icon: { kind: 'url', src: '/icons/mesh.webp' },
+        paletteSection: 'site',
+        paletteOrder: 40,
+    },
+    mcp: {
+        description: 'A captured session reference with an optional renderable mesh.',
+    },
+};