@pascal-app/viewer 0.9.1 → 1.0.0-beta.1

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

@@ -1,9 +1,9 @@
-import { getEffectiveWallSurfaceMaterial, getMaterialPresetByRef, getWallSurfaceMaterialSignature, resolveMaterial, } from '@pascal-app/core';
+import { getEffectiveWallSurfaceMaterial, getMaterialPresetByRef, getWallSurfaceMaterialSignature, getWallSurfaceSideFromBandSlot, parseMaterialRef, resolveMaterial, WALL_SLOT_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
 import { Color } from 'three';
 import { Fn, float, fract, length, mix, positionLocal, smoothstep, step, vec2 } from 'three/tsl';
 import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
-import { baseMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveSurfaceColor, } from '../../lib/materials';
-const DEFAULT_WALL_COLOR = '#f2f0ed';
+import { baseMaterial, createDefaultMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveMaterialRef, resolveSurfaceColor, } from '../../lib/materials';
+const DEFAULT_WALL_COLOR = '#e9e7e3';
 const WALL_HIGHLIGHT_PROFILES = {
     delete: {
         color: new Color('#dc2626'),
@@ -11,12 +11,6 @@ const WALL_HIGHLIGHT_PROFILES = {
         emissiveBlend: 0.92,
         emissiveIntensity: 0.46,
     },
-    selection: {
-        color: new Color('#818cf8'),
-        blend: 0.32,
-        emissiveBlend: 0.7,
-        emissiveIntensity: 0.42,
-    },
 };
 const wallMaterialCache = new Map();
 const dotPattern = Fn(() => {
@@ -42,6 +36,108 @@ function getSurfaceVisibleMaterial(spec, shading) {
 function hasExplicitMaterial(spec) {
     return Boolean(spec.materialPreset || spec.material);
 }
+// Resolve a wall face's declared default — a catalog `library:` finish or a
+// flat colour — to a renderable material.
+function resolveWallSlotDefault(slotDefault, shading) {
+    if (parseMaterialRef(slotDefault)?.kind === 'library') {
+        return createMaterialFromPresetRef(slotDefault, shading) ?? baseMaterial(shading);
+    }
+    return createDefaultMaterial(slotDefault, 0.9, shading);
+}
+// Slot-first resolution for one wall face, matching every other paintable kind:
+//   node.slots[side] ref → legacy inline fields → declared slot default.
+// A dangling `scene:` ref (material deleted / copied across scenes) falls back
+// to the declared default — it never blocks rendering (the dangling-ref rule).
+function resolveWallFaceMaterial(wallNode, side, shading, sceneMaterials) {
+    const ref = wallNode.slots?.[side];
+    if (ref) {
+        return (resolveMaterialRef(ref, sceneMaterials, shading) ??
+            resolveWallSlotDefault(WALL_SLOT_DEFAULT[side], shading));
+    }
+    const spec = getEffectiveWallSurfaceMaterial(wallNode, side);
+    if (hasExplicitMaterial(spec)) {
+        return getSurfaceVisibleMaterial(spec, shading);
+    }
+    return resolveWallSlotDefault(WALL_SLOT_DEFAULT[side], shading);
+}
+function resolveWallSlotMaterial(wallNode, slotId, shading, sceneMaterials) {
+    const ref = wallNode.slots?.[slotId];
+    if (ref) {
+        return (resolveMaterialRef(ref, sceneMaterials, shading) ??
+            resolveWallSlotDefault(WALL_SURFACE_SLOT_DEFAULTS[slotId], shading));
+    }
+    const side = getWallSurfaceSideFromBandSlot(slotId);
+    if (side) {
+        return resolveWallFaceMaterial(wallNode, side, shading, sceneMaterials);
+    }
+    return resolveWallSlotDefault(WALL_SURFACE_SLOT_DEFAULTS[slotId], shading);
+}
+// Cache-key fragment for one face: the slot ref plus, for a `scene:` ref, the
+// referenced material's *content* — so editing a scene material assigned to a
+// wall invalidates the cache (a `library:` ref is static catalog content, so
+// its id alone is enough). Falls back to the legacy signature when unmigrated.
+function wallFaceMaterialSignature(wallNode, side, sceneMaterials) {
+    const ref = wallNode.slots?.[side];
+    if (ref) {
+        const parsed = parseMaterialRef(ref);
+        if (parsed?.kind === 'scene') {
+            return JSON.stringify({
+                ref,
+                material: sceneMaterials?.[parsed.id]?.material ?? null,
+            });
+        }
+        return JSON.stringify({ ref });
+    }
+    return getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, side));
+}
+function wallSlotMaterialSignature(wallNode, slotId, sceneMaterials) {
+    const ref = wallNode.slots?.[slotId];
+    if (ref) {
+        const parsed = parseMaterialRef(ref);
+        if (parsed?.kind === 'scene') {
+            return JSON.stringify({
+                ref,
+                material: sceneMaterials?.[parsed.id]?.material ?? null,
+            });
+        }
+        return JSON.stringify({ ref });
+    }
+    const side = getWallSurfaceSideFromBandSlot(slotId);
+    if (side)
+        return wallFaceMaterialSignature(wallNode, side, sceneMaterials);
+    return JSON.stringify({ default: WALL_SURFACE_SLOT_DEFAULTS[slotId] });
+}
+// Slot-first tint for the cutaway/invisible wall variant.
+function resolveWallFaceColor(wallNode, side, sceneMaterials, fallback) {
+    const ref = wallNode.slots?.[side];
+    if (ref) {
+        const parsed = parseMaterialRef(ref);
+        if (parsed?.kind === 'library') {
+            return getMaterialPresetByRef(ref)?.mapProperties?.color ?? fallback;
+        }
+        if (parsed?.kind === 'scene') {
+            const sceneMaterial = sceneMaterials?.[parsed.id];
+            return sceneMaterial ? resolveMaterial(sceneMaterial.material).color : fallback;
+        }
+        return fallback;
+    }
+    return getSurfaceColor(getEffectiveWallSurfaceMaterial(wallNode, side), fallback);
+}
+function resolveWallSlotColor(wallNode, slotId, sceneMaterials, fallback) {
+    const ref = wallNode.slots?.[slotId];
+    if (ref) {
+        const parsed = parseMaterialRef(ref);
+        if (parsed?.kind === 'library') {
+            return getMaterialPresetByRef(ref)?.mapProperties?.color ?? fallback;
+        }
+        if (parsed?.kind === 'scene') {
+            const sceneMaterial = sceneMaterials?.[parsed.id];
+            return sceneMaterial ? resolveMaterial(sceneMaterial.material).color : fallback;
+        }
+    }
+    const side = getWallSurfaceSideFromBandSlot(slotId);
+    return side ? resolveWallFaceColor(wallNode, side, sceneMaterials, fallback) : fallback;
+}
 function getSurfaceColor(spec, fallback = DEFAULT_WALL_COLOR) {
     const preset = getMaterialPresetByRef(spec.materialPreset);
     if (preset?.mapProperties?.color) {
@@ -73,6 +169,60 @@ function createHighlightedWallMaterial(material, kind) {
     highlightedMaterial.needsUpdate = true;
     return highlightedMaterial;
 }
+// Light selection highlight for walls (walls are excluded from the generic
+// editor selection highlight, so they need their own). Adds a gentle indigo
+// emissive (no albedo tint) so the real material/texture stays readable with a
+// soft "selected" glow. Two NodeMaterial-clone gotchas are handled:
+//   1. `clone()` on the WebGPU backend drops the texture-map nodes → re-attach
+//      them from the source (shared by reference).
+//   2. The wall's finish texture loads async, so an early clone has no map yet →
+//      cache keyed by the source `.map` and rebuild when it changes (self-heals
+//      once the texture lands).
+const SELECTION_HIGHLIGHT_COLOR = new Color('#818cf8');
+const SELECTION_EMISSIVE_BLEND = 0.4;
+const SELECTION_EMISSIVE_INTENSITY = 0.12;
+const SELECTION_TEXTURE_MAP_KEYS = [
+    'map',
+    'normalMap',
+    'roughnessMap',
+    'metalnessMap',
+    'aoMap',
+    'emissiveMap',
+    'bumpMap',
+    'displacementMap',
+    'alphaMap',
+    'lightMap',
+];
+const selectionHighlightCache = new WeakMap();
+function getSelectionHighlightMaterial(base) {
+    const baseMap = base.map ?? null;
+    const cached = selectionHighlightCache.get(base);
+    if (cached && cached.map === baseMap)
+        return cached.clone;
+    const clone = base.clone();
+    // Re-attach texture maps the WebGPU NodeMaterial clone drops.
+    const src = base;
+    const dst = clone;
+    for (const key of SELECTION_TEXTURE_MAP_KEYS) {
+        if (src[key])
+            dst[key] = src[key];
+    }
+    if ('emissive' in clone && clone.emissive) {
+        clone.emissive = clone.emissive
+            .clone()
+            .lerp(SELECTION_HIGHLIGHT_COLOR, SELECTION_EMISSIVE_BLEND);
+    }
+    if ('emissiveIntensity' in clone) {
+        clone.emissiveIntensity = Math.max(clone.emissiveIntensity ?? 0, SELECTION_EMISSIVE_INTENSITY);
+    }
+    clone.needsUpdate = true;
+    selectionHighlightCache.set(base, { clone, map: baseMap });
+    return clone;
+}
+/** Lazy light-emissive selection variant of a wall's material array (keeps texture). */
+export function getSelectionHighlightMaterials(materials) {
+    return materials.map(getSelectionHighlightMaterial);
+}
 function createInvisibleWallMaterial(color, shading) {
     const material = shading === 'solid'
         ? new MeshLambertNodeMaterial({
@@ -90,6 +240,22 @@ function createInvisibleWallMaterial(color, shading) {
     material.opacityNode = mix(float(0.0), float(0.24), dotPattern());
     return material;
 }
+function createTranslucentWallMaterial(color, shading) {
+    const material = shading === 'solid'
+        ? new MeshLambertNodeMaterial({
+            transparent: true,
+            color,
+            opacity: 0.35,
+            depthWrite: false,
+        })
+        : new MeshStandardNodeMaterial({
+            transparent: true,
+            color,
+            opacity: 0.35,
+            depthWrite: false,
+        });
+    return material;
+}
 function mapWallMaterialArray(materials, iteratee) {
     return materials.map(iteratee);
 }
@@ -104,17 +270,25 @@ function disposeOwnedMaterials(materials) {
         material.dispose();
     });
 }
-export function getWallMaterialHash(wallNode, shading) {
+export function getWallMaterialHash(wallNode, shading, sceneMaterials) {
     return JSON.stringify({
         shading,
-        interior: getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, 'interior')),
-        exterior: getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, 'exterior')),
+        interior: wallFaceMaterialSignature(wallNode, 'interior', sceneMaterials),
+        exterior: wallFaceMaterialSignature(wallNode, 'exterior', sceneMaterials),
+        lowerInterior: wallSlotMaterialSignature(wallNode, 'lowerInterior', sceneMaterials),
+        middleInterior: wallSlotMaterialSignature(wallNode, 'middleInterior', sceneMaterials),
+        upperInterior: wallSlotMaterialSignature(wallNode, 'upperInterior', sceneMaterials),
+        topInterior: wallSlotMaterialSignature(wallNode, 'topInterior', sceneMaterials),
+        lowerExterior: wallSlotMaterialSignature(wallNode, 'lowerExterior', sceneMaterials),
+        middleExterior: wallSlotMaterialSignature(wallNode, 'middleExterior', sceneMaterials),
+        upperExterior: wallSlotMaterialSignature(wallNode, 'upperExterior', sceneMaterials),
+        topExterior: wallSlotMaterialSignature(wallNode, 'topExterior', sceneMaterials),
     });
 }
-export function getMaterialsForWall(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+export function getMaterialsForWall(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme, sceneMaterials) {
     const cacheKey = `${wallNode.id}-${shading}-${textures}-${colorPreset}-${sceneTheme ?? 'base'}`;
     const materialHash = textures
-        ? getWallMaterialHash(wallNode, shading)
+        ? getWallMaterialHash(wallNode, shading, sceneMaterials)
         : JSON.stringify({ textures, colorPreset, sceneTheme });
     const existing = wallMaterialCache.get(cacheKey);
     if (existing && existing.materialHash === materialHash) {
@@ -123,50 +297,85 @@ export function getMaterialsForWall(wallNode, shading = 'rendered', textures = t
     if (existing) {
         disposeOwnedMaterials([
             existing.invisible,
+            existing.translucent,
             existing.deleteVisible,
             existing.deleteInvisible,
-            existing.highlightedVisible,
-            existing.highlightedInvisible,
+            existing.deleteTranslucent,
         ]);
     }
-    const interiorSpec = getEffectiveWallSurfaceMaterial(wallNode, 'interior');
-    const exteriorSpec = getEffectiveWallSurfaceMaterial(wallNode, 'exterior');
     const wallRoleMaterial = createSurfaceRoleMaterial('wall', colorPreset, undefined, sceneTheme);
-    // Untextured surfaces take the themed wall role colour even with textures on;
-    // only surfaces with an explicit preset/material keep their texture.
+    // Colored mode: each face resolves slot-first (node.slots ref → legacy inline
+    // fields → declared slot default, parity with the retired DEFAULT_WALL_MATERIAL).
+    // Textures-off collapses every face to the themed wall role (the guaranteed
+    // escape hatch). The edge/cap slot (index 0) stays role-based.
     const visible = textures
         ? [
             wallRoleMaterial,
-            hasExplicitMaterial(interiorSpec)
-                ? getSurfaceVisibleMaterial(interiorSpec, shading)
-                : wallRoleMaterial,
-            hasExplicitMaterial(exteriorSpec)
-                ? getSurfaceVisibleMaterial(exteriorSpec, shading)
-                : wallRoleMaterial,
+            resolveWallFaceMaterial(wallNode, 'interior', shading, sceneMaterials),
+            resolveWallFaceMaterial(wallNode, 'exterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'lowerInterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'middleInterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'upperInterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'topInterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'lowerExterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'middleExterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'upperExterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'topExterior', shading, sceneMaterials),
         ]
-        : [wallRoleMaterial, wallRoleMaterial, wallRoleMaterial];
+        : Array.from({ length: 11 }, () => wallRoleMaterial);
     const wallRoleColor = resolveSurfaceColor('wall', colorPreset, sceneTheme);
     const invisible = [
         createInvisibleWallMaterial(wallRoleColor, textures ? shading : 'solid'),
-        createInvisibleWallMaterial(textures ? getSurfaceColor(interiorSpec, wallRoleColor) : wallRoleColor, textures ? shading : 'solid'),
-        createInvisibleWallMaterial(textures ? getSurfaceColor(exteriorSpec, wallRoleColor) : wallRoleColor, textures ? shading : 'solid'),
+        ...['interior', 'exterior'].map((side) => createInvisibleWallMaterial(textures
+            ? resolveWallFaceColor(wallNode, side, sceneMaterials, wallRoleColor)
+            : wallRoleColor, textures ? shading : 'solid')),
+        ...[
+            'lowerInterior',
+            'middleInterior',
+            'upperInterior',
+            'topInterior',
+            'lowerExterior',
+            'middleExterior',
+            'upperExterior',
+            'topExterior',
+        ].map((slotId) => createInvisibleWallMaterial(textures
+            ? resolveWallSlotColor(wallNode, slotId, sceneMaterials, wallRoleColor)
+            : wallRoleColor, textures ? shading : 'solid')),
+    ];
+    const translucent = [
+        createTranslucentWallMaterial(wallRoleColor, textures ? shading : 'solid'),
+        ...['interior', 'exterior'].map((side) => createTranslucentWallMaterial(textures
+            ? resolveWallFaceColor(wallNode, side, sceneMaterials, wallRoleColor)
+            : wallRoleColor, textures ? shading : 'solid')),
+        ...[
+            'lowerInterior',
+            'middleInterior',
+            'upperInterior',
+            'topInterior',
+            'lowerExterior',
+            'middleExterior',
+            'upperExterior',
+            'topExterior',
+        ].map((slotId) => createTranslucentWallMaterial(textures
+            ? resolveWallSlotColor(wallNode, slotId, sceneMaterials, wallRoleColor)
+            : wallRoleColor, textures ? shading : 'solid')),
     ];
-    const highlightedVisible = mapWallMaterialArray(visible, (material) => createHighlightedWallMaterial(material, 'selection'));
-    const highlightedInvisible = mapWallMaterialArray(invisible, (material) => createHighlightedWallMaterial(material, 'selection'));
     const deleteVisible = mapWallMaterialArray(visible, (material) => createHighlightedWallMaterial(material, 'delete'));
     const deleteInvisible = mapWallMaterialArray(invisible, (material) => createHighlightedWallMaterial(material, 'delete'));
+    const deleteTranslucent = mapWallMaterialArray(translucent, (material) => createHighlightedWallMaterial(material, 'delete'));
     const result = {
         visible,
         invisible,
+        translucent,
         deleteVisible,
         deleteInvisible,
-        highlightedVisible,
-        highlightedInvisible,
+        deleteTranslucent,
         materialHash,
     };
     wallMaterialCache.set(cacheKey, result);
     return result;
 }
-export function getVisibleWallMaterials(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
-    return getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme).visible;
+export function getVisibleWallMaterials(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme, sceneMaterials) {
+    return getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme, sceneMaterials)
+        .visible;
 }

package/dist/systems/wall/wall-opening-cutout.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wall-opening-cutout.test.d.ts.map

package/dist/systems/wall/wall-opening-cutout.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-opening-cutout.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-opening-cutout.test.ts"],"names":[],"mappings":""}

package/dist/systems/wall/wall-opening-cutout.test.js

@@ -0,0 +1,59 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { calculateLevelMiters, DoorNode, sceneRegistry, WallNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { generateExtrudedWall } from './wall-system';
+describe('wall opening cutout', () => {
+    test('cuts a floor-level door directly from node geometry without a proxy mesh', () => {
+        const wall = WallNode.parse({
+            id: 'wall_floor-opening-cutout',
+            start: [0, 0],
+            end: [2, 0],
+            height: 2.5,
+            thickness: 0.1,
+        });
+        const door = DoorNode.parse({
+            id: 'door_floor-opening-cutout',
+            wallId: wall.id,
+            position: [1, 1.05, 0],
+            width: 0.9,
+            height: 2.1,
+        });
+        const wallMesh = new THREE.Mesh();
+        sceneRegistry.nodes.set(wall.id, wallMesh);
+        try {
+            const geometry = generateExtrudedWall(wall, [door], calculateLevelMiters([wall]));
+            const position = geometry.getAttribute('position');
+            const index = geometry.index;
+            const openingLeft = door.position[0] - door.width / 2;
+            const openingRight = door.position[0] + door.width / 2;
+            let wallFaceTrianglesInsideOpening = 0;
+            let baseTrianglesInsideOpening = 0;
+            for (let offset = 0; offset < (index?.count ?? position.count); offset += 3) {
+                const indices = [0, 1, 2].map((corner) => index ? index.getX(offset + corner) : offset + corner);
+                const vertices = indices.map((vertexIndex) => new THREE.Vector3(position.getX(vertexIndex), position.getY(vertexIndex), position.getZ(vertexIndex)));
+                const centroid = vertices
+                    .reduce((sum, vertex) => sum.add(vertex), new THREE.Vector3())
+                    .multiplyScalar(1 / 3);
+                const insideOpeningX = centroid.x > openingLeft + 1e-4 && centroid.x < openingRight - 1e-4;
+                if (!insideOpeningX)
+                    continue;
+                const onWallFace = vertices.every((vertex) => Math.abs(Math.abs(vertex.z) - (wall.thickness ?? 0.1) / 2) < 1e-5);
+                if (onWallFace && centroid.y > 1e-4 && centroid.y < door.height - 1e-4) {
+                    wallFaceTrianglesInsideOpening += 1;
+                }
+                if (vertices.every((vertex) => Math.abs(vertex.y) < 1e-5)) {
+                    baseTrianglesInsideOpening += 1;
+                }
+            }
+            expect(wallFaceTrianglesInsideOpening).toBe(0);
+            expect(baseTrianglesInsideOpening).toBe(0);
+            geometry.dispose();
+        }
+        finally {
+            sceneRegistry.nodes.delete(wall.id);
+            wallMesh.geometry.dispose();
+        }
+    });
+});

package/dist/systems/wall/wall-support-extension.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wall-support-extension.test.d.ts.map

package/dist/systems/wall/wall-support-extension.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-support-extension.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-support-extension.test.ts"],"names":[],"mappings":""}

package/dist/systems/wall/wall-support-extension.test.js

@@ -0,0 +1,116 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { calculateLevelMiters, getWallPlaneTop, WallNode, } from '@pascal-app/core';
+import { generateExtrudedWall } from './wall-system';
+describe('wall support extension', () => {
+    test('preserves the raised wall origin and top while filling down to the lower support', () => {
+        const wall = WallNode.parse({ start: [0, 0], end: [4, 0], height: 2.5, thickness: 0.1 });
+        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0.6, 0.05);
+        geometry.computeBoundingBox();
+        expect(geometry.boundingBox?.min.y).toBeCloseTo(-0.55);
+        expect(geometry.boundingBox?.max.y).toBeCloseTo(2.5);
+        // With mesh.position.y = 0.6, the wall spans world Y=0.05..3.1.
+        expect((geometry.boundingBox?.min.y ?? 0) + 0.6).toBeCloseTo(0.05);
+        expect((geometry.boundingBox?.max.y ?? 0) + 0.6).toBeCloseTo(3.1);
+        geometry.dispose();
+    });
+    test('retains the existing negative-slab top constraint', () => {
+        const wall = WallNode.parse({ start: [0, 0], end: [4, 0], height: 2.5, thickness: 0.1 });
+        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), -0.4, -0.4);
+        geometry.computeBoundingBox();
+        expect(geometry.boundingBox?.min.y).toBeCloseTo(0);
+        expect(geometry.boundingBox?.max.y).toBeCloseTo(2.9);
+        expect((geometry.boundingBox?.max.y ?? 0) - 0.4).toBeCloseTo(2.5);
+        geometry.dispose();
+    });
+    test('plane-bound wall tops out at the storey plane regardless of slab elevation', () => {
+        const wall = WallNode.parse({ start: [0, 0], end: [4, 0], thickness: 0.1 });
+        const flat = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0, 0, undefined, 3);
+        flat.computeBoundingBox();
+        expect(flat.boundingBox?.max.y).toBeCloseTo(3);
+        expect(flat.boundingBox?.min.y).toBeCloseTo(0);
+        flat.dispose();
+        const raised = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0.6, 0.6, undefined, 3);
+        raised.computeBoundingBox();
+        // Mesh sits at Y=0.6, so a 2.4 local top keeps the world top at the 3m
+        // plane — the raised slab shortens the wall instead of lifting its top.
+        expect(raised.boundingBox?.max.y).toBeCloseTo(2.4);
+        expect(raised.boundingBox?.min.y).toBeCloseTo(0);
+        raised.dispose();
+    });
+    test('plane-bound wall under a flush thick deck tops out at the deck underside', () => {
+        // level_1 carries a flush deck occupying [-0.3, 0] above the storey
+        // plane: the covering-clamped plane for level_0 is 2.5 − 0.3 = 2.2.
+        const wall = WallNode.parse({
+            start: [0.5, 2],
+            end: [3.5, 2],
+            thickness: 0.1,
+            parentId: 'level_0',
+        });
+        const base = { object: 'node', parentId: null, visible: true, metadata: {}, children: [] };
+        const nodes = {
+            level_0: {
+                ...base,
+                id: 'level_0',
+                type: 'level',
+                level: 0,
+                height: 2.5,
+                children: [wall.id],
+            },
+            level_1: {
+                ...base,
+                id: 'level_1',
+                type: 'level',
+                level: 1,
+                height: 2.5,
+                children: ['slab_deck'],
+            },
+            slab_deck: {
+                ...base,
+                id: 'slab_deck',
+                type: 'slab',
+                parentId: 'level_1',
+                polygon: [
+                    [0, 0],
+                    [4, 0],
+                    [4, 4],
+                    [0, 4],
+                ],
+                holes: [],
+                elevation: 0,
+                thickness: 0.3,
+            },
+        };
+        const planeTop = getWallPlaneTop(wall, 'level_0', nodes);
+        expect(planeTop).toBeCloseTo(2.2);
+        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0, 0, undefined, planeTop);
+        geometry.computeBoundingBox();
+        // Mesh sits at Y=0, so the world top lands at the deck underside instead
+        // of colliding with the slab solid above.
+        expect(geometry.boundingBox?.max.y).toBeCloseTo(2.2);
+        expect(geometry.boundingBox?.min.y).toBeCloseTo(0);
+        geometry.dispose();
+    });
+    test('raises only the high-supported part of a mixed wall run', () => {
+        const wall = WallNode.parse({ start: [0, 0], end: [4, 0], height: 2.5, thickness: 0.1 });
+        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0.6, 0.05, [
+            { start: 0, end: 0.5, elevation: 0.6 },
+            { start: 0.5, end: 1, elevation: 0.05 },
+        ]);
+        const position = geometry.getAttribute('position');
+        let highSpanMinY = Number.POSITIVE_INFINITY;
+        let lowSpanMinY = Number.POSITIVE_INFINITY;
+        for (let index = 0; index < position.count; index++) {
+            const x = position.getX(index);
+            const y = position.getY(index);
+            if (x < 1.9)
+                highSpanMinY = Math.min(highSpanMinY, y);
+            if (x > 2.1)
+                lowSpanMinY = Math.min(lowSpanMinY, y);
+        }
+        expect(highSpanMinY).toBeCloseTo(0);
+        expect(lowSpanMinY).toBeCloseTo(-0.55);
+        geometry.dispose();
+    });
+});

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

@@ -1,11 +1,7 @@
-import { type AnyNode, type WallMiterData, type WallNode } from '@pascal-app/core';
+import { type AnyNode, type WallMiterData, type WallNode, type WallSlabSupportSegment } from '@pascal-app/core';
 import * as THREE from 'three';
 export declare const WallSystem: () => null;
-/**
- * Generates extruded wall geometry with mitering and cutouts
- *
- * Key insight from demo: polygon is built in WORLD coordinates first,
- * then we transform to wall-local for the 3D mesh.
- */
-export declare function generateExtrudedWall(wallNode: WallNode, childrenNodes: AnyNode[], miterData: WallMiterData, slabElevation?: number): THREE.BufferGeometry;
+type WallTerrainBottomSampler = (x: number, z: number) => number | null;
+export declare function generateExtrudedWall(wallNode: WallNode, childrenNodes: AnyNode[], miterData: WallMiterData, slabElevation?: number, baseElevation?: number, baseSegments?: readonly WallSlabSupportSegment[], storeyHeight?: number, terrainBottomAt?: WallTerrainBottomSampler): THREE.BufferGeometry;
+export {};
 //# sourceMappingURL=wall-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAqBZ,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA8T9B,eAAO,MAAM,UAAU,YAwJtB,CAAA;AAkGD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,GAChB,KAAK,CAAC,cAAc,CAyGtB"}
+{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EA2BZ,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,sBAAsB,EAI5B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAqd9B,eAAO,MAAM,UAAU,YAwJtB,CAAA;AAgND,KAAK,wBAAwB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;AAgEvE,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,EACjB,aAAa,SAAgB,EAC7B,YAAY,GAAE,SAAS,sBAAsB,EAE5C,EACD,YAAY,SAAuB,EACnC,eAAe,CAAC,EAAE,wBAAwB,GACzC,KAAK,CAAC,cAAc,CA0OtB"}