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

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

@@ -1,8 +1,11 @@
-import { type SlabNode } from '@pascal-app/core';
+import { type SlabNode, type SlabPolygonContext } from '@pascal-app/core';
 import * as THREE from 'three';
-export declare const SlabSystem: () => null;
 /**
- * Generates extruded slab geometry from polygon
+ * 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 declare function generateSlabGeometry(slabNode: SlabNode): THREE.BufferGeometry;
+export declare function generateSlabGeometry(slabNode: SlabNode, context: SlabPolygonContext): THREE.BufferGeometry;
 //# sourceMappingURL=slab-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAe9B,eAAO,MAAM,UAAU,YAkCtB,CAAA;AAkBD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAG7E"}
+{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,cAAc,CAItB"}

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

@@ -1,68 +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;
-        // Process dirty slabs
-        dirtyNodes.forEach((id) => {
-            const node = nodes[id];
-            if (!node || node.type !== 'slab')
-                return;
-            const mesh = sceneRegistry.nodes.get(id);
-            if (mesh) {
-                updateSlabGeometry(getEffectiveNode(node), mesh);
-                clearDirty(id);
-            }
-            // If mesh not found, keep it dirty for next frame
-        });
-    }, 1);
-    return null;
-};
 /**
- * Updates the geometry for a single slab
+ * 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]`.
  */
-function updateSlabGeometry(node, mesh) {
-    const newGeo = generateSlabGeometry(node);
-    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
- */
-export function generateSlabGeometry(slabNode) {
-    const elevation = slabNode.elevation ?? 0.05;
-    return elevation < 0 ? generatePoolGeometry(slabNode) : generatePositiveSlabGeometry(slabNode);
+export function generateSlabGeometry(slabNode, context) {
+    return slabNode.recessed
+        ? generatePoolGeometry(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
@@ -104,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
@@ -115,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) {
-    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode));
+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();
@@ -131,14 +87,14 @@ function generatePositiveSlabGeometry(slabNode) {
     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) {
@@ -165,7 +121,7 @@ function generatePositiveSlabGeometry(slabNode) {
         }
         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);
@@ -195,37 +151,29 @@ function generatePositiveSlabGeometry(slabNode) {
     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:
  *   - floor in XZ plane at Y=0, normals pointing +Y (visible when looking down into pool)
  *   - walls from Y=0 to Y=depth, inward-facing normals (visible from inside pool)
  */
-function generatePoolGeometry(slabNode) {
-    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode));
-    const depth = Math.abs(slabNode.elevation ?? 0.05);
+function generatePoolGeometry(slabNode, context) {
+    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context));
+    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();
     const positions = [];
     const uvs = [];
     const indices = [];
-    const bounds = new THREE.Box2();
-    for (const [x, z] of polygon) {
-        bounds.expandByPoint(new THREE.Vector2(x, z));
-    }
-    for (const hole of holePolygons) {
-        for (const [x, z] of hole) {
-            bounds.expandByPoint(new THREE.Vector2(x, z));
-        }
-    }
-    const floorWidth = Math.max(bounds.max.x - bounds.min.x, 0.001);
-    const floorHeight = Math.max(bounds.max.y - bounds.min.y, 0.001);
     const pushFloorVertex = (x, y, z) => {
         positions.push(x, y, z);
-        uvs.push((x - bounds.min.x) / floorWidth, (z - bounds.min.y) / floorHeight);
+        // 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);
     };
     const pushWallVertex = (x, y, z, u, v) => {
         positions.push(x, y, z);

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

@@ -3,6 +3,13 @@
 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) {
@@ -12,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],
@@ -31,7 +41,7 @@ describe('generateSlabGeometry', () => {
                 ],
             ],
         });
-        const geometry = generateSlabGeometry(slab);
+        const geometry = generateSlabGeometry(slab, EMPTY_CONTEXT);
         expect((geometry.index?.count ?? 0) / 3).toBeGreaterThan(0);
         expect(hasVertexAt(geometry, 1, 1)).toBe(true);
         expect(hasVertexAt(geometry, 3, 1)).toBe(true);
@@ -39,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],
@@ -54,9 +60,43 @@ describe('generateSlabGeometry', () => {
                 ],
             ],
         });
-        const geometry = generateSlabGeometry(slab);
+        const geometry = generateSlabGeometry(slab, EMPTY_CONTEXT);
         expect((geometry.index?.count ?? 0) / 3).toBeGreaterThan(0);
         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

@@ -76,7 +76,7 @@ export const StairSystem = () => {
         // --- Pass 1b: Sync chained transforms to individual segment meshes (edit mode) ---
         for (const stairId of parentsNeedingSegmentSync) {
             const baseStairNode = nodes[stairId];
-            if (!baseStairNode || baseStairNode.type !== 'stair')
+            if (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
@@ -98,7 +98,7 @@ export const StairSystem = () => {
             if (stairsProcessed >= MAX_STAIRS_PER_FRAME)
                 break;
             const node = nodes[id];
-            if (!node || node.type !== 'stair') {
+            if (node?.type !== 'stair') {
                 pendingStairUpdates.delete(id);
                 continue;
             }
@@ -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++;
                 }
             }
@@ -434,6 +434,9 @@ function createEmptyGeometry() {
     // 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.setAttribute('normal', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
     geometry.addGroup(0, 0, STAIR_TREAD_MATERIAL_INDEX);
     geometry.addGroup(0, 0, STAIR_SIDE_MATERIAL_INDEX);
     return geometry;
@@ -745,7 +748,7 @@ function computeAbsoluteHeight(node) {
     if (!node.parentId)
         return 0;
     const parent = nodes[node.parentId];
-    if (!parent || parent.type !== 'stair')
+    if (parent?.type !== 'stair')
         return 0;
     const stair = parent;
     const segments = (stair.children ?? [])

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

@@ -0,0 +1,31 @@
+import type { DoorNode, WindowNode } from '@pascal-app/core';
+import * as THREE from 'three';
+export type OpeningCutoutNode = DoorNode | WindowNode;
+export type OpeningCutoutRect = {
+    left: number;
+    right: number;
+    bottom: number;
+    top: number;
+};
+export declare function getOpeningCutoutProxyDepth(wallThickness: number): number;
+/**
+ * Pure cutout profile for a shaped door / window opening. `rect` is in
+ * the caller's coordinate frame — the wall CSG pipeline passes wall-local
+ * coords, the roof-wall pipeline an origin-centered rect — so the same
+ * radii / arch math serves both hosts.
+ */
+export declare function buildOpeningCutoutShape(opening: OpeningCutoutNode, rect: OpeningCutoutRect): THREE.Shape;
+export declare function buildOpeningCutoutGeometry(opening: OpeningCutoutNode, rect: OpeningCutoutRect, depth: number, wallThickness: number): THREE.BufferGeometry;
+/**
+ * Whether the cutout profile's bottom edge is a flat chord. Cuts whose
+ * bottom sits coplanar with the host wall base get extended slightly
+ * downward to keep CSG away from coplanar faces — but only a flat chord
+ * may extend; shifting a rounded bottom would distort the profile.
+ */
+export declare function hasFlatOpeningCutoutBottom(opening: OpeningCutoutNode): boolean;
+/**
+ * Extends floor-level flat cutouts below the host wall so CSG never has to
+ * subtract a face exactly coplanar with the wall base.
+ */
+export declare function getOpeningCutoutBottomPadding(opening: OpeningCutoutNode, bottom: number): number;
+//# sourceMappingURL=opening-cutout-geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opening-cutout-geometry.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/opening-cutout-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,UAAU,CAAA;AAErD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAYD,wBAAgB,0BAA0B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAExE;AASD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,iBAAiB,GACtB,KAAK,CAAC,KAAK,CAuCb;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,KAAK,CAAC,cAAc,CAqBtB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAW9E;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEhG"}

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

@@ -0,0 +1,167 @@
+import * as THREE from 'three';
+// The cutout proxy doubles as the invisible raycast hit target for an opening:
+// centered on the wall and extending past both faces so it wins the scene
+// raycast over the recessed door/window body for front AND back selection +
+// paint. Wall CSG rebuilds opening cuts directly from node data, so this proxy
+// only needs to clear the wall thickness plus a small proud margin. A snug depth
+// keeps the hit target useful without blanketing the room floor in a top-down
+// view (the bug a 1m-deep proxy caused in narrow hallways).
+const OPENING_CUTOUT_PROXY_PROUD_MARGIN = 0.08;
+const OPENING_CUTOUT_BOTTOM_PADDING = 0.02;
+export function getOpeningCutoutProxyDepth(wallThickness) {
+    return Math.max(wallThickness, 0) + OPENING_CUTOUT_PROXY_PROUD_MARGIN;
+}
+/**
+ * Pure cutout profile for a shaped door / window opening. `rect` is in
+ * the caller's coordinate frame — the wall CSG pipeline passes wall-local
+ * coords, the roof-wall pipeline an origin-centered rect — so the same
+ * radii / arch math serves both hosts.
+ */
+export function buildOpeningCutoutShape(opening, rect) {
+    const { left, right, bottom, top } = rect;
+    const width = Math.max(right - left, 1e-6);
+    const height = Math.max(top - bottom, 1e-6);
+    const shape = new THREE.Shape();
+    if (opening.openingShape === 'arch') {
+        const halfWidth = width / 2;
+        const centerX = (left + right) / 2;
+        const archHeight = Math.min(Math.max(opening.archHeight ?? width / 2, 0.01), height);
+        const springY = top - archHeight;
+        const segments = 32;
+        shape.moveTo(left, bottom);
+        shape.lineTo(right, bottom);
+        shape.lineTo(right, springY);
+        for (let index = 1; index <= segments; index += 1) {
+            const x = right + (left - right) * (index / segments);
+            const normalizedX = Math.min(Math.abs((x - centerX) / halfWidth), 1);
+            const y = springY + archHeight * Math.sqrt(Math.max(1 - normalizedX * normalizedX, 0));
+            shape.lineTo(x, y);
+        }
+        shape.lineTo(left, bottom);
+        shape.closePath();
+        return shape;
+    }
+    if (opening.openingShape === 'rounded') {
+        const radii = getRoundedOpeningRadii(opening, width, height);
+        applyRoundedOpeningShape(shape, left, right, bottom, top, radii);
+        return shape;
+    }
+    shape.moveTo(left, bottom);
+    shape.lineTo(right, bottom);
+    shape.lineTo(right, top);
+    shape.lineTo(left, top);
+    shape.closePath();
+    return shape;
+}
+export function buildOpeningCutoutGeometry(opening, rect, depth, wallThickness) {
+    const shape = buildOpeningCutoutShape(opening, rect);
+    const bevelSize = opening.openingShape === 'rounded'
+        ? Math.min(Math.max(opening.openingRevealRadius ?? 0.025, 0), Math.max(wallThickness * 0.45, 0.001), Math.max((opening.cornerRadius ?? 0.15) * 0.45, 0.001))
+        : 0;
+    const geometry = new THREE.ExtrudeGeometry(shape, {
+        depth,
+        bevelEnabled: bevelSize > 0,
+        bevelSegments: bevelSize > 0 ? 8 : 0,
+        bevelSize,
+        bevelThickness: bevelSize,
+        curveSegments: 24,
+    });
+    geometry.translate(0, 0, -depth / 2);
+    return geometry;
+}
+/**
+ * Whether the cutout profile's bottom edge is a flat chord. Cuts whose
+ * bottom sits coplanar with the host wall base get extended slightly
+ * downward to keep CSG away from coplanar faces — but only a flat chord
+ * may extend; shifting a rounded bottom would distort the profile.
+ */
+export function hasFlatOpeningCutoutBottom(opening) {
+    if (opening.openingShape !== 'rounded' || opening.type !== 'window')
+        return true;
+    if (opening.openingRadiusMode === 'individual') {
+        const [, , bottomRight = 0, bottomLeft = 0] = opening.openingCornerRadii ?? [
+            0.15, 0.15, 0.15, 0.15,
+        ];
+        return bottomRight <= 1e-6 && bottomLeft <= 1e-6;
+    }
+    return Math.max(opening.cornerRadius ?? 0.15, 0) <= 1e-6;
+}
+/**
+ * Extends floor-level flat cutouts below the host wall so CSG never has to
+ * subtract a face exactly coplanar with the wall base.
+ */
+export function getOpeningCutoutBottomPadding(opening, bottom) {
+    return bottom < 0.005 && hasFlatOpeningCutoutBottom(opening) ? OPENING_CUTOUT_BOTTOM_PADDING : 0;
+}
+function getRoundedOpeningRadii(opening, width, height) {
+    if (opening.type !== 'window') {
+        if (opening.openingRadiusMode === 'individual') {
+            const [topLeft = 0, topRight = 0] = opening.openingTopRadii ?? [0.15, 0.15];
+            return normalizeCornerRadii({
+                topLeft: Math.max(topLeft, 0),
+                topRight: Math.max(topRight, 0),
+                bottomRight: 0,
+                bottomLeft: 0,
+            }, width, height);
+        }
+        const maxRadius = Math.min(width / 2, height);
+        const radius = Math.min(Math.max(opening.cornerRadius ?? 0.15, 0), maxRadius);
+        return { topLeft: radius, topRight: radius, bottomRight: 0, bottomLeft: 0 };
+    }
+    if (opening.openingRadiusMode === 'individual') {
+        const [topLeft = 0, topRight = 0, bottomRight = 0, bottomLeft = 0] = opening.openingCornerRadii ?? [0.15, 0.15, 0.15, 0.15];
+        return normalizeCornerRadii({
+            topLeft: Math.max(topLeft, 0),
+            topRight: Math.max(topRight, 0),
+            bottomRight: Math.max(bottomRight, 0),
+            bottomLeft: Math.max(bottomLeft, 0),
+        }, width, height);
+    }
+    const maxRadius = Math.min(width / 2, height / 2);
+    const radius = Math.min(Math.max(opening.cornerRadius ?? 0.15, 0), maxRadius);
+    return { topLeft: radius, topRight: radius, bottomRight: radius, bottomLeft: radius };
+}
+function normalizeCornerRadii(radii, width, height) {
+    const next = { ...radii };
+    const maxScale = Math.min(1, width / Math.max(next.topLeft + next.topRight, 1e-6), width / Math.max(next.bottomLeft + next.bottomRight, 1e-6), height / Math.max(next.topLeft + next.bottomLeft, 1e-6), height / Math.max(next.topRight + next.bottomRight, 1e-6));
+    if (maxScale < 1) {
+        next.topLeft *= maxScale;
+        next.topRight *= maxScale;
+        next.bottomRight *= maxScale;
+        next.bottomLeft *= maxScale;
+    }
+    return next;
+}
+function applyRoundedOpeningShape(shape, left, right, bottom, top, radii) {
+    const { topLeft, topRight, bottomRight, bottomLeft } = radii;
+    shape.moveTo(left + bottomLeft, bottom);
+    shape.lineTo(right - bottomRight, bottom);
+    if (bottomRight > 1e-6) {
+        shape.absarc(right - bottomRight, bottom + bottomRight, bottomRight, -Math.PI / 2, 0, false);
+    }
+    else {
+        shape.lineTo(right, bottom);
+    }
+    shape.lineTo(right, top - topRight);
+    if (topRight > 1e-6) {
+        shape.absarc(right - topRight, top - topRight, topRight, 0, Math.PI / 2, false);
+    }
+    else {
+        shape.lineTo(right, top);
+    }
+    shape.lineTo(left + topLeft, top);
+    if (topLeft > 1e-6) {
+        shape.absarc(left + topLeft, top - topLeft, topLeft, Math.PI / 2, Math.PI, false);
+    }
+    else {
+        shape.lineTo(left, top);
+    }
+    shape.lineTo(left, bottom + bottomLeft);
+    if (bottomLeft > 1e-6) {
+        shape.absarc(left + bottomLeft, bottom + bottomLeft, bottomLeft, Math.PI, Math.PI * 1.5, false);
+    }
+    else {
+        shape.lineTo(left, bottom);
+    }
+    shape.closePath();
+}

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

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

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

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