@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/ridge-vent/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { RidgeVentNode as RidgeVentSchema, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useScene } from '@pascal-app/core';
+import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
@@ -42,27 +42,9 @@ export default function RidgeVentPanel() {
         setSelection({ selectedIds: [] });
     }, [node, setMovingNode, setSelection]);
     const handleDuplicate = useCallback(() => {
-        if (!node)
-            return;
-        triggerSFX('sfx:item-pick');
-        const parentId = node.roofSegmentId;
-        if (!parentId)
-            return;
-        const state = useScene.getState();
-        const meta = typeof node.metadata === 'object' && node.metadata !== null
-            ? node.metadata
-            : {};
-        const cloneInput = {
-            ...node,
-            id: undefined,
-            metadata: { ...meta, isNew: true },
-        };
-        const cloned = RidgeVentSchema.parse(cloneInput);
-        state.createNode(cloned, parentId);
-        state.dirtyNodes.add(parentId);
-        setMovingNode(cloned);
-        setSelection({ selectedIds: [] });
-    }, [node, setMovingNode, setSelection]);
+        if (node)
+            duplicateNodeAndPickUp(node);
+    }, [node]);
     const handleDelete = useCallback(() => {
         if (!(selectedId && node))
             return;

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AAuDzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,iBAAiB,GAAI,qBAAqB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,uCAiMtE,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AAuDzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,iBAAiB,GAAI,qBAAqB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,uCA4MtE,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/ridge-vent/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, normalizeRoofSegmentTrim, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, getRoofMaterialArray, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { createMaterial, createSurfaceRoleMaterial, getRoofMaterialArray, resolveMaterialRef, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
 import { RIDGE_LIFT, resolveRidgeSnap } from '../shared/ridge-snap';
@@ -96,6 +96,7 @@ const RidgeVentRenderer = ({ node: storeNode }) => {
     const parentRoof = useScene((state) => segmentStore?.parentId
         ? state.nodes[segmentStore.parentId]
         : undefined);
+    const sceneMaterials = useScene((state) => state.materials);
     const segmentGeometryKey = ridgeVentSegmentGeometryKey(segment);
     const rotationY = node.rotation ?? 0;
     const snap = useMemo(() => segment && Math.abs(rotationY) < 1e-5
@@ -131,16 +132,14 @@ const RidgeVentRenderer = ({ node: storeNode }) => {
         const createDefaultTopMaterial = () => {
             const parentSpec = parentRoof ? getEffectiveRoofSurfaceMaterial(parentRoof, 'top') : undefined;
             const spec = segment ? getEffectiveSegmentSurfaceMaterial(segment, 'top', parentSpec) : null;
-            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);
             }
             const roofMaterials = parentRoof
-                ? getRoofMaterialArray(parentRoof, shading, textures, colorPreset, sceneTheme)
+                ? getRoofMaterialArray(parentRoof, shading, textures, colorPreset, sceneTheme, null, sceneMaterials)
                 : null;
             return (roofMaterials?.[3] ??
                 createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme));
@@ -149,7 +148,8 @@ const RidgeVentRenderer = ({ node: storeNode }) => {
             return createMaterial(node.material, shading);
         }
         if (node.materialPreset) {
-            return createMaterialFromPresetRef(node.materialPreset, shading) ?? createDefaultTopMaterial();
+            return (resolveMaterialRef(node.materialPreset, sceneMaterials, shading) ??
+                createDefaultTopMaterial());
         }
         return createDefaultTopMaterial();
     }, [
@@ -161,6 +161,7 @@ const RidgeVentRenderer = ({ node: storeNode }) => {
         node.materialPreset,
         segment,
         parentRoof,
+        sceneMaterials,
     ]);
     // Map vent-local geometry into the host segment's local frame (where the trim
     // cut prisms live). Recompose the same pose the inner mesh group is mounted

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,CAqK1D,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';
@@ -85,11 +86,12 @@ export const roofDefinition = {
     // Drafted as a 2-corner footprint (axis-aligned bbox), not a directional
     // edge → no angle-lock mode (grid / lines / off only).
     snapDraftDirectional: false,
-    schemaVersion: 3,
+    schemaVersion: 4,
     schema: RoofNode,
     category: 'structure',
     surfaceRole: 'roof',
     extensions: {
+        [PANEL_MODEL_EXTENSION]: roofPanelModel,
         [DRAFTING_SURFACE_EXTENSION_KEY]: {
             kind: 'roof',
         },
@@ -103,6 +105,9 @@ export const roofDefinition = {
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
+        // F2 layers stack inward from the covering-top plane along the facet
+        // normal; the body is their sum and the roof stores no thickness.
+        assembly: { reference: 'covering', measure: 'normal', body: () => null },
         // Contribute a plan AABB to the alignment-guide candidate pool so a roof
         // (and any moving sibling) snaps against the roof's outer silhouette.
         // Roof has no centred-box footprint — it's the union of its
@@ -219,6 +224,7 @@ export const roofDefinition = {
     parametrics: roofParametrics,
     handles: resolveRoofHandles,
     floorplan: buildRoofFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/roof/floorplan.d.ts

@@ -1,4 +1,12 @@
 import { type FloorplanGeometry, type GeometryContext, type RoofNode } from '@pascal-app/core';
+/**
+ * `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 declare function roofPitchLabel(pitchDeg: number): string;
 /**
  * Roof-level floor-plan builder. Draws the whole merged-roof plan: the
  * unioned silhouette and every segment's ridge/hip/break linework. The

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAuIzB;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAwHjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AA0BzB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AA2LD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAsMjG"}

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

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

package/dist/roof/panel-model.js

@@ -0,0 +1,155 @@
+import { nodeRegistry, useScene, } from '@pascal-app/core';
+import { duplicateNodeAndPickUp, 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',
+            // 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({
+                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: () => {
+                        const live = useScene.getState().nodes[node.id];
+                        if (live)
+                            duplicateNodeAndPickUp(live);
+                    },
+                },
+                {
+                    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,uCAogBhC"}