@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/roof/floorplan.js

@@ -1,5 +1,66 @@
-import { roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
+import { getRoofSegmentVisibleTopBounds, roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
+import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { getConicalRoofPlanFootprint, getRoofSegmentPlanLinework } from '../roof-segment/floorplan';
+/**
+ * `roof-segment.pitch` is stored in DEGREES; a roof plan is annotated as the
+ * rise over a 12 run. 30.256° → tan 0.5833 × 12 → 7.00 → '7:12'. Rounded to
+ * the nearest half, so a modelled pitch a hair off a standard slope still
+ * reads as the slope the framer will cut. Returns '' for a flat roof, which
+ * has no slope to annotate.
+ */
+export function roofPitchLabel(pitchDeg) {
+    if (!Number.isFinite(pitchDeg) || pitchDeg <= 0)
+        return '';
+    const rise = Math.tan((pitchDeg * Math.PI) / 180) * 12;
+    if (!Number.isFinite(rise) || rise <= 0)
+        return '';
+    const rounded = Math.round(rise * 2) / 2;
+    return `${Number.isInteger(rounded) ? rounded : rounded.toFixed(1)}:12`;
+}
+/**
+ * One down-slope arrow per roof PLANE, in segment-local coordinates
+ * (lx = width axis, lz = depth axis) — the same local space
+ * `getRoofSegmentPlanLinework` returns ridges and hips in:
+ *
+ *   gable / gambrel   two planes falling away from the centre ridge (±lz)
+ *   shed              one plane, high eave at −lz falling to +lz
+ *   hip / mansard /   four planes, one off each eave
+ *     dutch
+ *   flat              none
+ *
+ * Arrows run from just off the ridge to just short of the eave so the head
+ * lands inside the roof outline rather than on it.
+ */
+function slopeArrows(node) {
+    const hw = Math.max(node.width, 0.01) / 2;
+    const hd = Math.max(node.depth, 0.01) / 2;
+    const along = (run) => ({ near: run * 0.14, far: run * 0.86 });
+    switch (node.roofType) {
+        case 'flat':
+            return [];
+        case 'shed':
+            // Unchanged from the linework builder: the 3D shed falls −lz → +lz.
+            return [{ tail: [0, -hd * 0.55], head: [0, hd * 0.55] }];
+        case 'gable':
+        case 'gambrel': {
+            const z = along(hd);
+            return [
+                { tail: [-hw * 0.35, z.near], head: [-hw * 0.35, z.far] },
+                { tail: [hw * 0.35, -z.near], head: [hw * 0.35, -z.far] },
+            ];
+        }
+        default: {
+            const z = along(hd);
+            const x = along(hw);
+            return [
+                { tail: [0, z.near], head: [0, z.far] },
+                { tail: [0, -z.near], head: [0, -z.far] },
+                { tail: [x.near, 0], head: [x.far, 0] },
+                { tail: [-x.near, 0], head: [-x.far, 0] },
+            ];
+        }
+    }
+}
 function overlapEntry(entry, ctx) {
     const supportSegment = entry.roof.support?.kind === 'roof'
         ? ctx.resolve(entry.roof.support.roofSegmentId)
@@ -17,7 +78,7 @@ function overlapEntry(entry, ctx) {
     };
 }
 /** A segment's footprint + ridge/hip/break/slope linework, in world plan coords. */
-function buildSegPlan(roof, seg) {
+function buildSegPlan(roof, seg, drafting) {
     const cosRoof = Math.cos(-roof.rotation);
     const sinRoof = Math.sin(-roof.rotation);
     const segCx = roof.position[0] + seg.position[0] * cosRoof - seg.position[2] * sinRoof;
@@ -39,17 +100,42 @@ function buildSegPlan(roof, seg) {
     const footprint = seg.roofType === 'conical'
         ? getConicalRoofPlanFootprint(seg).map(([x, z]) => tp(x, z))
         : [tp(-hw, -hd), tp(hw, -hd), tp(hw, hd), tp(-hw, hd)];
+    const ridges = lw.ridges.map(mapSeg);
+    const hips = lw.hips.map(mapSeg);
+    const breaks = lw.breaks.map(mapSeg);
+    if (!drafting) {
+        const slopes = lw.slope
+            ? [
+                {
+                    tail: tp(lw.slope.tail[0], lw.slope.tail[1]),
+                    head: tp(lw.slope.head[0], lw.slope.head[1]),
+                    pitch: '',
+                },
+            ]
+            : [];
+        return { footprint, eave: footprint, ridges, hips, breaks, slopes };
+    }
+    // The drip edge: core's own visible-top bounds, which add the horizontal
+    // component of `overhang` (plus half the wall thickness and, on the sloped
+    // faces, the shingle projection) to the footprint on each side.
+    const edge = getRoofSegmentVisibleTopBounds(seg);
+    const pitch = roofPitchLabel(seg.pitch);
     return {
         footprint,
-        ridges: lw.ridges.map(mapSeg),
-        hips: lw.hips.map(mapSeg),
-        breaks: lw.breaks.map(mapSeg),
-        slope: lw.slope
-            ? {
-                tail: tp(lw.slope.tail[0], lw.slope.tail[1]),
-                head: tp(lw.slope.head[0], lw.slope.head[1]),
-            }
-            : null,
+        eave: [
+            tp(edge.minX, edge.minZ),
+            tp(edge.maxX, edge.minZ),
+            tp(edge.maxX, edge.maxZ),
+            tp(edge.minX, edge.maxZ),
+        ],
+        ridges,
+        hips,
+        breaks,
+        slopes: slopeArrows(seg).map((arrow) => ({
+            tail: tp(arrow.tail[0], arrow.tail[1]),
+            head: tp(arrow.head[0], arrow.head[1]),
+            pitch,
+        })),
     };
 }
 function pointInPolygon(point, polygon) {
@@ -126,10 +212,13 @@ export function buildRoofFloorplan(node, ctx) {
     const segments = ctx.children.filter((c) => c.type === 'roof-segment');
     if (segments.length === 0)
         return null;
+    // Eave outlines, an arrow per plane, pitch tags and the 'roof-plan' role are
+    // sheet drafting; the editor plan keeps its outline, linework and one arrow.
+    const drafting = readFloorplanContext(ctx).drafting;
     const entries = segments.map((segment) => ({
         roof: node,
         segment,
-        plan: buildSegPlan(node, segment),
+        plan: buildSegPlan(node, segment, drafting),
     }));
     for (const sibling of ctx.siblings) {
         if (sibling.type !== 'roof')
@@ -138,7 +227,7 @@ export function buildRoofFloorplan(node, ctx) {
             const segment = ctx.resolve(childId);
             if (segment?.type !== 'roof-segment')
                 continue;
-            entries.push({ roof: sibling, segment, plan: buildSegPlan(sibling, segment) });
+            entries.push({ roof: sibling, segment, plan: buildSegPlan(sibling, segment, drafting) });
         }
     }
     const currentEntries = entries.filter((entry) => entry.roof.id === node.id);
@@ -156,11 +245,15 @@ export function buildRoofFloorplan(node, ctx) {
             plan: entry.plan,
             cutters,
             footprints: subtractPolygonsFromPolygon(entry.plan.footprint, cutters),
+            eaves: subtractPolygonsFromPolygon(entry.plan.eave, cutters),
+            /** True when the drip edge is far enough outside the wall line to draw. */
+            hasOverhang: drafting && polygonSpread(entry.plan.eave) - polygonSpread(entry.plan.footprint) > 0.04,
         };
     });
     const rings = unionPolygons(visiblePlans.flatMap(({ footprints }) => footprints));
     if (rings.length === 0)
         return null;
+    const eaveRings = unionPolygons(visiblePlans.flatMap(({ eaves, hasOverhang }) => (hasOverhang ? eaves : [])));
     const view = ctx.viewState;
     const palette = view?.palette;
     const showSelectedChrome = (view?.selected ?? false) || (view?.highlighted ?? false);
@@ -168,6 +261,13 @@ export function buildRoofFloorplan(node, ctx) {
     const eaveWidth = showSelectedChrome ? 0.04 : 0.03;
     const ridgeWidth = showSelectedChrome ? 0.05 : 0.038;
     const hipWidth = showSelectedChrome ? 0.04 : 0.026;
+    const overhangWidth = showSelectedChrome ? 0.03 : 0.022;
+    // Drafted, two strata: the REFERENCE a floor plan always carries (the dashed
+    // overhang line — the roof flying past the walls) and the ROOF PLAN
+    // proper (outline, ridges, hips, arrows, pitches), which is the
+    // 'roof-plan' annotation — off over a floor plan until the Roof plan
+    // layer is on, the roof is selected, or the sheet IS the roof plan.
+    const reference = [];
     const children = [];
     const pushLine = (a, b, width) => {
         children.push({
@@ -182,7 +282,25 @@ export function buildRoofFloorplan(node, ctx) {
             pointerEvents: 'none',
         });
     };
-    // Merged outline (eaves).
+    // The drip edge — the roof's actual outer boundary, overhang included —
+    // drawn DASHED under the wall line so the two never read as one edge. This
+    // is the convention every roof plan uses: solid where the roof meets the
+    // structure, dashed where it flies past it.
+    for (const ring of eaveRings) {
+        if (ring.length < 3)
+            continue;
+        reference.push({
+            kind: 'polygon',
+            points: ring.map(([x, z]) => [x, z]),
+            fill: 'none',
+            stroke: ink,
+            strokeWidth: overhangWidth,
+            strokeDasharray: '0.28 0.16',
+            strokeLinejoin: 'miter',
+            pointerEvents: 'none',
+        });
+    }
+    // Merged outline (wall line under the roof).
     for (const ring of rings) {
         if (ring.length < 3)
             continue;
@@ -212,9 +330,11 @@ export function buildRoofFloorplan(node, ctx) {
                 pushLine(visible[0], visible[1], ridgeWidth);
             }
         }
-        if (plan.slope) {
-            const { tail, head } = plan.slope;
-            const visibleSlope = clipLineByCutters([tail, head], cutters).at(-1);
+        // One down-slope arrow per roof plane, each tagged with the pitch in
+        // 12ths — the annotation a roof plan is read for. The arrow points the
+        // way water runs; the tag is the number the framer cuts to.
+        for (const slope of plan.slopes) {
+            const visibleSlope = clipLineByCutters([slope.tail, slope.head], cutters).at(-1);
             if (!visibleSlope)
                 continue;
             const [visibleTail, visibleHead] = visibleSlope;
@@ -239,7 +359,63 @@ export function buildRoofFloorplan(node, ctx) {
                 strokeLinejoin: 'round',
                 pointerEvents: 'none',
             });
+            if (!slope.pitch || len < PITCH_LABEL_MIN_RUN)
+                continue;
+            // Set beside the shaft, clear of it, at the arrow's midpoint. The
+            // perpendicular is chosen so the tag always sits ABOVE its arrow (and
+            // to its right where the arrow runs vertically), so opposing slopes of
+            // the same roof do not put their tags on opposite sides.
+            let px = uz;
+            let pz = -ux;
+            if (pz > 1e-6 || (Math.abs(pz) <= 1e-6 && px < 0)) {
+                px = -px;
+                pz = -pz;
+            }
+            const mx = (visibleTail[0] + visibleHead[0]) / 2 + px * PITCH_LABEL_OFFSET;
+            const mz = (visibleTail[1] + visibleHead[1]) / 2 + pz * PITCH_LABEL_OFFSET;
+            children.push({
+                kind: 'text',
+                x: mx,
+                y: mz,
+                text: slope.pitch,
+                fontSize: PITCH_LABEL_FONT_SIZE,
+                fill: ink,
+                stroke: '#ffffff',
+                strokeWidth: PITCH_LABEL_FONT_SIZE * 0.3,
+                paintOrder: 'stroke',
+                fontFamily: 'system-ui, -apple-system, sans-serif',
+                fontWeight: 600,
+                textAnchor: 'middle',
+                dominantBaseline: 'central',
+                upright: true,
+                metadata: floorplanGeometryMetadata({ annotationRole: 'roof-pitch' }),
+            });
         }
     }
-    return children.length > 0 ? { kind: 'group', children } : null;
+    if (!drafting)
+        return children.length > 0 ? { kind: 'group', children } : null;
+    if (reference.length === 0 && children.length === 0)
+        return null;
+    // A selected / highlighted roof shows its plan whatever the layer says —
+    // the user is looking at the roof.
+    const plan = showSelectedChrome
+        ? { kind: 'group', children }
+        : {
+            kind: 'group',
+            children,
+            metadata: floorplanGeometryMetadata({ annotationRole: 'roof-plan' }),
+        };
+    return { kind: 'group', children: children.length > 0 ? [...reference, plan] : reference };
+}
+/** Longest edge of a polygon's bounding box — how the overhang test compares. */
+function polygonSpread(polygon) {
+    if (polygon.length === 0)
+        return 0;
+    const xs = polygon.map(([x]) => x);
+    const zs = polygon.map(([, z]) => z);
+    return Math.max(...xs) - Math.min(...xs) + (Math.max(...zs) - Math.min(...zs));
 }
+const PITCH_LABEL_FONT_SIZE = 0.22;
+const PITCH_LABEL_OFFSET = 0.24;
+/** Below this arrow length the tag would sit on top of its own arrowhead. */
+const PITCH_LABEL_MIN_RUN = 0.6;

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

@@ -1 +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"}
+{"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,CAyJnD,CAAA"}

package/dist/roof/panel-model.js

@@ -1,5 +1,5 @@
 import { nodeRegistry, useScene, } from '@pascal-app/core';
-import { duplicateRoofSubtree, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { duplicateNodeAndPickUp, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 export const roofPanelModel = {
     rows({ node, nodes, update }) {
@@ -28,7 +28,12 @@ export const roofPanelModel = {
             kind: 'action',
             section: 'Segments',
             label: 'Draw Segment',
-            onSelect: () => activate('roof'),
+            // Arming a tool ends the selection; the roof tool draws into the roof
+            // selected while it is armed, so hand it this one explicitly.
+            onSelect: () => {
+                activate('roof');
+                select(node.id);
+            },
         });
         for (const axis of [0, 1, 2])
             rows.push({
@@ -124,10 +129,9 @@ export const roofPanelModel = {
                     id: 'duplicate',
                     label: 'Duplicate',
                     onSelect: () => {
-                        if (!useScene.getState().nodes[node.id])
-                            return;
-                        triggerSFX('sfx:item-pick');
-                        duplicateRoofSubtree(node.id, { mode: 'move' });
+                        const live = useScene.getState().nodes[node.id];
+                        if (live)
+                            duplicateNodeAndPickUp(live);
                     },
                 },
                 {

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

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

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, commitParametricNodeFields, 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';
@@ -124,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/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/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/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/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/duct-body-paint.d.ts

@@ -1,6 +1,2 @@
-import type { SlotDeclaration } from '@pascal-app/core';
-export declare const DUCT_BODY_SLOT_ID = "body";
-export declare const DUCT_BODY_SLOT_DEFAULT = "#ffffff";
-export declare function ductBodySlots(): SlotDeclaration[];
 export declare const ductBodyPaint: import("@pascal-app/core").PaintCapability;
 //# sourceMappingURL=duct-body-paint.d.ts.map

package/dist/shared/duct-body-paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duct-body-paint.d.ts","sourceRoot":"","sources":["../../src/shared/duct-body-paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGvD,eAAO,MAAM,iBAAiB,SAAS,CAAA;AACvC,eAAO,MAAM,sBAAsB,YAAY,CAAA;AAE/C,wBAAgB,aAAa,IAAI,eAAe,EAAE,CAEjD;AAED,eAAO,MAAM,aAAa,4CAMxB,CAAA"}
+{"version":3,"file":"duct-body-paint.d.ts","sourceRoot":"","sources":["../../src/shared/duct-body-paint.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,4CAMxB,CAAA"}

package/dist/shared/duct-body-paint.js

@@ -1,9 +1,5 @@
+import { DUCT_BODY_SLOT_ID } from '@pascal-app/core';
 import { createSlotPaintCapability, previewGeometrySlot } from './slot-paint';
-export const DUCT_BODY_SLOT_ID = 'body';
-export const DUCT_BODY_SLOT_DEFAULT = '#ffffff';
-export function ductBodySlots() {
-    return [{ slotId: DUCT_BODY_SLOT_ID, label: 'Body', default: DUCT_BODY_SLOT_DEFAULT }];
-}
 export const ductBodyPaint = createSlotPaintCapability({
     resolveRole: ({ hitObject }) => {
         const slotId = hitObject?.userData?.slotId;

package/dist/shared/item-interaction-actions.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The light switch for a single selected item or procedural item. Play/Stop
+ * comes from the action menu's `capabilities.mechanism` button.
+ */
+export default function ItemInteractionActions(): import("react").JSX.Element | null;
+//# sourceMappingURL=item-interaction-actions.d.ts.map

package/dist/shared/item-interaction-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-interaction-actions.d.ts","sourceRoot":"","sources":["../../src/shared/item-interaction-actions.tsx"],"names":[],"mappings":"AAOA;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,sBAAsB,uCAsB7C"}