@pascal-app/nodes 1.0.1 → 1.0.3

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":"AAmQA,QAAA,MAAM,cAAc,0CAkWnB,CAAA;AA8BD,eAAe,cAAc,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/liquid-line/tool.tsx"],"names":[],"mappings":"AAmQA,QAAA,MAAM,cAAc,0CAsWnB,CAAA;AA8BD,eAAe,cAAc,CAAA"}

package/dist/liquid-line/tool.js

@@ -262,6 +262,7 @@ const LiquidLineTool = () => {
             // rather than folding into one mitered polyline run.
             const line = LiquidLineNode.parse({
                 ...liquidLineDefinition.defaults(),
+                ...useEditor.getState().toolDefaults['liquid-line'],
                 name: 'Liquid Line',
                 path: [start, end],
             });
@@ -279,7 +280,10 @@ const LiquidLineTool = () => {
             const traced = tracePath(target);
             if (!traced)
                 return;
-            const defaults = liquidLineDefinition.defaults();
+            const defaults = {
+                ...liquidLineDefinition.defaults(),
+                ...useEditor.getState().toolDefaults['liquid-line'],
+            };
             const create = [];
             for (let i = 0; i < traced.length - 1; i++) {
                 const a = traced[i];

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,CAoExE,CAAA"}
+{"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"}

package/dist/measurement/definition.js

@@ -29,6 +29,7 @@ export const measurementDefinition = {
         presettable: false,
     },
     dirtyTracking: false,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/tool.tsx"],"names":[],"mappings":"AA+DA,QAAA,MAAM,eAAe,0CA2bpB,CAAA;AA8BD,eAAe,eAAe,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/tool.tsx"],"names":[],"mappings":"AA+DA,QAAA,MAAM,eAAe,0CAucpB,CAAA;AA8BD,eAAe,eAAe,CAAA"}

package/dist/pipe-segment/tool.js

@@ -28,6 +28,7 @@ function getConnectionPorts(levelId, nodes) {
 }
 const PipeSegmentTool = () => {
     const { activeLevelId, sceneApi, unit } = useRegistryToolContext();
+    const toolDefaults = useEditor((s) => s.toolDefaults['pipe-segment']);
     const continuationSeedRef = useRef(currentPipeContinuationSeed());
     const continuationSeed = continuationSeedRef.current;
     const hangerDefaults = useEditor((state) => state.toolDefaults['pipe-segment']);
@@ -42,14 +43,14 @@ const PipeSegmentTool = () => {
     autoHangersRef.current = autoHangers;
     const pendingPromotionRef = useRef(continuationSeed?.promotedFitting ?? null);
     const defaults = pipeSegmentDefinition.defaults();
-    const [system, setSystem] = useState(continuationSeed?.pipe.system ?? defaults.system);
+    const [system, setSystem] = useState(continuationSeed?.pipe.system ?? toolDefaults?.system ?? defaults.system);
     const [sloped, setSloped] = useState(false);
     const slopePercent = 100 / 48;
     const slopeDirection = 1;
     const gradeRef = useRef(slopePercent / 100);
     gradeRef.current = (slopeDirection * slopePercent) / 100;
-    const [diameter, setDiameter] = useState(continuationSeed?.pipe.diameter ?? defaults.diameter);
-    const [pipeMaterial, setPipeMaterial] = useState(continuationSeed?.pipe.pipeMaterial ?? defaults.pipeMaterial);
+    const [diameter, setDiameter] = useState(continuationSeed?.pipe.diameter ?? toolDefaults?.diameter ?? defaults.diameter);
+    const [pipeMaterial, setPipeMaterial] = useState(continuationSeed?.pipe.pipeMaterial ?? toolDefaults?.pipeMaterial ?? defaults.pipeMaterial);
     const systemRef = useRef(system);
     systemRef.current = system;
     const slopedRef = useRef(sloped);
@@ -63,6 +64,16 @@ const PipeSegmentTool = () => {
         mode.setEnabled('pipe-segment', initialAutoHangersRef.current);
         return () => mode.setEnabled('pipe-segment', false);
     }, []);
+    useEffect(() => {
+        if (!toolDefaults)
+            return;
+        if (toolDefaults.system)
+            setSystem(toolDefaults.system);
+        if (typeof toolDefaults.diameter === 'number')
+            setDiameter(toolDefaults.diameter);
+        if (toolDefaults.pipeMaterial)
+            setPipeMaterial(toolDefaults.pipeMaterial);
+    }, [toolDefaults]);
     const commitSegment = ({ start: rawStart, end, startConnection, endConnection, surfaceTarget, previewOnly = false, }) => {
         if (!activeLevelId)
             return null;

package/dist/pipe-trap/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CAqHjB,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CAoHjB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/pipe-trap/tool.js

@@ -25,16 +25,14 @@ function snap(value, step) {
  */
 const PipeTrapTool = () => {
     const activeLevelId = useViewer((s) => s.selection.levelId);
+    const toolDefaults = useEditor((s) => s.toolDefaults['pipe-trap']);
     const [cursor, setCursor] = useState(null);
     const [yaw, setYaw] = useState(0);
-    const [diameter] = useState(pipeTrapDefinition.defaults().diameter);
     const yawRef = useRef(0);
-    const diameterRef = useRef(diameter);
-    diameterRef.current = diameter;
     const previewNode = useMemo(() => PipeTrapNode.parse({
         ...pipeTrapDefinition.defaults(),
-        diameter,
-    }), [diameter]);
+        ...toolDefaults,
+    }), [toolDefaults]);
     const ghost = useMemo(() => {
         const group = buildPipeTrapGeometry(previewNode);
         group.traverse((child) => {
@@ -56,7 +54,7 @@ const PipeTrapTool = () => {
                     applySnap: isMagneticSnapActive(),
                     bypass: !isMagneticSnapActive(),
                 }),
-                diameter: diameterRef.current,
+                diameter: previewNode.diameter,
             };
         };
         let lastEvent = null;
@@ -68,6 +66,7 @@ const PipeTrapTool = () => {
             const r = resolve(event);
             const trap = PipeTrapNode.parse({
                 ...pipeTrapDefinition.defaults(),
+                ...toolDefaults,
                 diameter: r.diameter,
                 position: r.position,
                 rotation: yawRef.current,
@@ -104,9 +103,9 @@ const PipeTrapTool = () => {
             window.removeEventListener('keydown', onKeyDown, true);
             clearDrawAlignment();
         };
-    }, [activeLevelId]);
+    }, [activeLevelId, previewNode.diameter, toolDefaults]);
     if (!activeLevelId || !cursor)
         return null;
-    return (_jsxs(LevelOffsetGroup, { children: [_jsx("group", { position: cursor, rotation: [0, yaw, 0], children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [cursor[0], cursor[1] + 0.5, cursor[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: [diameter, "\" Trap"] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" })] }) })] }));
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx("group", { position: cursor, rotation: [0, yaw, 0], children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [cursor[0], cursor[1] + 0.5, cursor[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: [previewNode.diameter, "\" Trap"] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" })] }) })] }));
 };
 export default PipeTrapTool;

package/dist/procedural-item/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgD,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpG,OAAO,EAKL,kBAAkB,EAWnB,MAAM,mCAAmC,CAAA;AA6D1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAmO9E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgD,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpG,OAAO,EAKL,kBAAkB,EAWnB,MAAM,mCAAmC,CAAA;AA8D1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAqO9E,CAAA"}

package/dist/procedural-item/definition.js

@@ -1,6 +1,7 @@
 import { useScene } from '@pascal-app/core';
 import { boundsOf, boxCorners, evaluateRecipe, frame, ProceduralItemNode, parameterPatch, proceduralFootprint, proceduralSlotColor, queryProceduralItem, resolveProceduralWallPlacement, setProceduralMaterial, shelfRecipe, snapParameters, transformPoint, validateProceduralRelations, } from '@pascal-app/core/procedural-items';
 import { itemPaint } from '../item/paint';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
 import { proceduralFloorplanMoveTarget } from './move-session';
 const GIZMO_SIDE_OFFSET = 0.3;
 const GIZMO_FRONT_OFFSET = 0.3;
@@ -69,6 +70,7 @@ export const proceduralItemDefinition = {
         position: [0, 0, 0],
         rotation: [0, 0, 0],
     }),
+    extensions: { 'pascal:editor/floorplan': { directDrag: true } },
     capabilities: {
         selectable: { hitVolume: 'bbox' },
         dragBounds: (n) => {
@@ -91,7 +93,7 @@ export const proceduralItemDefinition = {
         },
         movable: { axes: ['x', 'z'], gridSnap: true },
         rotatable: { axes: ['y'], snapAngles: [0, Math.PI / 4, Math.PI / 2, Math.PI] },
-        duplicable: true,
+        duplicable: { subtree: 'with-children' },
         deletable: true,
         slots: (n) => {
             const node = n;
@@ -116,6 +118,7 @@ export const proceduralItemDefinition = {
     parametrics: { groups: [], customPanel: () => import('@pascal-app/editor/procedural-items') },
     affordanceTools: { move: () => import('./move-tool') },
     floorplanMoveTarget: proceduralFloorplanMoveTarget,
+    floorplanAffectedIds: restingFloorplanAffectedIds,
     keyboardActions: {
         r: {
             appliesTo: (n) => Boolean(n.wallId),

package/dist/ridge-vent/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAwIxC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CA2DpE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAwIxC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CA4DpE,CAAA"}

package/dist/ridge-vent/definition.js

@@ -169,6 +169,7 @@ export const ridgeVentDefinition = {
     parametrics: ridgeVentParametrics,
     handles: ridgeVentHandles,
     floorplan: buildRidgeVentFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAgK1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AAczB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAkK1D,CAAA"}

package/dist/roof/definition.js

@@ -1,6 +1,7 @@
 import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
-import { DRAFTING_SURFACE_EXTENSION_KEY } from '@pascal-app/editor';
+import { DRAFTING_SURFACE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
 import { buildRoofFloorplan } from './floorplan';
+import { roofPanelModel } from './panel-model';
 import { roofParametrics } from './parametrics';
 import useRoofFootprintSource from './roof-footprint-source';
 import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode';
@@ -90,6 +91,7 @@ export const roofDefinition = {
     category: 'structure',
     surfaceRole: 'roof',
     extensions: {
+        [PANEL_MODEL_EXTENSION]: roofPanelModel,
         [DRAFTING_SURFACE_EXTENSION_KEY]: {
             kind: 'roof',
         },
@@ -219,6 +221,7 @@ export const roofDefinition = {
     parametrics: roofParametrics,
     handles: resolveRoofHandles,
     floorplan: buildRoofFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/roof/panel-model.d.ts

@@ -0,0 +1,4 @@
+import { type RoofNode } from '@pascal-app/core';
+import { type NodePanelModel } from '@pascal-app/editor';
+export declare const roofPanelModel: NodePanelModel<RoofNode>;
+//# sourceMappingURL=panel-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel-model.d.ts","sourceRoot":"","sources":["../../src/roof/panel-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,cAAc,EAIpB,MAAM,oBAAoB,CAAA;AAG3B,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,QAAQ,CAqJnD,CAAA"}

package/dist/roof/panel-model.js

@@ -0,0 +1,151 @@
+import { nodeRegistry, useScene, } from '@pascal-app/core';
+import { duplicateRoofSubtree, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+export const roofPanelModel = {
+    rows({ node, nodes, update }) {
+        const select = (id) => useViewer.getState().setSelection({ selectedIds: [id] });
+        const activate = (kind) => {
+            triggerSFX('sfx:item-pick');
+            const editor = useEditor.getState();
+            editor.setTool(kind);
+            if (editor.mode !== 'build')
+                editor.setMode('build');
+        };
+        const segments = (node.children ?? [])
+            .map((id) => nodes[id])
+            .filter((child) => child?.type === 'roof-segment');
+        const segmentIds = new Set(segments.map((segment) => segment.id));
+        const rows = segments.map((segment, index) => ({
+            id: segment.id,
+            kind: 'choice',
+            section: 'Segments',
+            label: segment.name || `Segment ${index + 1}`,
+            value: segment.roofType,
+            onSelect: () => select(segment.id),
+        }));
+        rows.push({
+            id: 'add-segment',
+            kind: 'action',
+            section: 'Segments',
+            label: 'Draw Segment',
+            onSelect: () => activate('roof'),
+        });
+        for (const axis of [0, 1, 2])
+            rows.push({
+                id: `position-${axis}`,
+                kind: 'stepper',
+                section: 'Position',
+                label: 'XYZ'[axis],
+                value: node.position[axis],
+                unit: 'm',
+                step: 0.05,
+                min: -Infinity,
+                max: Infinity,
+                onChange: (value) => {
+                    const live = useScene.getState().nodes[node.id];
+                    const position = [...(live?.position ?? node.position)];
+                    position[axis] = value;
+                    update({ position });
+                },
+            });
+        rows.push({
+            id: 'rotation',
+            kind: 'stepper',
+            section: 'Position',
+            label: 'Rotation',
+            value: Math.round((node.rotation * 180) / Math.PI),
+            unit: '°',
+            step: 1,
+            min: -180,
+            max: 180,
+            onChange: (degrees) => update({ rotation: (degrees * Math.PI) / 180 }),
+        }, {
+            id: 'rotate',
+            kind: 'actions',
+            section: 'Position',
+            actions: [-1, 1].map((direction) => ({
+                id: `rotate-${direction}`,
+                label: direction < 0 ? '-45°' : '+45°',
+                onSelect: () => {
+                    triggerSFX('sfx:item-rotate');
+                    const live = useScene.getState().nodes[node.id];
+                    update({ rotation: (live?.rotation ?? node.rotation) + (direction * Math.PI) / 4 });
+                },
+            })),
+        });
+        for (const child of Object.values(nodes)) {
+            if (!child ||
+                !('roofSegmentId' in child) ||
+                !child.roofSegmentId ||
+                !segmentIds.has(child.roofSegmentId))
+                continue;
+            rows.push({
+                id: child.id,
+                kind: 'action',
+                section: 'Elements',
+                label: child.name || nodeRegistry.get(child.type)?.presentation?.label || child.type,
+                onSelect: () => select(child.id),
+            });
+        }
+        for (const [kind, definition] of nodeRegistry.entries()) {
+            if (definition.presentation?.hidden ||
+                definition.capabilities.wallOpeningPlacement ||
+                (definition.capabilities.roofAccessory === undefined &&
+                    definition.presentation?.paletteGroup !== 'roof-features'))
+                continue;
+            const icon = definition.presentation?.icon;
+            rows.push({
+                id: `add-${kind}`,
+                kind: 'action',
+                section: 'Features & extensions',
+                label: `Add ${definition.presentation?.label ?? kind}`,
+                icon: icon?.kind === 'url' ? { src: icon.src } : undefined,
+                onSelect: () => activate(kind),
+            });
+        }
+        rows.push({
+            id: 'roof-actions',
+            kind: 'actions',
+            section: 'Actions',
+            actions: [
+                {
+                    id: 'move',
+                    label: 'Move',
+                    onSelect: () => {
+                        const live = useScene.getState().nodes[node.id];
+                        if (!live)
+                            return;
+                        triggerSFX('sfx:item-pick');
+                        useEditor.getState().setMovingNode(live);
+                        useViewer.getState().setSelection({ selectedIds: [] });
+                    },
+                },
+                {
+                    id: 'duplicate',
+                    label: 'Duplicate',
+                    onSelect: () => {
+                        if (!useScene.getState().nodes[node.id])
+                            return;
+                        triggerSFX('sfx:item-pick');
+                        duplicateRoofSubtree(node.id, { mode: 'move' });
+                    },
+                },
+                {
+                    id: 'delete',
+                    label: 'Delete',
+                    onSelect: () => {
+                        const live = useScene.getState().nodes[node.id];
+                        if (!live)
+                            return;
+                        triggerSFX('sfx:item-delete');
+                        useScene.getState().deleteNode(node.id);
+                        if (live.parentId)
+                            useScene.getState().markDirty(live.parentId);
+                        useViewer.getState().setSelection({ selectedIds: [] });
+                    },
+                },
+            ],
+        });
+        return rows;
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof/panel.tsx"],"names":[],"mappings":"AAkCA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA4gBhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof/panel.tsx"],"names":[],"mappings":"AAmCA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA2gBhC"}

package/dist/roof/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, duplicateRoofSubtree, formatLinearMeasurement, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { ActionButton, ActionGroup, commitParametricNodeFields, duplicateRoofSubtree, formatLinearMeasurement, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Plus, Trash2 } from 'lucide-react';
 import { useCallback, useState } from 'react';
@@ -12,7 +12,6 @@ export default function RoofPanel() {
     const unit = useViewer((s) => s.unit);
     const metricNotation = useViewer((s) => s.metricNotation);
     const setSelection = useViewer((s) => s.setSelection);
-    const updateNode = useScene((s) => s.updateNode);
     const setMovingNode = useEditor((s) => s.setMovingNode);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
     // Shallow selector — only re-renders when the segment list content changes.
@@ -107,8 +106,8 @@ export default function RoofPanel() {
     const handleUpdate = useCallback((updates) => {
         if (!selectedId)
             return;
-        updateNode(selectedId, updates);
-    }, [selectedId, updateNode]);
+        commitParametricNodeFields(selectedId, updates);
+    }, [selectedId]);
     const handleClose = useCallback(() => {
         setSelection({ selectedIds: [] });
     }, [setSelection]);

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/roof/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEtE,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAG1D,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/roof/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEtE,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAkB1D,CAAA"}

package/dist/roof/parametrics.js

@@ -1,4 +1,19 @@
 export const roofParametrics = {
-    groups: [],
+    groups: [
+        {
+            label: 'Position',
+            fields: [
+                { key: 'position', kind: 'vec3' },
+                {
+                    key: 'rotation',
+                    kind: 'number',
+                    label: 'Rotation (rad)',
+                    min: -Math.PI,
+                    max: Math.PI,
+                    step: Math.PI / 36,
+                },
+            ],
+        },
+    ],
     customPanel: () => import('./panel'),
 };

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoS1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA4ExE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoS1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA6ExE,CAAA"}

package/dist/roof-segment/definition.js

@@ -316,6 +316,7 @@ export const roofSegmentDefinition = {
     },
     parametrics: roofSegmentParametrics,
     handles: resolveRoofSegmentHandles,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

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,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE7E,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAGxE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/roof-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE7E,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAmLxE,CAAA"}

package/dist/roof-segment/parametrics.js

@@ -1,4 +1,179 @@
 export const roofSegmentParametrics = {
-    groups: [],
+    groups: [
+        {
+            label: 'Footprint',
+            fields: [
+                { key: 'width', kind: 'number', unit: 'm', min: 0.5, max: 1000, step: 0.5 },
+                {
+                    key: 'depth',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.5,
+                    max: 1000,
+                    step: 0.5,
+                    visibleIf: (node) => node.roofType !== 'conical',
+                },
+            ],
+        },
+        {
+            label: 'Shape',
+            fields: [
+                {
+                    key: 'wallHeight',
+                    kind: 'number',
+                    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: 'conicalFullCircle',
+                    kind: 'boolean',
+                    label: 'Full circle',
+                    visibleIf: (node) => node.roofType === 'conical',
+                },
+                {
+                    key: 'gambrelLowerWidthRatio',
+                    kind: 'number',
+                    label: 'Kink depth',
+                    min: 0.1,
+                    max: 0.9,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'gambrel',
+                },
+                {
+                    key: 'gambrelLowerHeightRatio',
+                    kind: 'number',
+                    label: 'Kink height',
+                    min: 0.1,
+                    max: 0.9,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'gambrel',
+                },
+                {
+                    key: 'mansardSteepWidthRatio',
+                    kind: 'number',
+                    label: 'Waist width',
+                    min: 0.05,
+                    max: 0.45,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'mansard',
+                },
+                {
+                    key: 'mansardSteepHeightRatio',
+                    kind: 'number',
+                    label: 'Waist height',
+                    min: 0.1,
+                    max: 0.9,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'mansard',
+                },
+                {
+                    key: 'dutchHipWidthRatio',
+                    kind: 'number',
+                    label: 'Waist width',
+                    min: 0.05,
+                    max: 0.45,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'dutch',
+                },
+                {
+                    key: 'dutchHipHeightRatio',
+                    kind: 'number',
+                    label: 'Waist height',
+                    min: 0.1,
+                    max: 0.9,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'dutch',
+                },
+                {
+                    key: 'dutchWaistLengthRatio',
+                    kind: 'number',
+                    label: 'Waist length',
+                    min: 0.1,
+                    max: 1,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'dutch',
+                },
+                {
+                    key: 'dutchTopRakeThickness',
+                    kind: 'number',
+                    label: 'Top rake thickness',
+                    unit: 'm',
+                    min: 0.01,
+                    max: 0.5,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'dutch',
+                },
+                {
+                    key: 'dutchGabletRake',
+                    kind: 'number',
+                    label: 'Top rake length',
+                    unit: 'm',
+                    min: 0,
+                    max: 3,
+                    step: 0.01,
+                    visibleIf: (node) => node.roofType === 'dutch',
+                },
+            ],
+        },
+        {
+            label: 'Structure',
+            fields: [
+                {
+                    key: 'wallThickness',
+                    kind: 'number',
+                    label: 'Wall thickness',
+                    unit: 'm',
+                    min: 0.05,
+                    max: 1,
+                    step: 0.05,
+                },
+                {
+                    key: 'deckThickness',
+                    kind: 'number',
+                    label: 'Deck thickness',
+                    unit: 'm',
+                    min: 0.04,
+                    max: 0.3,
+                    step: 0.01,
+                },
+                { key: 'overhang', kind: 'number', unit: 'm', min: 0, max: 1, step: 0.05 },
+                {
+                    key: 'shingleThickness',
+                    kind: 'number',
+                    label: 'Shingle thickness',
+                    unit: 'm',
+                    min: 0.02,
+                    max: 0.3,
+                    step: 0.01,
+                },
+                {
+                    key: 'wallShell',
+                    kind: 'enum',
+                    label: 'Wall shell',
+                    options: ['auto', 'include', 'omit'],
+                },
+            ],
+        },
+        {
+            label: 'Position',
+            fields: [
+                { key: 'position', kind: 'vec3' },
+                {
+                    key: 'rotation',
+                    kind: 'number',
+                    label: 'Rotation (rad)',
+                    min: -Math.PI,
+                    max: Math.PI,
+                    step: Math.PI / 36,
+                    visibleIf: (node) => node.roofType !== 'conical',
+                },
+            ],
+        },
+    ],
+    derive: (next, patch) => next.roofType === 'conical' && patch.width !== undefined ? { depth: next.width } : {},
     customPanel: () => import('./panel'),
 };

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,CAiD1D,CAAA"}
+{"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"}