@pascal-app/viewer 0.8.0 → 0.9.2

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

@@ -1,8 +1,15 @@
-import { getScaledDimensions, resolveLevelId, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 // ============================================================================
 // ITEM SYSTEM
 // ============================================================================
+/**
+ * Per-frame wall-side offset for items mounted to wall faces. The slab-
+ * elevation lift for floor items lives in the generic
+ * `<FloorElevationSystem>` and runs at priority 1 — it has already
+ * landed `mesh.position.y` by the time this system clears the dirty
+ * mark at priority 2.
+ */
 export const ItemSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
@@ -12,31 +19,35 @@ export const ItemSystem = () => {
         const nodes = useScene.getState().nodes;
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
-            if (!node || node.type !== 'item')
+            if (node?.type !== 'item')
                 return;
             const item = node;
             const mesh = sceneRegistry.nodes.get(id);
             if (!mesh)
                 return;
             if (item.asset.attachTo === 'wall-side') {
-                // Wall-attached item: offset Z by half the parent wall's thickness
-                const parentWall = item.parentId ? nodes[item.parentId] : undefined;
-                if (parentWall && parentWall.type === 'wall') {
-                    const wallThickness = parentWall.thickness ?? 0.1;
+                // Wall-attached item: offset Z by half the host wall's thickness.
+                // Roof-segment wall faces share the convention — the face frame's
+                // z = 0 is the wall mid-plane, so the same push lands the item on
+                // the outer surface.
+                const parent = item.parentId ? nodes[item.parentId] : undefined;
+                const thickness = parent?.type === 'wall'
+                    ? (parent.thickness ?? 0.1)
+                    : parent?.type === 'roof-segment'
+                        ? (parent.wallThickness ?? 0.1)
+                        : undefined;
+                if (thickness !== undefined) {
                     const side = item.side === 'front' ? 1 : -1;
-                    mesh.position.z = (wallThickness / 2) * side;
-                }
-            }
-            else if (!item.asset.attachTo) {
-                // If parented to another item (surface placement), R3F handles positioning via the hierarchy
-                const parentNode = item.parentId ? nodes[item.parentId] : undefined;
-                if (parentNode?.type !== 'item') {
-                    // Floor item: elevate by slab height (using full footprint overlap)
-                    const levelId = resolveLevelId(item, nodes);
-                    const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, item.position, getScaledDimensions(item), item.rotation);
-                    mesh.position.y = slabElevation + item.position[1];
+                    mesh.position.z = (thickness / 2) * side;
                 }
             }
+            // Hold the mark until the model settles (loaded, terminally failed, or
+            // never expected — see ItemRenderer.markSettled). Registration alone
+            // isn't "built": clearing then would let scene-ready fire while GLBs are
+            // still downloading and a bake would export loading placeholders.
+            const settled = mesh.userData.itemModelSettled;
+            if (!settled)
+                return;
             clearDirty(id);
         });
     }, 2);

package/dist/systems/item-light/item-light-system.d.ts

@@ -1,2 +1,2 @@
-export declare function ItemLightSystem(): import("react/jsx-runtime").JSX.Element;
+export declare function ItemLightSystem(): import("react").JSX.Element;
 //# sourceMappingURL=item-light-system.d.ts.map

package/dist/systems/item-light/item-light-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AAwFA,wBAAgB,eAAe,4CA+M9B"}
+{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AAuFA,wBAAgB,eAAe,gCA8N9B"}

package/dist/systems/item-light/item-light-system.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { sceneRegistry, useInteractive, useScene } from '@pascal-app/core';
+import { findLevelAncestorId, sceneRegistry, useInteractive, useScene } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useRef } from 'react';
 import { MathUtils, Vector3 } from 'three';
@@ -42,8 +42,7 @@ function scoreRegistration(reg, nodes, selectedLevelId, levelMode, interactiveSt
     // Normalised distance component (assumes scenes < 200 units)
     const dist = _camPos.distanceTo(_itemPos) / 200;
     // ── Level factor ──────────────────────────────────────────────────────────
-    const node = nodes[nodeId];
-    const itemLevelId = node?.parentId ?? null;
+    const itemLevelId = findLevelAncestorId(nodeId, nodes);
     let levelPenalty = 0;
     if (selectedLevelId) {
         if (itemLevelId !== selectedLevelId) {
@@ -97,7 +96,10 @@ export function ItemLightSystem() {
             }
             scored.sort((a, b) => a.score - b.score);
             // Build the desired assignment (top POOL_SIZE keys)
-            const desired = scored.slice(0, POOL_SIZE).map((s) => s.key);
+            const desired = scored
+                .filter((s) => Number.isFinite(s.score))
+                .slice(0, POOL_SIZE)
+                .map((s) => s.key);
             // Build a map of currently-assigned keys → slot index for hysteresis
             const currentlyAssigned = new Map();
             for (let i = 0; i < POOL_SIZE; i++) {
@@ -181,9 +183,11 @@ export function ItemLightSystem() {
                 continue;
             // Fade-out phase: lerp intensity → 0, then complete the transition
             if (slot.isFadingOut) {
+                light.visible = true;
                 light.intensity = MathUtils.lerp(light.intensity, 0, dt * 12);
                 if (light.intensity < 0.01) {
                     light.intensity = 0;
+                    light.visible = false;
                     slot.isFadingOut = false;
                     slot.key = slot.pendingKey;
                     slot.pendingKey = null;
@@ -200,12 +204,14 @@ export function ItemLightSystem() {
             if (!slot.key) {
                 // Idle slot — keep dark
                 light.intensity = 0;
+                light.visible = false;
                 continue;
             }
             const reg = registrations.get(slot.key);
             if (!reg) {
                 slot.key = null;
                 light.intensity = 0;
+                light.visible = false;
                 continue;
             }
             // Snap world position each frame
@@ -226,10 +232,17 @@ export function ItemLightSystem() {
             const targetIntensity = isOn
                 ? MathUtils.lerp(reg.effect.intensityRange[0], reg.effect.intensityRange[1], t)
                 : reg.effect.intensityRange[0];
+            if (targetIntensity > 0) {
+                light.visible = true;
+            }
             light.intensity = MathUtils.lerp(light.intensity, targetIntensity, dt * 12);
+            if (targetIntensity <= 0 && light.intensity < 0.01) {
+                light.intensity = 0;
+                light.visible = false;
+            }
         }
     });
-    return (_jsx(_Fragment, { children: Array.from({ length: POOL_SIZE }, (_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, ref: (el) => {
+    return (_jsx(_Fragment, { children: Array.from({ length: POOL_SIZE }, (_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, visible: false, ref: (el) => {
                 lightRefs.current[i] = el;
             } }, i))) }));
 }

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

@@ -1 +1 @@
-{"version":3,"file":"level-system.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-system.tsx"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW,YAsCvB,CAAA"}
+{"version":3,"file":"level-system.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-system.tsx"],"names":[],"mappings":"AAeA,eAAO,MAAM,WAAW,YA6DvB,CAAA"}

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

@@ -1,9 +1,14 @@
-import { sceneRegistry, useScene } from '@pascal-app/core';
+import { getLevelHeight, sceneRegistry, useScene } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { lerp } from 'three/src/math/MathUtils.js';
+import { applyShadowOnly, clearShadowOnly } from '../../lib/shadow-only';
 import useViewer from '../../store/use-viewer';
-import { getLevelHeight } from './level-utils';
 const EXPLODED_GAP = 5;
+// Levels currently in shadow-caster-only mode (solo hides them from the color
+// passes but keeps their sun shadows). Tracked so we can restore layer masks
+// exactly once on transition; apply re-runs every frame so meshes rebuilt
+// while hidden (theme/texture changes) get re-hidden.
+const shadowOnlyLevels = new WeakSet();
 export const LevelSystem = () => {
     useFrame((_, delta) => {
         const nodes = useScene.getState().nodes;
@@ -19,6 +24,9 @@ export const LevelSystem = () => {
         });
         entries.sort((a, b) => a.index - b.index);
         // Walk sorted levels, accumulating base Y offsets
+        const selectedIndex = selectedLevel
+            ? entries.find((e) => e.levelId === selectedLevel)?.index
+            : undefined;
         let cumulativeY = 0;
         for (const { levelId, index, obj } of entries) {
             const level = nodes[levelId];
@@ -26,8 +34,24 @@ export const LevelSystem = () => {
             const explodedExtra = levelMode === 'exploded' ? index * EXPLODED_GAP : 0;
             const targetY = baseY + explodedExtra;
             obj.position.y = lerp(obj.position.y, targetY, delta * 12); // Smoothly animate to new Y position
-            obj.visible = levelMode !== 'solo' || level?.id === selectedLevel || !selectedLevel;
-            cumulativeY += getLevelHeight(levelId, nodes);
+            // Solo: hidden levels ABOVE the soloed one stay in the shadow map
+            // (shadow-caster-only) so the sun still shadows the soloed floor through
+            // them; levels below can't block the sun, so they plain-hide.
+            const hidden = levelMode === 'solo' && Boolean(selectedLevel) && level?.id !== selectedLevel;
+            const castsWhileHidden = hidden && selectedIndex !== undefined && index > selectedIndex;
+            if (castsWhileHidden) {
+                applyShadowOnly(obj);
+                shadowOnlyLevels.add(obj);
+                obj.visible = true;
+            }
+            else {
+                if (shadowOnlyLevels.has(obj)) {
+                    clearShadowOnly(obj);
+                    shadowOnlyLevels.delete(obj);
+                }
+                obj.visible = !hidden;
+            }
+            cumulativeY += getLevelHeight(levelId, nodes, (wallId) => sceneRegistry.nodes.get(wallId)?.position.y);
         }
     }, 5); // Using a lower priority so it runs after transforms from other systems have settled
     return null;

package/dist/systems/level/level-utils.d.ts

@@ -1,6 +1,3 @@
-import { useScene } from '@pascal-app/core';
-export declare const DEFAULT_LEVEL_HEIGHT = 2.5;
-export declare function getLevelHeight(levelId: string, nodes: ReturnType<typeof useScene.getState>['nodes']): number;
 /**
  * Instantly snaps all level Objects3D to their true stacked Y positions
  * (ignores levelMode — always uses stacked, no exploded gap).

package/dist/systems/level/level-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level-utils.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAET,MAAM,kBAAkB,CAAA;AAEzB,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAQvC,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GACnD,MAAM,CA8BR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,IAAI,CAyCtD"}
+{"version":3,"file":"level-utils.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-utils.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,IAAI,CA6CtD"}

package/dist/systems/level/level-utils.js

@@ -1,43 +1,4 @@
-import { sceneRegistry, useScene, } from '@pascal-app/core';
-export const DEFAULT_LEVEL_HEIGHT = 2.5;
-// Cache: levelId → computed height. Invalidated when the nodes reference changes.
-// Zustand produces a new `nodes` object on every mutation, so reference equality
-// is a zero-cost way to detect stale data without any subscription overhead.
-const heightCache = new Map();
-let lastNodesRef = null;
-export function getLevelHeight(levelId, nodes) {
-    if (nodes !== lastNodesRef) {
-        heightCache.clear();
-        lastNodesRef = nodes;
-    }
-    if (heightCache.has(levelId))
-        return heightCache.get(levelId);
-    const level = nodes[levelId];
-    if (!level)
-        return DEFAULT_LEVEL_HEIGHT;
-    let maxTop = 0;
-    for (const childId of level.children) {
-        const child = nodes[childId];
-        if (!child)
-            continue;
-        if (child.type === 'ceiling') {
-            const ch = child.height ?? DEFAULT_LEVEL_HEIGHT;
-            if (ch > maxTop)
-                maxTop = ch;
-        }
-        else if (child.type === 'wall') {
-            let meshY = sceneRegistry.nodes.get(childId)?.position.y ?? 0;
-            if (meshY < 0)
-                meshY = 0;
-            const top = meshY + (child.height ?? DEFAULT_LEVEL_HEIGHT);
-            if (top > maxTop)
-                maxTop = top;
-        }
-    }
-    const height = maxTop > 0 ? maxTop : DEFAULT_LEVEL_HEIGHT;
-    heightCache.set(levelId, height);
-    return height;
-}
+import { getLevelHeight, sceneRegistry, useScene } from '@pascal-app/core';
 /**
  * Instantly snaps all level Objects3D to their true stacked Y positions
  * (ignores levelMode — always uses stacked, no exploded gap).
@@ -68,7 +29,7 @@ export function snapLevelsToTruePositions() {
     for (const { levelId, obj } of entries) {
         obj.position.y = cumulativeY;
         obj.visible = true;
-        cumulativeY += getLevelHeight(levelId, nodes);
+        cumulativeY += getLevelHeight(levelId, nodes, (wallId) => sceneRegistry.nodes.get(wallId)?.position.y);
     }
     return () => {
         for (const { levelId, obj } of entries) {

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

@@ -1,5 +1,6 @@
 import { type RoofNode } from '@pascal-app/core';
-import * as THREE from 'three';
+import type * as THREE from 'three';
+import { type ColorPreset, type RenderShading } from '../../lib/materials';
 export type RoofMaterialArray = [THREE.Material, THREE.Material, THREE.Material, THREE.Material];
-export declare function getRoofMaterialArray(node: RoofNode): RoofMaterialArray | null;
+export declare function getRoofMaterialArray(node: RoofNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): RoofMaterialArray | null;
 //# 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,MAAM,OAAO,CAAA;AAG9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AA4BhG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,iBAAiB,GAAG,IAAI,CA8B7E"}
+{"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"}

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

@@ -1,6 +1,15 @@
 import { getEffectiveRoofSurfaceMaterial, } from '@pascal-app/core';
-import * as THREE from 'three';
-import { createMaterial, createMaterialFromPresetRef } from '../../lib/materials';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, 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)
+// so a roof reads as continuous with the walls below it.
+const ROOF_DEFAULT_REFS = [
+    'library:concrete-drywall',
+    'library:preset-softwhite',
+    'library:preset-softwhite',
+    'library:roof-terracottatiles',
+];
 const roofMaterialArrayCache = new Map();
 function getSurfaceMaterialSignature(spec) {
     return JSON.stringify({
@@ -8,20 +17,24 @@ function getSurfaceMaterialSignature(spec) {
         materialPreset: spec.materialPreset ?? null,
     });
 }
-function createResolvedMaterial(material, materialPreset) {
+function createResolvedMaterial(material, materialPreset, shading) {
     if (materialPreset) {
-        return createMaterialFromPresetRef(materialPreset);
+        return createMaterialFromPresetRef(materialPreset, shading);
     }
     if (material) {
-        return createMaterial(material);
+        return createMaterial(material, shading);
     }
     return null;
 }
-export function getRoofMaterialArray(node) {
+export function getRoofMaterialArray(node, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
     const top = getEffectiveRoofSurfaceMaterial(node, 'top');
     const edge = getEffectiveRoofSurfaceMaterial(node, 'edge');
     const wall = getEffectiveRoofSurfaceMaterial(node, 'wall');
     const cacheKey = JSON.stringify({
+        shading,
+        textures,
+        colorPreset,
+        sceneTheme,
         top: getSurfaceMaterialSignature(top),
         edge: getSurfaceMaterialSignature(edge),
         wall: getSurfaceMaterialSignature(wall),
@@ -29,17 +42,49 @@ export function getRoofMaterialArray(node) {
     const cached = roofMaterialArrayCache.get(cacheKey);
     if (cached)
         return cached;
-    const topMaterial = createResolvedMaterial(top.material, top.materialPreset);
-    const edgeMaterial = createResolvedMaterial(edge.material, edge.materialPreset);
-    const wallMaterial = createResolvedMaterial(wall.material, wall.materialPreset);
+    // Themed role colours: roof top/edge use the 'roof' role, the soffit/underside
+    // uses 'ceiling'. These also fill any untextured slot so an untextured roof is
+    // theme-coloured regardless of the textures toggle (no more white default).
+    const roofMaterial = createSurfaceRoleMaterial('roof', colorPreset, undefined, sceneTheme);
+    const ceilingMaterial = createSurfaceRoleMaterial('ceiling', colorPreset, undefined, sceneTheme);
+    const roleArray = [
+        roofMaterial,
+        ceilingMaterial,
+        ceilingMaterial,
+        roofMaterial,
+    ];
+    // Textures-off (monochrome) is the guaranteed escape hatch: themed role
+    // colours, no catalog finishes.
+    if (!textures) {
+        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)) {
-        return null;
+        roofMaterialArrayCache.set(cacheKey, defaultArray);
+        return defaultArray;
     }
+    // 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.
     const materialArray = [
-        edgeMaterial ?? wallMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
-        wallMaterial ?? edgeMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
-        wallMaterial ?? edgeMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
-        topMaterial ?? wallMaterial ?? edgeMaterial ?? new THREE.MeshStandardMaterial(),
+        edgeMaterial ?? defaultArray[0],
+        wallMaterial ?? defaultArray[1],
+        wallMaterial ?? defaultArray[2],
+        topMaterial ?? defaultArray[3],
     ];
     roofMaterialArrayCache.set(cacheKey, materialArray);
     return materialArray;

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

@@ -1,16 +1,56 @@
-import { type RoofSegmentNode } from '@pascal-app/core';
+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;
 /**
- * Generate complete hollow-shell geometry for a roof segment.
- * Ports the prototype's CSG approach using three-bvh-csg.
+ * Four dummy materials used as identity placeholders during CSG. Shared
+ * across every input brush so three-bvh-csg can preserve reference
+ * equality on the result and `mapRoofGroupMaterialIndex` can map result
+ * groups back to slots 0..3. Exposed so kinds that compose additional
+ * CSG ops on top of `getRoofSegmentBrushes` (e.g. dormer) use the same
+ * identity refs.
  */
-export declare function getRoofSegmentBrushes(node: RoofSegmentNode): {
+export declare const roofCsgDummyMats: [
+    THREE.MeshBasicMaterial,
+    THREE.MeshBasicMaterial,
+    THREE.MeshBasicMaterial,
+    THREE.MeshBasicMaterial
+];
+export declare const ROOF_MATERIAL_SLOT_COUNT = 4;
+type RoofSegmentBrushSet = {
     deckSlab: Brush;
     shinSlab: Brush;
     wallBrush: Brush;
     innerBrush: Brush;
-} | null;
-export declare function generateRoofSegmentGeometry(node: RoofSegmentNode): THREE.BufferGeometry;
+    rakeBoards: THREE.BufferGeometry | null;
+};
+export declare function mapRoofGroupMaterialIndex(groupMaterialIndex: number | undefined, csgMaterials: THREE.Material[], matToIndex: Map<THREE.Material, number>): number;
+/**
+ * Subtract a segment's trim cuts from an arbitrary segment-local geometry,
+ * returning the clipped result. The input geometry is consumed (disposed) on
+ * each successful CSG pass — callers that need to keep the original must pass a
+ * clone. Returns the input untouched when the segment has no trim. Used
+ * internally for rake-board / end-slope attachments and exported so roof
+ * accessories (chimney, vents, skylight, …) can clip their own meshes by the
+ * same trim, in the same segment-local frame.
+ */
+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.
+ */
+export declare function getRoofSegmentBrushes(node: RoofSegmentNode): 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 = {
+    point: THREE.Vector3;
+    normal: THREE.Vector3;
+};
+/**
+ * Returns the outer roof surface frame (point + normal) at a given segment-local XZ.
+ * This is used for skylight placement + cut direction so cutouts remain perpendicular
+ * to the true roof surface even on multi-slope roofs (gambrel/mansard/dutch).
+ */
+export declare function getRoofOuterSurfaceFrameAtPoint(segment: RoofSegmentNode, lx: number, lz: number): SurfaceFrame;
+export {};
 //# sourceMappingURL=roof-system.d.ts.map

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,EAIL,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AA4CvE,eAAO,MAAM,UAAU,YAsFtB,CAAA;AAqLD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAqRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAmDvF"}
+{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAcZ,KAAK,eAAe,EAKrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAwIvE,eAAO,MAAM,UAAU,YAuItB,CAAA;AAmXD;;;;;;;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;AAgUD;;;;;;;;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,CA+SvF;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,KAAK,CAAC,cAAc,CAsFtB;AAsLD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,eAAe,QA2ExF;AAijBD,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"}