@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/ridge-vent/tool.js

@@ -1,17 +1,17 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, RidgeVentNode, sceneRegistry, useScene, } from '@pascal-app/core';
 import { triggerSFX } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import * as THREE from 'three';
-import { resolveRidgeSnap } from '../shared/ridge-snap';
-import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
-import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
-import { getRoofTopSurfaceY } from '../shared/roof-surface';
-import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
-import { ridgeVentDefinition } from './definition';
-import RidgeVentPreview from './preview';
+import { resolveRidgeSnap } from '../shared/ridge-snap.js';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview.js';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit.js';
+import { getRoofTopSurfaceY } from '../shared/roof-surface.js';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides.js';
+import { ridgeVentDefinition } from './definition.js';
+import RidgeVentPreview from './preview.js';
 const worldPoint = new THREE.Vector3();
 /**
  * Ridge vent placement tool. The cursor preview snaps to the nearest

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

@@ -0,0 +1,5 @@
+import { type RoofSegmentNode } from '@pascal-app/core';
+export declare function BarrelRoofPanel({ node: stored }: {
+    node: RoofSegmentNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=barrel-panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"barrel-panel.d.ts","sourceRoot":"","sources":["../../src/roof/barrel-panel.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAYzB,wBAAgB,eAAe,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,+BA+C1E"}

package/dist/roof/barrel-panel.js

@@ -0,0 +1,17 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getActiveRoofHeight, getEffectiveNode, useLiveNodeOverrides, } from '@pascal-app/core';
+import { getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, SliderControl, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo } from 'react';
+import { createRoofGlazingPreview } from './glazing-preview.js';
+export function BarrelRoofPanel({ node: stored }) {
+    useLiveNodeOverrides((state) => state.overrides.get(stored.id));
+    const node = getEffectiveNode(stored);
+    const unit = useViewer((state) => state.unit);
+    const preview = useMemo(() => createRoofGlazingPreview([stored.id]), [stored.id]);
+    useEffect(() => () => preview.cancel(), [preview]);
+    return (_jsxs(PanelSection, { title: "Barrel arch", children: [_jsx(SliderControl, { label: "Rise", min: metersToLinearUnit(0.01, unit), max: metersToLinearUnit(node.depth / 2, unit), step: 0.1, precision: 2, unit: getLinearUnitLabel(unit), value: metersToLinearUnit(getActiveRoofHeight(node), unit), onChange: (value) => preview.previewFields({
+                    barrelRise: Math.min(node.depth / 2, linearControlValueToMeters(value, unit, { minMeters: 0.01 })),
+                }), onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true }), _jsx(SliderControl, { label: "Arch bays", min: 4, max: 32, step: 1, precision: 0, value: node.barrelSegments ?? 12, onChange: (value) => preview.previewFields({ barrelSegments: Math.round(value) }), onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true }), _jsx("p", { className: "px-1 text-xs text-muted-foreground", children: "Flat panes follow a circular arch. Rise is measured from the eaves." })] }));
+}

package/dist/roof/conical-roof.d.ts

@@ -1,3 +1,7 @@
 import { type AnyNode, type AnyNodeId, type LevelNode, RoofSegmentNode, type SceneApi, type WallNode } from '@pascal-app/core';
-export declare function createConicalRoofSectorAboveWall(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>, sceneApi: SceneApi, targetLevelId: LevelNode['id']): RoofSegmentNode['id'] | null;
+/**
+ * A cone over a curved wall, picked from the wall's own level or the one above it (`armedLevelId`).
+ * It goes where every roof goes (`roofLevelTarget`): on the level directly above the wall's storey.
+ */
+export declare function createConicalRoofSectorAboveWall(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>, sceneApi: SceneApi, armedLevelId: LevelNode['id']): RoofSegmentNode['id'] | null;
 //# sourceMappingURL=conical-roof.d.ts.map

package/dist/roof/conical-roof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conical-roof.d.ts","sourceRoot":"","sources":["../../src/roof/conical-roof.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,SAAS,EAEd,eAAe,EAGf,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,GAC7B,eAAe,CAAC,IAAI,CAAC,GAAG,IAAI,CAkD9B"}
+{"version":3,"file":"conical-roof.d.ts","sourceRoot":"","sources":["../../src/roof/conical-roof.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,SAAS,EAEd,eAAe,EAGf,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAKzB;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,SAAS,CAAC,IAAI,CAAC,GAC5B,eAAe,CAAC,IAAI,CAAC,GAAG,IAAI,CAoD9B"}

package/dist/roof/conical-roof.js

@@ -1,16 +1,20 @@
-import { getLevelBelow, getWallArcData, RoofNode, RoofSegmentNode, resolveLevelId, resolveRoofWallTopElevation, } from '@pascal-app/core';
+import { getActiveRoofHeight, getLevelBelow, getWallArcData, RoofNode, RoofSegmentNode, resolveLevelId, resolveRoofWallTopElevation, } from '@pascal-app/core';
+import { roofLevelTarget, writeRoofNodes } from './roof-level-target.js';
 const DEFAULT_CONICAL_ROOF_PITCH = 40;
-export function createConicalRoofSectorAboveWall(wall, nodes, sceneApi, targetLevelId) {
+/**
+ * A cone over a curved wall, picked from the wall's own level or the one above it (`armedLevelId`).
+ * It goes where every roof goes (`roofLevelTarget`): on the level directly above the wall's storey.
+ */
+export function createConicalRoofSectorAboveWall(wall, nodes, sceneApi, armedLevelId) {
     const arc = getWallArcData(wall);
-    if (!(arc && nodes[targetLevelId]?.type === 'level'))
+    if (!(arc && nodes[armedLevelId]?.type === 'level'))
         return null;
     const completeNodes = nodes;
     const sourceLevelId = resolveLevelId(wall, completeNodes);
-    const levelBelowId = getLevelBelow(targetLevelId, completeNodes)?.id;
-    if (sourceLevelId !== targetLevelId && sourceLevelId !== levelBelowId)
+    const levelBelowId = getLevelBelow(armedLevelId, completeNodes)?.id;
+    if (sourceLevelId !== armedLevelId && sourceLevelId !== levelBelowId)
         return null;
     const existingRoof = Object.values(nodes).find((node) => node.type === 'roof' &&
-        node.parentId === targetLevelId &&
         typeof node.metadata === 'object' &&
         node.metadata !== null &&
         !Array.isArray(node.metadata) &&
@@ -33,21 +37,21 @@ export function createConicalRoofSectorAboveWall(wall, nodes, sceneApi, targetLe
         conicalSweepAngle: arc.delta,
         conicalFullCircle: true,
     });
+    const target = roofLevelTarget(nodes, sourceLevelId, getActiveRoofHeight(segment));
     const roof = RoofNode.parse({
         name: `Roof ${roofCount + 1}`,
         metadata: { conicalSourceWallId: wall.id },
         support: { kind: 'walls' },
-        position: [arc.center.x, resolveRoofWallTopElevation(targetLevelId, wall, nodes), arc.center.y],
+        position: [
+            arc.center.x,
+            resolveRoofWallTopElevation(target.levelId, wall, target.nodes),
+            arc.center.y,
+        ],
         children: [segment.id],
     });
-    const ops = [
-        { node: roof, parentId: targetLevelId },
+    writeRoofNodes(sceneApi, target, [
+        { node: roof, parentId: target.levelId },
         { node: segment, parentId: roof.id },
-    ];
-    if (sceneApi.createMany)
-        sceneApi.createMany(ops);
-    else
-        for (const op of ops)
-            sceneApi.upsert(op.node, op.parentId);
+    ]);
     return segment.id;
 }

package/dist/roof/definition.d.ts

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { RoofNode } from './schema';
+import { RoofNode } from './schema.js';
 /**
  * Roof is a composite node with `roof-segment` children that own the
  * per-segment geometry. Its floor-plan contribution merges those child

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;AAczB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAkK1D,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,CA6K1D,CAAA"}

package/dist/roof/definition.js

@@ -1,11 +1,11 @@
 import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
 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';
-import { RoofNode } from './schema';
+import { buildRoofFloorplan } from './floorplan.js';
+import { roofPanelModel } from './panel-model.js';
+import { roofParametrics } from './parametrics.js';
+import useRoofFootprintSource from './roof-footprint-source.js';
+import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode.js';
+import { RoofNode } from './schema.js';
 const MOVE_FRONT_OFFSET = 0.35;
 const MIN_ROOF_FOOTPRINT = 1;
 function getRoofFootprintBounds(node, sceneApi) {
@@ -86,7 +86,7 @@ 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',
@@ -102,9 +102,20 @@ export const roofDefinition = {
         return rest;
     },
     capabilities: {
+        exterior: true,
+        reveal: {
+            phase: 'roof',
+            style: 'assemble',
+            height: 4,
+            // The roof lifts out of the way while the furniture drops in, then seats again.
+            clears: { for: 'furnishing', height: 2.4 },
+        },
         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
@@ -162,9 +173,9 @@ export const roofDefinition = {
     // lookup — no hardcoded dispatcher arm. Shared with roof-segment / stair
     // / stair-segment via `shared/move-roof-tool`.
     affordanceTools: {
-        move: () => import('../shared/move-roof-tool'),
+        move: () => import('../shared/move-roof-tool.js'),
     },
-    tool: () => import('./tool'),
+    tool: () => import('./tool.js'),
     toolHints: [
         { key: 'Left click', label: 'Set roof footprint' },
         {
@@ -224,10 +235,10 @@ export const roofDefinition = {
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     system: {
-        module: () => import('./system'),
+        module: () => import('./system.js'),
         priority: 3,
     },
     presentation: {

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,EAGpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AA8LD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA0MjG"}

package/dist/roof/floorplan.js

@@ -1,5 +1,67 @@
-import { roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
-import { getConicalRoofPlanFootprint, getRoofSegmentPlanLinework } from '../roof-segment/floorplan';
+import { getGlazedRoofPlanLines, getRoofSegmentVisibleTopBounds, roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
+import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { getConicalRoofPlanFootprint, getRoofSegmentPlanLinework } from '../roof-segment/floorplan.js';
+/**
+ * `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 'barrel':
+        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 +79,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 +101,44 @@ 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);
+    const glazing = getGlazedRoofPlanLines(seg).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, glazing, 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 = seg.roofType === 'barrel' ? '' : 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,
+        glazing,
+        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 +215,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 +230,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 +248,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 +264,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 +285,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;
@@ -197,6 +318,10 @@ export function buildRoofFloorplan(node, ctx) {
         });
     }
     for (const { plan, cutters } of visiblePlans) {
+        for (const line of plan.glazing) {
+            for (const visible of clipLineByCutters(line, cutters))
+                pushLine(visible[0], visible[1], hipWidth);
+        }
         for (const line of plan.breaks) {
             for (const visible of clipLineByCutters(line, cutters)) {
                 pushLine(visible[0], visible[1], hipWidth);
@@ -212,9 +337,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 +366,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/glazed-geometry.d.ts

@@ -0,0 +1,5 @@
+import type { RoofGeometryAdapter } from '@pascal-app/viewer';
+import type { Mesh } from 'three';
+export declare const glazedRoofGeometryAdapter: RoofGeometryAdapter;
+export declare function syncGlazedRoofShadow(mesh: Mesh, appearance?: import("three").Material<import("three").MaterialEventMap>[] | import("three").Material<import("three").MaterialEventMap>): void;
+//# sourceMappingURL=glazed-geometry.d.ts.map

package/dist/roof/glazed-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glazed-geometry.d.ts","sourceRoot":"","sources":["../../src/roof/glazed-geometry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAEjC,eAAO,MAAM,yBAAyB,EAAE,mBAIvC,CAAA;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,4HAAgB,QAiB1E"}

package/dist/roof/glazed-geometry.js

@@ -0,0 +1,27 @@
+import { isGlazedRoofSegment } from '@pascal-app/core';
+export const glazedRoofGeometryAdapter = {
+    syncGeometry(node, mesh) {
+        if (isGlazedRoofSegment(node))
+            syncGlazedRoofShadow(mesh);
+    },
+};
+export function syncGlazedRoofShadow(mesh, appearance = mesh.material) {
+    const shadow = mesh.getObjectByName('glazed-roof-shadow');
+    if (!shadow)
+        return;
+    const materials = Array.isArray(appearance) ? appearance : [appearance];
+    const indices = [];
+    for (const group of mesh.geometry.groups) {
+        const material = materials[group.materialIndex ?? 0];
+        if (material?.transparent && material.opacity < 1)
+            continue;
+        for (let i = group.start; i < group.start + group.count; i++)
+            indices.push(mesh.geometry.index ? mesh.geometry.index.getX(i) : i);
+    }
+    const geometry = mesh.geometry.clone();
+    geometry.clearGroups();
+    geometry.setIndex(indices);
+    geometry.setDrawRange(0, indices.length);
+    shadow.geometry.dispose();
+    shadow.geometry = geometry;
+}

package/dist/roof/glazed-materials.d.ts

@@ -0,0 +1,14 @@
+import { type RoofSegmentNode, type SceneMaterial, type SceneMaterialId } from '@pascal-app/core';
+import { type ColorPreset, type RenderShading } from '@pascal-app/viewer';
+import { type Material } from 'three';
+export { GLAZED_ROOF_SLOTS } from '@pascal-app/core';
+export declare function createGlazedRoofMaterials(node: Pick<RoofSegmentNode, 'glazing' | 'slots'>, shading: RenderShading, materials?: Record<SceneMaterialId, SceneMaterial>, { textures, colorPreset, sceneTheme, debugColors, }?: {
+    textures?: boolean;
+    colorPreset?: ColorPreset;
+    sceneTheme?: string;
+    debugColors?: boolean;
+}): {
+    visible: Material<import("three").MaterialEventMap>[];
+    owned: Material<import("three").MaterialEventMap>[];
+};
+//# sourceMappingURL=glazed-materials.d.ts.map

package/dist/roof/glazed-materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glazed-materials.d.ts","sourceRoot":"","sources":["../../src/roof/glazed-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAIhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEpD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,OAAO,CAAC,EAChD,OAAO,EAAE,aAAa,EACtB,SAAS,GAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAM,EACtD,EACE,QAAe,EACf,WAAoB,EACpB,UAAU,EACV,WAAmB,GACpB,GAAE;IACD,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,OAAO,CAAA;CACjB;;;EAwCP"}

package/dist/roof/glazed-materials.js

@@ -0,0 +1,42 @@
+import { GLAZED_ROOF_SLOTS, getRoofGlazing, } from '@pascal-app/core';
+import { createSurfaceRoleMaterial, resolveMaterialRef, } from '@pascal-app/viewer';
+import { FrontSide } from 'three';
+import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+import { getRoofDebugMaterials } from './roof-materials.js';
+export { GLAZED_ROOF_SLOTS } from '@pascal-app/core';
+export function createGlazedRoofMaterials(node, shading, materials = {}, { textures = true, colorPreset = 'clay', sceneTheme, debugColors = false, } = {}) {
+    const config = getRoofGlazing(node);
+    const owned = [];
+    const visible = GLAZED_ROOF_SLOTS.map((slot, index) => {
+        if (debugColors || !textures) {
+            const source = debugColors
+                ? getRoofDebugMaterials(shading)[index]
+                : createSurfaceRoleMaterial(index === 1 ? 'glazing' : 'roof', colorPreset, FrontSide, sceneTheme);
+            const material = source.clone();
+            if (!debugColors && index === 1)
+                material.opacity = config.glassOpacity;
+            owned.push(material);
+            return material;
+        }
+        const override = resolveMaterialRef(node.slots?.[slot], materials, shading);
+        if (override)
+            return override;
+        const glass = index === 1;
+        const properties = {
+            color: glass ? config.glassColor : config.frameColor,
+            transparent: glass,
+            opacity: glass ? config.glassOpacity : 1,
+            depthWrite: !glass,
+        };
+        const material = shading === 'solid'
+            ? new MeshLambertNodeMaterial(properties)
+            : new MeshStandardNodeMaterial({
+                ...properties,
+                roughness: glass ? config.glassRoughness : 0.4,
+                metalness: index === 0 ? 0.65 : 0,
+            });
+        owned.push(material);
+        return material;
+    });
+    return { visible: [...visible, visible[0]], owned };
+}