@pascal-app/viewer 0.8.0 → 0.9.1

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

@@ -1,6 +1,9 @@
-import { getRenderableSlabPolygon, sceneRegistry, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, getRenderableSlabPolygon, pointInPolygon2D, polygonsIntersect, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
+import { useEffect } from 'react';
 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)
@@ -13,6 +16,15 @@ function ensureUv2Attribute(geometry) {
 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;
@@ -24,7 +36,7 @@ export const SlabSystem = () => {
                 return;
             const mesh = sceneRegistry.nodes.get(id);
             if (mesh) {
-                updateSlabGeometry(node, mesh);
+                updateSlabGeometry(getEffectiveNode(node), mesh);
                 clearDirty(id);
             }
             // If mesh not found, keep it dirty for next frame
@@ -52,31 +64,133 @@ export function generateSlabGeometry(slabNode) {
     const elevation = slabNode.elevation ?? 0.05;
     return elevation < 0 ? generatePoolGeometry(slabNode) : generatePositiveSlabGeometry(slabNode);
 }
+// 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
+// outward only for CCW). outsetPolygon and the slab tool preserve the drawn
+// winding, so a CW-drawn slab gets inward-facing walls that FrontSide culls and
+// the slab reads as see-through from the front. Normalize to CCW first.
+function ensureCounterClockwisePolygon(polygon) {
+    let area2 = 0;
+    for (let i = 0; i < polygon.length; i++) {
+        const j = (i + 1) % polygon.length;
+        area2 += polygon[i][0] * polygon[j][1] - polygon[j][0] * polygon[i][1];
+    }
+    return area2 < 0 ? [...polygon].reverse() : polygon;
+}
+function isStrictInteriorHole(contour, hole) {
+    return (hole.every((point) => pointInPolygon2D(point, contour, { includeBoundary: false })) &&
+        !polygonsIntersect(contour, hole));
+}
+function affectsContour(contour, hole) {
+    return (polygonsIntersect(contour, hole) ||
+        hole.some((point) => pointInPolygon2D(point, contour, { includeBoundary: false })) ||
+        contour.some((point) => pointInPolygon2D(point, hole, { includeBoundary: false })));
+}
+function buildSlabRegions(contour, holes) {
+    const containedHoles = [];
+    const edgeCutouts = [];
+    for (const hole of holes) {
+        if (hole.length < 3)
+            continue;
+        if (isStrictInteriorHole(contour, hole))
+            containedHoles.push(hole);
+        else if (affectsContour(contour, hole))
+            edgeCutouts.push(hole);
+    }
+    const contours = edgeCutouts.length > 0 ? subtractPolygonsFromPolygon(contour, edgeCutouts) : [contour];
+    return contours.map((regionContour) => ({
+        contour: regionContour,
+        holes: containedHoles.filter((hole) => isStrictInteriorHole(regionContour, hole)),
+    }));
+}
 /**
  * Standard slab: flat extrusion upward from Y=0 by elevation 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
+ * (DoubleSide on the floor-role NodeMaterial poisons the MRT scene pass — see
+ * nodes/slab/geometry.ts), and ExtrudeGeometry's hole walls are single-sided,
+ * so their interior faces get back-face culled and you see straight through the
+ * cut. Emitting each hole-wall quad twice with opposite winding makes the inner
+ * thickness visible from any angle: the two coincident triangles never z-fight
+ * because exactly one faces the camera under FrontSide culling.
  */
 function generatePositiveSlabGeometry(slabNode) {
-    const polygon = getRenderableSlabPolygon(slabNode);
+    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode));
     const elevation = slabNode.elevation ?? 0.05;
+    const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
     if (polygon.length < 3)
         return new THREE.BufferGeometry();
-    const shape = new THREE.Shape();
-    shape.moveTo(polygon[0][0], -polygon[0][1]);
-    for (let i = 1; i < polygon.length; i++)
-        shape.lineTo(polygon[i][0], -polygon[i][1]);
-    shape.closePath();
-    for (const holePolygon of slabNode.holes ?? []) {
-        if (holePolygon.length < 3)
-            continue;
-        const holePath = new THREE.Path();
-        holePath.moveTo(holePolygon[0][0], -holePolygon[0][1]);
-        for (let i = 1; i < holePolygon.length; i++)
-            holePath.lineTo(holePolygon[i][0], -holePolygon[i][1]);
-        holePath.closePath();
-        shape.holes.push(holePath);
+    const positions = [];
+    const uvs = [];
+    const indices = [];
+    // --- Side walls ---
+    // Each segment gets its own 4 verts so computeVertexNormals doesn't average
+    // across faces. Outer walls are single-sided with outward normals; hole walls
+    // emit a second flipped quad (own verts) so they read as double-sided.
+    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);
+        uvs.push(0, 0);
+        positions.push(b.x, 0, b.y);
+        uvs.push(len, 0);
+        positions.push(b.x, elevation, b.y);
+        uvs.push(len, elevation);
+        positions.push(a.x, elevation, a.y);
+        uvs.push(0, elevation);
+        // 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) {
+            indices.push(base, base + 2, base + 1, base, base + 3, base + 2);
+        }
+        else {
+            indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+        }
+    };
+    for (const region of buildSlabRegions(polygon, holePolygons)) {
+        const contour2d = ensureCounterClockwisePolygon(region.contour).map(([x, z]) => new THREE.Vector2(x, z));
+        const holes2d = region.holes
+            .filter((h) => h.length >= 3)
+            .map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
+        // --- Top & bottom caps ---
+        // capPoints order (contour then holes) matches triangulateShape's index space.
+        // UVs reproduce ExtrudeGeometry's WorldUVGenerator mapping (shape-space x,-z)
+        // so textured slabs keep the same floor projection.
+        const capPoints = [...contour2d, ...holes2d.flat()];
+        const topBase = positions.length / 3;
+        for (const p of capPoints) {
+            positions.push(p.x, elevation, p.y);
+            uvs.push(p.x, -p.y);
+        }
+        const bottomBase = positions.length / 3;
+        for (const p of capPoints) {
+            positions.push(p.x, 0, p.y);
+            uvs.push(p.x, -p.y);
+        }
+        const capTris = THREE.ShapeUtils.triangulateShape(contour2d, holes2d);
+        for (const tri of capTris) {
+            const [a, b, c] = [tri[0], tri[1], tri[2]];
+            // Reversed winding → +Y normal on top; standard winding → -Y on bottom.
+            indices.push(topBase + a, topBase + c, topBase + b);
+            indices.push(bottomBase + a, bottomBase + b, bottomBase + c);
+        }
+        for (let i = 0; i < contour2d.length; i++) {
+            addWall(contour2d[i], contour2d[(i + 1) % contour2d.length], false);
+        }
+        for (const hole of holes2d) {
+            for (let i = 0; i < hole.length; i++) {
+                const a = hole[i];
+                const b = hole[(i + 1) % hole.length];
+                addWall(a, b, false);
+                addWall(a, b, true);
+            }
+        }
     }
-    const geometry = new THREE.ExtrudeGeometry(shape, { depth: elevation, bevelEnabled: false });
-    geometry.rotateX(-Math.PI / 2);
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    geometry.setIndex(indices);
     geometry.computeVertexNormals();
     return geometry;
 }
@@ -90,19 +204,19 @@ function generatePositiveSlabGeometry(slabNode) {
  *   - walls from Y=0 to Y=depth, inward-facing normals (visible from inside pool)
  */
 function generatePoolGeometry(slabNode) {
-    const polygon = getRenderableSlabPolygon(slabNode);
+    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode));
     const depth = Math.abs(slabNode.elevation ?? 0.05);
+    const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
     if (polygon.length < 3)
         return new THREE.BufferGeometry();
     const positions = [];
     const uvs = [];
     const indices = [];
-    const n = polygon.length;
     const bounds = new THREE.Box2();
     for (const [x, z] of polygon) {
         bounds.expandByPoint(new THREE.Vector2(x, z));
     }
-    for (const hole of slabNode.holes ?? []) {
+    for (const hole of holePolygons) {
         for (const [x, z] of hole) {
             bounds.expandByPoint(new THREE.Vector2(x, z));
         }
@@ -117,34 +231,38 @@ function generatePoolGeometry(slabNode) {
         positions.push(x, y, z);
         uvs.push(u, v);
     };
-    // --- Floor at Y=0 ---
-    for (const [x, z] of polygon)
-        pushFloorVertex(x, 0, z);
-    const pts2d = polygon.map(([x, z]) => new THREE.Vector2(x, z));
-    const holesPts2d = (slabNode.holes ?? []).map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
-    for (const hole of slabNode.holes ?? []) {
-        for (const [x, z] of hole)
+    for (const region of buildSlabRegions(polygon, holePolygons)) {
+        const contour = ensureCounterClockwisePolygon(region.contour);
+        const floorBase = positions.length / 3;
+        // --- Floor at Y=0 ---
+        for (const [x, z] of contour)
             pushFloorVertex(x, 0, z);
-    }
-    const floorTris = THREE.ShapeUtils.triangulateShape(pts2d, holesPts2d);
-    for (const tri of floorTris) {
-        // Reversed winding → normals point +Y (upward) in XZ plane
-        indices.push(tri[0], tri[2], tri[1]);
-    }
-    // --- Inner walls (no top cap at Y=depth) ---
-    // Standard winding on a CCW polygon in XZ gives inward-facing normals.
-    for (let i = 0; i < n; i++) {
-        const j = (i + 1) % n;
-        const [x0, z0] = polygon[i];
-        const [x1, z1] = polygon[j];
-        const vBase = positions.length / 3;
-        const segmentLength = Math.max(Math.hypot(x1 - x0, z1 - z0), 0.001);
-        pushWallVertex(x0, 0, z0, 0, 0); // v0 — floor level
-        pushWallVertex(x1, 0, z1, segmentLength, 0); // v1 — floor level
-        pushWallVertex(x1, depth, z1, segmentLength, depth); // v2 — ground level
-        pushWallVertex(x0, depth, z0, 0, depth); // v3 — ground level
-        indices.push(vBase, vBase + 1, vBase + 2);
-        indices.push(vBase, vBase + 2, vBase + 3);
+        const pts2d = contour.map(([x, z]) => new THREE.Vector2(x, z));
+        const holesPts2d = region.holes.map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
+        for (const hole of region.holes) {
+            for (const [x, z] of hole)
+                pushFloorVertex(x, 0, z);
+        }
+        const floorTris = THREE.ShapeUtils.triangulateShape(pts2d, holesPts2d);
+        for (const tri of floorTris) {
+            // Reversed winding → normals point +Y (upward) in XZ plane
+            indices.push(floorBase + tri[0], floorBase + tri[2], floorBase + tri[1]);
+        }
+        // --- Inner walls (no top cap at Y=depth) ---
+        // Standard winding on a CCW polygon in XZ gives inward-facing normals.
+        for (let i = 0; i < contour.length; i++) {
+            const j = (i + 1) % contour.length;
+            const [x0, z0] = contour[i];
+            const [x1, z1] = contour[j];
+            const vBase = positions.length / 3;
+            const segmentLength = Math.max(Math.hypot(x1 - x0, z1 - z0), 0.001);
+            pushWallVertex(x0, 0, z0, 0, 0); // v0 — floor level
+            pushWallVertex(x1, 0, z1, segmentLength, 0); // v1 — floor level
+            pushWallVertex(x1, depth, z1, segmentLength, depth); // v2 — ground level
+            pushWallVertex(x0, depth, z0, 0, depth); // v3 — ground level
+            indices.push(vBase, vBase + 1, vBase + 2);
+            indices.push(vBase, vBase + 2, vBase + 3);
+        }
     }
     const geo = new THREE.BufferGeometry();
     geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));

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

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

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

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

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

@@ -0,0 +1,62 @@
+// @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 { SlabNode } from '@pascal-app/core';
+import { generateSlabGeometry } from './slab-system';
+function hasVertexAt(geometry, x, z) {
+    const positions = geometry.getAttribute('position');
+    for (let index = 0; index < positions.count; index += 1) {
+        if (Math.abs(positions.getX(index) - x) < 1e-6 && Math.abs(positions.getZ(index) - z) < 1e-6) {
+            return true;
+        }
+    }
+    return false;
+}
+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],
+            ],
+            holes: [
+                [
+                    [1, -0.5],
+                    [3, -0.5],
+                    [3, 1],
+                    [1, 1],
+                ],
+            ],
+        });
+        const geometry = generateSlabGeometry(slab);
+        expect((geometry.index?.count ?? 0) / 3).toBeGreaterThan(0);
+        expect(hasVertexAt(geometry, 1, 1)).toBe(true);
+        expect(hasVertexAt(geometry, 3, 1)).toBe(true);
+    });
+    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],
+            ],
+            holes: [
+                [
+                    [1, -0.5],
+                    [3, -0.5],
+                    [3, 1],
+                    [1, 1],
+                ],
+            ],
+        });
+        const geometry = generateSlabGeometry(slab);
+        expect((geometry.index?.count ?? 0) / 3).toBeGreaterThan(0);
+        expect(hasVertexAt(geometry, 1, 1)).toBe(true);
+        expect(hasVertexAt(geometry, 3, 1)).toBe(true);
+    });
+});

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

@@ -1,7 +1,8 @@
 import { type StairNode, type StairSegmentNode } from '@pascal-app/core';
 import type * as THREE from 'three';
+import { type ColorPreset, type RenderShading } from '../../lib/materials';
 export type StairBodyMaterials = [THREE.Material, THREE.Material];
-export declare function getStairBodyMaterials(stair: StairNode): StairBodyMaterials;
-export declare function getStairRailingMaterial(stair: StairNode): THREE.Material;
-export declare function getStraightStairSegmentBodyMaterials(segment: StairSegmentNode, parentNode?: StairNode): StairBodyMaterials;
+export declare function getStairBodyMaterials(stair: StairNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset): StairBodyMaterials;
+export declare function getStairRailingMaterial(stair: StairNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset): THREE.Material;
+export declare function getStraightStairSegmentBodyMaterials(segment: StairSegmentNode, parentNode?: StairNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset): StairBodyMaterials;
 //# sourceMappingURL=stair-materials.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stair-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAOnC,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AA6BjE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,kBAAkB,CAkB1E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,CAAC,QAAQ,CASxE;AAED,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,gBAAgB,EACzB,UAAU,CAAC,EAAE,SAAS,GACrB,kBAAkB,CAWpB"}
+{"version":3,"file":"stair-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EACL,KAAK,WAAW,EAKhB,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAA;AAE5B,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AAoCjE,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,GAChC,kBAAkB,CAqBpB;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,GAChC,KAAK,CAAC,QAAQ,CAoBhB;AAED,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,gBAAgB,EACzB,UAAU,CAAC,EAAE,SAAS,EACtB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,GAChC,kBAAkB,CAsBpB"}

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

@@ -1,5 +1,5 @@
 import { getEffectiveStairSurfaceMaterial, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, DEFAULT_STAIR_MATERIAL, } from '../../lib/materials';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, DEFAULT_STAIR_MATERIAL, } from '../../lib/materials';
 const stairBodyMaterialCache = new Map();
 const stairRailingMaterialCache = new Map();
 function getSurfaceMaterialSignature(spec) {
@@ -8,19 +8,25 @@ function getSurfaceMaterialSignature(spec) {
         materialPreset: spec.materialPreset ?? null,
     });
 }
-function createResolvedMaterial(material, materialPreset) {
+function createResolvedMaterial(material, materialPreset, shading, textures, colorPreset) {
+    if (!textures) {
+        return createSurfaceRoleMaterial('joinery', colorPreset);
+    }
     if (materialPreset) {
-        return createMaterialFromPresetRef(materialPreset) ?? DEFAULT_STAIR_MATERIAL;
+        return createMaterialFromPresetRef(materialPreset, shading) ?? DEFAULT_STAIR_MATERIAL(shading);
     }
     if (material) {
-        return createMaterial(material);
+        return createMaterial(material, shading);
     }
-    return DEFAULT_STAIR_MATERIAL;
+    return DEFAULT_STAIR_MATERIAL(shading);
 }
-export function getStairBodyMaterials(stair) {
+export function getStairBodyMaterials(stair, shading = 'rendered', textures = true, colorPreset = 'clay') {
     const tread = getEffectiveStairSurfaceMaterial(stair, 'tread');
     const side = getEffectiveStairSurfaceMaterial(stair, 'side');
     const cacheKey = JSON.stringify({
+        shading,
+        textures,
+        colorPreset,
         tread: getSurfaceMaterialSignature(tread),
         side: getSurfaceMaterialSignature(side),
     });
@@ -28,29 +34,38 @@ export function getStairBodyMaterials(stair) {
     if (cached)
         return cached;
     const materials = [
-        createResolvedMaterial(tread.material, tread.materialPreset),
-        createResolvedMaterial(side.material, side.materialPreset),
+        createResolvedMaterial(tread.material, tread.materialPreset, shading, textures, colorPreset),
+        createResolvedMaterial(side.material, side.materialPreset, shading, textures, colorPreset),
     ];
     stairBodyMaterialCache.set(cacheKey, materials);
     return materials;
 }
-export function getStairRailingMaterial(stair) {
+export function getStairRailingMaterial(stair, shading = 'rendered', textures = true, colorPreset = 'clay') {
     const railing = getEffectiveStairSurfaceMaterial(stair, 'railing');
-    const cacheKey = getSurfaceMaterialSignature(railing);
+    const cacheKey = JSON.stringify({
+        shading,
+        textures,
+        colorPreset,
+        railing: getSurfaceMaterialSignature(railing),
+    });
     const cached = stairRailingMaterialCache.get(cacheKey);
     if (cached)
         return cached;
-    const material = createResolvedMaterial(railing.material, railing.materialPreset);
+    const material = createResolvedMaterial(railing.material, railing.materialPreset, shading, textures, colorPreset);
     stairRailingMaterialCache.set(cacheKey, material);
     return material;
 }
-export function getStraightStairSegmentBodyMaterials(segment, parentNode) {
+export function getStraightStairSegmentBodyMaterials(segment, parentNode, shading = 'rendered', textures = true, colorPreset = 'clay') {
     if (segment.material !== undefined || typeof segment.materialPreset === 'string') {
-        const override = createResolvedMaterial(segment.material, segment.materialPreset);
+        const override = createResolvedMaterial(segment.material, segment.materialPreset, shading, textures, colorPreset);
         return [override, override];
     }
     if (parentNode) {
-        return getStairBodyMaterials(parentNode);
+        return getStairBodyMaterials(parentNode, shading, textures, colorPreset);
+    }
+    if (!textures) {
+        const material = createSurfaceRoleMaterial('joinery', colorPreset);
+        return [material, material];
     }
-    return [DEFAULT_STAIR_MATERIAL, DEFAULT_STAIR_MATERIAL];
+    return [DEFAULT_STAIR_MATERIAL(shading), DEFAULT_STAIR_MATERIAL(shading)];
 }

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

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

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

@@ -1,6 +1,5 @@
-import { resolveLevelId, sceneRegistry, spatialGridManager, syncAutoStairOpenings, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, getFloorStackedPosition, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
-import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 const pendingStairUpdates = new Set();
@@ -17,26 +16,6 @@ export const StairSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
     const rootNodeIds = useScene((state) => state.rootNodeIds);
-    const syncingAutoOpeningsRef = useRef(false);
-    useEffect(() => {
-        const applyUpdates = (updates) => {
-            if (updates.length === 0)
-                return;
-            syncingAutoOpeningsRef.current = true;
-            useScene.getState().updateNodes(updates);
-            queueMicrotask(() => {
-                syncingAutoOpeningsRef.current = false;
-            });
-        };
-        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
-        return useScene.subscribe((state, prevState) => {
-            if (syncingAutoOpeningsRef.current)
-                return;
-            if (state.nodes === prevState.nodes)
-                return;
-            applyUpdates(syncAutoStairOpenings(state.nodes));
-        });
-    }, []);
     useFrame(() => {
         if (rootNodeIds.length === 0) {
             pendingStairUpdates.clear();
@@ -58,8 +37,13 @@ export const StairSystem = () => {
                 if (mesh) {
                     const isVisible = mesh.parent?.visible !== false;
                     if (isVisible && segmentsProcessed < MAX_SEGMENTS_PER_FRAME) {
-                        // Geometry will be updated; chained position is applied in the parent sync pass below
-                        updateStairSegmentGeometry(node, mesh);
+                        // Geometry will be updated; chained position is applied in the parent sync pass below.
+                        // Merge live overrides so width / length / height drags update the
+                        // mesh in real time — the resize arrows publish to
+                        // `useLiveNodeOverrides` and only commit to scene on pointer-up, so
+                        // without this the geometry would rebuild from the pre-drag values.
+                        const effectiveSegment = getEffectiveNode(node);
+                        updateStairSegmentGeometry(effectiveSegment, mesh);
                         if (node.parentId)
                             parentsNeedingSegmentSync.add(node.parentId);
                         segmentsProcessed++;
@@ -68,11 +52,9 @@ export const StairSystem = () => {
                         return; // Over budget — keep dirty, process next frame
                     }
                     else if (mesh.geometry.type === 'BoxGeometry') {
-                        // Replace BoxGeometry placeholder with empty geometry
+                        // Replace BoxGeometry placeholder with a non-drawing degenerate one.
                         mesh.geometry.dispose();
-                        const placeholder = new THREE.BufferGeometry();
-                        placeholder.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
-                        mesh.geometry = placeholder;
+                        mesh.geometry = createEmptyGeometry();
                     }
                     clearDirty(id);
                 }
@@ -93,9 +75,17 @@ export const StairSystem = () => {
         });
         // --- Pass 1b: Sync chained transforms to individual segment meshes (edit mode) ---
         for (const stairId of parentsNeedingSegmentSync) {
-            const stairNode = nodes[stairId];
-            if (!stairNode || stairNode.type !== 'stair')
+            const baseStairNode = nodes[stairId];
+            if (!baseStairNode || baseStairNode.type !== 'stair')
                 continue;
+            // Merge any in-flight drag override (e.g. parent-stair rotate handle)
+            // so slab-elevation spatial queries match where the segments are
+            // actually being rendered. Without this, dragging the rotate gizmo
+            // looks up slabs at the pre-drag world XZ — if rotation carries a
+            // segment off the original slab footprint, the floor-stack
+            // resolver would otherwise read the pre-drag footprint and drop
+            // the flight or landing below the floor mid-drag.
+            const stairNode = getEffectiveNode(baseStairNode);
             const group = sceneRegistry.nodes.get(stairId);
             if (group) {
                 syncStairGroupElevation(stairNode, group, nodes);
@@ -217,9 +207,14 @@ function updateStairSegmentGeometry(node, mesh) {
  * not by the node's stored position field.
  */
 function syncSegmentMeshTransforms(stairNode, nodes) {
+    // Merge live overrides into each segment so the chain math reflects the
+    // in-flight drag (a width / length change shifts every downstream segment's
+    // anchor). Without this, dragging a width handle would resize the dragged
+    // segment's mesh but leave subsequent segments at their pre-drag positions.
     const segments = (stairNode.children ?? [])
         .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
+        .filter((n) => n?.type === 'stair-segment')
+        .map((n) => getEffectiveNode(n));
     if (segments.length === 0)
         return;
     const transforms = computeSegmentTransforms(segments);
@@ -234,35 +229,20 @@ function syncSegmentMeshTransforms(stairNode, nodes) {
     }
 }
 function syncStairGroupElevation(stairNode, group, nodes) {
-    const levelId = resolveLevelId(stairNode, nodes);
-    const slabElevation = getStairSlabElevation(levelId, stairNode, nodes);
-    group.position.y = stairNode.position[1] + slabElevation;
-}
-function getStairSlabElevation(levelId, stairNode, nodes) {
-    const segments = (stairNode.children ?? [])
-        .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
-    if (segments.length === 0)
-        return 0;
-    const transforms = computeSegmentTransforms(segments);
-    let maxElevation = Number.NEGATIVE_INFINITY;
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        const transform = transforms[i];
-        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, segment.length / 2, transform.rotation);
-        const centerInGroupX = transform.position[0] + centerOffsetX;
-        const centerInGroupZ = transform.position[2] + centerOffsetZ;
-        const [centerOffsetWorldX, centerOffsetWorldZ] = rotateXZ(centerInGroupX, centerInGroupZ, stairNode.rotation);
-        const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, [
-            stairNode.position[0] + centerOffsetWorldX,
-            stairNode.position[1] + transform.position[1],
-            stairNode.position[2] + centerOffsetWorldZ,
-        ], [segment.width, Math.max(segment.height, segment.thickness, 0.01), segment.length], [0, stairNode.rotation + transform.rotation, 0]);
-        if (slabElevation > maxElevation) {
-            maxElevation = slabElevation;
+    const effectiveNodes = { ...nodes, [stairNode.id]: stairNode };
+    for (const childId of stairNode.children ?? []) {
+        const segment = nodes[childId];
+        if (segment?.type === 'stair-segment') {
+            effectiveNodes[segment.id] = getEffectiveNode(segment);
         }
     }
-    return maxElevation === Number.NEGATIVE_INFINITY ? 0 : maxElevation;
+    const visualPosition = getFloorStackedPosition({
+        node: stairNode,
+        nodes: effectiveNodes,
+        position: stairNode.position,
+        rotation: stairNode.rotation,
+    });
+    group.position.y = visualPosition[1];
 }
 // ============================================================================
 // MERGED STAIR GEOMETRY
@@ -281,9 +261,14 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
         return;
     }
     const children = stairNode.children ?? [];
+    // Merge live overrides — same reason as `syncSegmentMeshTransforms`: a
+    // width / length / height drag publishes the new value to
+    // `useLiveNodeOverrides`, so the merged geometry has to read through that
+    // overlay or the merged mesh stays at pre-drag values until pointer-up.
     const segments = children
         .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
+        .filter((n) => n?.type === 'stair-segment')
+        .map((n) => getEffectiveNode(n));
     if (segments.length === 0) {
         replaceMeshGeometry(mergedMesh, createEmptyGeometry());
         return;
@@ -444,7 +429,11 @@ function rotateXZ(x, z, angle) {
 }
 function createEmptyGeometry() {
     const geometry = new THREE.BufferGeometry();
-    geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+    // Three zero-vertices (one degenerate, invisible triangle), not an empty
+    // attribute: an empty position (count 0) leaves WebGPU vertex buffer slot 0
+    // unbound and the draw is rejected ("Vertex buffer slot 0 … was not set"),
+    // poisoning the command encoder. The count-0 groups keep nothing drawn.
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
     geometry.addGroup(0, 0, STAIR_TREAD_MATERIAL_INDEX);
     geometry.addGroup(0, 0, STAIR_SIDE_MATERIAL_INDEX);
     return geometry;
@@ -479,7 +468,7 @@ function generateStairRailingGeometry(stairNode, segments, transforms) {
     for (let index = 1; index < segmentRailPaths.length; index++) {
         const previousPath = segmentRailPaths[index - 1];
         const currentPath = segmentRailPaths[index];
-        if (!(previousPath && currentPath && currentPath.connectFromPrevious))
+        if (!(previousPath && currentPath?.connectFromPrevious))
             continue;
         if (previousPath.segment.segmentType === 'landing')
             continue;

package/dist/systems/surface-hole-geometry.d.ts

@@ -0,0 +1,3 @@
+import { type Point2D } from '../lib/polygon-union';
+export declare function mergeSurfaceHolePolygons(holes: Point2D[][]): Point2D[][];
+//# sourceMappingURL=surface-hole-geometry.d.ts.map

package/dist/systems/surface-hole-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-hole-geometry.d.ts","sourceRoot":"","sources":["../../src/systems/surface-hole-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,sBAAsB,CAAA;AAElE,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAExE"}