@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/systems/roof/__fixtures__/roof-plane-cases.js

@@ -0,0 +1,317 @@
+/**
+ * Every roof the hosted Architect plugin's `hip_roof_planes` and `gable_roof_planes` built, each
+ * beside the `roof_segment_add` call that covers it and the roof segment that call writes, so the
+ * two plane tools can retire into it (catalogue slice R). No stored thread called either tool, so
+ * the cases are what their contracts take (both ridge axes, a hip either way and square, the
+ * default, wide, flush and wider-than-the-eaves gable overhangs, a thickness, an eave on the plate,
+ * over it and on posts) and the plugin's own call (a hip at the walls' 2.6 m tops).
+ *
+ * The plane tools took the rectangle of the walls' outside faces, a rise per 12, the overhang past
+ * those faces in metres (a gable's ends their own), a thickness square to the slope (0.29 m by
+ * default) and an eave height that was the roof's SURFACE at the outside wall face. The segment
+ * takes the same rectangle (`rectAt: 'outside'`), the pitch, the overhangs and the thickness in
+ * any unit, and an eave that is the plate it bears on, its default the walls' tops; the walls'
+ * thickness, which it reads from the walls along those faces (6.5 in where none stand, a porch on
+ * posts), puts their centre lines inside the faces.
+ *
+ * A plane call whose roof stood on its walls, or over them, is the same roof as a segment: same
+ * outline, surface, ridge and thickness (`lift` 0).
+ *
+ * Not reproduced, on purpose (no stored call made either, so each is a call a model could make):
+ * - A plane call with its eave at the walls' tops, the plugin's own and the likeliest, sank its roof
+ *   into them: its slab's underside stood `thickness / cos(pitch)` under the plate at the wall face.
+ *   A segment is never sunk under the walls it sits on (`eave_under_walls`); the replacement leaves
+ *   the eave out and the roof sits on them, the same outline, pitch and thickness, its surface
+ *   `lift` higher. Those rows say so.
+ * - Planes over a storey with another over it stood inside that storey; a segment refuses that
+ *   (`into_storey_above`). The hosted table checks the refusal.
+ * - The plane tools answered each plane's id, so one slope could be edited or painted on its own
+ *   (`update_roof_plane`). A segment is one mass whose slopes change together; one slope on its own
+ *   is `create_roof_plane`'s, which stays, and the retired tools' answer says so.
+ *
+ * The viewer runs the segments through the roof geometry against the planes' own geometry
+ * (`roof-plane-cases.test.ts`); the hosted plugin runs each replacement call through
+ * `roof_segment_add` and reads back the segment it wrote.
+ */
+const IN = 0.0254;
+/** The walls' thickness, a 2x6 wall finished: what `roof_segment_add` reads from them. */
+export const ROOF_PLANE_WALL_THICKNESS = 6.5 * IN;
+/** The covering a segment lays over its deck, in the thickness the plane tools took whole. */
+export const ROOF_PLANE_COVERING = 0.02;
+/** The plane tools' defaults. */
+const PLANE_OVERHANG = 0.457;
+const PLANE_GABLE_OVERHANG = 0.305;
+const PLANE_THICKNESS = 0.29;
+const slopeOf = (pitch) => Math.atan(pitch / 12);
+/** Where a plane call put the roof's surface at the wall face for a roof bearing on `plate`. */
+function surfaceOnPlate(plate, pitch, thickness = PLANE_THICKNESS) {
+    const slope = slopeOf(pitch);
+    return plate - (ROOF_PLANE_WALL_THICKNESS / 2) * Math.tan(slope) + thickness / Math.cos(slope);
+}
+/** The plate under a plane call's surface: what `eaveHeight` is to a segment. */
+function plateUnder(call) {
+    const slope = slopeOf(call.pitch);
+    return (call.eaveHeight +
+        (ROOF_PLANE_WALL_THICKNESS / 2) * Math.tan(slope) -
+        (call.thickness ?? PLANE_THICKNESS) / Math.cos(slope));
+}
+function roofPlaneCase(name, walls, call, replacement) {
+    const [ax, az, bx, bz] = call.rect;
+    const t = ROOF_PLANE_WALL_THICKNESS;
+    const w = Math.abs(bx - ax) - t;
+    const d = Math.abs(bz - az) - t;
+    const axis = replacement.ridgeAxis;
+    const slope = slopeOf(call.pitch);
+    const thickness = call.thickness ?? PLANE_THICKNESS;
+    const under = plateUnder(call);
+    // a segment bears on its walls' tops at the lowest; over them, where the planes put it
+    const eave = walls ? Math.max(under, walls.height) : under;
+    return {
+        name,
+        walls,
+        call,
+        replacement,
+        segment: {
+            roofType: replacement.roofType,
+            name: replacement.name,
+            centre: [(ax + bx) / 2, (az + bz) / 2],
+            width: axis === 'x' ? w : d,
+            depth: axis === 'x' ? d : w,
+            rotation: axis === 'x' ? 0 : -Math.PI / 2,
+            pitch: (slope * 180) / Math.PI,
+            overhang: (call.overhang ?? PLANE_OVERHANG) / Math.cos(slope),
+            ...(call.tool === 'gable_roof_planes'
+                ? { gableOverhang: call.gableOverhang ?? PLANE_GABLE_OVERHANG }
+                : {}),
+            wallThickness: t,
+            deckThickness: thickness - ROOF_PLANE_COVERING,
+            shingleThickness: ROOF_PLANE_COVERING,
+            eave,
+        },
+        lift: eave - under,
+    };
+}
+/** The 12 × 8 m house, walls 2.6 m tall: its outside faces. */
+const WIDE = [-0.08255, -0.08255, 12.08255, 8.08255];
+/** The same house turned: 8 m wide, 12 m deep. */
+const DEEP = [-0.08255, -0.08255, 8.08255, 12.08255];
+/** A 10 m square house. */
+const SQUARE = [-0.08255, -0.08255, 10.08255, 10.08255];
+/** A porch roof on posts, clear of the house, their outside faces. */
+const PORCH = [14, 2, 18, 6];
+const PLATE = 2.6;
+const house = (rect) => ({ rect, height: PLATE });
+export const ROOF_PLANE_CASES = [
+    roofPlaneCase('hip_roof_planes defaults, its surface where a roof on the 2.6 m plate has it', house(WIDE), {
+        tool: 'hip_roof_planes',
+        rect: WIDE,
+        pitch: 6,
+        eaveHeight: surfaceOnPlate(PLATE, 6),
+        name: 'Hip',
+    }, {
+        roofType: 'hip',
+        name: 'Hip',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 6,
+        overhangIn: '0.457 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase("hip_roof_planes at the walls' tops (the plugin's own call): the planes sank into the walls", house(WIDE), { tool: 'hip_roof_planes', rect: WIDE, pitch: 6, eaveHeight: PLATE }, {
+        roofType: 'hip',
+        name: 'Hip',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 6,
+        overhangIn: '0.457 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase('hip_roof_planes deeper than wide (its ridge north-south), 5:12, 0.6 m eaves, 0.2 m thick', house(DEEP), {
+        tool: 'hip_roof_planes',
+        rect: DEEP,
+        pitch: 5,
+        eaveHeight: surfaceOnPlate(PLATE, 5, 0.2),
+        overhang: 0.6,
+        thickness: 0.2,
+        name: 'Main',
+    }, {
+        roofType: 'hip',
+        name: 'Main',
+        rect: DEEP,
+        rectAt: 'outside',
+        ridgeAxis: 'z',
+        pitchTwelfths: 5,
+        overhangIn: '0.6 m',
+        thicknessIn: '0.2 m',
+    }),
+    roofPlaneCase('hip_roof_planes over a square: a pyramid, 8:12, 0.3 m eaves', house(SQUARE), {
+        tool: 'hip_roof_planes',
+        rect: SQUARE,
+        pitch: 8,
+        eaveHeight: surfaceOnPlate(PLATE, 8),
+        overhang: 0.3,
+    }, {
+        roofType: 'hip',
+        name: 'Hip',
+        rect: SQUARE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 8,
+        overhangIn: '0.3 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase('hip_roof_planes flush with the walls (no eaves), 4:12', house(WIDE), {
+        tool: 'hip_roof_planes',
+        rect: WIDE,
+        pitch: 4,
+        eaveHeight: surfaceOnPlate(PLATE, 4),
+        overhang: 0,
+    }, {
+        roofType: 'hip',
+        name: 'Hip',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 4,
+        overhangIn: '0 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase('hip_roof_planes on a plate 0.3 m over the walls: the eave given (floating over them, it stays on their storey)', house(WIDE), {
+        tool: 'hip_roof_planes',
+        rect: WIDE,
+        pitch: 6,
+        eaveHeight: surfaceOnPlate(PLATE + 0.3, 6),
+    }, {
+        roofType: 'hip',
+        name: 'Hip',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 6,
+        overhangIn: '0.457 m',
+        thicknessIn: '0.29 m',
+        eaveHeight: PLATE + 0.3,
+    }),
+    roofPlaneCase('gable_roof_planes defaults, the ridge east-west: 18 in eaves, 12 in at the gable ends', house(WIDE), {
+        tool: 'gable_roof_planes',
+        rect: WIDE,
+        ridgeAxis: 'x',
+        pitch: 6,
+        eaveHeight: surfaceOnPlate(PLATE, 6),
+        name: 'Gable',
+    }, {
+        roofType: 'gable',
+        name: 'Gable',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 6,
+        overhangIn: '0.457 m',
+        gableOverhangIn: '0.305 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase("gable_roof_planes at the walls' tops: the planes sank into the walls", house(WIDE), { tool: 'gable_roof_planes', rect: WIDE, ridgeAxis: 'x', pitch: 6, eaveHeight: PLATE }, {
+        roofType: 'gable',
+        name: 'Gable',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 6,
+        overhangIn: '0.457 m',
+        gableOverhangIn: '0.305 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase('gable_roof_planes, the ridge north-south over the deep house, 8:12', house(DEEP), {
+        tool: 'gable_roof_planes',
+        rect: DEEP,
+        ridgeAxis: 'z',
+        pitch: 8,
+        eaveHeight: surfaceOnPlate(PLATE, 8),
+    }, {
+        roofType: 'gable',
+        name: 'Gable',
+        rect: DEEP,
+        rectAt: 'outside',
+        ridgeAxis: 'z',
+        pitchTwelfths: 8,
+        overhangIn: '0.457 m',
+        gableOverhangIn: '0.305 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase('gable_roof_planes, the ridge north-south across the wide house, 4:12', house(WIDE), {
+        tool: 'gable_roof_planes',
+        rect: WIDE,
+        ridgeAxis: 'z',
+        pitch: 4,
+        eaveHeight: surfaceOnPlate(PLATE, 4),
+    }, {
+        roofType: 'gable',
+        name: 'Gable',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'z',
+        pitchTwelfths: 4,
+        overhangIn: '0.457 m',
+        gableOverhangIn: '0.305 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase('gable_roof_planes with gable ends reaching past the eaves: 0.9 m rakes, 0.3 m eaves, 3:12', house(WIDE), {
+        tool: 'gable_roof_planes',
+        rect: WIDE,
+        ridgeAxis: 'x',
+        pitch: 3,
+        eaveHeight: surfaceOnPlate(PLATE, 3, 0.25),
+        overhang: 0.3,
+        gableOverhang: 0.9,
+        thickness: 0.25,
+    }, {
+        roofType: 'gable',
+        name: 'Gable',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 3,
+        overhangIn: '0.3 m',
+        gableOverhangIn: '0.9 m',
+        thicknessIn: '0.25 m',
+    }),
+    roofPlaneCase('gable_roof_planes with flush gable ends', house(WIDE), {
+        tool: 'gable_roof_planes',
+        rect: WIDE,
+        ridgeAxis: 'x',
+        pitch: 6,
+        eaveHeight: surfaceOnPlate(PLATE, 6),
+        gableOverhang: 0,
+    }, {
+        roofType: 'gable',
+        name: 'Gable',
+        rect: WIDE,
+        rectAt: 'outside',
+        ridgeAxis: 'x',
+        pitchTwelfths: 6,
+        overhangIn: '0.457 m',
+        gableOverhangIn: '0 m',
+        thicknessIn: '0.29 m',
+    }),
+    roofPlaneCase('gable_roof_planes over a porch on posts: its eave on the beam, given', null, {
+        tool: 'gable_roof_planes',
+        rect: PORCH,
+        ridgeAxis: 'z',
+        pitch: 6,
+        eaveHeight: surfaceOnPlate(2.4, 6),
+        name: 'Porch',
+    }, {
+        roofType: 'gable',
+        name: 'Porch',
+        rect: PORCH,
+        rectAt: 'outside',
+        ridgeAxis: 'z',
+        pitchTwelfths: 6,
+        overhangIn: '0.457 m',
+        gableOverhangIn: '0.305 m',
+        thicknessIn: '0.29 m',
+        eaveHeight: 2.4,
+    }),
+];

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

@@ -1,6 +1,20 @@
-import { type RoofNode } from '@pascal-app/core';
+import { type AnyNode, type RoofNode, type SceneMaterial, type SceneMaterialId } from '@pascal-app/core';
 import type * as THREE from 'three';
 import { type ColorPreset, type RenderShading } from '../../lib/materials';
+type SceneMaterials = Record<SceneMaterialId, SceneMaterial> | undefined;
 export type RoofMaterialArray = [THREE.Material, THREE.Material, THREE.Material, THREE.Material];
-export declare function getRoofMaterialArray(node: RoofNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): RoofMaterialArray | null;
+/**
+ * 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 walls are
+ * the roof's level's, or for a roof on a level of its own (a building's roof
+ * level), the storey's directly below. The most common ref among them wins;
+ * null when none declares one.
+ */
+export declare function levelWallCladdingRef(nodes: Readonly<Record<string, AnyNode | undefined>>, roof: Pick<RoofNode, 'parentId'>): string | null;
+export declare function getRoofMaterialArray(node: RoofNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string, 
+/** Catalog ref for the gable/trim band when unpainted — see `levelWallCladdingRef`. */
+wallCladdingRef?: string | null, sceneMaterials?: SceneMaterials): RoofMaterialArray | null;
+export {};
 //# sourceMappingURL=roof-materials.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EACL,KAAK,WAAW,EAIhB,KAAK,aAAa,EAEnB,MAAM,qBAAqB,CAAA;AAa5B,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AA6BhG,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,iBAAiB,GAAG,IAAI,CAsE1B"}
+{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMZ,KAAK,QAAQ,EAEb,KAAK,aAAa,EAClB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EACL,KAAK,WAAW,EAGhB,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAaxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AAqChG;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,EACpD,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,GAC/B,MAAM,GAAG,IAAI,CAyBf;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM;AACnB,uFAAuF;AACvF,eAAe,GAAE,MAAM,GAAG,IAAW,EACrC,cAAc,CAAC,EAAE,cAAc,GAC9B,iBAAiB,GAAG,IAAI,CA4D1B"}

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 { findLevelBelowId, getEffectiveRoofSurfaceMaterial, getLevelElevations, 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,64 @@ 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 walls are
+ * the roof's level's, or for a roof on a level of its own (a building's roof
+ * level), the storey's directly below. The most common ref among them wins;
+ * null when none declares one.
+ */
+export function levelWallCladdingRef(nodes, roof) {
+    const levelId = roof.parentId;
+    if (!levelId)
+        return null;
+    const wallsOn = (id) => Object.values(nodes).filter((node) => node?.type === 'wall' && node.parentId === id);
+    const own = wallsOn(levelId);
+    const walls = own.length
+        ? own
+        : wallsOn(findLevelBelowId(levelId, getLevelElevations(nodes)));
+    const counts = new Map();
+    for (const wall of walls) {
+        const ref = wallAssemblyFinishRef(wall);
+        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 +77,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)
@@ -59,32 +102,22 @@ export function getRoofMaterialArray(node, shading = 'rendered', textures = true
         roofMaterialArrayCache.set(cacheKey, roleArray);
         return roleArray;
     }
-    // Textures-on default appearance: catalog finishes per slot (terracotta
-    // 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(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);
-    if (!(topMaterial || edgeMaterial || wallMaterial)) {
-        roofMaterialArrayCache.set(cacheKey, defaultArray);
-        return defaultArray;
-    }
+    const resolve = (spec) => createResolvedMaterial(spec.material, spec.materialPreset, sceneMaterials, shading);
+    const topMaterial = resolve(top);
+    const edgeMaterial = resolve(edge);
+    const wallMaterial = resolve(wall);
     // Each slot resolves to its own role only, then the declared default — never
     // another role. Cross-role fallback here used to splatter a single painted
     // surface (e.g. the edge) across the shingle and soffit slots. The legacy
     // catch-all still fills every role because `getEffectiveRoofSurfaceMaterial`
     // returns it for top/edge/wall alike.
+    // Resolve an unpainted slot's catalog default lazily: painted roofs must
+    // not load unused finish assets (or make capture readiness depend on them).
     const materialArray = [
-        edgeMaterial ?? defaultArray[0],
-        wallMaterial ?? defaultArray[1],
-        wallMaterial ?? defaultArray[2],
-        topMaterial ?? defaultArray[3],
+        edgeMaterial ?? resolveSlotDefaultMaterial(wallCladdingRef ?? ROOF_DEFAULT_REFS[0], shading),
+        wallMaterial ?? resolveSlotDefaultMaterial(ROOF_DEFAULT_REFS[1], shading),
+        wallMaterial ?? resolveSlotDefaultMaterial(ROOF_DEFAULT_REFS[2], shading),
+        topMaterial ?? resolveSlotDefaultMaterial(ROOF_DEFAULT_REFS[3], shading),
     ];
     roofMaterialArrayCache.set(cacheKey, materialArray);
     return materialArray;

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

@@ -1,7 +1,21 @@
 import { type AnyNode, type RoofSegmentNode } from '@pascal-app/core';
 import * as THREE from 'three';
 import { Brush } from 'three-bvh-csg';
-export declare const RoofSystem: () => null;
+/**
+ * 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;
+/** What a plugin adds to a segment mesh after its geometry is rebuilt. */
+export type RoofGeometryAdapter = {
+    syncGeometry: (node: RoofSegmentNode, mesh: THREE.Mesh) => void;
+};
+export declare const RoofSystem: ({ geometryAdapter }?: {
+    geometryAdapter?: RoofGeometryAdapter;
+}) => null;
 /**
  * Four dummy materials used as identity placeholders during CSG. Shared
  * across every input brush so three-bvh-csg can preserve reference
@@ -36,11 +50,14 @@ 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 clipDirectRoofGeometryAgainstSiblings(geometry: THREE.BufferGeometry, node: RoofSegmentNode, nodes: Record<string, AnyNode>, space: 'roof' | 'segment'): THREE.BufferGeometry;
 export declare function remapRoofShellFaces(geometry: THREE.BufferGeometry, node: RoofSegmentNode): void;
 export type SurfaceFrame = {
     point: THREE.Vector3;

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,EA6BZ,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AA4JvE;;;;;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;AAiFD,0EAA0E;AAC1E,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,CAAC,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,KAAK,IAAI,CAAA;CAChE,CAAA;AAED,eAAO,MAAM,UAAU,yBAAyB;IAAE,eAAe,CAAC,EAAE,mBAAmB,CAAA;CAAE,SA0JxF,CAAA;AAqbD;;;;;;;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;AA4XD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,EACrC,OAAO,EAAE,eAAe,GACvB,KAAK,CAAC,cAAc,GAAG,IAAI,CAgC7B;AAuHD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,EACrB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,mBAAmB,GAAG,IAAI,CA4V5B;AAkFD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,KAAK,CAAC,cAAc,CA8GtB;AAED,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,KAAK,CAAC,cAAc,CAiCtB;AA+vCD,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,CA+Ld"}