@pascal-app/viewer 1.0.0-beta.5 → 1.0.0

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

@@ -1,11 +1,11 @@
-import { getDutchEndSlopeFaces, getDutchRoofShapeMetrics, getEffectiveNode, getRoofModuleFaces, getRoofShapeInsets, getRoofShapeRatios, getSegmentSlopeFrame, hasSegmentMaterialOverride, nodeRegistry, normalizeRoofSegmentTrim, ROOF_SHAPE_DEFAULTS, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+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 { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { mergeGeometries, mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { ADDITION, Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
 import { computeBoundsTree } from 'three-mesh-bvh';
 import { applyWorldScaleBoxUVs } from '../../lib/box-uv';
-import { ensureRenderableGeometryAttributes } from '../../lib/csg-utils';
+import { ensureRenderableGeometryAttributes, subtractCsgBrush } from '../../lib/csg-utils';
 function csgGeometry(brush) {
     return brush.geometry;
 }
@@ -108,9 +108,71 @@ function createDegenerateRoofPlaceholder() {
 }
 // Pending merged-roof updates carried across frames (for throttling)
 const pendingRoofUpdates = 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) {
+    pendingRoofUpdates.add(roofId);
+    const roof = nodes[roofId]?.type === 'roof' ? getEffectiveNode(nodes[roofId]) : undefined;
+    if (roof?.type !== 'roof' || !roof.parentId)
+        return;
+    const currentBounds = getRoofPlanBounds({
+        position: roof.position,
+        rotation: roof.rotation,
+        segments: (roof.children ?? []).flatMap((id) => {
+            const segment = nodes[id];
+            if (segment?.type !== 'roof-segment')
+                return [];
+            const effective = getEffectiveNode(segment);
+            return [
+                {
+                    position: effective.position,
+                    rotation: effective.rotation,
+                    width: effective.width,
+                    depth: effective.depth,
+                },
+            ];
+        }),
+    });
+    const oldBounds = previousRoofPlanBounds.get(roofId);
+    if (currentBounds)
+        previousRoofPlanBounds.set(roofId, currentBounds);
+    const parent = nodes[roof.parentId];
+    if (!parent || !('children' in parent) || !Array.isArray(parent.children))
+        return;
+    for (const siblingId of parent.children) {
+        const sibling = nodes[siblingId];
+        if (sibling?.type !== 'roof' || sibling.id === roofId)
+            continue;
+        const effectiveSibling = getEffectiveNode(sibling);
+        const siblingBounds = getRoofPlanBounds({
+            position: effectiveSibling.position,
+            rotation: effectiveSibling.rotation,
+            segments: (effectiveSibling.children ?? []).flatMap((id) => {
+                const segment = nodes[id];
+                if (segment?.type !== 'roof-segment')
+                    return [];
+                const effective = getEffectiveNode(segment);
+                return [
+                    {
+                        position: effective.position,
+                        rotation: effective.rotation,
+                        width: effective.width,
+                        depth: effective.depth,
+                    },
+                ];
+            }),
+        });
+        if (!siblingBounds)
+            continue;
+        previousRoofPlanBounds.set(sibling.id, siblingBounds);
+        if ((currentBounds && roofPlanBoundsOverlap(currentBounds, siblingBounds)) ||
+            (oldBounds && roofPlanBoundsOverlap(oldBounds, siblingBounds))) {
+            pendingRoofUpdates.add(sibling.id);
+        }
+    }
+}
 // ============================================================================
 // ROOF SYSTEM
 // ============================================================================
@@ -127,6 +189,7 @@ export const RoofSystem = () => {
         // Clear stale pending updates when the scene is unloaded
         if (rootNodeIds.length === 0) {
             pendingRoofUpdates.clear();
+            previousRoofPlanBounds.clear();
             warnedMergedRoofNaNIds.clear();
             for (const cached of mergedRoofSegmentGeometryCache.values()) {
                 disposeCachedMergedRoofSegmentGeometrySet(cached);
@@ -207,11 +270,11 @@ export const RoofSystem = () => {
                 }
                 // Queue the parent roof for a merged geometry update
                 if (effectiveSegment.parentId) {
-                    pendingRoofUpdates.add(effectiveSegment.parentId);
+                    queueSiblingRoofUpdates(effectiveSegment.parentId, nodes);
                 }
             }
             else if (node.type === 'roof') {
-                pendingRoofUpdates.add(id);
+                queueSiblingRoofUpdates(id, nodes);
                 clearDirty(id);
             }
         });
@@ -408,16 +471,36 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
     }
     let totalShinSlab = null;
     let totalDeckSlab = null;
-    let totalWall = null;
-    let totalInner = null;
+    let totalWallShell = null;
     const rakeBoardGeometries = [];
+    const directSegmentGeometries = [];
+    const csgChildren = [];
     for (const child of children) {
+        const directGeometry = withSegmentUvMatrix(composeSegmentWorldMatrix(roofNode.position, roofNode.rotation ?? 0, child.position, child.rotation ?? 0), () => buildCustomShedGeometry(child, nodes) ?? buildDirectConicalSectorGeometry(child));
+        if (directGeometry) {
+            let withPanels = addShedInsetEndPanels(directGeometry, [child], false);
+            _matrix.compose(_position.set(child.position[0], child.position[1], child.position[2]), _quaternion.setFromAxisAngle(_yAxis, child.rotation), _scale);
+            withPanels.applyMatrix4(_matrix);
+            withPanels = clipDirectRoofGeometryAgainstSiblings(withPanels, child, nodes, 'roof');
+            directSegmentGeometries.push(withPanels);
+            continue;
+        }
+        csgChildren.push(child);
         const brushes = getMergedRoofSegmentBrushes(roofNode, child, nodes);
         if (!brushes)
             continue;
         if (brushes.rakeBoards) {
             rakeBoardGeometries.push(brushes.rakeBoards);
         }
+        const occludingInterior = buildOccludingRoofInterior(child, nodes, 'roof');
+        if (occludingInterior) {
+            const exposedShingles = subtractCsgBrush(brushes.shinSlab, occludingInterior, csgEvaluator);
+            brushes.shinSlab.geometry.dispose();
+            brushes.shinSlab = exposedShingles;
+            const exposedDeck = subtractCsgBrush(brushes.deckSlab, occludingInterior, csgEvaluator);
+            brushes.deckSlab.geometry.dispose();
+            brushes.deckSlab = exposedDeck;
+        }
         if (totalShinSlab) {
             const next = csgEvaluator.evaluate(totalShinSlab, brushes.shinSlab, ADDITION);
             totalShinSlab.geometry.dispose();
@@ -438,34 +521,41 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
         else {
             totalDeckSlab = brushes.deckSlab;
         }
-        if (totalWall) {
-            const next = csgEvaluator.evaluate(totalWall, brushes.wallBrush, ADDITION);
-            totalWall.geometry.dispose();
+        if (!shouldIncludeRoofSegmentWallShell(child, roofNode)) {
             brushes.wallBrush.geometry.dispose();
-            prepareBrushForCSG(next);
-            totalWall = next;
-        }
-        else {
-            totalWall = brushes.wallBrush;
-        }
-        if (totalInner) {
-            const next = csgEvaluator.evaluate(totalInner, brushes.innerBrush, ADDITION);
-            totalInner.geometry.dispose();
             brushes.innerBrush.geometry.dispose();
-            prepareBrushForCSG(next);
-            totalInner = next;
         }
         else {
-            totalInner = brushes.innerBrush;
+            let wallShell = csgEvaluator.evaluate(brushes.wallBrush, brushes.innerBrush, SUBTRACTION);
+            brushes.wallBrush.geometry.dispose();
+            brushes.innerBrush.geometry.dispose();
+            prepareBrushForCSG(wallShell);
+            if (occludingInterior) {
+                const exposedWall = subtractCsgBrush(wallShell, occludingInterior, csgEvaluator);
+                wallShell.geometry.dispose();
+                wallShell = exposedWall;
+            }
+            if (totalWallShell) {
+                const next = csgEvaluator.evaluate(totalWallShell, wallShell, ADDITION);
+                totalWallShell.geometry.dispose();
+                wallShell.geometry.dispose();
+                prepareBrushForCSG(next);
+                totalWallShell = next;
+            }
+            else {
+                totalWallShell = wallShell;
+            }
         }
+        occludingInterior?.geometry.dispose();
     }
-    if (totalShinSlab && totalDeckSlab && totalWall && totalInner) {
+    if (totalShinSlab && totalDeckSlab) {
         try {
-            const finalWallTrimmed = csgEvaluator.evaluate(totalWall, totalInner, SUBTRACTION);
-            prepareBrushForCSG(finalWallTrimmed);
             const shinDeck = csgEvaluator.evaluate(totalShinSlab, totalDeckSlab, ADDITION);
             prepareBrushForCSG(shinDeck);
-            const combined = csgEvaluator.evaluate(shinDeck, finalWallTrimmed, ADDITION);
+            let combined = shinDeck;
+            if (totalWallShell) {
+                combined = csgEvaluator.evaluate(shinDeck, totalWallShell, ADDITION);
+            }
             prepareBrushForCSG(combined);
             const resultGeo = csgGeometry(combined);
             if (geometryHasInvalidAttributes(resultGeo)) {
@@ -474,14 +564,15 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
                     warnedMergedRoofNaNIds.add(roofNode.id);
                 }
                 resultGeo.dispose();
-                finalWallTrimmed.geometry.dispose();
-                shinDeck.geometry.dispose();
+                if (combined !== shinDeck)
+                    shinDeck.geometry.dispose();
                 totalShinSlab.geometry.dispose();
                 totalDeckSlab.geometry.dispose();
-                totalWall.geometry.dispose();
-                totalInner.geometry.dispose();
+                totalWallShell?.geometry.dispose();
                 for (const geometry of rakeBoardGeometries)
                     geometry.dispose();
+                for (const geometry of directSegmentGeometries)
+                    geometry.dispose();
                 return;
             }
             const resultMaterials = csgMaterials(combined);
@@ -494,9 +585,10 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
             for (const g of resultGeo.groups) {
                 g.materialIndex = mapRoofGroupMaterialIndex(g.materialIndex, resultMaterials, matToIndex);
             }
-            let finalGeo = resultGeo;
-            if (rakeBoardGeometries.length > 0) {
-                const merged = mergeGeometriesPreservingGroups([finalGeo, ...rakeBoardGeometries]);
+            let finalGeo = addShedInsetEndPanels(resultGeo, csgChildren, true);
+            const appendedGeometries = [...rakeBoardGeometries, ...directSegmentGeometries];
+            if (appendedGeometries.length > 0) {
+                const merged = mergeGeometriesPreservingGroups([finalGeo, ...appendedGeometries]);
                 if (merged) {
                     finalGeo.dispose();
                     finalGeo = merged;
@@ -504,23 +596,40 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
             }
             for (const geometry of rakeBoardGeometries)
                 geometry.dispose();
+            for (const geometry of directSegmentGeometries)
+                geometry.dispose();
+            directSegmentGeometries.length = 0;
             finalGeo.computeVertexNormals();
             ensureRenderableGeometryAttributes(finalGeo);
             mergedMesh.geometry.dispose();
             mergedMesh.geometry = finalGeo;
-            finalWallTrimmed.geometry.dispose();
-            shinDeck.geometry.dispose();
+            if (combined !== shinDeck)
+                shinDeck.geometry.dispose();
         }
         catch (e) {
             console.error('Merged roof CSG failed:', e);
         }
         totalShinSlab.geometry.dispose();
         totalDeckSlab.geometry.dispose();
-        totalWall.geometry.dispose();
-        totalInner.geometry.dispose();
+        totalWallShell?.geometry.dispose();
         for (const geometry of rakeBoardGeometries)
             geometry.dispose();
     }
+    if (directSegmentGeometries.length > 0) {
+        const finalGeo = directSegmentGeometries.length === 1
+            ? directSegmentGeometries[0]
+            : mergeGeometriesPreservingGroups(directSegmentGeometries);
+        if (finalGeo) {
+            finalGeo.computeVertexNormals();
+            ensureRenderableGeometryAttributes(finalGeo);
+            mergedMesh.geometry.dispose();
+            mergedMesh.geometry = finalGeo;
+        }
+        for (const geometry of directSegmentGeometries) {
+            if (geometry !== finalGeo)
+                geometry.dispose();
+        }
+    }
 }
 function geometryHasInvalidAttributes(geometry) {
     const position = geometry.getAttribute('position');
@@ -707,6 +816,8 @@ const SHINGLE_SURFACE_EPSILON = 0.02;
 const RAKE_FACE_NORMAL_EPSILON = 0.3;
 const RAKE_FACE_ALIGNMENT_EPSILON = 0.35;
 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;
 const DUTCH_RAKE_TOP_MATERIAL_INDEX = 3;
 const DUTCH_RAKE_SLOPE_SEAT_OFFSET = 0.0002;
@@ -714,6 +825,41 @@ function pushDoubleSidedFace(targetFaces, face) {
     targetFaces.push(face);
     targetFaces.push(face.map((point) => point.clone()).reverse());
 }
+function readShedFootprintPieces(node) {
+    const value = node.shedFootprintPieces;
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((polygon) => {
+        if (!Array.isArray(polygon))
+            return [];
+        const points = polygon.flatMap((point) => {
+            if (!Array.isArray(point) || point.length < 2)
+                return [];
+            const x = readFiniteNumber(point[0]);
+            const z = readFiniteNumber(point[1]);
+            return x === null || z === null ? [] : [[x, z]];
+        });
+        return points.length >= 3 && points.length === polygon.length ? [points] : [];
+    });
+}
+function readShedOpenEndSides(node) {
+    const value = node.shedOpenEndSides;
+    if (!Array.isArray(value))
+        return new Set();
+    return new Set(value.filter((side) => side === 'left' || side === 'right'));
+}
+function shouldIncludeRoofSegmentWallShell(node, parentRoof) {
+    if (node.wallShell === 'include')
+        return true;
+    if (node.wallShell === 'omit')
+        return false;
+    if (node.roofType !== 'shed')
+        return true;
+    // Older composite roofs use overlapping shed segments as deck pieces. Their
+    // wall volumes were never part of the rendered shell and make CSG grow
+    // exponentially when unioned together.
+    return !parentRoof || (parentRoof.children?.length ?? 0) <= 1;
+}
 function hasSegmentTrim(node) {
     const trim = normalizeRoofSegmentTrim(node);
     return (trim.left > 0 ||
@@ -949,6 +1095,7 @@ export function clipGeometryBySegmentTrim(geometry, segment) {
  */
 export function getRoofSegmentBrushes(node) {
     const { roofType, width, depth, wallHeight, wallThickness, deckThickness, overhang, shingleThickness, } = node;
+    const conicalCoverage = getConicalRoofCoverage(node);
     const { activeRh, tanTheta, cosTheta, sinTheta } = getSegmentSlopeFrame(node);
     const shapeRatios = getRoofShapeRatios({
         gambrelLowerWidthRatio: node.gambrelLowerWidthRatio,
@@ -963,18 +1110,20 @@ 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) => {
+    const getVol = (wExt, vOffset, baseY, matIndex, isVoid, materialRule) => {
         const wV = Math.max(0.01, width + 2 * wExt);
         const dV = Math.max(0.01, depth + 2 * wExt);
         const autoDrop = wExt * tanTheta;
-        const whV = Math.max(0.01, wallHeight - autoDrop + vOffset);
+        // 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);
         let rhV = activeRh;
         if (activeRh > 0) {
             rhV = activeRh + autoDrop;
             if (roofType === 'shed')
                 rhV = activeRh + 2 * autoDrop;
         }
-        const safeBaseY = Math.min(baseY, whV - 0.05);
         let structuralI = baseI;
         if (isVoid) {
             structuralI += deckThickness;
@@ -985,21 +1134,26 @@ export function getRoofSegmentBrushes(node) {
             d: dV,
             wh: whV,
             rh: rhV,
-            baseY: safeBaseY,
+            baseY,
             insets: { dutchI: structuralI },
             baseW: width,
             baseD: depth,
             tanTheta,
             shapeRatios,
             dutchTopRakeThickness: node.dutchTopRakeThickness,
+            conicalStartAngle: conicalCoverage.startAngle,
+            conicalSweepAngle: conicalCoverage.sweepAngle,
         }).map((face) => face.map((point) => new THREE.Vector3(point.x, point.y, point.z)));
-        return createGeometryFromFaces(faces, matIndex);
+        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 deckTopGeo = getVol(deckExt, verticalRt, 0, 1, false);
+    const shedRoofSideMaterialRule = roofType === 'shed'
+        ? (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 stSin = shingleThickness * sinTheta;
     const stCos = shingleThickness * cosTheta;
@@ -1016,7 +1170,7 @@ export function getRoofSegmentBrushes(node) {
     let shinTopW = shinBotW;
     let shinTopD = shinBotD;
     let transZ = 0;
-    if (['hip', 'mansard', 'dutch'].includes(roofType)) {
+    if (['hip', 'mansard', 'dutch', 'conical'].includes(roofType)) {
         shinTopW += 2 * stSin;
         shinTopD += 2 * stSin;
     }
@@ -1077,6 +1231,8 @@ export function getRoofSegmentBrushes(node) {
         tanTheta,
         shapeRatios,
         dutchTopRakeThickness: node.dutchTopRakeThickness,
+        conicalStartAngle: conicalCoverage.startAngle,
+        conicalSweepAngle: conicalCoverage.sweepAngle,
     }).map((face) => face.map((point) => new THREE.Vector3(point.x, point.y, point.z)));
     const topFaces = getRoofModuleFaces({
         type: roofType,
@@ -1091,13 +1247,16 @@ export function getRoofSegmentBrushes(node) {
         tanTheta,
         shapeRatios,
         dutchTopRakeThickness: node.dutchTopRakeThickness,
+        conicalStartAngle: conicalCoverage.startAngle,
+        conicalSweepAngle: conicalCoverage.sweepAngle,
     }).map((face) => face.map((point) => new THREE.Vector3(point.x, point.y, point.z)));
     let rakeBoards = null;
     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 shinBotGeo = createGeometryFromFaces(botFaces, (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : 1);
-    const shinTopGeo = createGeometryFromFaces(topFaces, (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : 1);
+    const shedRoofSideMaterialIndex = roofType === 'shed' ? 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) {
         shinTopGeo.translate(0, 0, transZ);
         rakeBoards?.translate(0, 0, transZ);
@@ -1201,12 +1360,22 @@ export function getRoofSegmentBrushes(node) {
     return null;
 }
 export function generateRoofSegmentGeometry(node, nodes) {
-    const parentRoof = node.parentId ? nodes?.[node.parentId] : undefined;
-    const parentRoofPosition = parentRoof && 'position' in parentRoof ? parentRoof.position : undefined;
-    const parentRoofRotation = parentRoof && 'rotation' in parentRoof
-        ? (parentRoof.rotation ?? 0)
-        : 0;
-    const brushes = withSegmentUvMatrix(composeSegmentWorldMatrix(parentRoofPosition, parentRoofRotation, node.position, node.rotation ?? 0), () => getRoofSegmentBrushes(node));
+    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));
+    if (directSegmentGeometry) {
+        let result = addShedInsetEndPanels(directSegmentGeometry, [node], false);
+        if (nodes) {
+            result = clipDirectRoofGeometryAgainstSiblings(result, node, nodes, 'segment');
+        }
+        result.computeVertexNormals();
+        ensureRenderableGeometryAttributes(result);
+        return result;
+    }
+    const brushes = withSegmentUvMatrix(segmentWorldMatrix, () => getRoofSegmentBrushes(node));
     if (!brushes) {
         // Fallback: simple box
         return new THREE.BoxGeometry(node.width, node.wallHeight, node.depth);
@@ -1217,12 +1386,23 @@ export function generateRoofSegmentGeometry(node, nodes) {
     const { deckSlab, shinSlab, wallBrush, innerBrush, rakeBoards } = brushes;
     let resultGeo = new THREE.BufferGeometry();
     try {
-        const hollowWall = csgEvaluator.evaluate(wallBrush, innerBrush, SUBTRACTION);
-        prepareBrushForCSG(hollowWall);
         const shinDeck = csgEvaluator.evaluate(shinSlab, deckSlab, ADDITION);
         prepareBrushForCSG(shinDeck);
-        const combined = csgEvaluator.evaluate(shinDeck, hollowWall, ADDITION);
+        let combined = shinDeck;
+        let hollowWall = null;
+        if (shouldIncludeRoofSegmentWallShell(node, parentRoof)) {
+            hollowWall = csgEvaluator.evaluate(wallBrush, innerBrush, SUBTRACTION);
+            prepareBrushForCSG(hollowWall);
+            combined = csgEvaluator.evaluate(shinDeck, hollowWall, ADDITION);
+        }
         prepareBrushForCSG(combined);
+        const siblingInterior = nodes ? buildOccludingRoofInterior(node, nodes, 'segment') : null;
+        if (siblingInterior) {
+            const unclipped = combined;
+            combined = subtractCsgBrush(unclipped, siblingInterior, csgEvaluator);
+            unclipped.geometry.dispose();
+            siblingInterior.geometry.dispose();
+        }
         resultGeo = csgGeometry(combined);
         if (geometryHasInvalidAttributes(resultGeo)) {
             resultGeo.dispose();
@@ -1239,8 +1419,10 @@ export function generateRoofSegmentGeometry(node, nodes) {
             group.materialIndex = mapRoofGroupMaterialIndex(group.materialIndex, resultMaterials, matToIndex);
         }
         remapRoofShellFaces(resultGeo, node);
-        hollowWall.geometry.dispose();
-        shinDeck.geometry.dispose();
+        resultGeo = addShedInsetEndPanels(resultGeo, [node], false);
+        hollowWall?.geometry.dispose();
+        if (combined !== shinDeck)
+            shinDeck.geometry.dispose();
     }
     catch (e) {
         console.error('Roof CSG failed:', e);
@@ -1262,6 +1444,124 @@ export function generateRoofSegmentGeometry(node, nodes) {
     ensureRenderableGeometryAttributes(resultGeo);
     return resultGeo;
 }
+function clipDirectRoofGeometryAgainstSiblings(geometry, node, nodes, space) {
+    const siblingInterior = buildOccludingRoofInterior(node, nodes, space);
+    if (!siblingInterior)
+        return geometry;
+    const brush = new Brush(geometry, dummyMats);
+    prepareBrushForCSG(brush);
+    try {
+        const clipped = subtractCsgBrush(brush, siblingInterior, csgEvaluator);
+        const clippedGeometry = csgGeometry(clipped);
+        const clippedMaterials = csgMaterials(clipped);
+        const materialIndices = new Map([
+            [dummyMats[0], 0],
+            [dummyMats[1], 1],
+            [dummyMats[2], 2],
+            [dummyMats[3], 3],
+        ]);
+        for (const group of clippedGeometry.groups) {
+            group.materialIndex = mapRoofGroupMaterialIndex(group.materialIndex, clippedMaterials, materialIndices);
+        }
+        geometry.dispose();
+        clippedGeometry.computeVertexNormals();
+        ensureRenderableGeometryAttributes(clippedGeometry);
+        return clippedGeometry;
+    }
+    catch (error) {
+        console.error('Direct roof intersection CSG failed:', error);
+        return geometry;
+    }
+    finally {
+        siblingInterior.geometry.dispose();
+    }
+}
+function buildOccludingRoofInterior(node, nodes, space) {
+    if (!node.parentId)
+        return null;
+    const parent = nodes[node.parentId];
+    if (parent?.type !== 'roof')
+        return null;
+    const roofEntries = collectSiblingRoofEntries(parent, nodes);
+    const currentEntry = roofEntries.find(({ segment }) => segment.id === node.id);
+    if (!currentEntry)
+        return null;
+    const targetRoofInverse = composeRoofTransform(parent).invert();
+    const targetSegmentInverse = composeSegmentTransform(node).invert();
+    let combinedInterior = null;
+    for (let siblingIndex = 0; siblingIndex < roofEntries.length; siblingIndex++) {
+        const entry = roofEntries[siblingIndex];
+        const sibling = entry.segment;
+        if (sibling.id === node.id)
+            continue;
+        if (sibling.roofType === 'shed')
+            continue;
+        const siblingOwnsOverlap = roofOverlapEntryOwns(roofOverlapEntry(entry.roof, sibling, nodes), roofOverlapEntry(currentEntry.roof, node, nodes));
+        if (!siblingOwnsOverlap)
+            continue;
+        const siblingBrushes = getRoofSegmentBrushes(sibling);
+        if (!siblingBrushes)
+            continue;
+        const siblingInTargetRoof = new THREE.Matrix4()
+            .multiplyMatrices(targetRoofInverse, composeRoofTransform(entry.roof))
+            .multiply(composeSegmentTransform(sibling));
+        const relativeMatrix = space === 'segment'
+            ? new THREE.Matrix4().multiplyMatrices(targetSegmentInverse, siblingInTargetRoof)
+            : siblingInTargetRoof;
+        csgGeometry(siblingBrushes.innerBrush).applyMatrix4(relativeMatrix);
+        siblingBrushes.innerBrush.updateMatrixWorld();
+        siblingBrushes.shinSlab.geometry.dispose();
+        siblingBrushes.deckSlab.geometry.dispose();
+        siblingBrushes.wallBrush.geometry.dispose();
+        siblingBrushes.rakeBoards?.dispose();
+        if (combinedInterior) {
+            const next = csgEvaluator.evaluate(combinedInterior, siblingBrushes.innerBrush, ADDITION);
+            combinedInterior.geometry.dispose();
+            siblingBrushes.innerBrush.geometry.dispose();
+            prepareBrushForCSG(next);
+            combinedInterior = next;
+        }
+        else {
+            combinedInterior = siblingBrushes.innerBrush;
+        }
+    }
+    return combinedInterior;
+}
+function roofOverlapEntry(roof, segment, nodes) {
+    const supportSegment = roof.support?.kind === 'roof' ? nodes[roof.support.roofSegmentId] : undefined;
+    return {
+        roofId: String(roof.id),
+        segmentId: String(segment.id),
+        supportRoofId: supportSegment?.type === 'roof-segment' && supportSegment.parentId
+            ? String(supportSegment.parentId)
+            : undefined,
+        supportRoofSegmentId: roof.support?.kind === 'roof' ? String(roof.support.roofSegmentId) : undefined,
+        roofType: segment.roofType,
+        width: segment.width,
+        depth: segment.depth,
+    };
+}
+function collectSiblingRoofEntries(targetRoof, nodes) {
+    const parent = targetRoof.parentId ? nodes[targetRoof.parentId] : undefined;
+    const orderedRoofIds = parent && 'children' in parent && Array.isArray(parent.children)
+        ? parent.children.filter((id) => nodes[id]?.type === 'roof')
+        : [targetRoof.id];
+    if (!orderedRoofIds.includes(targetRoof.id))
+        orderedRoofIds.push(targetRoof.id);
+    return orderedRoofIds.flatMap((roofId) => {
+        const roof = getEffectiveNode(nodes[roofId]);
+        return (roof.children ?? []).flatMap((segmentId) => {
+            const segment = nodes[segmentId];
+            return segment?.type === 'roof-segment' ? [{ roof, segment: getEffectiveNode(segment) }] : [];
+        });
+    });
+}
+function composeRoofTransform(roof) {
+    return new THREE.Matrix4().compose(new THREE.Vector3(...roof.position), new THREE.Quaternion().setFromAxisAngle(_yAxis, roof.rotation ?? 0), new THREE.Vector3(1, 1, 1));
+}
+function composeSegmentTransform(segment) {
+    return new THREE.Matrix4().compose(new THREE.Vector3(...segment.position), new THREE.Quaternion().setFromAxisAngle(_yAxis, segment.rotation ?? 0), new THREE.Vector3(1, 1, 1));
+}
 function createGeometryFromRawAttributes(positions, normals, uvs, groups) {
     const geometry = new THREE.BufferGeometry();
     geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
@@ -1298,6 +1598,742 @@ function mergeGeometriesPreservingGroups(geometries) {
     }
     return merged;
 }
+// Signed bend reference for a banded segment: the divisor that turns a flat
+// along-width coordinate into an arc angle.
+function bandSignedRef(arc) {
+    return (Math.sign(arc.centerZ) || 1) * arc.radius;
+}
+// Concentric map: rotate a flat segment-local (x, z) about the stored arc center by
+// the angle its along-width coordinate subtends. The back (wall) edge lands at the
+// wall's radius, the front edge at radius ± depth — a thin annular band, never a disc.
+function bendBandPoint(arc, signedRef, x, z) {
+    const phi = (x - arc.centerX) / signedRef;
+    const radial = z - arc.centerZ;
+    return {
+        x: arc.centerX - radial * Math.sin(phi),
+        z: arc.centerZ + radial * Math.cos(phi),
+    };
+}
+// Remap every vertex of a flat segment-local geometry onto the concentric band,
+// keeping Y. Used for the side-infill end panels so they follow the arc ends.
+function applyBandBendToGeometry(geometry, arc) {
+    const position = geometry.getAttribute('position');
+    if (!position)
+        return;
+    const signedRef = bandSignedRef(arc);
+    for (let index = 0; index < position.count; index++) {
+        const bent = bendBandPoint(arc, signedRef, position.getX(index), position.getZ(index));
+        position.setX(index, bent.x);
+        position.setZ(index, bent.z);
+    }
+    position.needsUpdate = true;
+}
+// Faceted annular-band deck for a shed segment bent across its width. The slope runs
+// unchanged along depth (Z); the width axis (X) sweeps the stored concentric arc, so
+// the deck hugs the host wall as a thin band and can never balloon into a disc.
+function buildConcentricBandDeckGeometry(node) {
+    const arc = node.arc;
+    if (!arc)
+        return null;
+    const width = node.width;
+    const halfWidth = width / 2;
+    const halfDepth = node.depth / 2;
+    const signedRef = bandSignedRef(arc);
+    const { cosTheta } = getSegmentSlopeFrame(node);
+    const verticalThickness = node.deckThickness / Math.max(0.1, cosTheta) + node.shingleThickness * cosTheta;
+    const facetCount = Math.max(4, Math.min(32, Math.ceil(width / 0.4)));
+    const bend = (localX, localZ) => {
+        const bent = bendBandPoint(arc, signedRef, localX, localZ);
+        return new THREE.Vector3(bent.x, getRoofSegmentSurfaceY(node, localX, localZ), bent.z);
+    };
+    const backBottom = [];
+    const frontBottom = [];
+    for (let index = 0; index <= facetCount; index++) {
+        const localX = -halfWidth + (index / facetCount) * width;
+        backBottom.push(bend(localX, -halfDepth));
+        frontBottom.push(bend(localX, halfDepth));
+    }
+    const raise = (point) => new THREE.Vector3(point.x, point.y + verticalThickness, point.z);
+    const backTop = backBottom.map(raise);
+    const frontTop = frontBottom.map(raise);
+    const faces = [];
+    for (let index = 0; index < facetCount; index++) {
+        const next = index + 1;
+        // Each angular interval is its own convex quad. A single polygon around
+        // the complete annular boundary is concave, so fan triangulation sends
+        // diagonals through the open center and fills the roof as a solid sector.
+        faces.push([
+            backBottom[index].clone(),
+            backBottom[next].clone(),
+            frontBottom[next].clone(),
+            frontBottom[index].clone(),
+        ], [
+            frontTop[index].clone(),
+            frontTop[next].clone(),
+            backTop[next].clone(),
+            backTop[index].clone(),
+        ], [
+            backBottom[next].clone(),
+            backBottom[index].clone(),
+            backTop[index].clone(),
+            backTop[next].clone(),
+        ], [
+            frontBottom[index].clone(),
+            frontBottom[next].clone(),
+            frontTop[next].clone(),
+            frontTop[index].clone(),
+        ]);
+    }
+    const last = facetCount;
+    faces.push([backBottom[0].clone(), frontBottom[0].clone(), frontTop[0].clone(), backTop[0].clone()], [
+        frontBottom[last].clone(),
+        backBottom[last].clone(),
+        backTop[last].clone(),
+        frontTop[last].clone(),
+    ]);
+    const merged = createGeometryFromFaces(faces, (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : ROOF_EDGE_MATERIAL_INDEX);
+    merged.computeVertexNormals();
+    ensureRenderableGeometryAttributes(merged);
+    return merged;
+}
+function buildDirectConicalSectorGeometry(node) {
+    if (node.roofType !== 'conical' || hasSegmentTrim(node))
+        return null;
+    const coverage = getConicalRoofCoverage(node);
+    if (coverage.fullCircle)
+        return null;
+    const { activeRh, tanTheta, cosTheta, sinTheta } = getSegmentSlopeFrame(node);
+    const deckRadius = node.width / 2 + node.wallThickness / 2 + node.overhang * Math.max(0, cosTheta);
+    const deckDrop = (deckRadius - node.width / 2) * tanTheta;
+    const deckVerticalThickness = node.deckThickness / Math.max(0.1, cosTheta);
+    const shingleRadialThickness = node.shingleThickness * sinTheta;
+    const shingleVerticalThickness = node.shingleThickness * cosTheta;
+    const deckBottom = {
+        radius: deckRadius,
+        eaveY: node.wallHeight - deckDrop,
+        peakY: node.wallHeight + activeRh,
+    };
+    const deckTop = {
+        radius: deckRadius,
+        eaveY: deckBottom.eaveY + deckVerticalThickness,
+        peakY: deckBottom.peakY + deckVerticalThickness,
+    };
+    const shingleTop = {
+        radius: deckRadius + shingleRadialThickness,
+        eaveY: deckTop.eaveY + shingleVerticalThickness,
+        peakY: deckTop.peakY + shingleVerticalThickness + shingleRadialThickness * tanTheta,
+    };
+    const radialSegments = Math.max(1, Math.ceil((48 * Math.abs(coverage.sweepAngle)) / (Math.PI * 2)));
+    const angles = Array.from({ length: radialSegments + 1 }, (_, index) => coverage.startAngle + (index / radialSegments) * coverage.sweepAngle);
+    const ring = (profile) => angles.map((angle) => new THREE.Vector3(Math.cos(angle) * profile.radius, profile.eaveY, Math.sin(angle) * profile.radius));
+    const deckBottomRing = ring(deckBottom);
+    const deckTopRing = ring(deckTop);
+    const shingleTopRing = ring(shingleTop);
+    const deckBottomApex = new THREE.Vector3(0, deckBottom.peakY, 0);
+    const deckTopApex = new THREE.Vector3(0, deckTop.peakY, 0);
+    const shingleTopApex = new THREE.Vector3(0, shingleTop.peakY, 0);
+    const orient = (face, upward) => {
+        const normalY = new THREE.Vector3()
+            .subVectors(face[1], face[0])
+            .cross(new THREE.Vector3().subVectors(face[2], face[0])).y;
+        return normalY >= 0 === upward ? face : [...face].reverse();
+    };
+    const layerFaces = (bottomRing, bottomApex, topRing, topApex) => {
+        const bottomFaces = [];
+        const topFaces = [];
+        const edgeFaces = [];
+        for (let index = 0; index < radialSegments; index += 1) {
+            const next = index + 1;
+            bottomFaces.push(orient([bottomRing[index], bottomRing[next], bottomApex].map((point) => point.clone()), false));
+            topFaces.push(orient([topRing[index], topRing[next], topApex].map((point) => point.clone()), true));
+            edgeFaces.push([
+                bottomRing[index].clone(),
+                bottomRing[next].clone(),
+                topRing[next].clone(),
+                topRing[index].clone(),
+            ]);
+        }
+        const last = radialSegments;
+        edgeFaces.push([bottomApex.clone(), bottomRing[0].clone(), topRing[0].clone(), topApex.clone()], [bottomApex.clone(), topApex.clone(), topRing[last].clone(), bottomRing[last].clone()]);
+        return { bottomFaces, topFaces, edgeFaces };
+    };
+    const deck = layerFaces(deckBottomRing, deckBottomApex, deckTopRing, deckTopApex);
+    const shingles = layerFaces(deckTopRing, deckTopApex, shingleTopRing, shingleTopApex);
+    const geometries = [
+        createGeometryFromFaces([...deck.bottomFaces, ...deck.edgeFaces], ROOF_EDGE_MATERIAL_INDEX),
+        createGeometryFromFaces(shingles.topFaces, 3),
+        createGeometryFromFaces(shingles.edgeFaces, ROOF_EDGE_MATERIAL_INDEX),
+    ];
+    if (node.wallHeight > 0.001) {
+        const outerRadius = node.width / 2 + node.wallThickness / 2;
+        const innerRadius = Math.max(0.005, node.width / 2 - node.wallThickness / 2);
+        const outerBottom = angles.map((angle) => new THREE.Vector3(Math.cos(angle) * outerRadius, 0, Math.sin(angle) * outerRadius));
+        const outerTop = outerBottom.map((point) => new THREE.Vector3(point.x, node.wallHeight, point.z));
+        const innerBottom = angles.map((angle) => new THREE.Vector3(Math.cos(angle) * innerRadius, 0, Math.sin(angle) * innerRadius));
+        const innerTop = innerBottom.map((point) => new THREE.Vector3(point.x, node.wallHeight, point.z));
+        const wallFaces = [];
+        for (let index = 0; index < radialSegments; index += 1) {
+            const next = index + 1;
+            pushDoubleSidedFace(wallFaces, [
+                outerBottom[next],
+                outerBottom[index],
+                outerTop[index],
+                outerTop[next],
+            ]);
+            pushDoubleSidedFace(wallFaces, [
+                innerBottom[index],
+                innerBottom[next],
+                innerTop[next],
+                innerTop[index],
+            ]);
+        }
+        const last = radialSegments;
+        pushDoubleSidedFace(wallFaces, [outerBottom[0], innerBottom[0], innerTop[0], outerTop[0]]);
+        pushDoubleSidedFace(wallFaces, [
+            innerBottom[last],
+            outerBottom[last],
+            outerTop[last],
+            innerTop[last],
+        ]);
+        geometries.push(createGeometryFromFaces(wallFaces, ROOF_EDGE_MATERIAL_INDEX));
+    }
+    const merged = mergeGeometriesPreservingGroups(geometries);
+    for (const geometry of geometries)
+        geometry.dispose();
+    if (!merged)
+        return null;
+    merged.computeVertexNormals();
+    ensureRenderableGeometryAttributes(merged);
+    return merged;
+}
+function clipRoofPolygonAtX(polygon, boundaryX, keepGreater) {
+    const clipped = [];
+    for (let index = 0; index < polygon.length; index++) {
+        const current = polygon[index];
+        const next = polygon[(index + 1) % polygon.length];
+        const currentInside = keepGreater ? current[0] >= boundaryX : current[0] <= boundaryX;
+        const nextInside = keepGreater ? next[0] >= boundaryX : next[0] <= boundaryX;
+        if (currentInside)
+            clipped.push([current[0], current[1]]);
+        if (currentInside === nextInside)
+            continue;
+        const ratio = (boundaryX - current[0]) / (next[0] - current[0]);
+        clipped.push([boundaryX, current[1] + (next[1] - current[1]) * ratio]);
+    }
+    return clipped;
+}
+function sanitizeRoofPlanPolygon(polygon) {
+    const tolerance = 1e-8;
+    const points = polygon.filter((point, index) => {
+        const previous = polygon[(index + polygon.length - 1) % polygon.length];
+        return Math.hypot(point[0] - previous[0], point[1] - previous[1]) > tolerance;
+    });
+    let changed = true;
+    while (changed && points.length >= 3) {
+        changed = false;
+        for (let index = 0; index < points.length; index++) {
+            const previous = points[(index + points.length - 1) % points.length];
+            const point = points[index];
+            const next = points[(index + 1) % points.length];
+            const cross = (point[0] - previous[0]) * (next[1] - point[1]) -
+                (point[1] - previous[1]) * (next[0] - point[0]);
+            if (Math.abs(cross) > tolerance)
+                continue;
+            points.splice(index, 1);
+            changed = true;
+            break;
+        }
+    }
+    return points;
+}
+function facetBandedRoofPieces(pieces, width) {
+    const facetCount = Math.max(4, Math.min(32, Math.ceil(width / 0.4)));
+    const halfWidth = width / 2;
+    const facetWidth = width / facetCount;
+    const faceted = [];
+    for (const piece of pieces) {
+        for (let index = 0; index < facetCount; index++) {
+            const minX = -halfWidth + index * facetWidth;
+            const maxX = index === facetCount - 1 ? halfWidth : minX + facetWidth;
+            const clipped = clipRoofPolygonAtX(clipRoofPolygonAtX(piece, minX, true), maxX, false);
+            const area = clipped.reduce((sum, point, pointIndex) => {
+                const next = clipped[(pointIndex + 1) % clipped.length];
+                return sum + point[0] * next[1] - next[0] * point[1];
+            }, 0);
+            if (clipped.length >= 3 && Math.abs(area) > 1e-8)
+                faceted.push(clipped);
+        }
+    }
+    return faceted;
+}
+function facetBandedRoofBoundary(polygon, width) {
+    const facetCount = Math.max(4, Math.min(32, Math.ceil(width / 0.4)));
+    const halfWidth = width / 2;
+    const facetWidth = width / facetCount;
+    const boundaries = Array.from({ length: facetCount - 1 }, (_, index) => -halfWidth + (index + 1) * facetWidth);
+    const segments = [];
+    for (let index = 0; index < polygon.length; index++) {
+        const start = polygon[index];
+        const end = polygon[(index + 1) % polygon.length];
+        const deltaX = end[0] - start[0];
+        const splits = boundaries
+            .flatMap((boundaryX) => {
+            if (Math.abs(deltaX) <= 1e-8)
+                return [];
+            const ratio = (boundaryX - start[0]) / deltaX;
+            return ratio > 1e-8 && ratio < 1 - 1e-8 ? [ratio] : [];
+        })
+            .sort((left, right) => left - right);
+        const points = [0, ...splits, 1].map((ratio) => [
+            start[0] + (end[0] - start[0]) * ratio,
+            start[1] + (end[1] - start[1]) * ratio,
+        ]);
+        for (let pointIndex = 0; pointIndex + 1 < points.length; pointIndex++) {
+            segments.push([points[pointIndex], points[pointIndex + 1]]);
+        }
+    }
+    return segments;
+}
+function transformShedPlanPoint(node, point) {
+    // `shedFootprintPieces` are persisted in the flat segment frame, while a
+    // curved host's rendered deck is bent onto its annular band below. Keep the
+    // overlap/joint queries in that same rendered frame; otherwise a curved run
+    // can be matched against a neighbour at the opposite end of the wall.
+    const frame = node.shedJointFrame;
+    const bent = node.arc && frame
+        ? bendBandPoint(node.arc, bandSignedRef(node.arc), point[0], point[1])
+        : { x: point[0], z: point[1] };
+    const rotation = node.rotation ?? 0;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const segmentPoint = [
+        (node.position[0] ?? 0) + bent.x * cos + bent.z * sin,
+        (node.position[2] ?? 0) - bent.x * sin + bent.z * cos,
+    ];
+    if (!frame)
+        return segmentPoint;
+    const ownerCos = Math.cos(frame.rotation);
+    const ownerSin = Math.sin(frame.rotation);
+    return [
+        frame.position[0] + segmentPoint[0] * ownerCos + segmentPoint[1] * ownerSin,
+        frame.position[2] - segmentPoint[0] * ownerSin + segmentPoint[1] * ownerCos,
+    ];
+}
+function inverseTransformShedPlanPoint(node, point) {
+    const frame = node.shedJointFrame;
+    let source = point;
+    if (frame) {
+        const ownerCos = Math.cos(frame.rotation);
+        const ownerSin = Math.sin(frame.rotation);
+        const dx = point[0] - frame.position[0];
+        const dz = point[1] - frame.position[2];
+        source = [dx * ownerCos - dz * ownerSin, dx * ownerSin + dz * ownerCos];
+    }
+    const rotation = node.rotation ?? 0;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const dx = source[0] - (node.position[0] ?? 0);
+    const dz = source[1] - (node.position[2] ?? 0);
+    const segmentPoint = [dx * cos - dz * sin, dx * sin + dz * cos];
+    if (!node.arc || !frame)
+        return segmentPoint;
+    const signedRef = bandSignedRef(node.arc);
+    const radialX = segmentPoint[0] - node.arc.centerX;
+    const radialZ = segmentPoint[1] - node.arc.centerZ;
+    const radialSign = -(Math.sign(node.arc.centerZ) || 1);
+    const phi = Math.atan2(-radialX * radialSign, radialZ * radialSign);
+    const radial = Math.hypot(radialX, radialZ) * radialSign;
+    return [node.arc.centerX + phi * signedRef, node.arc.centerZ + radial];
+}
+function pointInOrNearShedPolygon(point, polygon, tolerance) {
+    if (pointInPolygon2D([point[0], point[1]], polygon, { includeBoundary: false }))
+        return true;
+    if (!(tolerance > 0))
+        return false;
+    const toleranceSquared = tolerance * tolerance;
+    for (let index = 0; index < polygon.length; index++) {
+        const start = polygon[index];
+        const end = polygon[(index + 1) % polygon.length];
+        const dx = end[0] - start[0];
+        const dz = end[1] - start[1];
+        const lengthSquared = dx * dx + dz * dz;
+        const ratio = lengthSquared > 1e-12
+            ? Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSquared))
+            : 0;
+        const closestX = start[0] + dx * ratio;
+        const closestZ = start[1] + dz * ratio;
+        const distanceSquared = (point[0] - closestX) * (point[0] - closestX) + (point[1] - closestZ) * (point[1] - closestZ);
+        if (distanceSquared <= toleranceSquared)
+            return true;
+    }
+    return false;
+}
+// Managed shed segments record the ids of their joined owners. Restricting sibling detection
+// to these keeps a shed from mitering against a run it merely passes near in
+// world space (e.g. the two free ends of a J that overlap across its mouth).
+function isJoinedShedSibling(node, candidate) {
+    const neighbors = node.shedJointNeighborIds;
+    if (!neighbors || neighbors.length === 0)
+        return true;
+    return candidate.shedJointOwnerId !== undefined && neighbors.includes(candidate.shedJointOwnerId);
+}
+function shedJoinTolerance(node, sibling) {
+    const sideOverhang = (segment) => {
+        const structuralSpan = readFiniteNumber(segment.shedSideInfillSpan);
+        return structuralSpan === null ? 0 : Math.max(0, (segment.width - structuralSpan) / 2);
+    };
+    return Math.max(0.02, Math.min(0.2, Math.max(node.overhang, sibling.overhang, node.wallThickness, sibling.wallThickness, sideOverhang(node), sideOverhang(sibling))));
+}
+function siblingShedSegments(node, nodes) {
+    return Object.values(nodes).filter((candidate) => candidate.type === 'roof-segment' &&
+        candidate.id !== node.id &&
+        (Boolean(node.parentId && candidate.parentId === node.parentId) ||
+            Boolean(node.shedJointScopeId && candidate.shedJointScopeId === node.shedJointScopeId)) &&
+        candidate.roofType === 'shed' &&
+        isJoinedShedSibling(node, candidate));
+}
+function edgeTouchesSiblingShed(node, start, end, nodes) {
+    if (!nodes)
+        return false;
+    const siblings = siblingShedSegments(node, nodes);
+    if (siblings.length === 0)
+        return false;
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const length = Math.hypot(dx, dz);
+    if (length <= 1e-6)
+        return false;
+    const nx = -dz / length;
+    const nz = dx / length;
+    for (const ratio of [0.25, 0.5, 0.75]) {
+        const x = start[0] + dx * ratio;
+        const z = start[1] + dz * ratio;
+        const world = transformShedPlanPoint(node, [x, z]);
+        const samples = [
+            world,
+            transformShedPlanPoint(node, [x + nx * 1e-4, z + nz * 1e-4]),
+            transformShedPlanPoint(node, [x - nx * 1e-4, z - nz * 1e-4]),
+        ];
+        for (const sample of samples) {
+            if (siblings.some((sibling) => {
+                const local = inverseTransformShedPlanPoint(sibling, sample);
+                const footprints = readShedFootprintPieces(sibling);
+                const polygons = footprints.length > 0
+                    ? footprints
+                    : sibling.managedByParent
+                        ? [managedShedFootprint(sibling)]
+                        : [];
+                return polygons.some((polygon) => pointInOrNearShedPolygon(local, polygon, shedJoinTolerance(node, sibling)));
+            })) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function findSiblingShedAcrossEdge(node, start, end, nodes) {
+    if (!nodes)
+        return undefined;
+    const siblings = siblingShedSegments(node, nodes);
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const length = Math.hypot(dx, dz);
+    if (length <= 1e-6)
+        return undefined;
+    const nx = -dz / length;
+    const nz = dx / length;
+    return siblings.find((sibling) => [0.25, 0.5, 0.75].every((ratio) => {
+        const x = start[0] + dx * ratio;
+        const z = start[1] + dz * ratio;
+        const samples = [
+            transformShedPlanPoint(node, [x, z]),
+            transformShedPlanPoint(node, [x + nx * 1e-4, z + nz * 1e-4]),
+            transformShedPlanPoint(node, [x - nx * 1e-4, z - nz * 1e-4]),
+        ];
+        return samples.some((sample) => {
+            const local = inverseTransformShedPlanPoint(sibling, sample);
+            const footprints = readShedFootprintPieces(sibling);
+            const polygons = footprints.length > 0
+                ? footprints
+                : sibling.managedByParent
+                    ? [managedShedFootprint(sibling)]
+                    : [];
+            return polygons.some((polygon) => pointInOrNearShedPolygon(local, polygon, shedJoinTolerance(node, sibling)));
+        });
+    }));
+}
+function shedWorldYOrigin(node, nodes) {
+    if (node.shedJointFrame)
+        return node.shedJointFrame.position[1] + (node.position[1] ?? 0);
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    return (parent?.type === 'roof' ? (parent.position[1] ?? 0) : 0) + (node.position[1] ?? 0);
+}
+function shedVerticalThickness(node) {
+    const { cosTheta } = getSegmentSlopeFrame(node);
+    return node.deckThickness / Math.max(0.1, cosTheta) + node.shingleThickness * cosTheta;
+}
+function siblingShedTopYInNodeFrame(node, sibling, point, nodes) {
+    const worldPoint = transformShedPlanPoint(node, point);
+    const siblingPoint = inverseTransformShedPlanPoint(sibling, worldPoint);
+    return (shedWorldYOrigin(sibling, nodes) +
+        getRoofSegmentSurfaceY(sibling, siblingPoint[0], siblingPoint[1]) +
+        shedVerticalThickness(sibling) -
+        shedWorldYOrigin(node, nodes));
+}
+function buildShedJointTransitionFaces(node, sibling, start, end, nodes, verticalThickness) {
+    const heights = (point) => {
+        const ownTop = getRoofSegmentSurfaceY(node, point[0], point[1]) + verticalThickness;
+        const siblingTop = siblingShedTopYInNodeFrame(node, sibling, point, nodes);
+        return { ownTop, siblingTop };
+    };
+    const startHeights = heights(start);
+    const endHeights = heights(end);
+    const startDelta = startHeights.siblingTop - startHeights.ownTop;
+    const endDelta = endHeights.siblingTop - endHeights.ownTop;
+    const tolerance = 1e-5;
+    const face = (firstPoint, firstHeights, secondPoint, secondHeights) => {
+        const firstOwn = new THREE.Vector3(firstPoint[0], firstHeights.ownTop, firstPoint[1]);
+        const secondOwn = new THREE.Vector3(secondPoint[0], secondHeights.ownTop, secondPoint[1]);
+        const secondSibling = new THREE.Vector3(secondPoint[0], secondHeights.siblingTop, secondPoint[1]);
+        const firstSibling = new THREE.Vector3(firstPoint[0], firstHeights.siblingTop, firstPoint[1]);
+        if (Math.abs(firstHeights.siblingTop - firstHeights.ownTop) <= tolerance) {
+            return [firstOwn, secondOwn, secondSibling];
+        }
+        if (Math.abs(secondHeights.siblingTop - secondHeights.ownTop) <= tolerance) {
+            return [firstOwn, secondOwn, firstSibling];
+        }
+        return [firstOwn, secondOwn, secondSibling, firstSibling];
+    };
+    // Geometric ownership: a run closes the step only along the stretch where its
+    // own roof top sits BELOW the sibling's (delta > 0), raising a vertical wall up
+    // to the sibling's top. `delta` is antisymmetric between the two runs, so every
+    // point of a seam is owned by exactly one run — the lower one — independent of
+    // run count, chain vs. loop topology, or random node ids. Flush stretches
+    // (|delta| <= tol) have no step and draw nothing, so a reversed/continuous fold
+    // stays open. This replaces the old id-order tiebreak and the "skip when joined
+    // on both ends" rule, which together left every seam of a closed loop unclosed.
+    const faces = [];
+    if (startDelta > tolerance && endDelta > tolerance) {
+        pushDoubleSidedFace(faces, face(start, startHeights, end, endHeights));
+    }
+    else if (startDelta > tolerance || endDelta > tolerance) {
+        const ratio = startDelta / (startDelta - endDelta);
+        const crossingPoint = [
+            start[0] + (end[0] - start[0]) * ratio,
+            start[1] + (end[1] - start[1]) * ratio,
+        ];
+        const crossingHeights = heights(crossingPoint);
+        if (startDelta > tolerance) {
+            pushDoubleSidedFace(faces, face(start, startHeights, crossingPoint, crossingHeights));
+        }
+        else {
+            pushDoubleSidedFace(faces, face(crossingPoint, crossingHeights, end, endHeights));
+        }
+    }
+    return faces;
+}
+function clipShedPolygonByLine(polygon, lineStart, lineEnd, outsidePoint) {
+    const lineDx = lineEnd[0] - lineStart[0];
+    const lineDz = lineEnd[1] - lineStart[1];
+    const outsideSide = Math.sign(lineDx * (outsidePoint[1] - lineStart[1]) - lineDz * (outsidePoint[0] - lineStart[0])) || 1;
+    const side = (point) => outsideSide * (lineDx * (point[1] - lineStart[1]) - lineDz * (point[0] - lineStart[0]));
+    const clipped = [];
+    for (let index = 0; index < polygon.length; index++) {
+        const current = polygon[index];
+        const next = polygon[(index + 1) % polygon.length];
+        const currentSide = side(current);
+        const nextSide = side(next);
+        const currentInside = currentSide <= 1e-7;
+        const nextInside = nextSide <= 1e-7;
+        if (currentInside)
+            clipped.push([current[0], current[1]]);
+        if (currentInside !== nextInside) {
+            const ratio = currentSide / (currentSide - nextSide);
+            clipped.push([
+                current[0] + (next[0] - current[0]) * ratio,
+                current[1] + (next[1] - current[1]) * ratio,
+            ]);
+        }
+    }
+    return clipped;
+}
+function managedShedFootprint(node) {
+    const trim = normalizeRoofSegmentTrim(node);
+    let polygon = [
+        [-node.width / 2 + trim.left, -node.depth / 2 + trim.back],
+        [node.width / 2 - trim.right, -node.depth / 2 + trim.back],
+        [node.width / 2 - trim.right, node.depth / 2 - trim.front],
+        [-node.width / 2 + trim.left, node.depth / 2 - trim.front],
+    ];
+    const diagonalTrims = [
+        {
+            x: trim.frontLeftX,
+            z: trim.frontLeftZ,
+            start: [-node.width / 2 + trim.left + trim.frontLeftX, node.depth / 2 - trim.front],
+            end: [-node.width / 2 + trim.left, node.depth / 2 - trim.front - trim.frontLeftZ],
+            outside: [-node.width / 2 - 1, node.depth / 2 + 1],
+        },
+        {
+            x: trim.frontRightX,
+            z: trim.frontRightZ,
+            start: [node.width / 2 - trim.right, node.depth / 2 - trim.front - trim.frontRightZ],
+            end: [node.width / 2 - trim.right - trim.frontRightX, node.depth / 2 - trim.front],
+            outside: [node.width / 2 + 1, node.depth / 2 + 1],
+        },
+        {
+            x: trim.backLeftX,
+            z: trim.backLeftZ,
+            start: [-node.width / 2 + trim.left, -node.depth / 2 + trim.back + trim.backLeftZ],
+            end: [-node.width / 2 + trim.left + trim.backLeftX, -node.depth / 2 + trim.back],
+            outside: [-node.width / 2 - 1, -node.depth / 2 - 1],
+        },
+        {
+            x: trim.backRightX,
+            z: trim.backRightZ,
+            start: [node.width / 2 - trim.right - trim.backRightX, -node.depth / 2 + trim.back],
+            end: [node.width / 2 - trim.right, -node.depth / 2 + trim.back + trim.backRightZ],
+            outside: [node.width / 2 + 1, -node.depth / 2 - 1],
+        },
+    ];
+    for (const diagonal of diagonalTrims) {
+        if (diagonal.x <= 0 || diagonal.z <= 0 || polygon.length < 3)
+            continue;
+        polygon = clipShedPolygonByLine(polygon, diagonal.start, diagonal.end, diagonal.outside);
+    }
+    return polygon;
+}
+function buildCustomShedGeometry(node, nodes) {
+    if (node.roofType !== 'shed')
+        return null;
+    const storedPieces = readShedFootprintPieces(node);
+    const pieces = storedPieces.length > 0
+        ? storedPieces
+        : node.managedByParent
+            ? [managedShedFootprint(node)]
+            : [];
+    const banded = isBandedShedSegment(node) && node.arc;
+    if (pieces.length === 0)
+        return banded ? buildConcentricBandDeckGeometry(node) : null;
+    const renderPieces = banded
+        ? [...facetBandedRoofPieces(pieces.slice(0, 1), node.width), ...pieces.slice(1)]
+        : pieces;
+    const { cosTheta } = getSegmentSlopeFrame(node);
+    const verticalThickness = node.deckThickness / Math.max(0.1, cosTheta) + node.shingleThickness * cosTheta;
+    const geometries = [];
+    for (const polygon of renderPieces) {
+        const sanitized = sanitizeRoofPlanPolygon(polygon);
+        const signedArea = sanitized.reduce((area, point, index) => {
+            const next = sanitized[(index + 1) % sanitized.length];
+            return area + point[0] * next[1] - next[0] * point[1];
+        }, 0);
+        if (Math.abs(signedArea) <= 1e-9)
+            continue;
+        const outline = signedArea > 0 ? sanitized : [...sanitized].reverse();
+        const edgeSiblings = banded
+            ? outline.map(() => undefined)
+            : outline.map((point, index) => {
+                const next = outline[(index + 1) % outline.length];
+                return edgeTouchesSiblingShed(node, point, next, nodes)
+                    ? findSiblingShedAcrossEdge(node, point, next, nodes)
+                    : undefined;
+            });
+        const topY = outline.map(([x, z]) => getRoofSegmentSurfaceY(node, x, z) + verticalThickness);
+        // A convex curved/straight joint places its triangular infill on the
+        // straight run. Pin that patch's shared edge to the curved surface so the
+        // infill meets both roofs instead of floating above the curved seam.
+        if (!banded && outline.length === 3 && nodes) {
+            for (let index = 0; index < outline.length; index++) {
+                const sibling = edgeSiblings[index];
+                if (!sibling?.arc)
+                    continue;
+                const next = (index + 1) % outline.length;
+                topY[index] = siblingShedTopYInNodeFrame(node, sibling, outline[index], nodes);
+                topY[next] = siblingShedTopYInNodeFrame(node, sibling, outline[next], nodes);
+            }
+        }
+        const bottom = outline.map(([x, z], index) => new THREE.Vector3(x, topY[index] - verticalThickness, z));
+        const triangles = THREE.ShapeUtils.triangulateShape(outline.map(([x, z]) => new THREE.Vector2(x, z)), []);
+        const jointTransitionFaces = [];
+        const faces = triangles.flatMap((triangle) => {
+            const bottomFace = triangle.map((index) => bottom[index].clone());
+            const normalY = new THREE.Vector3()
+                .subVectors(bottomFace[1], bottomFace[0])
+                .cross(new THREE.Vector3().subVectors(bottomFace[2], bottomFace[0])).y;
+            if (normalY > 0)
+                bottomFace.reverse();
+            const topFace = [...bottomFace]
+                .reverse()
+                .map((point) => new THREE.Vector3(point.x, point.y + verticalThickness, point.z));
+            return [bottomFace, topFace];
+        });
+        if (!banded) {
+            for (let index = 0; index < bottom.length; index++) {
+                const next = (index + 1) % bottom.length;
+                const sideFace = [
+                    bottom[next].clone(),
+                    bottom[index].clone(),
+                    new THREE.Vector3(bottom[index].x, bottom[index].y + verticalThickness, bottom[index].z),
+                    new THREE.Vector3(bottom[next].x, bottom[next].y + verticalThickness, bottom[next].z),
+                ];
+                const sibling = edgeSiblings[index];
+                if (!sibling) {
+                    faces.push(sideFace);
+                    continue;
+                }
+                if (nodes && Boolean(node.arc) === Boolean(sibling.arc)) {
+                    jointTransitionFaces.push(...buildShedJointTransitionFaces(node, sibling, outline[index], outline[next], nodes, verticalThickness));
+                }
+            }
+        }
+        geometries.push(createGeometryFromFaces(faces, (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : ROOF_EDGE_MATERIAL_INDEX));
+        if (jointTransitionFaces.length > 0) {
+            geometries.push(createGeometryFromFaces(jointTransitionFaces, 3));
+        }
+    }
+    if (banded) {
+        const boundaryFaces = [];
+        const jointTransitionFaces = [];
+        for (const polygon of unionPolygons(pieces.map((piece) => [...piece]))) {
+            for (const [start, end] of facetBandedRoofBoundary(sanitizeRoofPlanPolygon(polygon), node.width)) {
+                const startBottom = new THREE.Vector3(start[0], getRoofSegmentSurfaceY(node, start[0], start[1]), start[1]);
+                const endBottom = new THREE.Vector3(end[0], getRoofSegmentSurfaceY(node, end[0], end[1]), end[1]);
+                const sibling = edgeTouchesSiblingShed(node, start, end, nodes)
+                    ? findSiblingShedAcrossEdge(node, start, end, nodes)
+                    : undefined;
+                if (sibling && nodes && Boolean(node.arc) === Boolean(sibling.arc)) {
+                    jointTransitionFaces.push(...buildShedJointTransitionFaces(node, sibling, start, end, nodes, verticalThickness));
+                    continue;
+                }
+                if (sibling)
+                    continue;
+                boundaryFaces.push([
+                    endBottom,
+                    startBottom,
+                    new THREE.Vector3(startBottom.x, startBottom.y + verticalThickness, startBottom.z),
+                    new THREE.Vector3(endBottom.x, endBottom.y + verticalThickness, endBottom.z),
+                ]);
+            }
+        }
+        if (boundaryFaces.length > 0) {
+            geometries.push(createGeometryFromFaces(boundaryFaces, ROOF_EDGE_MATERIAL_INDEX));
+        }
+        if (jointTransitionFaces.length > 0) {
+            geometries.push(createGeometryFromFaces(jointTransitionFaces, 3));
+        }
+    }
+    if (geometries.length === 0)
+        return null;
+    const merged = mergeGeometriesPreservingGroups(geometries);
+    for (const geometry of geometries)
+        geometry.dispose();
+    if (!merged)
+        return null;
+    if (banded)
+        applyBandBendToGeometry(merged, banded);
+    merged.computeVertexNormals();
+    ensureRenderableGeometryAttributes(merged);
+    return merged;
+}
 function collectGeometryPlanes(geometry) {
     const source = geometry.index ? geometry.toNonIndexed() : geometry;
     const position = source.getAttribute('position');
@@ -1720,6 +2756,108 @@ function buildDutchRakeBoards(W, D, wh, rh, i, shapeRatios, rake, thickness) {
         geometry.dispose();
     return merged;
 }
+function createShedInsetEndPanelGeometry(node) {
+    if (node.roofType !== 'shed')
+        return null;
+    const trim = normalizeRoofSegmentTrim(node);
+    const openEndSides = readShedOpenEndSides(node);
+    const hasCornerSide = (side) => side < 0
+        ? openEndSides.has('left') ||
+            (trim.frontLeftX > 0 && trim.frontLeftZ > 0) ||
+            (trim.backLeftX > 0 && trim.backLeftZ > 0)
+        : (trim.frontRightX > 0 && trim.frontRightZ > 0) ||
+            (trim.backRightX > 0 && trim.backRightZ > 0) ||
+            openEndSides.has('right');
+    const sideInset = Math.min(Math.max(node.wallThickness, 0.05), node.overhang * 0.5, 0.12);
+    const fallbackPanelHalfWidth = Math.max(0.01, node.width / 2 - sideInset);
+    const sidePanelX = (side) => resolveShedSideInfillX(node, side, fallbackPanelHalfWidth);
+    const { activeRh, tanTheta } = getSegmentSlopeFrame(node);
+    const shapeRatios = getRoofShapeRatios({
+        gambrelLowerWidthRatio: node.gambrelLowerWidthRatio,
+        mansardSteepWidthRatio: node.mansardSteepWidthRatio,
+        dutchHipWidthRatio: node.dutchHipWidthRatio,
+        dutchHipHeightRatio: node.dutchHipHeightRatio,
+        dutchWaistLengthRatio: node.dutchWaistLengthRatio,
+        dutchGabletRake: node.dutchGabletRake,
+    });
+    const wallOuterOffset = node.wallThickness / 2;
+    const autoDrop = wallOuterOffset * tanTheta;
+    const wh = Math.max(0.05, node.wallHeight - autoDrop);
+    const rh = activeRh > 0 ? activeRh + 2 * autoDrop : activeRh;
+    const faces = getRoofModuleFaces({
+        type: 'shed',
+        w: node.width + node.wallThickness,
+        d: node.depth + node.wallThickness,
+        wh,
+        rh,
+        baseY: 0,
+        insets: {},
+        baseW: node.width,
+        baseD: node.depth,
+        tanTheta,
+        shapeRatios,
+        dutchTopRakeThickness: node.dutchTopRakeThickness,
+    }).map((face) => face.map((point) => new THREE.Vector3(point.x, point.y, point.z)));
+    const wallFaces = [];
+    for (const faceIndex of [6, 8]) {
+        const face = faces[faceIndex];
+        if (!face)
+            continue;
+        const faceSide = face.some((point) => point.x < 0) ? -1 : 1;
+        if (hasCornerSide(faceSide))
+            continue;
+        wallFaces.push(face.map((point) => {
+            const side = point.x < 0 ? -1 : 1;
+            return new THREE.Vector3(sidePanelX(side), point.y, point.z);
+        }));
+    }
+    if (wallFaces.length === 0)
+        return null;
+    return createGeometryFromFaces(wallFaces, ROOF_INSET_WALL_MATERIAL_INDEX);
+}
+function resolveShedSideInfillX(node, side, fallbackPanelHalfWidth) {
+    const sideX = readFiniteNumber(side < 0 ? node.shedSideInfillMinX : node.shedSideInfillMaxX);
+    if (sideX !== null)
+        return THREE.MathUtils.clamp(sideX, -node.width / 2, node.width / 2);
+    const span = readFiniteNumber(node.shedSideInfillSpan);
+    if (span !== null && span > 0) {
+        return side * Math.min(span / 2, node.width / 2);
+    }
+    return side * fallbackPanelHalfWidth;
+}
+function readFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function addShedInsetEndPanels(geometry, segments, applySegmentTransform) {
+    const shedSegments = segments.filter((segment) => segment.roofType === 'shed' && segment.shedInsetEndPanels);
+    if (shedSegments.length === 0)
+        return geometry;
+    const panelGeometries = [];
+    for (const segment of shedSegments) {
+        const panel = createShedInsetEndPanelGeometry(segment);
+        if (!panel)
+            continue;
+        // A banded (curved) deck rotates each span end about the arc center; the flat
+        // end panel is at a fixed X, so the bend is a rigid rotation that seats it on
+        // the arc end. Applied before any segment transform so it stays segment-local.
+        if (isBandedShedSegment(segment) && segment.arc)
+            applyBandBendToGeometry(panel, segment.arc);
+        if (applySegmentTransform) {
+            _matrix.compose(_position.set(segment.position[0], segment.position[1], segment.position[2]), _quaternion.setFromAxisAngle(_yAxis, segment.rotation), _scale);
+            panel.applyMatrix4(_matrix);
+        }
+        panelGeometries.push(panel);
+    }
+    if (panelGeometries.length === 0)
+        return geometry;
+    const merged = mergeGeometriesPreservingGroups([geometry, ...panelGeometries]);
+    for (const panel of panelGeometries)
+        panel.dispose();
+    if (!merged)
+        return geometry;
+    geometry.dispose();
+    return merged;
+}
 /**
  * Converts an array of face polygons into a BufferGeometry.
  * Each face is triangulated via fan triangulation.
@@ -1884,7 +3022,7 @@ export function getRoofOuterSurfaceFrameAtPoint(segment, lx, lz) {
     let shinTopW = shinBotW;
     let shinTopD = shinBotD;
     let transZ = 0;
-    if (['hip', 'mansard', 'dutch'].includes(roofType)) {
+    if (['hip', 'mansard', 'dutch', 'conical'].includes(roofType)) {
         shinTopW += 2 * stSin;
         shinTopD += 2 * stSin;
     }
@@ -1906,7 +3044,7 @@ export function getRoofOuterSurfaceFrameAtPoint(segment, lx, lz) {
         let iB = 0;
         let iL = 0;
         let iR = 0;
-        if (roofType === 'hip') {
+        if (roofType === 'hip' || roofType === 'conical') {
             iF = inset;
             iB = inset;
             iL = inset;