@pascal-app/nodes 1.0.1 → 1.0.4

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, duplicateNodeAndPickUp, 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]);
@@ -125,15 +124,8 @@ export default function RoofPanel() {
         setSelection({ selectedIds: [segmentId] });
     }, [setSelection]);
     const handleDuplicate = useCallback(() => {
-        if (!node)
-            return;
-        triggerSFX('sfx:item-pick');
-        try {
-            duplicateRoofSubtree(node.id, { mode: 'move' });
-        }
-        catch (e) {
-            console.error('Failed to duplicate roof', e);
-        }
+        if (node)
+            duplicateNodeAndPickUp(node);
     }, [node]);
     const handleMove = useCallback(() => {
         if (node) {

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/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/roof/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAQzB,eAAO,MAAM,YAAY,GAAI,mBAAmB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAkHjE,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/roof/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAczB,eAAO,MAAM,YAAY,GAAI,mBAAmB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCA8HjE,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/roof/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { hasSegmentMaterialOverride, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { getRoofMaterialArray, NodeRenderer, useNodeEvents, useViewer } from '@pascal-app/viewer';
+import { getRoofMaterialArray, levelWallCladdingRef, NodeRenderer, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
@@ -65,7 +65,10 @@ export const RoofRenderer = ({ node: rawNode }) => {
     }));
     // 4 groups map 1:1 to the roof's 4-material array (see getRoofMaterialArray).
     const placeholderGeometry = useMemo(() => createPlaceholderGeometry(4), []);
-    const customMaterial = useMemo(() => getRoofMaterialArray(node, shading, textures, colorPreset, sceneTheme), [node, shading, textures, colorPreset, sceneTheme]);
+    // The gable band is clad like the walls below it (their assemblies).
+    const wallCladdingRef = useScene((state) => levelWallCladdingRef(state.nodes, node));
+    const sceneMaterials = useScene((state) => state.materials);
+    const customMaterial = useMemo(() => getRoofMaterialArray(node, shading, textures, colorPreset, sceneTheme, wallCladdingRef, sceneMaterials), [node, shading, textures, colorPreset, sceneTheme, wallCladdingRef, sceneMaterials]);
     const material = debugColors
         ? getRoofDebugMaterials(shading)
         : customMaterial || getRoofMaterials(shading, textures, colorPreset);

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/panel.d.ts.map

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

package/dist/roof-segment/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { createDefaultRidgeVentsForSegment, getConicalRoofCoverage, isAutoGutterEnabled, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, normalizeRoofSegmentTrim, ROOF_SHAPE_DEFAULTS, RoofSegmentNode as RoofSegmentNodeSchema, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, ToggleControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { createDefaultRidgeVentsForSegment, getConicalRoofCoverage, isAutoGutterEnabled, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, normalizeRoofSegmentTrim, ROOF_SHAPE_DEFAULTS, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, ToggleControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Check, Copy, Move, Pencil, RotateCcw, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
@@ -146,28 +146,9 @@ export default function RoofSegmentPanel() {
         }
     }, [node, setRoofHostDragArmedId, setSelection, updateNode]);
     const handleDuplicate = useCallback(() => {
-        if (!node?.parentId)
-            return;
-        triggerSFX('sfx:item-pick');
-        let duplicateInfo = structuredClone(node);
-        delete duplicateInfo.id;
-        duplicateInfo.metadata = { ...duplicateInfo.metadata, isNew: true };
-        // Offset slightly so it's visible
-        duplicateInfo.position = [
-            duplicateInfo.position[0] + 1,
-            duplicateInfo.position[1],
-            duplicateInfo.position[2] + 1,
-        ];
-        try {
-            const duplicate = RoofSegmentNodeSchema.parse(duplicateInfo);
-            useScene.getState().createNode(duplicate, duplicate.parentId);
-            setSelection({ selectedIds: [] });
-            setMovingNode(duplicate);
-        }
-        catch (e) {
-            console.error('Failed to duplicate roof segment', e);
-        }
-    }, [node, setSelection, setMovingNode]);
+        if (node)
+            duplicateNodeAndPickUp(node);
+    }, [node]);
     const handleMove = useCallback(() => {
         if (node) {
             triggerSFX('sfx:item-pick');

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/roof-segment/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/roof-segment/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAazB,eAAO,MAAM,mBAAmB,GAAI,UAAU;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,gCAsGtE,CAAA;AAED,eAAe,mBAAmB,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/roof-segment/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAczB,eAAO,MAAM,mBAAmB,GAAI,UAAU;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,gCAyHtE,CAAA;AAED,eAAe,mBAAmB,CAAA"}

package/dist/roof-segment/renderer.js

@@ -1,15 +1,22 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, useRegistry, useScene, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, getRoofMaterialArray, useNodeEvents, useViewer, } from '@pascal-app/viewer';
-import { useEffect, useMemo, useRef } from 'react';
+import { createMaterial, getRoofMaterialArray, levelWallCladdingRef, resolveMaterialRef, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
 import { getRoofDebugMaterials, getRoofMaterials } from '../roof/roof-materials';
 import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
 export const RoofSegmentRenderer = ({ node }) => {
     const ref = useRef(null);
     const nodes = useScene((state) => state.nodes);
+    const sceneMaterials = useScene((state) => state.materials);
     useRegistry(node.id, 'roof-segment', ref);
+    // The renderer loads lazily, so the scene-load dirty mark can be consumed
+    // before this mesh registers. A painted segment is built only from its own
+    // mesh (the merged shell skips it), so it would keep its empty placeholder.
+    useLayoutEffect(() => {
+        useScene.getState().markDirty(node.id);
+    }, [node.id]);
     const handlers = useNodeEvents(node, 'roof-segment');
     const debugColors = useViewer((s) => s.debugColors);
     const shading = useViewer((s) => s.shading);
@@ -33,16 +40,16 @@ export const RoofSegmentRenderer = ({ node }) => {
     //   slot 1 → 'wall'  (deck top & shingle eave bands)
     //   slot 2 → 'wall'  (interior)
     //   slot 3 → 'top'   (shingle / roof surface)
+    // The gable band is clad like the walls below it (their assemblies).
+    const wallCladdingRef = useScene((state) => parentNode ? levelWallCladdingRef(state.nodes, parentNode) : null);
     // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
     const customMaterial = useMemo(() => {
         const resolveSlot = (role) => {
             const parentSpec = parentNode ? getEffectiveRoofSurfaceMaterial(parentNode, role) : undefined;
             const spec = getEffectiveSegmentSurfaceMaterial(node, role, parentSpec);
-            if (typeof spec.materialPreset === 'string') {
-                const resolved = createMaterialFromPresetRef(spec.materialPreset, shading);
-                if (resolved)
-                    return resolved;
-            }
+            const resolved = resolveMaterialRef(spec.materialPreset, sceneMaterials, shading);
+            if (resolved)
+                return resolved;
             if (spec.material !== undefined) {
                 return createMaterial(spec.material, shading);
             }
@@ -51,7 +58,7 @@ export const RoofSegmentRenderer = ({ node }) => {
         // Themed parent-roof array (per-role scene-theme colours) — used both as the
         // full fallback and to fill any individual untextured slot below.
         const themedArray = parentNode
-            ? getRoofMaterialArray(parentNode, shading, textures, colorPreset, sceneTheme)
+            ? getRoofMaterialArray(parentNode, shading, textures, colorPreset, sceneTheme, wallCladdingRef, sceneMaterials)
             : null;
         const edge = resolveSlot('edge');
         const wall = resolveSlot('wall');
@@ -71,10 +78,12 @@ export const RoofSegmentRenderer = ({ node }) => {
         node.topMaterial,
         node.topMaterialPreset,
         node.edgeMaterial,
+        wallCladdingRef,
         node.edgeMaterialPreset,
         node.wallMaterial,
         node.wallMaterialPreset,
         parentNode,
+        sceneMaterials,
         shading,
         textures,
         colorPreset,

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"}

package/dist/scan/definition.js

@@ -30,6 +30,7 @@ export const scanDefinition = {
         presettable: false,
     },
     parametrics: scanParametrics,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/separator/definition.d.ts

@@ -0,0 +1,3 @@
+import { type NodeDefinition, SeparatorNode } from '@pascal-app/core';
+export declare const separatorDefinition: NodeDefinition<typeof SeparatorNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/separator/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAErE,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CAqCpE,CAAA"}

package/dist/separator/definition.js

@@ -0,0 +1,39 @@
+import { SeparatorNode } from '@pascal-app/core';
+export const separatorDefinition = {
+    kind: 'separator',
+    bake: 'strip',
+    schemaVersion: 1,
+    schema: SeparatorNode,
+    category: 'structure',
+    defaults: () => {
+        const { id: _id, type: _type, ...rest } = SeparatorNode.parse({ start: [0, 0], end: [1, 0] });
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: false,
+        deletable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    rendersChildren: false,
+    renderer: { kind: 'parametric', module: () => import('./renderer') },
+    floorplan: (node) => ({
+        kind: 'line',
+        x1: node.start[0],
+        y1: node.start[1],
+        x2: node.end[0],
+        y2: node.end[1],
+        stroke: '#818cf8',
+        strokeWidth: 2,
+        strokeDasharray: '6 4',
+        vectorEffect: 'non-scaling-stroke',
+        pointerEvents: 'stroke',
+    }),
+    presentation: {
+        icon: { kind: 'iconify', name: 'lucide:split' },
+        label: 'Separator',
+        hidden: true,
+        actionMenu: false,
+    },
+};

package/dist/separator/renderer.d.ts

@@ -0,0 +1,5 @@
+import { type SeparatorNode } from '@pascal-app/core';
+export default function SeparatorRenderer({ node }: {
+    node: SeparatorNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/separator/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,aAAa,EAAyB,MAAM,kBAAkB,CAAA;AAU5E,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,+BAgD1E"}

package/dist/separator/renderer.js

@@ -0,0 +1,36 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRegistry, useScene } from '@pascal-app/core';
+import { useEditor } from '@pascal-app/editor';
+import { useNodeEvents, useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import { BufferGeometry, Float32BufferAttribute } from 'three';
+import { LineBasicNodeMaterial, MeshBasicNodeMaterial } from 'three/webgpu';
+const separatorMaterial = new LineBasicNodeMaterial({ color: '#818cf8', depthWrite: false });
+const hitMaterial = new MeshBasicNodeMaterial({ transparent: true, opacity: 0, depthWrite: false });
+export default function SeparatorRenderer({ node }) {
+    const ref = useRef(null);
+    useRegistry(node.id, 'separator', ref);
+    const roomId = useEditor((s) => s.room?.zoneId);
+    const viewerRoomId = useViewer((s) => s.selection.zoneId);
+    const zone = useScene((s) => {
+        const id = roomId ?? viewerRoomId;
+        return id ? s.nodes[id] : undefined;
+    });
+    const visible = zone?.type === 'zone' && zone.boundarySeparatorIds.includes(node.id);
+    const events = useNodeEvents(node, 'separator');
+    const y = zone?.type === 'zone' ? (zone.floor?.elevation ?? 0.05) + 0.02 : 0.07;
+    const dx = node.end[0] - node.start[0], dz = node.end[1] - node.start[1];
+    const length = Math.hypot(dx, dz);
+    const geometry = useMemo(() => {
+        const positions = [];
+        if (Number.isFinite(length)) {
+            for (let distance = 0; distance < length; distance += 0.25) {
+                positions.push(distance, 0, 0, Math.min(distance + 0.15, length), 0, 0);
+            }
+        }
+        return new BufferGeometry().setAttribute('position', new Float32BufferAttribute(positions, 3));
+    }, [length]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    return (_jsx("group", { ref: ref, visible: visible, children: visible && (_jsxs(_Fragment, { children: [_jsx("lineSegments", { geometry: geometry, material: separatorMaterial, position: [node.start[0], y, node.start[1]], rotation: [0, -Math.atan2(dz, dx), 0], raycast: () => { } }), _jsx("mesh", { ...events, material: hitMaterial, position: [(node.start[0] + node.end[0]) / 2, y, (node.start[1] + node.end[1]) / 2], rotation: [0, -Math.atan2(dz, dx), 0], children: _jsx("boxGeometry", { args: [length, 0.03, 0.1] }) })] })) }));
+}

package/dist/shared/commit-opening-move.d.ts

@@ -0,0 +1,4 @@
+import { type AnyNodeId, type DoorNode, type WindowNode } from '@pascal-app/core';
+/** A move changes placement, not persistent ownership (Array, assets, etc.). */
+export declare function commitOpeningMove(id: AnyNodeId, patch: Partial<DoorNode | WindowNode>): void;
+//# sourceMappingURL=commit-opening-move.d.ts.map

package/dist/shared/commit-opening-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-opening-move.d.ts","sourceRoot":"","sources":["../../src/shared/commit-opening-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAY,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE3F,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,GAAG,UAAU,CAAC,QAKrF"}

package/dist/shared/commit-opening-move.js

@@ -0,0 +1,9 @@
+import { useScene } from '@pascal-app/core';
+/** A move changes placement, not persistent ownership (Array, assets, etc.). */
+export function commitOpeningMove(id, patch) {
+    const node = useScene.getState().nodes[id];
+    if (!node || (node.type !== 'window' && node.type !== 'door'))
+        return;
+    const { isNew: _new, isTransient: _transient, ...metadata } = node.metadata;
+    useScene.getState().updateNode(id, { ...patch, metadata });
+}

package/dist/shared/curtain-opening-limits.d.ts

@@ -0,0 +1,14 @@
+import { type AnyNode, type AnyNodeId, type DoorNode, type WindowNode } from '@pascal-app/core';
+type Opening = DoorNode | WindowNode;
+export declare function curtainOpeningResizeMax(opening: Opening, nodes: Readonly<Record<AnyNodeId, AnyNode>>, axis: 'x' | 'y', sign: number): number | undefined;
+export declare function curtainOpeningLimits(opening: Opening, nodes: Readonly<Record<AnyNodeId, AnyNode>>): {
+    margin: number;
+    length: number;
+    top: number;
+    bottom: number;
+    width: number;
+    height: number;
+} | null;
+export declare function constrainCurtainOpening<T extends Opening>(opening: T, patch: Partial<T>, nodes: Readonly<Record<AnyNodeId, AnyNode>>): Partial<T>;
+export {};
+//# sourceMappingURL=curtain-opening-limits.d.ts.map

package/dist/shared/curtain-opening-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-opening-limits.d.ts","sourceRoot":"","sources":["../../src/shared/curtain-opening-limits.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,QAAQ,EAGb,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB,KAAK,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAA;AAEpC,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,IAAI,EAAE,GAAG,GAAG,GAAG,EACf,IAAI,EAAE,MAAM,sBAcb;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;;;;;;;SAwB5C;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,OAAO,EACvD,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,OAAO,CAAC,CAAC,CAAC,CAsBZ"}

package/dist/shared/curtain-opening-limits.js

@@ -0,0 +1,53 @@
+import { getCurtainWallConfig, getWallCurveLength, } from '@pascal-app/core';
+import { resolveWallOpeningCeiling } from './wall-opening-ceiling';
+export function curtainOpeningResizeMax(opening, nodes, axis, sign) {
+    const limits = curtainOpeningLimits(opening, nodes);
+    if (!limits)
+        return undefined;
+    if (axis === 'y') {
+        const anchor = opening.position[1] - (sign * opening.height) / 2;
+        return Math.max(0, sign > 0 ? limits.top - anchor : anchor - limits.bottom);
+    }
+    const direction = Math.cos(opening.rotation[1]) >= 0 ? sign : -sign;
+    const anchor = opening.position[0] - (direction * opening.width) / 2;
+    return Math.max(0, direction > 0 ? limits.length - limits.margin - anchor : anchor - limits.margin);
+}
+export function curtainOpeningLimits(opening, nodes) {
+    const wall = nodes[(opening.parentId ?? opening.wallId)];
+    if (wall?.type !== 'wall' || wall.wallType !== 'curtain')
+        return null;
+    const margin = getCurtainWallConfig(wall).perimeterWidth;
+    const length = getWallCurveLength(wall);
+    const top = resolveWallOpeningCeiling(wall, nodes) - margin;
+    const bottom = opening.type === 'door' ? 0 : margin;
+    return {
+        margin,
+        length,
+        top,
+        bottom,
+        width: Math.max(0, 2 * Math.min(opening.position[0] - margin, length - margin - opening.position[0])),
+        height: Math.max(0, opening.type === 'door'
+            ? top
+            : 2 * Math.min(opening.position[1] - bottom, top - opening.position[1])),
+    };
+}
+export function constrainCurtainOpening(opening, patch, nodes) {
+    const limits = curtainOpeningLimits(opening, nodes);
+    if (!limits || !('width' in patch || 'height' in patch || 'position' in patch))
+        return patch;
+    const next = { ...opening, ...patch };
+    const moving = patch.position !== undefined && patch.width === undefined && patch.height === undefined;
+    const availableWidth = Math.max(0, limits.length - 2 * limits.margin);
+    const availableHeight = Math.max(0, limits.top - limits.bottom);
+    const widthLimit = moving || limits.width < 0.01 ? availableWidth : limits.width;
+    const heightLimit = moving || limits.height < 0.01 ? availableHeight : limits.height;
+    const width = Math.min(Math.max(0.01, next.width), widthLimit);
+    const height = Math.min(Math.max(0.01, next.height), heightLimit);
+    if (width < 0.01 || height < 0.01)
+        return {};
+    const x = Math.max(limits.margin + width / 2, Math.min(limits.length - limits.margin - width / 2, next.position[0]));
+    const y = opening.type === 'door'
+        ? height / 2
+        : Math.max(limits.bottom + height / 2, Math.min(limits.top - height / 2, next.position[1]));
+    return { ...patch, width, height, position: [x, y, next.position[2]] };
+}

package/dist/shared/draft-axis-guides.d.ts

@@ -27,10 +27,4 @@ export declare function DraftAngleArc({ arc, color }: {
     arc: DraftAngleLabel['arc'];
     color: string;
 }): import("react").JSX.Element;
-export declare function DraftMeasurementLabel({ color, label, position, shadowColor, }: {
-    color: string;
-    label: string;
-    position: [number, number, number];
-    shadowColor: string;
-}): import("react").JSX.Element;
 //# sourceMappingURL=draft-axis-guides.d.ts.map