@pascal-app/viewer 0.9.1 → 0.9.2

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

@@ -1,8 +1,10 @@
-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 extruded slab geometry from polygon. `context` carries the
+ * slab's level neighbourhood (walls + sibling slabs) driving the per-edge
+ * render offsets — see `getRenderableSlabPolygon`.
  */
-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,EAQL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAIxB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAe9B,eAAO,MAAM,UAAU,YA2CtB,CAAA;AAuCD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,cAAc,CAKtB"}

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

@@ -29,14 +29,18 @@ export const SlabSystem = () => {
         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 || node.type !== 'slab')
+            if (node?.type !== 'slab')
                 return;
             const mesh = sceneRegistry.nodes.get(id);
             if (mesh) {
-                updateSlabGeometry(getEffectiveNode(node), 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
@@ -44,11 +48,30 @@ export const SlabSystem = () => {
     }, 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, mesh) {
-    const newGeo = generateSlabGeometry(node);
+function updateSlabGeometry(node, context, mesh) {
+    const newGeo = generateSlabGeometry(node, context);
     ensureUv2Attribute(newGeo);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
@@ -58,11 +81,15 @@ function updateSlabGeometry(node, mesh) {
     mesh.position.y = elevation < 0 ? elevation : 0;
 }
 /**
- * Generates extruded slab geometry from polygon
+ * Generates extruded slab geometry from polygon. `context` carries the
+ * slab's level neighbourhood (walls + sibling slabs) driving the per-edge
+ * render offsets — see `getRenderableSlabPolygon`.
  */
-export function generateSlabGeometry(slabNode) {
+export function generateSlabGeometry(slabNode, context) {
     const elevation = slabNode.elevation ?? 0.05;
-    return elevation < 0 ? generatePoolGeometry(slabNode) : generatePositiveSlabGeometry(slabNode);
+    return elevation < 0
+        ? generatePoolGeometry(slabNode, context)
+        : generatePositiveSlabGeometry(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
@@ -115,8 +142,8 @@ 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 generatePositiveSlabGeometry(slabNode, context) {
+    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context));
     const elevation = slabNode.elevation ?? 0.05;
     const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
     if (polygon.length < 3)
@@ -203,8 +230,8 @@ function generatePositiveSlabGeometry(slabNode) {
  *   - 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));
+function generatePoolGeometry(slabNode, context) {
+    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context));
     const depth = Math.abs(slabNode.elevation ?? 0.05);
     const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
     if (polygon.length < 3)
@@ -212,20 +239,11 @@ function generatePoolGeometry(slabNode) {
     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 generatePositiveSlabGeometry'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,7 @@
 import { describe, expect, test } from 'bun:test';
 import { SlabNode } from '@pascal-app/core';
 import { generateSlabGeometry } from './slab-system';
+const EMPTY_CONTEXT = { walls: [], siblingSlabs: [] };
 function hasVertexAt(geometry, x, z) {
     const positions = geometry.getAttribute('position');
     for (let index = 0; index < positions.count; index += 1) {
@@ -31,7 +32,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);
@@ -54,7 +55,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);

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;
             }
@@ -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":""}

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

@@ -0,0 +1,172 @@
+// @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 { DoorNode, WindowNode } from '@pascal-app/core';
+import { buildOpeningCutoutGeometry, buildOpeningCutoutShape, getOpeningCutoutBottomPadding, hasFlatOpeningCutoutBottom, } from './opening-cutout-geometry';
+function containsPoint(points, x, y) {
+    return points.some((point) => Math.abs(point.x - x) < 1e-6 && Math.abs(point.y - y) < 1e-6);
+}
+function getBounds(points) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const point of points) {
+        minX = Math.min(minX, point.x);
+        maxX = Math.max(maxX, point.x);
+        minY = Math.min(minY, point.y);
+        maxY = Math.max(maxY, point.y);
+    }
+    return { minX, maxX, minY, maxY };
+}
+describe('buildOpeningCutoutShape', () => {
+    test('rectangle profile passes the rect through unchanged', () => {
+        const door = DoorNode.parse({});
+        const rect = { left: 1.2, right: 2.1, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+        expect(bounds.minY).toBeCloseTo(rect.bottom, 9);
+        expect(bounds.maxY).toBeCloseTo(rect.top, 9);
+    });
+    test('door rounded profile rounds only the top corners', () => {
+        const door = DoorNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const rect = { left: -0.45, right: 0.45, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.left, rect.top - 0.2)).toBe(true);
+        expect(containsPoint(points, rect.left + 0.2, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.2)).toBe(true);
+        expect(containsPoint(points, rect.right - 0.2, rect.top)).toBe(true);
+    });
+    test('window rounded profile rounds all four corners', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const rect = { left: -0.75, right: 0.75, bottom: 0.9, top: 2.4 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(false);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.left + 0.2, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.bottom + 0.2)).toBe(true);
+        expect(containsPoint(points, rect.right - 0.2, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.2)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+        expect(bounds.minY).toBeCloseTo(rect.bottom, 9);
+        expect(bounds.maxY).toBeCloseTo(rect.top, 9);
+    });
+    test('shared corner radius is clamped to the opening half-extent', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 10 });
+        const rect = { left: -0.75, right: 0.75, bottom: 0.9, top: 2.4 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        // 1.5 × 1.5 opening → radius clamps to 0.75; arcs meet at edge midpoints.
+        expect(containsPoint(points, rect.left, rect.bottom + 0.75)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.75)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+    });
+    test('individual radii normalize when their sum exceeds the opening width', () => {
+        const window = WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [4, 4, 0, 0],
+        });
+        const rect = { left: -0.5, right: 0.5, bottom: 0, top: 2 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        // Width 1 with top radii summing to 8 → scaled down to 0.5 each.
+        expect(containsPoint(points, rect.left, rect.top - 0.5)).toBe(true);
+        expect(containsPoint(points, rect.left + 0.5, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+    });
+    test('arch profile springs at top - archHeight and peaks at the rect top', () => {
+        const door = DoorNode.parse({ openingShape: 'arch', archHeight: 0.45 });
+        const rect = { left: -0.45, right: 0.45, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.45)).toBe(true);
+        expect(containsPoint(points, 0, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+    });
+    test('profiles are origin-agnostic — offset rects yield translated points', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const centered = buildOpeningCutoutShape(window, {
+            left: -0.75,
+            right: 0.75,
+            bottom: -0.75,
+            top: 0.75,
+        }).getPoints();
+        const offset = buildOpeningCutoutShape(window, {
+            left: 2.25,
+            right: 3.75,
+            bottom: 0.9,
+            top: 2.4,
+        }).getPoints();
+        for (const point of centered) {
+            expect(containsPoint(offset, point.x + 3, point.y + 1.65)).toBe(true);
+        }
+        for (const point of offset) {
+            expect(containsPoint(centered, point.x - 3, point.y - 1.65)).toBe(true);
+        }
+    });
+});
+describe('buildOpeningCutoutGeometry', () => {
+    test('extrudes the rect through the depth, centered on the mid-plane', () => {
+        const door = DoorNode.parse({});
+        const geometry = buildOpeningCutoutGeometry(door, { left: -0.45, right: 0.45, bottom: -1.05, top: 1.05 }, 0.24, 0.1);
+        geometry.computeBoundingBox();
+        // Float32 position buffer → ~1e-7 relative precision.
+        const box = geometry.boundingBox;
+        expect(box.min.x).toBeCloseTo(-0.45, 6);
+        expect(box.max.x).toBeCloseTo(0.45, 6);
+        expect(box.min.y).toBeCloseTo(-1.05, 6);
+        expect(box.max.y).toBeCloseTo(1.05, 6);
+        expect(box.min.z).toBeCloseTo(-0.12, 6);
+        expect(box.max.z).toBeCloseTo(0.12, 6);
+    });
+});
+describe('hasFlatOpeningCutoutBottom', () => {
+    test('flat for rectangles, arches, and door rounded (top-only radii)', () => {
+        expect(hasFlatOpeningCutoutBottom(DoorNode.parse({}))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'arch' }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(DoorNode.parse({ openingShape: 'rounded' }))).toBe(true);
+    });
+    test('rounded windows depend on their bottom radii', () => {
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'rounded' }))).toBe(false);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0 }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [0.2, 0.2, 0, 0],
+        }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [0.2, 0.2, 0.2, 0.2],
+        }))).toBe(false);
+    });
+});
+describe('getOpeningCutoutBottomPadding', () => {
+    test('pads floor-level openings with a flat bottom', () => {
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({}), 0)).toBe(0.02);
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({ openingShape: 'rounded' }), 0)).toBe(0.02);
+        expect(getOpeningCutoutBottomPadding(WindowNode.parse({ openingShape: 'arch' }), 0)).toBe(0.02);
+    });
+    test('does not pad openings above the floor or rounded window bottoms', () => {
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({}), 0.9)).toBe(0);
+        expect(getOpeningCutoutBottomPadding(WindowNode.parse({ openingShape: 'rounded' }), 0)).toBe(0);
+    });
+});

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":"AAsCA,eAAO,MAAM,UAAU,YAwItB,CAAA"}
+{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAqDA,eAAO,MAAM,UAAU,YAyKtB,CAAA"}