@pascal-app/viewer 1.0.1 → 1.0.4

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

@@ -1,5 +1,5 @@
-import { getEffectiveRoofSurfaceMaterial, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveSlotDefaultMaterial, } from '../../lib/materials';
+import { getEffectiveRoofSurfaceMaterial, parseMaterialRef, wallAssemblyFinishRef, } from '@pascal-app/core';
+import { createMaterial, createSurfaceRoleMaterial, resolveMaterialRef, resolveSlotDefaultMaterial, } from '../../lib/materials';
 // Declared catalog defaults for an unpainted roof, per the 4-slot layout
 // (0 wall/trim · 1 deck · 2 interior soffit · 3 shingle top). The wall/trim
 // band mirrors the wall kind's default (WALL_SLOT_DEFAULT = concrete-drywall)
@@ -11,22 +11,59 @@ const ROOF_DEFAULT_REFS = [
     'library:roof-terracottatiles',
 ];
 const roofMaterialArrayCache = new Map();
-function getSurfaceMaterialSignature(spec) {
+function getSurfaceMaterialSignature(spec, sceneMaterials) {
+    const ref = parseMaterialRef(spec.materialPreset);
     return JSON.stringify({
         material: spec.material ?? null,
         materialPreset: spec.materialPreset ?? null,
+        sceneMaterial: ref?.kind === 'scene'
+            ? (sceneMaterials?.[ref.id]?.material ?? null)
+            : null,
     });
 }
-function createResolvedMaterial(material, materialPreset, shading) {
-    if (materialPreset) {
-        return createMaterialFromPresetRef(materialPreset, shading);
-    }
+function createResolvedMaterial(material, materialPreset, sceneMaterials, shading) {
+    // An unknown or dangling ref resolves to nothing: fall through to the
+    // colour, then the slot default, as the segment renderer does.
+    const preset = resolveMaterialRef(materialPreset, sceneMaterials, shading);
+    if (preset)
+        return preset;
     if (material) {
         return createMaterial(material, shading);
     }
     return null;
 }
-export function getRoofMaterialArray(node, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+/**
+ * The cladding the walls under a roof declare through their ASSEMBLIES
+ * (`wall.assembly.exterior.finish` → catalog ref), so the roof's gable band —
+ * the triangle of wall above the plate that the roof kind builds — is skinned
+ * like the walls it sits on instead of the bare drywall default. The most
+ * common ref among the level's walls wins; null when none declares one.
+ */
+export function levelWallCladdingRef(nodes, roof) {
+    const levelId = roof.parentId;
+    if (!levelId)
+        return null;
+    const counts = new Map();
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'wall' || node.parentId !== levelId)
+            continue;
+        const ref = wallAssemblyFinishRef(node);
+        if (ref)
+            counts.set(ref, (counts.get(ref) ?? 0) + 1);
+    }
+    let best = null;
+    let bestCount = 0;
+    for (const [ref, count] of counts) {
+        if (count > bestCount) {
+            best = ref;
+            bestCount = count;
+        }
+    }
+    return best;
+}
+export function getRoofMaterialArray(node, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme, 
+/** Catalog ref for the gable/trim band when unpainted — see `levelWallCladdingRef`. */
+wallCladdingRef = null, sceneMaterials) {
     const top = getEffectiveRoofSurfaceMaterial(node, 'top');
     const edge = getEffectiveRoofSurfaceMaterial(node, 'edge');
     const wall = getEffectiveRoofSurfaceMaterial(node, 'wall');
@@ -35,9 +72,10 @@ export function getRoofMaterialArray(node, shading = 'rendered', textures = true
         textures,
         colorPreset,
         sceneTheme,
-        top: getSurfaceMaterialSignature(top),
-        edge: getSurfaceMaterialSignature(edge),
-        wall: getSurfaceMaterialSignature(wall),
+        wallCladdingRef,
+        top: getSurfaceMaterialSignature(top, sceneMaterials),
+        edge: getSurfaceMaterialSignature(edge, sceneMaterials),
+        wall: getSurfaceMaterialSignature(wall, sceneMaterials),
     });
     const cached = roofMaterialArrayCache.get(cacheKey);
     if (cached)
@@ -63,14 +101,15 @@ export function getRoofMaterialArray(node, shading = 'rendered', textures = true
     // shingle, soft-white deck/soffit, wall-coloured trim). Used both when the
     // roof is unpainted and to fill any individual unpainted slot below.
     const defaultArray = [
-        resolveSlotDefaultMaterial(ROOF_DEFAULT_REFS[0], shading),
+        resolveSlotDefaultMaterial(wallCladdingRef ?? ROOF_DEFAULT_REFS[0], shading),
         resolveSlotDefaultMaterial(ROOF_DEFAULT_REFS[1], shading),
         resolveSlotDefaultMaterial(ROOF_DEFAULT_REFS[2], shading),
         resolveSlotDefaultMaterial(ROOF_DEFAULT_REFS[3], shading),
     ];
-    const topMaterial = createResolvedMaterial(top.material, top.materialPreset, shading);
-    const edgeMaterial = createResolvedMaterial(edge.material, edge.materialPreset, shading);
-    const wallMaterial = createResolvedMaterial(wall.material, wall.materialPreset, shading);
+    const resolve = (spec) => createResolvedMaterial(spec.material, spec.materialPreset, sceneMaterials, shading);
+    const topMaterial = resolve(top);
+    const edgeMaterial = resolve(edge);
+    const wallMaterial = resolve(wall);
     if (!(topMaterial || edgeMaterial || wallMaterial)) {
         roofMaterialArrayCache.set(cacheKey, defaultArray);
         return defaultArray;

package/dist/systems/roof/roof-system.d.ts

@@ -1,6 +1,14 @@
 import { type AnyNode, type RoofSegmentNode } from '@pascal-app/core';
 import * as THREE from 'three';
 import { Brush } from 'three-bvh-csg';
+/**
+ * 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 declare function getPendingRoofMergeCount(): number;
+export declare function countPendingRoofShells(pending: Iterable<string>, mounted: (id: string) => THREE.Object3D | undefined): number;
 export declare const RoofSystem: () => null;
 /**
  * Four dummy materials used as identity placeholders during CSG. Shared
@@ -36,10 +44,12 @@ export declare function mapRoofGroupMaterialIndex(groupMaterialIndex: number | u
  */
 export declare function clipGeometryBySegmentTrim(geometry: THREE.BufferGeometry | null, segment: RoofSegmentNode): THREE.BufferGeometry | null;
 /**
- * Generate complete hollow-shell geometry for a roof segment.
- * Ports the prototype's CSG approach using three-bvh-csg.
+ * `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 declare function getRoofSegmentBrushes(node: RoofSegmentNode): RoofSegmentBrushSet | null;
+export declare function getRoofSegmentBrushes(node: RoofSegmentNode, options?: {
+    fascia?: boolean;
+}): RoofSegmentBrushSet | null;
 export declare function generateRoofSegmentGeometry(node: RoofSegmentNode, nodes?: Record<string, AnyNode>): THREE.BufferGeometry;
 export declare function remapRoofShellFaces(geometry: THREE.BufferGeometry, node: RoofSegmentNode): void;
 export type SurfaceFrame = {

package/dist/systems/roof/roof-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAoBZ,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAkMvE,eAAO,MAAM,UAAU,YAwItB,CAAA;AAgbD;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE;IAC7B,KAAK,CAAC,iBAAiB;IACvB,KAAK,CAAC,iBAAiB;IACvB,KAAK,CAAC,iBAAiB;IACvB,KAAK,CAAC,iBAAiB;CAMxB,CAAA;AAID,eAAO,MAAM,wBAAwB,IAAI,CAAA;AAEzC,KAAK,mBAAmB,GAAG;IACzB,QAAQ,EAAE,KAAK,CAAA;IACf,QAAQ,EAAE,KAAK,CAAA;IACf,SAAS,EAAE,KAAK,CAAA;IAChB,UAAU,EAAE,KAAK,CAAA;IACjB,UAAU,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAAA;CACxC,CAAA;AA0FD,wBAAgB,yBAAyB,CACvC,kBAAkB,EAAE,MAAM,GAAG,SAAS,EACtC,YAAY,EAAE,KAAK,CAAC,QAAQ,EAAE,EAC9B,UAAU,EAAE,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,GACtC,MAAM,CAuBR;AAoWD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,EACrC,OAAO,EAAE,eAAe,GACvB,KAAK,CAAC,cAAc,GAAG,IAAI,CAyB7B;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,mBAAmB,GAAG,IAAI,CA8TvF;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,KAAK,CAAC,cAAc,CA2GtB;AAuyCD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,eAAe,QA0ExF;AA+qBD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAA;IACpB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CACtB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,YAAY,CAqLd"}
+{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAoBZ,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAqIvE;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAIjD;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,EACzB,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,KAAK,CAAC,QAAQ,GAAG,SAAS,GAClD,MAAM,CAIR;AA+DD,eAAO,MAAM,UAAU,YAwItB,CAAA;AAgbD;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE;IAC7B,KAAK,CAAC,iBAAiB;IACvB,KAAK,CAAC,iBAAiB;IACvB,KAAK,CAAC,iBAAiB;IACvB,KAAK,CAAC,iBAAiB;CAMxB,CAAA;AAID,eAAO,MAAM,wBAAwB,IAAI,CAAA;AAEzC,KAAK,mBAAmB,GAAG;IACzB,QAAQ,EAAE,KAAK,CAAA;IACf,QAAQ,EAAE,KAAK,CAAA;IACf,SAAS,EAAE,KAAK,CAAA;IAChB,UAAU,EAAE,KAAK,CAAA;IACjB,UAAU,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAAA;CACxC,CAAA;AA4FD,wBAAgB,yBAAyB,CACvC,kBAAkB,EAAE,MAAM,GAAG,SAAS,EACtC,YAAY,EAAE,KAAK,CAAC,QAAQ,EAAE,EAC9B,UAAU,EAAE,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,GACtC,MAAM,CAuBR;AAuXD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,EACrC,OAAO,EAAE,eAAe,GACvB,KAAK,CAAC,cAAc,GAAG,IAAI,CAyB7B;AAoHD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,EACrB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,mBAAmB,GAAG,IAAI,CAyV5B;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,KAAK,CAAC,cAAc,CA6GtB;AAuyCD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,eAAe,QA0ExF;AAirBD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAA;IACpB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CACtB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,YAAY,CAqLd"}

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

@@ -112,6 +112,22 @@ const previousRoofPlanBounds = new Map();
 const warnedMergedRoofNaNIds = new Set();
 const MAX_ROOFS_PER_FRAME = 1;
 const MAX_SEGMENTS_PER_FRAME = 3;
+/**
+ * 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, (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) {
     pendingRoofUpdates.add(roofId);
     const roof = nodes[roofId]?.type === 'roof' ? getEffectiveNode(nodes[roofId]) : undefined;
@@ -400,7 +416,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);
@@ -734,6 +750,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 +837,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) {
@@ -1093,7 +1127,119 @@ 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) {
+/** 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, deckExt, eaveTopY, tanTheta) {
+    const { roofType, width, depth } = node;
+    const { thickness: bt, height: bh } = FASCIA_BOARD;
+    const out = bt / 2 - FASCIA_EMBED;
+    const halfD = depth / 2 + deckExt;
+    const zE = halfD + out;
+    const xE = width / 2 + deckExt + 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') {
+        for (const sz of [-1, 1])
+            board([-xL, eaveTopY, sz * zE], [xL, eaveTopY, sz * zE], [0, 1]);
+        // the side boards butt the eave boards' backs
+        for (const sx of [-1, 1])
+            board([sx * xE, eaveTopY, -zE + bt / 2], [sx * xE, eaveTopY, 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, overhang, shingleThickness, } = node;
     const conicalCoverage = getConicalRoofCoverage(node);
     const { activeRh, tanTheta, cosTheta, sinTheta } = getSegmentSlopeFrame(node);
@@ -1110,20 +1256,27 @@ 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 plateSeated = wallHeight <= 0;
+    const getVol = (wExt, vOffset, baseY, matIndex, isVoid, materialRule, onPlate = false) => {
         const wV = Math.max(0.01, width + 2 * wExt);
         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 +1287,7 @@ export function getRoofSegmentBrushes(node) {
             d: dV,
             wh: whV,
             rh: rhV,
-            baseY,
+            baseY: safeBaseY,
             insets: { dutchI: structuralI },
             baseW: width,
             baseD: depth,
@@ -1146,15 +1299,24 @@ 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 wallGeo = getVol(wallThickness / 2, 0, 0, 0, false, undefined, true);
+    const innerGeo = getVol(-wallThickness / 2, 0, -5, 2, false, undefined, true);
     const horizontalOverhang = overhang * cosTheta;
     const deckExt = wallThickness / 2 + horizontalOverhang;
-    const shedRoofSideMaterialRule = roofType === 'shed'
-        ? (normal) => normal.y > SHINGLE_SURFACE_EPSILON ? 3 : ROOF_EDGE_MATERIAL_INDEX
+    // 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);
+    // 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, deckExt, deckEaveTopY, tanTheta) : null;
     const stSin = shingleThickness * sinTheta;
     const stCos = shingleThickness * cosTheta;
     const shinBotW = Math.max(0.01, width + 2 * deckExt);
@@ -1254,7 +1416,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) {
@@ -1298,6 +1460,9 @@ export function getRoofSegmentBrushes(node) {
     }
     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 +1477,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,6 +1528,7 @@ export function getRoofSegmentBrushes(node) {
         wallBrush.geometry.dispose();
     if (innerBrush)
         innerBrush.geometry.dispose();
+    fasciaBrush?.geometry.dispose();
     rakeBoards?.dispose();
     return null;
 }
@@ -1375,7 +1548,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);
@@ -2757,7 +2930,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);

package/dist/systems/slab/slab-system.d.ts

@@ -7,5 +7,5 @@ import * as THREE from 'three';
  * a recessed slab is an open shell (pool), everything else a solid occupying
  * `[elevation − thickness, elevation]`.
  */
-export declare function generateSlabGeometry(slabNode: SlabNode, context: SlabPolygonContext): THREE.BufferGeometry;
+export declare function generateSlabGeometry(slabNode: SlabNode, context: SlabPolygonContext, platformBaseAt?: (x: number, z: number) => number): THREE.BufferGeometry;
 //# sourceMappingURL=slab-system.d.ts.map

package/dist/systems/slab/slab-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAExB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAO9B;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,cAAc,CAItB"}
+{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAExB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAO9B;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,EAC3B,cAAc,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAChD,KAAK,CAAC,cAAc,CAItB"}

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

@@ -11,10 +11,29 @@ import { mergeSurfaceHolePolygons } from '../surface-hole-geometry';
  * a recessed slab is an open shell (pool), everything else a solid occupying
  * `[elevation − thickness, elevation]`.
  */
-export function generateSlabGeometry(slabNode, context) {
+export function generateSlabGeometry(slabNode, context, platformBaseAt) {
     return slabNode.recessed
         ? generatePoolGeometry(slabNode, context)
-        : generateSolidSlabGeometry(slabNode, context);
+        : generateSolidSlabGeometry(slabNode, context, platformBaseAt);
+}
+/** Rings below this area (m²) have collapsed: a sliver cap would still grow full-height side walls. */
+const MIN_SLAB_REGION_AREA = 1e-6;
+function signedArea2(polygon) {
+    let area2 = 0;
+    for (let i = 0; i < polygon.length; i++) {
+        const j = (i + 1) % polygon.length;
+        area2 += polygon[i][0] * polygon[j][1] - polygon[j][0] * polygon[i][1];
+    }
+    return area2;
+}
+/**
+ * A renderable polygon collapses when snapping its edges to wall faces or
+ * sibling seams leaves fewer than three points or no area (a threshold strip
+ * inside a wall band). Such a slab builds an empty geometry instead of a sliver;
+ * a hole or cut region that collapses the same way is skipped.
+ */
+function isCollapsedPolygon(polygon) {
+    return polygon.length < 3 || Math.abs(signedArea2(polygon)) / 2 < MIN_SLAB_REGION_AREA;
 }
 // Earcut normalizes cap triangulation regardless of input winding, but the side
 // walls below assume a CCW contour (the unflipped quad's right-hand normal faces
@@ -22,12 +41,7 @@ export function generateSlabGeometry(slabNode, context) {
 // winding, so a CW-drawn slab gets inward-facing walls that FrontSide culls and
 // the slab reads as see-through from the front. Normalize to CCW first.
 function ensureCounterClockwisePolygon(polygon) {
-    let area2 = 0;
-    for (let i = 0; i < polygon.length; i++) {
-        const j = (i + 1) % polygon.length;
-        area2 += polygon[i][0] * polygon[j][1] - polygon[j][0] * polygon[i][1];
-    }
-    return area2 < 0 ? [...polygon].reverse() : polygon;
+    return signedArea2(polygon) < 0 ? [...polygon].reverse() : polygon;
 }
 function isStrictInteriorHole(contour, hole) {
     return (hole.every((point) => pointInPolygon2D(point, contour, { includeBoundary: false })) &&
@@ -42,7 +56,7 @@ function buildSlabRegions(contour, holes) {
     const containedHoles = [];
     const edgeCutouts = [];
     for (const hole of holes) {
-        if (hole.length < 3)
+        if (isCollapsedPolygon(hole))
             continue;
         if (isStrictInteriorHole(contour, hole))
             containedHoles.push(hole);
@@ -68,13 +82,24 @@ function buildSlabRegions(contour, holes) {
  * thickness visible from any angle: the two coincident triangles never z-fight
  * because exactly one faces the camera under FrontSide culling.
  */
-function generateSolidSlabGeometry(slabNode, context) {
+function generateSolidSlabGeometry(slabNode, context, platformBaseAt) {
     const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context));
     const elevation = slabNode.elevation ?? 0.05;
     const thickness = slabNode.thickness ?? 0.05;
     const bottom = elevation - thickness;
+    const bottomAt = (x, z) => platformBaseAt ? Math.min(bottom, platformBaseAt(x, z)) : bottom;
+    const sampleRing = (ring) => !platformBaseAt
+        ? ring
+        : ring.flatMap((a, i) => {
+            const b = ring[(i + 1) % ring.length];
+            const count = Math.max(1, Math.ceil(Math.hypot(b[0] - a[0], b[1] - a[1]) / 0.25));
+            return Array.from({ length: count }, (_, j) => [
+                a[0] + ((b[0] - a[0]) * j) / count,
+                a[1] + ((b[1] - a[1]) * j) / count,
+            ]);
+        });
     const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
-    if (polygon.length < 3)
+    if (isCollapsedPolygon(polygon))
         return new THREE.BufferGeometry();
     const positions = [];
     const uvs = [];
@@ -86,10 +111,10 @@ function generateSolidSlabGeometry(slabNode, context) {
     const addWall = (a, b, flipped) => {
         const base = positions.length / 3;
         const len = Math.max(Math.hypot(b.x - a.x, b.y - a.y), 0.001);
-        positions.push(a.x, bottom, a.y);
-        uvs.push(0, 0);
-        positions.push(b.x, bottom, b.y);
-        uvs.push(len, 0);
+        positions.push(a.x, bottomAt(a.x, a.y), a.y);
+        uvs.push(0, bottomAt(a.x, a.y) - bottom);
+        positions.push(b.x, bottomAt(b.x, b.y), b.y);
+        uvs.push(len, bottomAt(b.x, b.y) - bottom);
         positions.push(b.x, elevation, b.y);
         uvs.push(len, thickness);
         positions.push(a.x, elevation, a.y);
@@ -104,10 +129,12 @@ function generateSolidSlabGeometry(slabNode, context) {
         }
     };
     for (const region of buildSlabRegions(polygon, holePolygons)) {
-        const contour2d = ensureCounterClockwisePolygon(region.contour).map(([x, z]) => new THREE.Vector2(x, z));
+        if (isCollapsedPolygon(region.contour))
+            continue;
+        const contour2d = sampleRing(ensureCounterClockwisePolygon(region.contour)).map(([x, z]) => new THREE.Vector2(x, z));
         const holes2d = region.holes
             .filter((h) => h.length >= 3)
-            .map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
+            .map((h) => sampleRing(h).map(([x, z]) => new THREE.Vector2(x, z)));
         // --- Top & bottom caps ---
         // capPoints order (contour then holes) matches triangulateShape's index space.
         // UVs reproduce ExtrudeGeometry's WorldUVGenerator mapping (shape-space x,-z)
@@ -128,7 +155,8 @@ function generateSolidSlabGeometry(slabNode, context) {
             const [a, b, c] = [tri[0], tri[1], tri[2]];
             // Reversed winding → +Y normal on top; standard winding → -Y on bottom.
             indices.push(topBase + a, topBase + c, topBase + b);
-            indices.push(bottomBase + a, bottomBase + b, bottomBase + c);
+            if (!platformBaseAt)
+                indices.push(bottomBase + a, bottomBase + b, bottomBase + c);
         }
         for (let i = 0; i < contour2d.length; i++) {
             addWall(contour2d[i], contour2d[(i + 1) % contour2d.length], false);
@@ -163,7 +191,7 @@ function generatePoolGeometry(slabNode, context) {
     const floor = slabNode.elevation ?? 0.05;
     const depth = Math.max(0, (slabNode.recessedRimElevation ?? 0) - floor);
     const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
-    if (polygon.length < 3)
+    if (isCollapsedPolygon(polygon))
         return new THREE.BufferGeometry();
     const positions = [];
     const uvs = [];
@@ -179,6 +207,8 @@ function generatePoolGeometry(slabNode, context) {
         uvs.push(u, v);
     };
     for (const region of buildSlabRegions(polygon, holePolygons)) {
+        if (isCollapsedPolygon(region.contour))
+            continue;
         const contour = ensureCounterClockwisePolygon(region.contour);
         const floorBase = positions.length / 3;
         // --- Floor at Y=0 ---

package/dist/systems/stair/stair-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AA2BA,eAAO,MAAM,WAAW,YAuGvB,CAAA"}
+{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AAiCA,eAAO,MAAM,WAAW,YAuGvB,CAAA"}