@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/systems/roof/roof-system.js

@@ -1,4 +1,4 @@
-import { getConicalRoofCoverage, getDutchEndSlopeFaces, getDutchRoofShapeMetrics, getEffectiveNode, getRoofModuleFaces, getRoofPlanBounds, getRoofSegmentSurfaceY, getRoofShapeInsets, getRoofShapeRatios, getSegmentSlopeFrame, hasSegmentMaterialOverride, isBandedShedSegment, nodeRegistry, normalizeRoofSegmentTrim, pointInPolygon2D, ROOF_SHAPE_DEFAULTS, roofOverlapEntryOwns, roofPlanBoundsOverlap, sceneRegistry, unionPolygons, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getBarrelRoofFaces, getBarrelRoofSolidPieces, getConicalRoofCoverage, getDutchEndSlopeFaces, getDutchRoofShapeMetrics, getEffectiveNode, getGlazedRoofFaces, getGlazedRoofPieceFaces, getGlazedRoofPieces, getRoofModuleFaces, getRoofPlanBounds, getRoofSegmentDeckReach, getRoofSegmentSurfaceY, getRoofShapeInsets, getRoofShapeRatios, getSegmentSlopeFrame, hasSegmentMaterialOverride, isBandedShedSegment, isGlazedRoofSegment, isIndependentRoofSegment, nodeRegistry, normalizeRoofSegmentTrim, pointInPolygon2D, ROOF_SHAPE_DEFAULTS, roofOverlapEntryOwns, roofPlanBoundsOverlap, sceneRegistry, unionPolygons, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { mergeGeometries, mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
@@ -6,6 +6,7 @@ import { ADDITION, Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
 import { computeBoundsTree } from 'three-mesh-bvh';
 import { applyWorldScaleBoxUVs } from '../../lib/box-uv';
 import { ensureRenderableGeometryAttributes, subtractCsgBrush } from '../../lib/csg-utils';
+import { isRevealAssembling } from '../construction-reveal/construction-reveal';
 function csgGeometry(brush) {
     return brush.geometry;
 }
@@ -20,7 +21,7 @@ csgEvaluator.attributes = ['position', 'normal', 'uv', 'uv2'];
 function computeGeometryBoundsTree(geometry) {
     ;
     geometry.computeBoundsTree = computeBoundsTree;
-    geometry.computeBoundsTree({ maxLeafSize: 10 });
+    geometry.computeBoundsTree({ targetLeafSize: 10 });
 }
 function prepareBrushForCSG(brush) {
     ensureRenderableGeometryAttributes(brush.geometry);
@@ -108,11 +109,60 @@ function createDegenerateRoofPlaceholder() {
 }
 // Pending merged-roof updates carried across frames (for throttling)
 const pendingRoofUpdates = new Set();
+const pendingIndependentSegments = new Set();
 const previousRoofPlanBounds = new Map();
 const warnedMergedRoofNaNIds = new Set();
 const MAX_ROOFS_PER_FRAME = 1;
 const MAX_SEGMENTS_PER_FRAME = 3;
-function queueSiblingRoofUpdates(roofId, nodes) {
+/** What each roof's shell was last merged from: its node and its segments, as the store held them. */
+const mergedFrom = new Map();
+function rememberMergedInputs(roof, nodes) {
+    const inputs = new Map();
+    for (const id of [roof.id, ...(roof.children ?? [])]) {
+        const node = nodes[id];
+        if (node)
+            inputs.set(id, node);
+    }
+    mergedFrom.set(roof.id, inputs);
+}
+/** Whether nothing a roof's shell is made of has changed since it was merged. */
+function mergedFromStillHolds(roofId, nodes) {
+    const inputs = mergedFrom.get(roofId);
+    const roof = nodes[roofId];
+    if (!inputs || roof?.type !== 'roof')
+        return false;
+    const ids = [roofId, ...(roof.children ?? [])];
+    return ids.length === inputs.size && ids.every((id) => inputs.get(id) === nodes[id]);
+}
+/**
+ * Roofs whose merged shell is still to build: until it is, the roof shows its segments apart (or
+ * an old shell), and a capture would show that. Only roofs on screen count, a first merge (a
+ * mounted group with no shell yet) included: one never mounted stays queued and would hold every
+ * capture.
+ */
+export function getPendingRoofMergeCount() {
+    return countPendingRoofShells([...pendingRoofUpdates, ...pendingIndependentSegments], (id) => sceneRegistry.nodes.get(id));
+}
+export function countPendingRoofShells(pending, mounted) {
+    let count = 0;
+    for (const id of pending)
+        if (mounted(id))
+            count++;
+    return count;
+}
+function queueSiblingRoofUpdates(roofId, nodes, changedSegmentId) {
+    const queueIndependent = (roof) => {
+        for (const id of roof.children) {
+            const segment = nodes[id];
+            if (segment?.type === 'roof-segment' &&
+                segment.id !== changedSegmentId &&
+                isIndependentRoofSegment(getEffectiveNode(segment)))
+                pendingIndependentSegments.add(segment.id);
+        }
+    };
+    const currentRoof = nodes[roofId];
+    if (currentRoof?.type === 'roof')
+        queueIndependent(currentRoof);
     pendingRoofUpdates.add(roofId);
     const roof = nodes[roofId]?.type === 'roof' ? getEffectiveNode(nodes[roofId]) : undefined;
     if (roof?.type !== 'roof' || !roof.parentId)
@@ -170,13 +220,11 @@ function queueSiblingRoofUpdates(roofId, nodes) {
         if ((currentBounds && roofPlanBoundsOverlap(currentBounds, siblingBounds)) ||
             (oldBounds && roofPlanBoundsOverlap(oldBounds, siblingBounds))) {
             pendingRoofUpdates.add(sibling.id);
+            queueIndependent(sibling);
         }
     }
 }
-// ============================================================================
-// ROOF SYSTEM
-// ============================================================================
-export const RoofSystem = () => {
+export const RoofSystem = ({ geometryAdapter } = {}) => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
     const rootNodeIds = useScene((state) => state.rootNodeIds);
@@ -189,23 +237,30 @@ export const RoofSystem = () => {
         // Clear stale pending updates when the scene is unloaded
         if (rootNodeIds.length === 0) {
             pendingRoofUpdates.clear();
+            pendingIndependentSegments.clear();
             previousRoofPlanBounds.clear();
             warnedMergedRoofNaNIds.clear();
+            mergedFrom.clear();
             for (const cached of mergedRoofSegmentGeometryCache.values()) {
                 disposeCachedMergedRoofSegmentGeometrySet(cached);
             }
             mergedRoofSegmentGeometryCache.clear();
             return;
         }
-        if (dirtyNodes.size === 0 && pendingRoofUpdates.size === 0)
+        if (dirtyNodes.size === 0 &&
+            pendingRoofUpdates.size === 0 &&
+            pendingIndependentSegments.size === 0)
             return;
         const nodes = useScene.getState().nodes;
         // --- Pass 1: Process dirty roof-segments (throttled) ---
         let segmentsProcessed = 0;
-        dirtyNodes.forEach((id) => {
+        new Set([...dirtyNodes, ...pendingIndependentSegments]).forEach((id) => {
+            const independentCascade = pendingIndependentSegments.has(id) && !dirtyNodes.has(id);
             const node = nodes[id];
-            if (!node)
+            if (!node) {
+                pendingIndependentSegments.delete(id);
                 return;
+            }
             // Cutting roof accessories cascade their dirty mark to the host
             // segment's parent roof so the merged shell re-CSGs with the new
             // cut. Non-cutting accessories (vents, panels, gutters, etc.) sit on
@@ -220,6 +275,8 @@ export const RoofSystem = () => {
                 const seg = segId ? nodes[segId] : undefined;
                 if (roofAccessory.buildCut && seg?.parentId) {
                     pendingRoofUpdates.add(seg.parentId);
+                    if (isIndependentRoofSegment(seg))
+                        useScene.getState().markDirty(seg.id);
                 }
                 clearDirty(id);
                 return;
@@ -245,7 +302,7 @@ export const RoofSystem = () => {
                     const revealOnly = mesh.parent?.name === 'segments-wrapper' &&
                         mesh.parent?.parent?.getObjectByName('merged-roof')?.visible === true;
                     if (isVisible && !revealOnly && segmentsProcessed < MAX_SEGMENTS_PER_FRAME) {
-                        updateRoofSegmentGeometry(effectiveSegment, mesh, nodes);
+                        updateRoofSegmentGeometry(effectiveSegment, mesh, nodes, geometryAdapter);
                         segmentsProcessed++;
                     }
                     else if (isVisible && !revealOnly) {
@@ -268,9 +325,12 @@ export const RoofSystem = () => {
                 else {
                     clearDirty(id);
                 }
-                // Queue the parent roof for a merged geometry update
-                if (effectiveSegment.parentId) {
-                    queueSiblingRoofUpdates(effectiveSegment.parentId, nodes);
+                pendingIndependentSegments.delete(id);
+                const parentId = effectiveSegment.parentId;
+                if (parentId &&
+                    !independentCascade &&
+                    !(isRevealAssembling(parentId) && mergedFromStillHolds(parentId, nodes))) {
+                    queueSiblingRoofUpdates(parentId, nodes, id);
                 }
             }
             else if (node.type === 'roof') {
@@ -286,6 +346,7 @@ export const RoofSystem = () => {
             const node = nodes[id];
             if (node?.type !== 'roof') {
                 pendingRoofUpdates.delete(id);
+                mergedFrom.delete(id);
                 continue;
             }
             const group = sceneRegistry.nodes.get(id);
@@ -294,11 +355,11 @@ export const RoofSystem = () => {
             const mergedMesh = group.getObjectByName('merged-roof');
             if (!mergedMesh)
                 continue;
-            if (mergedMesh.visible !== false) {
-                // Only rebuild when visible — RoofEditSystem re-triggers via markDirty on edit mode exit
-                updateMergedRoofGeometry(node, group, nodes);
-                roofsProcessed++;
-            }
+            // Built even while hidden: a roof assembling from its segments (construction
+            // reveal) hides its shell, and must show it whole the moment it is captured.
+            rememberMergedInputs(node, nodes);
+            updateMergedRoofGeometry(node, group, nodes);
+            roofsProcessed++;
             pendingRoofUpdates.delete(id);
         }
     }, 5); // Priority 5: run after all other systems have settled
@@ -307,13 +368,14 @@ export const RoofSystem = () => {
 // ============================================================================
 // GEOMETRY GENERATION
 // ============================================================================
-function updateRoofSegmentGeometry(node, mesh, nodes) {
+function updateRoofSegmentGeometry(node, mesh, nodes, adapter) {
     const newGeo = generateRoofSegmentGeometry(node, nodes);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
     computeGeometryBoundsTree(newGeo);
     mesh.position.set(node.position[0], node.position[1], node.position[2]);
     mesh.rotation.y = node.rotation;
+    adapter?.syncGeometry(node, mesh);
 }
 /**
  * Subtract every hosted accessory cut (`capabilities.roofAccessory.
@@ -400,7 +462,7 @@ function getMergedRoofSegmentBrushes(roofNode, segment, nodes) {
     if (cached?.key === cacheKey) {
         return cloneCachedMergedRoofSegmentBrushes(cached);
     }
-    const brushes = withSegmentUvMatrix(composeSegmentWorldMatrix(roofNode.position, roofNode.rotation ?? 0, segment.position, segment.rotation ?? 0), () => getRoofSegmentBrushes(segment));
+    const brushes = withSegmentUvMatrix(composeSegmentWorldMatrix(roofNode.position, roofNode.rotation ?? 0, segment.position, segment.rotation ?? 0), () => getRoofSegmentBrushes(segment, { fascia: wearsFascia(segment, roofNode) }));
     if (!brushes) {
         disposeCachedMergedRoofSegmentGeometrySet(cached);
         mergedRoofSegmentGeometryCache.delete(segmentId);
@@ -461,7 +523,7 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
         const scn = nodes[id];
         return scn ? getEffectiveNode(scn) : undefined;
     })
-        .filter((n) => n !== undefined && !hasSegmentMaterialOverride(n));
+        .filter((n) => n !== undefined && !hasSegmentMaterialOverride(n) && !isIndependentRoofSegment(n));
     if (children.length === 0) {
         mergedMesh.geometry.dispose();
         // Not BoxGeometry: its 6 groups against the merged mesh's 4-material array
@@ -734,6 +796,8 @@ function getMergedRoofSegmentCacheKey(roofNode, segment, nodes) {
     return JSON.stringify({
         roofPosition: roofNode.position ?? [0, 0, 0],
         roofRotation: roofNode.rotation ?? 0,
+        // a shed's fascia depends on whether its roof is a composite of pieces
+        composite: (roofNode.children?.length ?? 0) > 1,
         segment,
         accessories: getMergedRoofAccessoryCachePayload(segment, nodes),
     });
@@ -819,6 +883,22 @@ const TRIM_CUT_EPSILON = 0.002;
 const ROOF_EDGE_MATERIAL_INDEX = 0;
 const ROOF_INSET_WALL_MATERIAL_INDEX = 2;
 const DUTCH_RAKE_SIDE_MATERIAL_INDEX = 1;
+/**
+ * A lean-to's shed segment (the lean-to assembly writes the side-infill
+ * fields) has no wall band of its own: its high side is the host wall and
+ * its ends are the inset infill panels. Every other shed — a house's
+ * mono-pitch roof, hand-placed or generated — carries the same hollow wall
+ * band a gable does (the high wall and the raked side walls above the
+ * plate), sided in the wall/trim slot like a gable's pediment.
+ */
+function isLeanToShedSegment(node) {
+    return (node.roofType === 'shed' &&
+        (node.shedSideInfillSpan !== undefined ||
+            node.shedSideInfillMinX !== undefined ||
+            node.shedSideInfillMaxX !== undefined ||
+            node.shedFootprintPieces !== undefined ||
+            node.shedOpenEndSides !== undefined));
+}
 const DUTCH_RAKE_TOP_MATERIAL_INDEX = 3;
 const DUTCH_RAKE_SLOPE_SEAT_OFFSET = 0.0002;
 function pushDoubleSidedFace(targetFaces, face) {
@@ -981,7 +1061,12 @@ function buildSegmentTrimCutBrushes(segment) {
         return [];
     }
     const { activeRh } = getSegmentSlopeFrame(segment);
-    const extra = segment.wallThickness + segment.overhang + segment.deckThickness + segment.shingleThickness + 2;
+    const extra = segment.wallThickness +
+        segment.overhang +
+        (segment.gableOverhang ?? 0) +
+        segment.deckThickness +
+        segment.shingleThickness +
+        2;
     const minX = -segment.width / 2 - extra;
     const maxX = segment.width / 2 + extra;
     const minZ = -segment.depth / 2 - extra;
@@ -1075,6 +1160,9 @@ export function clipGeometryBySegmentTrim(geometry, segment) {
             prepareBrushForCSG(brush);
             const next = csgEvaluator.evaluate(brush, cut, SUBTRACTION);
             const trimmed = csgGeometry(next).clone();
+            const materialIndices = new Map(dummyMats.map((material, index) => [material, index]));
+            for (const group of trimmed.groups)
+                group.materialIndex = mapRoofGroupMaterialIndex(group.materialIndex, csgMaterials(next), materialIndices);
             currentGeometry.dispose();
             next.geometry.dispose();
             ensureRenderableGeometryAttributes(trimmed);
@@ -1093,8 +1181,124 @@ export function clipGeometryBySegmentTrim(geometry, segment) {
  * Generate complete hollow-shell geometry for a roof segment.
  * Ports the prototype's CSG approach using three-bvh-csg.
  */
-export function getRoofSegmentBrushes(node) {
-    const { roofType, width, depth, wallHeight, wallThickness, deckThickness, overhang, shingleThickness, } = node;
+/** A 1x8 fascia / rake board: actual 3/4 × 7-1/4 in. */
+const FASCIA_BOARD = { thickness: 0.019, height: 0.184 };
+/** A board's back sits this far inside the deck edge, so the union is one solid with no coplanar faces. */
+const FASCIA_EMBED = 0.002;
+/**
+ * Slot 2 takes the trim finish like the rake faces, and the shell remap
+ * leaves it alone: the remap would send a plumb eave board to the wall band
+ * and its top edge to the shingles.
+ */
+const FASCIA_MATERIAL_INDEX = 2;
+/**
+ * The fascia and rake boards a segment wears, in its own frame: a plumb 1x8
+ * on every eave with its top on the deck's top edge, and one up every gable
+ * or shed rake, from the eave line the deck itself is built on. Being part
+ * of the segment, they follow its pitch, size, overhang and type, and the
+ * trims, cuts and sibling roofs clip them like the deck. Gable, hip, shed
+ * and flat; null for the other forms.
+ */
+function buildFasciaBoards(node, reach, eaveTopY, tanTheta) {
+    const { roofType, width, depth } = node;
+    const bt = node.fasciaDepth ?? FASCIA_BOARD.thickness;
+    const bh = node.fasciaHeight ?? FASCIA_BOARD.height;
+    // A flat roof's boards sized on purpose reach its top, over the membrane's edge: a coping band.
+    const flatTopY = node.fasciaHeight !== undefined ? eaveTopY + node.shingleThickness : eaveTopY;
+    const out = bt / 2 - FASCIA_EMBED;
+    const halfD = depth / 2 + reach.z;
+    const zE = halfD + out;
+    const xE = width / 2 + reach.x + out;
+    // the eave boards run through the corners to the rake / side boards'
+    // outer faces (a lapped return, no notch at the corner)
+    const xL = xE + bt / 2;
+    const faces = [];
+    const board = (a, b, across) => {
+        const ax = (across[0] * bt) / 2;
+        const az = (across[1] * bt) / 2;
+        const p = [
+            [a[0] - ax, a[1] - bh, a[2] - az],
+            [b[0] - ax, b[1] - bh, b[2] - az],
+            [b[0] + ax, b[1] - bh, b[2] + az],
+            [a[0] + ax, a[1] - bh, a[2] + az],
+            [a[0] - ax, a[1], a[2] - az],
+            [b[0] - ax, b[1], b[2] - az],
+            [b[0] + ax, b[1], b[2] + az],
+            [a[0] + ax, a[1], a[2] + az],
+        ].map(([x, y, z]) => new THREE.Vector3(x, y, z));
+        const centre = p.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 8);
+        const quads = [
+            [0, 1, 2, 3],
+            [4, 5, 6, 7],
+            [0, 4, 5, 1],
+            [1, 5, 6, 2],
+            [2, 6, 7, 3],
+            [3, 7, 4, 0],
+        ];
+        for (const quad of quads) {
+            const face = quad.map((k) => p[k].clone());
+            const normal = new THREE.Vector3()
+                .subVectors(face[1], face[0])
+                .cross(new THREE.Vector3().subVectors(face[2], face[0]));
+            const faceCentre = face
+                .reduce((sum, v) => sum.add(v), new THREE.Vector3())
+                .multiplyScalar(1 / 4);
+            if (normal.dot(faceCentre.sub(centre)) < 0)
+                face.reverse();
+            faces.push(face);
+        }
+    };
+    if (roofType === 'gable') {
+        const ridgeY = eaveTopY + halfD * tanTheta;
+        board([-xL, eaveTopY, zE], [xL, eaveTopY, zE], [0, 1]);
+        board([-xL, eaveTopY, -zE], [xL, eaveTopY, -zE], [0, 1]);
+        for (const sx of [-1, 1]) {
+            board([sx * xE, eaveTopY, zE], [sx * xE, ridgeY, 0], [1, 0]);
+            board([sx * xE, ridgeY, 0], [sx * xE, eaveTopY, -zE], [1, 0]);
+        }
+    }
+    else if (roofType === 'hip' || roofType === 'flat') {
+        const y = roofType === 'flat' ? flatTopY : eaveTopY;
+        for (const sz of [-1, 1])
+            board([-xL, y, sz * zE], [xL, y, sz * zE], [0, 1]);
+        // the side boards butt the eave boards' backs
+        for (const sx of [-1, 1])
+            board([sx * xE, y, -zE + bt / 2], [sx * xE, y, zE - bt / 2], [1, 0]);
+    }
+    else if (roofType === 'shed') {
+        // the low eave at +z, the slope rising to −z
+        const highY = eaveTopY + 2 * halfD * tanTheta;
+        board([-xL, eaveTopY, zE], [xL, eaveTopY, zE], [0, 1]);
+        if (node.fasciaHighEdge ?? true)
+            board([-xL, highY, -zE], [xL, highY, -zE], [0, 1]);
+        for (const sx of [-1, 1])
+            board([sx * xE, eaveTopY, zE], [sx * xE, highY, -zE], [1, 0]);
+    }
+    else
+        return null;
+    return createGeometryFromFaces(faces, FASCIA_MATERIAL_INDEX);
+}
+/**
+ * Whether a drawn segment wears fascia boards. A lean-to carries its own
+ * trim, and a legacy composite shed roof stacks overlapping shed pieces as
+ * one deck (the same pieces whose wall shells are left out), so boards would
+ * show between them.
+ */
+function wearsFascia(node, parentRoof) {
+    if (node.fascia !== true)
+        return false;
+    if (node.roofType !== 'shed')
+        return true;
+    if (isLeanToShedSegment(node))
+        return false;
+    return !parentRoof || (parentRoof.children?.length ?? 0) <= 1;
+}
+/**
+ * `fascia`: build the segment's fascia boards into its deck. Only the roof
+ * renderer asks; a dormer, a chimney or a sibling's clip takes the bare shell.
+ */
+export function getRoofSegmentBrushes(node, options = {}) {
+    const { roofType, width, depth, wallHeight, wallThickness, deckThickness, shingleThickness } = node;
     const conicalCoverage = getConicalRoofCoverage(node);
     const { activeRh, tanTheta, cosTheta, sinTheta } = getSegmentSlopeFrame(node);
     const shapeRatios = getRoofShapeRatios({
@@ -1110,20 +1314,28 @@ export function getRoofSegmentBrushes(node) {
     // the 2D floorplan and the slope frame (which derives activeRh from the
     // same ratio). A hardcoded 0.25 desyncs the gablet from the parameter.
     const baseI = Math.min(width, depth) * node.dutchHipWidthRatio;
-    const getVol = (wExt, vOffset, baseY, matIndex, isVoid, materialRule) => {
-        const wV = Math.max(0.01, width + 2 * wExt);
+    const plateSeated = wallHeight <= 0;
+    // `xExt`: how far the volume reaches along x, where a gable's rakes are; the eaves' `wExt` else.
+    const getVol = (wExt, vOffset, baseY, matIndex, isVoid, materialRule, onPlate = false, xExt = wExt) => {
+        const wV = Math.max(0.01, width + 2 * xExt);
         const dV = Math.max(0.01, depth + 2 * wExt);
         const autoDrop = wExt * tanTheta;
         // Floor every prism at 5 cm so CSG never sees a degenerate volume — by
         // raising the top, never by sinking the base (the base is the wall top).
         // One floor for all volumes keeps each cutter level with the shell it carves.
-        const whV = Math.max(0.05, wallHeight - autoDrop + vOffset);
+        // A plate-seated roof (wallHeight 0) is the exception for its sloped deck
+        // volumes: their eave hangs below the plate, and raising it lifted the
+        // whole roof off its walls, so their base sinks instead.
+        const eaveY = wallHeight - autoDrop + vOffset;
+        const sinkBase = plateSeated && !onPlate && autoDrop !== 0;
+        const whV = sinkBase ? eaveY : Math.max(0.05, eaveY);
         let rhV = activeRh;
         if (activeRh > 0) {
             rhV = activeRh + autoDrop;
             if (roofType === 'shed')
                 rhV = activeRh + 2 * autoDrop;
         }
+        const safeBaseY = sinkBase ? Math.min(baseY, whV - 0.05) : baseY;
         let structuralI = baseI;
         if (isVoid) {
             structuralI += deckThickness;
@@ -1134,7 +1346,7 @@ export function getRoofSegmentBrushes(node) {
             d: dV,
             wh: whV,
             rh: rhV,
-            baseY,
+            baseY: safeBaseY,
             insets: { dutchI: structuralI },
             baseW: width,
             baseD: depth,
@@ -1146,18 +1358,27 @@ export function getRoofSegmentBrushes(node) {
         }).map((face) => face.map((point) => new THREE.Vector3(point.x, point.y, point.z)));
         return createGeometryFromFaces(faces, materialRule ?? matIndex);
     };
-    const wallGeo = getVol(wallThickness / 2, 0, 0, 0, false);
-    const innerGeo = getVol(-wallThickness / 2, 0, -5, 2, false);
-    const horizontalOverhang = overhang * cosTheta;
-    const deckExt = wallThickness / 2 + horizontalOverhang;
-    const shedRoofSideMaterialRule = roofType === 'shed'
-        ? (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : ROOF_EDGE_MATERIAL_INDEX
+    const wallGeo = getVol(wallThickness / 2, 0, 0, 0, false, undefined, true);
+    const innerGeo = getVol(-wallThickness / 2, 0, -5, 2, false, undefined, true);
+    const reach = getRoofSegmentDeckReach(node);
+    const deckExt = reach.z;
+    // A shed's deck and shingle edges take the wall/trim slot, unless it wears
+    // fascia boards: then they are fascia like a gable's, in the deck slot.
+    const shedEdgesInTrimSlot = roofType === 'shed' && !options.fascia;
+    const shedRoofSideMaterialRule = shedEdgesInTrimSlot
+        ? (normal) => (normal.y > SHINGLE_SURFACE_EPSILON ? 3 : ROOF_EDGE_MATERIAL_INDEX)
         : undefined;
-    const deckTopGeo = getVol(deckExt, verticalRt, 0, 1, false, shedRoofSideMaterialRule);
-    const deckBotGeo = getVol(deckExt, 0, -5, 0, true);
+    const deckTopGeo = getVol(deckExt, verticalRt, 0, 1, false, shedRoofSideMaterialRule, false, reach.x);
+    const deckBotGeo = getVol(deckExt, 0, -5, 0, true, undefined, false, reach.x);
+    // the deck's top edge at its outer plane, as `getVol` puts it
+    const deckEaveDrop = deckExt * tanTheta;
+    const deckEaveTopY = plateSeated && deckEaveDrop > 0
+        ? wallHeight - deckEaveDrop + verticalRt
+        : Math.max(0.05, wallHeight - deckEaveDrop + verticalRt);
+    const fasciaGeo = options.fascia ? buildFasciaBoards(node, reach, deckEaveTopY, tanTheta) : null;
     const stSin = shingleThickness * sinTheta;
     const stCos = shingleThickness * cosTheta;
-    const shinBotW = Math.max(0.01, width + 2 * deckExt);
+    const shinBotW = Math.max(0.01, width + 2 * reach.x);
     const shinBotD = Math.max(0.01, depth + 2 * deckExt);
     const deckDrop = deckExt * tanTheta;
     const shinBotWh = wallHeight - deckDrop + verticalRt;
@@ -1254,7 +1475,7 @@ export function getRoofSegmentBrushes(node) {
     if (roofType === 'dutch' && insetsTop.dutchI !== undefined) {
         rakeBoards = buildDutchRakeBoards(shinTopW, shinTopD, shinTopWh, shinTopRh, insetsTop.dutchI, shapeRatios, node.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake, node.dutchTopRakeThickness ?? ROOF_SHAPE_DEFAULTS.dutchTopRakeThickness);
     }
-    const shedRoofSideMaterialIndex = roofType === 'shed' ? ROOF_EDGE_MATERIAL_INDEX : 1;
+    const shedRoofSideMaterialIndex = shedEdgesInTrimSlot ? ROOF_EDGE_MATERIAL_INDEX : 1;
     const shinBotGeo = createGeometryFromFaces(botFaces, (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : shedRoofSideMaterialIndex);
     const shinTopGeo = createGeometryFromFaces(topFaces, (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : shedRoofSideMaterialIndex);
     if (transZ !== 0) {
@@ -1291,13 +1512,16 @@ export function getRoofSegmentBrushes(node) {
     const deckTopBrush = toBrush(deckTopGeo);
     const deckBotBrush = toBrush(deckBotGeo);
     if (deckBotBrush) {
-        const wV = Math.max(0.01, width + 2 * deckExt);
+        const wV = Math.max(0.01, width + 2 * reach.x);
         const dV = Math.max(0.01, depth + 2 * deckExt);
         deckBotBrush.scale.set(1 + eps / wV, 1, 1 + eps / dV);
         deckBotBrush.updateMatrixWorld();
     }
     const shinTopBrush = toBrush(shinTopGeo);
     const shinBotBrush = toBrush(shinBotGeo);
+    const fasciaBrush = fasciaGeo ? toBrush(fasciaGeo) : null;
+    if (fasciaGeo && !fasciaBrush)
+        fasciaGeo.dispose();
     if (shinBotBrush) {
         const wV = shinBotW;
         const dV = shinBotD;
@@ -1312,8 +1536,15 @@ export function getRoofSegmentBrushes(node) {
     shinBotGeo.dispose();
     if (deckTopBrush && deckBotBrush && wallBrush && innerBrush && shinTopBrush && shinBotBrush) {
         try {
-            const deckSlab = csgEvaluator.evaluate(deckTopBrush, deckBotBrush, SUBTRACTION);
+            let deckSlab = csgEvaluator.evaluate(deckTopBrush, deckBotBrush, SUBTRACTION);
             prepareBrushForCSG(deckSlab);
+            if (fasciaBrush) {
+                const withFascia = csgEvaluator.evaluate(deckSlab, fasciaBrush, ADDITION);
+                prepareBrushForCSG(withFascia);
+                deckSlab.geometry.dispose();
+                fasciaBrush.geometry.dispose();
+                deckSlab = withFascia;
+            }
             const shinSlab = csgEvaluator.evaluate(shinTopBrush, shinBotBrush, SUBTRACTION);
             prepareBrushForCSG(shinSlab);
             deckTopBrush.geometry.dispose();
@@ -1356,16 +1587,94 @@ export function getRoofSegmentBrushes(node) {
         wallBrush.geometry.dispose();
     if (innerBrush)
         innerBrush.geometry.dispose();
+    fasciaBrush?.geometry.dispose();
     rakeBoards?.dispose();
     return null;
 }
+function buildIndependentRoofSegmentGeometry(node, nodes) {
+    if (!isIndependentRoofSegment(node))
+        return null;
+    const pieces = isGlazedRoofSegment(node)
+        ? getGlazedRoofPieces(node)
+        : getBarrelRoofSolidPieces(node);
+    const build = (pieces) => {
+        const parts = pieces.map((piece) => createGeometryFromFaces(getGlazedRoofPieceFaces(piece).map((face) => face.map(({ x, y, z }) => new THREE.Vector3(x, y, z))), piece.slot));
+        const geometry = (parts.length ? mergeGeometries(parts, true) : null) ?? new THREE.BufferGeometry();
+        geometry.groups.forEach((group, index) => {
+            group.materialIndex = parts[index]?.groups[0]?.materialIndex ?? 0;
+        });
+        for (const part of parts)
+            part.dispose();
+        ensureRenderableGeometryAttributes(geometry);
+        return geometry;
+    };
+    let covering = build(pieces.filter((piece) => piece.face.normal[1] > 0));
+    let walls = build(pieces.filter((piece) => piece.face.normal[1] <= 0));
+    const subtract = (geometry, cutter) => {
+        if (!geometry.getAttribute('position')?.count)
+            return geometry;
+        const brush = new Brush(geometry, dummyMats);
+        prepareBrushForCSG(brush);
+        const result = csgEvaluator.evaluate(brush, cutter, SUBTRACTION);
+        const next = result.geometry.clone();
+        const indices = new Map(dummyMats.map((material, index) => [material, index]));
+        for (const group of next.groups)
+            group.materialIndex = mapRoofGroupMaterialIndex(group.materialIndex, csgMaterials(result), indices);
+        result.geometry.dispose();
+        geometry.dispose();
+        return next;
+    };
+    for (const id of node.children ?? []) {
+        const stored = nodes?.[id];
+        if (!stored)
+            continue;
+        const child = getEffectiveNode(stored);
+        if (child.metadata?.isTransient)
+            continue;
+        const capability = nodeRegistry.get(child.type)?.capabilities.roofAccessory;
+        const cutGeometry = capability?.buildCut?.(child, node);
+        if (!cutGeometry)
+            continue;
+        const cutter = new Brush(cutGeometry, dummyMats[0]);
+        try {
+            prepareBrushForCSG(cutter);
+            if (capability?.cutScope !== 'wall')
+                covering = subtract(covering, cutter);
+            walls = subtract(walls, cutter);
+        }
+        finally {
+            cutGeometry.dispose();
+        }
+    }
+    const parts = [covering, walls]
+        .filter((part) => part.getAttribute('position')?.count)
+        .map((part) => (part.index ? part.toNonIndexed() : part.clone()));
+    let geometry = (parts.length ? mergeGeometries(parts, false) : null) ?? new THREE.BufferGeometry();
+    let offset = 0;
+    for (const part of parts) {
+        for (const group of part.groups)
+            geometry.addGroup(offset + group.start, group.count, group.materialIndex);
+        offset += part.getAttribute('position').count;
+        part.dispose();
+    }
+    covering.dispose();
+    walls.dispose();
+    geometry = clipGeometryBySegmentTrim(geometry, node) ?? geometry;
+    ensureRenderableGeometryAttributes(geometry);
+    return geometry;
+}
 export function generateRoofSegmentGeometry(node, nodes) {
     const parentNode = node.parentId ? nodes?.[node.parentId] : undefined;
     const parentRoof = parentNode?.type === 'roof' ? parentNode : undefined;
     const parentRoofPosition = parentRoof?.position;
     const parentRoofRotation = parentRoof?.rotation ?? 0;
     const segmentWorldMatrix = composeSegmentWorldMatrix(parentRoofPosition, parentRoofRotation, node.position, node.rotation ?? 0);
-    const directSegmentGeometry = withSegmentUvMatrix(segmentWorldMatrix, () => buildCustomShedGeometry(node, nodes) ?? buildDirectConicalSectorGeometry(node));
+    const directSegmentGeometry = withSegmentUvMatrix(segmentWorldMatrix, () => {
+        const independent = buildIndependentRoofSegmentGeometry(node, nodes);
+        if (independent)
+            return independent;
+        return buildCustomShedGeometry(node, nodes) ?? buildDirectConicalSectorGeometry(node);
+    });
     if (directSegmentGeometry) {
         let result = addShedInsetEndPanels(directSegmentGeometry, [node], false);
         if (nodes) {
@@ -1375,7 +1684,7 @@ export function generateRoofSegmentGeometry(node, nodes) {
         ensureRenderableGeometryAttributes(result);
         return result;
     }
-    const brushes = withSegmentUvMatrix(segmentWorldMatrix, () => getRoofSegmentBrushes(node));
+    const brushes = withSegmentUvMatrix(segmentWorldMatrix, () => getRoofSegmentBrushes(node, { fascia: wearsFascia(node, parentRoof) }));
     if (!brushes) {
         // Fallback: simple box
         return new THREE.BoxGeometry(node.width, node.wallHeight, node.depth);
@@ -1444,7 +1753,7 @@ export function generateRoofSegmentGeometry(node, nodes) {
     ensureRenderableGeometryAttributes(resultGeo);
     return resultGeo;
 }
-function clipDirectRoofGeometryAgainstSiblings(geometry, node, nodes, space) {
+export function clipDirectRoofGeometryAgainstSiblings(geometry, node, nodes, space) {
     const siblingInterior = buildOccludingRoofInterior(node, nodes, space);
     if (!siblingInterior)
         return geometry;
@@ -2757,7 +3066,9 @@ function buildDutchRakeBoards(W, D, wh, rh, i, shapeRatios, rake, thickness) {
     return merged;
 }
 function createShedInsetEndPanelGeometry(node) {
-    if (node.roofType !== 'shed')
+    // a house shed has real end walls in its wall band; only a lean-to
+    // needs the inset infill panels
+    if (!isLeanToShedSegment(node))
         return null;
     const trim = normalizeRoofSegmentTrim(node);
     const openEndSides = readShedOpenEndSides(node);
@@ -2996,7 +3307,21 @@ function pushRoofUv(uvs, point, normal) {
  * to the true roof surface even on multi-slope roofs (gambrel/mansard/dutch).
  */
 export function getRoofOuterSurfaceFrameAtPoint(segment, lx, lz) {
-    const { roofType, width, depth, wallHeight, wallThickness, deckThickness, overhang, shingleThickness, } = segment;
+    if (isGlazedRoofSegment(segment) || segment.roofType === 'barrel') {
+        const face = (isGlazedRoofSegment(segment) ? getGlazedRoofFaces(segment) : getBarrelRoofFaces(segment)).find((face) => face.normal[1] > 0 &&
+            lx >= face.origin[0] &&
+            lx <= face.origin[0] + face.width &&
+            (lz - face.origin[2]) / face.v[2] >= -1e-6 &&
+            (lz - face.origin[2]) / face.v[2] <= face.length + 1e-6);
+        if (face) {
+            const v = (lz - face.origin[2]) / face.v[2];
+            return {
+                point: new THREE.Vector3(lx, face.origin[1] + face.v[1] * v, lz),
+                normal: new THREE.Vector3(...face.normal),
+            };
+        }
+    }
+    const { roofType, width, depth, wallHeight, deckThickness, shingleThickness } = segment;
     const { activeRh, tanTheta, cosTheta, sinTheta } = getSegmentSlopeFrame(segment);
     if (roofType === 'flat' || activeRh === 0) {
         return {
@@ -3005,11 +3330,11 @@ export function getRoofOuterSurfaceFrameAtPoint(segment, lx, lz) {
         };
     }
     const verticalRt = deckThickness / cosTheta;
-    const horizontalOverhang = overhang * cosTheta;
-    const deckExt = wallThickness / 2 + horizontalOverhang;
+    const reach = getRoofSegmentDeckReach(segment);
+    const deckExt = reach.z;
     const stSin = shingleThickness * sinTheta;
     const stCos = shingleThickness * cosTheta;
-    const shinBotW = Math.max(0.01, width + 2 * deckExt);
+    const shinBotW = Math.max(0.01, width + 2 * reach.x);
     const shinBotD = Math.max(0.01, depth + 2 * deckExt);
     const deckDrop = deckExt * tanTheta;
     const shinBotWh = wallHeight - deckDrop + verticalRt;