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

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

@@ -1,95 +1,21 @@
-import { getEffectiveNode, getRenderableSlabPolygon, pointInPolygon2D, polygonsIntersect, sceneRegistry, useScene, } from '@pascal-app/core';
-import { useFrame } from '@react-three/fiber';
-import { useEffect } from 'react';
+import { getRenderableSlabPolygon, pointInPolygon2D, polygonsIntersect, } from '@pascal-app/core';
 import * as THREE from 'three';
 import { subtractPolygonsFromPolygon } from '../../lib/polygon-union';
 import { mergeSurfaceHolePolygons } from '../surface-hole-geometry';
-function ensureUv2Attribute(geometry) {
-    const uv = geometry.getAttribute('uv');
-    if (!uv)
-        return;
-    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
-}
 // ============================================================================
-// SLAB SYSTEM
+// SLAB GEOMETRY GENERATORS
 // ============================================================================
-export const SlabSystem = () => {
-    const dirtyNodes = useScene((state) => state.dirtyNodes);
-    const clearDirty = useScene((state) => state.clearDirty);
-    const markDirty = useScene((state) => state.markDirty);
-    useEffect(() => {
-        const nodes = useScene.getState().nodes;
-        for (const node of Object.values(nodes)) {
-            if (node.type === 'slab') {
-                markDirty(node.id);
-            }
-        }
-    }, [markDirty]);
-    useFrame(() => {
-        if (dirtyNodes.size === 0)
-            return;
-        const nodes = useScene.getState().nodes;
-        const contextByLevel = new Map();
-        // Process dirty slabs
-        dirtyNodes.forEach((id) => {
-            const node = nodes[id];
-            if (node?.type !== 'slab')
-                return;
-            const mesh = sceneRegistry.nodes.get(id);
-            if (mesh) {
-                const slab = node;
-                const levelContext = contextByLevel.get(slab.parentId) ?? buildLevelSlabContext(slab.parentId, nodes);
-                contextByLevel.set(slab.parentId, levelContext);
-                updateSlabGeometry(getEffectiveNode(slab), excludeSlabFromContext(levelContext, slab.id), mesh);
-                clearDirty(id);
-            }
-            // If mesh not found, keep it dirty for next frame
-        });
-    }, 1);
-    return null;
-};
-function buildLevelSlabContext(levelId, nodes) {
-    const walls = [];
-    const siblingSlabs = [];
-    for (const node of Object.values(nodes)) {
-        if (node.parentId !== levelId)
-            continue;
-        if (node.type === 'wall')
-            walls.push(node);
-        else if (node.type === 'slab')
-            siblingSlabs.push(node);
-    }
-    return { walls, siblingSlabs };
-}
-function excludeSlabFromContext(context, slabId) {
-    return {
-        walls: context.walls,
-        siblingSlabs: context.siblingSlabs.filter((slab) => slab.id !== slabId),
-    };
-}
-/**
- * Updates the geometry for a single slab
- */
-function updateSlabGeometry(node, context, mesh) {
-    const newGeo = generateSlabGeometry(node, context);
-    ensureUv2Attribute(newGeo);
-    mesh.geometry.dispose();
-    mesh.geometry = newGeo;
-    // For negative elevation, shift the mesh down so the top face sits at Y=elevation
-    // rather than at Y=0. Positive elevation stays at Y=0 (slab sits at floor level).
-    const elevation = node.elevation ?? 0.05;
-    mesh.position.y = elevation < 0 ? elevation : 0;
-}
 /**
- * Generates extruded slab geometry from polygon. `context` carries the
- * slab's level neighbourhood (walls + sibling slabs) driving the per-edge
- * render offsets — see `getRenderableSlabPolygon`.
+ * Generates slab geometry from polygon. `context` carries the slab's level
+ * neighbourhood (walls + sibling slabs) driving the per-edge render offsets —
+ * see `getRenderableSlabPolygon`. Branches on the explicit `recessed` intent:
+ * a recessed slab is an open shell (pool), everything else a solid occupying
+ * `[elevation − thickness, elevation]`.
  */
 export function generateSlabGeometry(slabNode, context) {
-    const elevation = slabNode.elevation ?? 0.05;
-    return elevation < 0
+    return slabNode.recessed
         ? generatePoolGeometry(slabNode, context)
-        : generatePositiveSlabGeometry(slabNode, context);
+        : generateSolidSlabGeometry(slabNode, context);
 }
 // 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
@@ -131,7 +57,8 @@ function buildSlabRegions(contour, holes) {
     }));
 }
 /**
- * Standard slab: flat extrusion upward from Y=0 by elevation thickness.
+ * Solid slab occupying `[elevation − thickness, elevation]`: the top cap is
+ * the walking surface at `elevation`, the body grows downward by `thickness`.
  *
  * Built directly in 3D (Y-up) rather than via ExtrudeGeometry so the hole side
  * walls can be emitted double-sided. The slab material is forced to FrontSide
@@ -142,9 +69,11 @@ 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 generatePositiveSlabGeometry(slabNode, context) {
+function generateSolidSlabGeometry(slabNode, context) {
     const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context));
     const elevation = slabNode.elevation ?? 0.05;
+    const thickness = slabNode.thickness ?? 0.05;
+    const bottom = elevation - thickness;
     const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
     if (polygon.length < 3)
         return new THREE.BufferGeometry();
@@ -158,14 +87,14 @@ function generatePositiveSlabGeometry(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, 0, a.y);
+        positions.push(a.x, bottom, a.y);
         uvs.push(0, 0);
-        positions.push(b.x, 0, b.y);
+        positions.push(b.x, bottom, b.y);
         uvs.push(len, 0);
         positions.push(b.x, elevation, b.y);
-        uvs.push(len, elevation);
+        uvs.push(len, thickness);
         positions.push(a.x, elevation, a.y);
-        uvs.push(0, elevation);
+        uvs.push(0, thickness);
         // Standard winding on a CCW polygon gives inward-facing normals (see pool
         // path), so the unflipped quad faces outward; flipped is its back face.
         if (!flipped) {
@@ -192,7 +121,7 @@ function generatePositiveSlabGeometry(slabNode, context) {
         }
         const bottomBase = positions.length / 3;
         for (const p of capPoints) {
-            positions.push(p.x, 0, p.y);
+            positions.push(p.x, bottom, p.y);
             uvs.push(p.x, -p.y);
         }
         const capTris = THREE.ShapeUtils.triangulateShape(contour2d, holes2d);
@@ -222,8 +151,8 @@ function generatePositiveSlabGeometry(slabNode, context) {
     return geometry;
 }
 /**
- * Pool / recessed slab: floor cap at Y=0 (local) + inner walls up to Y=|elevation|.
- * No top cap — the opening at ground level is handled by the ground occluder hole.
+ * Pool / recessed slab: floor cap at Y=0 (local) + inner walls up to the rim.
+ * No top cap — the opening at the rim is handled by the ground occluder hole.
  * mesh.position.y must be set to elevation so the floor sits at the correct world Y.
  *
  * Geometry is built directly in 3D (Y-up) to avoid rotation confusion:
@@ -232,7 +161,8 @@ function generatePositiveSlabGeometry(slabNode, context) {
  */
 function generatePoolGeometry(slabNode, context) {
     const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context));
-    const depth = Math.abs(slabNode.elevation ?? 0.05);
+    const floor = slabNode.elevation ?? 0.05;
+    const depth = Math.max(0, (slabNode.recessedRimElevation ?? 0) - floor);
     const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
     if (polygon.length < 3)
         return new THREE.BufferGeometry();
@@ -241,7 +171,7 @@ function generatePoolGeometry(slabNode, context) {
     const indices = [];
     const pushFloorVertex = (x, y, z) => {
         positions.push(x, y, z);
-        // Floor UVs in metres (shape-space x, -z), matching generatePositiveSlabGeometry's
+        // Floor UVs in metres (shape-space x, -z), matching generateSolidSlabGeometry's
         // cap mapping so a finish tiles at the same world scale on every surface.
         uvs.push(x, -z);
     };

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

@@ -4,6 +4,12 @@ import { describe, expect, test } from 'bun:test';
 import { SlabNode } from '@pascal-app/core';
 import { generateSlabGeometry } from './slab-system';
 const EMPTY_CONTEXT = { walls: [], siblingSlabs: [] };
+const SQUARE = [
+    [0, 0],
+    [4, 0],
+    [4, 3],
+    [0, 3],
+];
 function hasVertexAt(geometry, x, z) {
     const positions = geometry.getAttribute('position');
     for (let index = 0; index < positions.count; index += 1) {
@@ -13,16 +19,19 @@ function hasVertexAt(geometry, x, z) {
     }
     return false;
 }
+function uniqueSortedYs(geometry) {
+    const positions = geometry.getAttribute('position');
+    const ys = new Set();
+    for (let index = 0; index < positions.count; index += 1) {
+        ys.add(Math.round(positions.getY(index) * 1e4) / 1e4);
+    }
+    return [...ys].sort((a, b) => a - b);
+}
 describe('generateSlabGeometry', () => {
     test('renders a boundary-overlapping hole as an open indentation', () => {
         const slab = SlabNode.parse({
             elevation: 0.05,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
+            polygon: SQUARE,
             holes: [
                 [
                     [1, -0.5],
@@ -40,12 +49,8 @@ describe('generateSlabGeometry', () => {
     test('renders a boundary-overlapping hole as an open indentation on recessed slabs', () => {
         const slab = SlabNode.parse({
             elevation: -0.2,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
+            recessed: true,
+            polygon: SQUARE,
             holes: [
                 [
                     [1, -0.5],
@@ -60,4 +65,38 @@ describe('generateSlabGeometry', () => {
         expect(hasVertexAt(geometry, 1, 1)).toBe(true);
         expect(hasVertexAt(geometry, 3, 1)).toBe(true);
     });
+    test('solid slab occupies [elevation − thickness, elevation]', () => {
+        const slab = SlabNode.parse({ elevation: 0.3, thickness: 0.1, polygon: SQUARE });
+        const ys = uniqueSortedYs(generateSlabGeometry(slab, EMPTY_CONTEXT));
+        expect(ys).toEqual([0.2, 0.3]);
+    });
+    test('migrated legacy slab (thickness = elevation) reproduces the [0, elevation] extrusion', () => {
+        const slab = SlabNode.parse({ elevation: 0.05, thickness: 0.05, polygon: SQUARE });
+        const geometry = generateSlabGeometry(slab, EMPTY_CONTEXT);
+        // Old-style expectations: extrude-from-zero put the bottom cap at 0 and
+        // the top cap at `elevation`, with 8 cap verts + 4 side quads (16 verts)
+        // and 12 triangles for a plain quad slab.
+        expect(uniqueSortedYs(geometry)).toEqual([0, 0.05]);
+        expect(geometry.getAttribute('position').count).toBe(24);
+        expect((geometry.index?.count ?? 0) / 3).toBe(12);
+        for (const [x, z] of SQUARE) {
+            expect(hasVertexAt(geometry, x, z)).toBe(true);
+        }
+    });
+    test('recess is keyed by the flag, not the elevation sign', () => {
+        const belowPlaneSolid = SlabNode.parse({ elevation: -0.2, thickness: 0.05, polygon: SQUARE });
+        // Without `recessed`, a negative elevation is just a solid placed below
+        // the level plane: closed body at [-0.25, -0.2], world-space Y baked in.
+        expect(uniqueSortedYs(generateSlabGeometry(belowPlaneSolid, EMPTY_CONTEXT))).toEqual([
+            -0.25, -0.2,
+        ]);
+        // The recessed shell is authored at local Y=0 (floor) up to |elevation|
+        // (rim), with no top cap: 4 floor verts + 4 wall quads = 20 verts,
+        // 2 floor + 8 wall triangles.
+        const pool = SlabNode.parse({ elevation: -0.2, recessed: true, polygon: SQUARE });
+        const poolGeometry = generateSlabGeometry(pool, EMPTY_CONTEXT);
+        expect(uniqueSortedYs(poolGeometry)).toEqual([0, 0.2]);
+        expect(poolGeometry.getAttribute('position').count).toBe(20);
+        expect((poolGeometry.index?.count ?? 0) / 3).toBe(10);
+    });
 });

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

@@ -106,7 +106,7 @@ export const StairSystem = () => {
             if (group) {
                 const mergedMesh = group.getObjectByName('merged-stair');
                 if (mergedMesh?.visible !== false) {
-                    updateMergedStairGeometry(node, group, nodes);
+                    updateMergedStairGeometry(getEffectiveNode(node), group, nodes);
                     stairsProcessed++;
                 }
             }

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

@@ -1 +1 @@
-{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAqDA,eAAO,MAAM,UAAU,YAyKtB,CAAA"}
+{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAyDA,eAAO,MAAM,UAAU,YAuLtB,CAAA"}

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

@@ -1,4 +1,4 @@
-import { emitter, getWallFaceBandConfig, sceneRegistry, useScene, } from '@pascal-app/core';
+import { emitter, getWallFaceBandConfig, getWallPlaneTop, resolveLevelId, resolveWallEffectiveHeight, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { Vector3 } from 'three/webgpu';
@@ -101,7 +101,10 @@ export const WallCutout = () => {
                 const hideWall = getWallHideState(wallNode, wallMesh, wallMode, u);
                 const isDeleteHighlighted = deleteHoveredWallId === wallId;
                 const isSelectionHighlighted = !isDeleteHighlighted && highlightedWallIds.has(wallId);
-                const shouldSelectionHighlight = isSelectionHighlighted && !getWallFaceBandConfig(wallNode).enabled;
+                const levelId = resolveLevelId(wallNode, sceneState.nodes);
+                const support = spatialGridManager.getSlabSupportForWall(levelId, wallNode.start, wallNode.end, wallNode.curveOffset ?? 0, wallNode.thickness, wallNode.supportSlabId);
+                const effectiveWallHeight = resolveWallEffectiveHeight(wallNode, getWallPlaneTop(wallNode, levelId, sceneState.nodes), support.elevation);
+                const shouldSelectionHighlight = isSelectionHighlighted && !getWallFaceBandConfig(wallNode, effectiveWallHeight).enabled;
                 const materials = getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme, sceneState.materials);
                 if (wallMode === 'translucent') {
                     ;

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

@@ -1,7 +1,7 @@
 // @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, WallNode } from '@pascal-app/core';
+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', () => {
@@ -24,6 +24,74 @@ describe('wall support extension', () => {
         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, [

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

@@ -1,11 +1,7 @@
 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, baseElevation?: number, baseSegments?: readonly WallSlabSupportSegment[]): 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,EAwBZ,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,sBAAsB,EAI5B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA4c9B,eAAO,MAAM,UAAU,YAwJtB,CAAA;AA2LD;;;;;GAKG;AACH,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,GACA,KAAK,CAAC,cAAc,CAsNtB"}
+{"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"}

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

@@ -1,9 +1,11 @@
-import { calculateLevelMiters, DEFAULT_WALL_HEIGHT, getAdjacentWallIds, getEffectiveNode, getWallBandSlotId, getWallCurveFrameAt, getWallFaceBandConfig, getWallFaceBandForHeight, getWallMiterBoundaryPoints, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { calculateLevelMiters, DEFAULT_LEVEL_HEIGHT, getAdjacentWallIds, getEffectiveNode, getWallBandSlotId, getWallCurveFrameAt, getWallFaceBandConfig, getWallFaceBandForHeight, getWallMiterBoundaryPoints, getWallPlaneTop, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, resolveWallTop, sceneRegistry, spatialGridManager, terrainSupportLift, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
 import { computeBoundsTree } from 'three-mesh-bvh';
 import { ensureRenderableGeometryAttributes, prepareBrushForCSG } from '../../lib/csg-utils';
+import { buildTerrainPerimeterFillGeometry } from '../../lib/terrain-perimeter-fill';
 import { buildOpeningCutoutGeometry, getOpeningCutoutBottomPadding, } from './opening-cutout-geometry';
 // Reusable CSG evaluator for better performance
 const csgEvaluator = new Evaluator();
@@ -133,17 +135,17 @@ function distanceToWallBoundaryEdge(point, edge) {
     const closestZ = edge.start.y + edgeDz * t;
     return Math.hypot(point.x - closestX, point.y - closestZ);
 }
-function getWallFaceMaterialIndex(wall, face, y) {
+function getWallFaceMaterialIndex(wall, face, y, effectiveWallHeight) {
     const semantic = face === 'front' ? wall.frontSide : wall.backSide;
     const fallback = face === 'front' ? 'interior' : 'exterior';
     const side = semantic === 'interior' || semantic === 'exterior' ? semantic : fallback;
-    const bands = getWallFaceBandConfig(wall);
+    const bands = getWallFaceBandConfig(wall, effectiveWallHeight);
     if (!bands.enabled)
         return WALL_BAND_SLOT_MATERIAL_INDEX[side];
-    const band = getWallFaceBandForHeight(wall, y);
+    const band = getWallFaceBandForHeight(wall, y, effectiveWallHeight);
     return WALL_BAND_SLOT_MATERIAL_INDEX[getWallBandSlotId(side, band)];
 }
-function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
+function assignWallMaterialGroups(geometry, wall, boundaryEdges, effectiveWallHeight) {
     const position = geometry.getAttribute('position');
     if (!position)
         return;
@@ -206,7 +208,7 @@ function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
             triangleMaterials[triangleIndex] = 0;
             continue;
         }
-        triangleMaterials[triangleIndex] = getWallFaceMaterialIndex(wall, nearestTag, centroid.y);
+        triangleMaterials[triangleIndex] = getWallFaceMaterialIndex(wall, nearestTag, centroid.y, effectiveWallHeight);
     }
     geometry.clearGroups();
     let currentMaterial = triangleMaterials[0] ?? 0;
@@ -309,8 +311,8 @@ function splitGeometryAtHorizontalPlanes(geometry, planes) {
     split.computeVertexNormals();
     return split;
 }
-function getWallBandSplitPlanes(wall) {
-    const bands = getWallFaceBandConfig(wall);
+function getWallBandSplitPlanes(wall, effectiveWallHeight) {
+    const bands = getWallFaceBandConfig(wall, effectiveWallHeight);
     if (!bands.enabled)
         return [];
     const planes = [bands.lowerTop];
@@ -318,7 +320,7 @@ function getWallBandSplitPlanes(wall) {
         planes.push(bands.middleTop);
     if (bands.count >= 4)
         planes.push(bands.upperTop);
-    return planes.filter((plane) => plane > WALL_BAND_SPLIT_EPSILON && plane < (wall.height ?? 2.5) - WALL_BAND_SPLIT_EPSILON);
+    return planes.filter((plane) => plane > WALL_BAND_SPLIT_EPSILON && plane < effectiveWallHeight - WALL_BAND_SPLIT_EPSILON);
 }
 // ============================================================================
 // WALL SYSTEM
@@ -529,8 +531,14 @@ function updateWallGeometry(wallId, miterData) {
     if (!mesh)
         return;
     const levelId = resolveLevelId(node, nodes);
-    const slabSupport = spatialGridManager.getSlabSupportForWall(levelId, node.start, node.end, node.curveOffset ?? 0, node.thickness);
+    // Covering-clamped plane: a flush/thick slab on the level above shortens
+    // the plane-bound walls below it (explicit-height walls ignore the value).
+    const planeTop = getWallPlaneTop(node, levelId, nodes);
+    const slabSupport = spatialGridManager.getSlabSupportForWall(levelId, node.start, node.end, node.curveOffset ?? 0, node.thickness, node.supportSlabId, undefined, node.supportOffset);
     const slabElevation = slabSupport.elevation;
+    const terrainBottomAt = node.fillToTerrain
+        ? (x, z) => terrainSupportLift(nodes, levelId, x, z)
+        : undefined;
     const childrenIds = node.children || [];
     // Merge live overrides into door / window children so cutouts track an
     // in-flight resize drag (door width arrow, window height arrow, etc.)
@@ -552,7 +560,7 @@ function updateWallGeometry(wallId, miterData) {
             return effective;
         return { ...effective, position: live.position };
     });
-    const builtGeo = generateExtrudedWall(node, childrenNodes, miterData, slabElevation, slabSupport.baseElevation, slabSupport.baseSegments);
+    const builtGeo = generateExtrudedWall(node, childrenNodes, miterData, slabElevation, slabSupport.baseElevation, slabSupport.baseSegments, planeTop, terrainBottomAt);
     const wallAngle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]);
     // World transform the render mesh will apply (position + Y-rotation below).
     // Reproduce it here so the UVs can be projected in WORLD space — see
@@ -564,7 +572,7 @@ function updateWallGeometry(wallId, miterData) {
     // Update collision mesh
     const collisionMesh = mesh.getObjectByName('collision-mesh');
     if (collisionMesh) {
-        const collisionGeo = generateExtrudedWall(node, [], miterData, slabElevation, slabSupport.baseElevation, slabSupport.baseSegments);
+        const collisionGeo = generateExtrudedWall(node, [], miterData, slabElevation, slabSupport.baseElevation, slabSupport.baseSegments, planeTop, terrainBottomAt);
         collisionMesh.geometry.dispose();
         collisionMesh.geometry = collisionGeo;
     }
@@ -635,16 +643,70 @@ function applyWorldPlanarWallUVs(geometry, worldMatrix) {
  * Key insight from demo: polygon is built in WORLD coordinates first,
  * then we transform to wall-local for the 3D mesh.
  */
+const WALL_TERRAIN_SAMPLE_STEP = 0.25;
+function densifyClosedWallPerimeter(points) {
+    const dense = [];
+    for (let index = 0; index < points.length; index += 1) {
+        const start = points[index];
+        const end = points[(index + 1) % points.length];
+        const length = Math.hypot(end.x - start.x, end.y - start.y);
+        const segments = Math.max(1, Math.ceil(length / WALL_TERRAIN_SAMPLE_STEP));
+        for (let segment = 0; segment < segments; segment += 1) {
+            const t = segment / segments;
+            dense.push({
+                x: start.x + (end.x - start.x) * t,
+                y: start.y + (end.y - start.y) * t,
+            });
+        }
+    }
+    return dense;
+}
+function buildWallTerrainFillGeometry(perimeter, worldToLocal, wallBaseElevation, terrainBottomAt) {
+    const worldPoints = densifyClosedWallPerimeter(perimeter);
+    if (worldPoints.length < 3)
+        return null;
+    const localPoints = worldPoints.map(worldToLocal);
+    const bottomY = worldPoints.map((point) => {
+        const terrainElevation = terrainBottomAt(point.x, point.y);
+        return terrainElevation == null ? 0 : Math.min(0, terrainElevation - wallBaseElevation);
+    });
+    return buildTerrainPerimeterFillGeometry(localPoints, bottomY, 0);
+}
+function mergeWallTerrainFill(body, fill, wall, boundaryEdges, effectiveWallHeight) {
+    if (!fill)
+        return body;
+    const bodyGeometry = body.index ? body.toNonIndexed() : body;
+    if (bodyGeometry !== body)
+        body.dispose();
+    ensureRenderableGeometryAttributes(bodyGeometry);
+    ensureRenderableGeometryAttributes(fill);
+    const merged = mergeGeometries([bodyGeometry, fill], false);
+    if (!merged) {
+        fill.dispose();
+        return bodyGeometry;
+    }
+    bodyGeometry.dispose();
+    fill.dispose();
+    merged.computeVertexNormals();
+    assignWallMaterialGroups(merged, wall, boundaryEdges, effectiveWallHeight);
+    ensureRenderableGeometryAttributes(merged);
+    return merged;
+}
 export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabElevation = 0, baseElevation = slabElevation, baseSegments = [
     { start: 0, end: 1, elevation: baseElevation },
-]) {
+], storeyHeight = DEFAULT_LEVEL_HEIGHT, terrainBottomAt) {
     const wallStart = { x: wallNode.start[0], y: wallNode.start[1] };
     const wallEnd = { x: wallNode.end[0], y: wallNode.end[1] };
-    const wallHeight = wallNode.height ?? DEFAULT_WALL_HEIGHT;
-    const topElevation = slabElevation > 0 ? slabElevation + wallHeight : wallHeight;
+    const topElevation = resolveWallTop(wallNode, storeyHeight, slabElevation);
+    const effectiveWallHeight = topElevation - slabElevation;
     const effectiveBaseElevation = Math.min(baseElevation, slabElevation);
     const localBottom = effectiveBaseElevation - slabElevation;
     const height = topElevation - effectiveBaseElevation;
+    // A slab at or above the storey plane leaves a plane-bound wall with no
+    // body — bail before ExtrudeGeometry sees a non-positive depth.
+    if (height <= 1e-9) {
+        return new THREE.BufferGeometry();
+    }
     const thickness = getWallThickness(wallNode);
     // Wall direction and normal (exactly like demo)
     const v = { x: wallEnd.x - wallStart.x, y: wallEnd.y - wallStart.y };
@@ -675,6 +737,9 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     // Convert polygon to local coordinates
     const localPoints = polyPoints.map(worldToLocal);
     const boundaryEdges = buildTaggedWallBoundaryEdges(wallNode, localPoints, miterData);
+    const terrainFill = terrainBottomAt
+        ? buildWallTerrainFillGeometry(polyPoints, worldToLocal, slabElevation, terrainBottomAt)
+        : null;
     // Build THREE.js shape
     // Shape uses (x, y) where we map: shape.x = local.x, shape.y = -local.z
     // The negation is needed because after rotateX(-PI/2), shape.y becomes -geometry.z
@@ -694,7 +759,7 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     if (Math.abs(localBottom) > 1e-9)
         geometry.translate(0, localBottom, 0);
     geometry.computeVertexNormals();
-    assignWallMaterialGroups(geometry, wallNode, boundaryEdges);
+    assignWallMaterialGroups(geometry, wallNode, boundaryEdges, effectiveWallHeight);
     ensureRenderableGeometryAttributes(geometry);
     // Start with the lowest required wall prism, then remove the volume below
     // each higher-supported run. This keeps the existing mitered footprint and
@@ -785,11 +850,11 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
         ...collectCutoutBrushes(wallNode, childrenNodes, thickness),
     ];
     if (cutoutBrushes.length === 0) {
-        const splitGeometry = splitGeometryAtHorizontalPlanes(geometry, getWallBandSplitPlanes(wallNode));
+        const splitGeometry = splitGeometryAtHorizontalPlanes(geometry, getWallBandSplitPlanes(wallNode, effectiveWallHeight));
         splitGeometry.computeVertexNormals();
-        assignWallMaterialGroups(splitGeometry, wallNode, boundaryEdges);
+        assignWallMaterialGroups(splitGeometry, wallNode, boundaryEdges, effectiveWallHeight);
         ensureRenderableGeometryAttributes(splitGeometry);
-        return splitGeometry;
+        return mergeWallTerrainFill(splitGeometry, terrainFill, wallNode, boundaryEdges, effectiveWallHeight);
     }
     // Create wall brush from geometry
     // Pre-compute BVH with new API to avoid deprecation warning
@@ -814,11 +879,11 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
         csgGeometry(brush).dispose();
     }
     const resultGeometry = csgGeometry(resultBrush);
-    const splitResultGeometry = splitGeometryAtHorizontalPlanes(resultGeometry, getWallBandSplitPlanes(wallNode));
+    const splitResultGeometry = splitGeometryAtHorizontalPlanes(resultGeometry, getWallBandSplitPlanes(wallNode, effectiveWallHeight));
     splitResultGeometry.computeVertexNormals();
-    assignWallMaterialGroups(splitResultGeometry, wallNode, boundaryEdges);
+    assignWallMaterialGroups(splitResultGeometry, wallNode, boundaryEdges, effectiveWallHeight);
     ensureRenderableGeometryAttributes(splitResultGeometry);
-    return splitResultGeometry;
+    return mergeWallTerrainFill(splitResultGeometry, terrainFill, wallNode, boundaryEdges, effectiveWallHeight);
 }
 /**
  * Collects opening and item cutout brushes for CSG subtraction. Door/window

package/dist/systems/wall/wall-terrain-bottom.test.d.ts

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

package/dist/systems/wall/wall-terrain-bottom.test.d.ts.map

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