@pascal-app/viewer 1.0.6 → 1.1.0

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

@@ -0,0 +1,14 @@
+import { type DoorNode, type OpeningCasingHost, type WindowNode } from '@pascal-app/core';
+import * as THREE from 'three';
+/** Name of the meshes a door or window builds its casing from. */
+export declare const OPENING_CASING_MESH_NAME = "opening-casing";
+/**
+ * A door's or window's casing as meshes in the unit's own frame, to hang on the
+ * mesh its frame is built on: the boards of `openingCasingBoards` on each cased
+ * face of the host, turned half round with a unit that faces the host's back. A
+ * rectangular opening is cased with butted boards. An arched or rounded one is
+ * cased with a band that follows the cutout's own profile over its head and down
+ * its sides; a window's bottom board stays straight below it.
+ */
+export declare function buildOpeningCasingMeshes(opening: DoorNode | WindowNode, host: OpeningCasingHost, material: THREE.Material): THREE.Mesh[];
+//# sourceMappingURL=opening-casing-geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opening-casing-geometry.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/opening-casing-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAGb,KAAK,iBAAiB,EAKtB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,kEAAkE;AAClE,eAAO,MAAM,wBAAwB,mBAAmB,CAAA;AAExD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,IAAI,EAAE,iBAAiB,EACvB,QAAQ,EAAE,KAAK,CAAC,QAAQ,GACvB,KAAK,CAAC,IAAI,EAAE,CAwCd"}

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

@@ -0,0 +1,102 @@
+import { getDoorOpeningSize, OPENING_CASING_PROUD, openingCasingBoards, openingCasingFaces, openingCasingWidth, openingHostFacing, } from '@pascal-app/core';
+import * as THREE from 'three';
+import { applyWorldScaleBoxUVs } from '../../lib/box-uv';
+import { buildOpeningCutoutShape, getRoundedOpeningRadii } from './opening-cutout-geometry';
+/** Name of the meshes a door or window builds its casing from. */
+export const OPENING_CASING_MESH_NAME = 'opening-casing';
+/**
+ * A door's or window's casing as meshes in the unit's own frame, to hang on the
+ * mesh its frame is built on: the boards of `openingCasingBoards` on each cased
+ * face of the host, turned half round with a unit that faces the host's back. A
+ * rectangular opening is cased with butted boards. An arched or rounded one is
+ * cased with a band that follows the cutout's own profile over its head and down
+ * its sides; a window's bottom board stays straight below it.
+ */
+export function buildOpeningCasingMeshes(opening, host, material) {
+    const facing = openingHostFacing(opening);
+    const size = getDoorOpeningSize(opening);
+    const shaped = size.width === opening.width &&
+        size.height === opening.height &&
+        (opening.openingShape === 'arch' || opening.openingShape === 'rounded');
+    const meshes = [];
+    const add = (geometry, face) => {
+        // Turned half round, the unit's x and z run against the host's.
+        if (facing < 0)
+            geometry.rotateY(Math.PI);
+        const mesh = new THREE.Mesh(geometry, material);
+        mesh.name = OPENING_CASING_MESH_NAME;
+        mesh.userData.slotId = `casing-${face}`;
+        meshes.push(mesh);
+    };
+    for (const board of openingCasingBoards(opening, host)) {
+        if (shaped && (board.part === 'head' || board.part === 'leg'))
+            continue;
+        const [width, height, depth] = board.size;
+        const geometry = new THREE.BoxGeometry(width, height, depth);
+        applyWorldScaleBoxUVs(geometry, width, height, depth);
+        geometry.translate(...board.center);
+        add(geometry, board.face);
+    }
+    if (shaped) {
+        const band = casingBandShape(opening, openingCasingWidth(opening));
+        for (const { face, plane, out } of openingCasingFaces(opening, host)) {
+            const geometry = new THREE.ExtrudeGeometry(band, {
+                depth: OPENING_CASING_PROUD,
+                bevelEnabled: false,
+                curveSegments: 24,
+            });
+            geometry.translate(0, 0, out > 0 ? plane : plane - OPENING_CASING_PROUD);
+            add(geometry, face);
+        }
+    }
+    return meshes;
+}
+/**
+ * The casing band of an arched or rounded opening as one outline, in the host
+ * frame: out from the cutout's profile by `width` over the head and down both
+ * sides, open along the bottom (a door's floor, a window's bottom board).
+ */
+function casingBandShape(opening, width) {
+    const halfWidth = opening.width / 2;
+    const halfHeight = opening.height / 2;
+    const inner = buildOpeningCutoutShape(opening, {
+        left: -halfWidth,
+        right: halfWidth,
+        bottom: -halfHeight,
+        top: halfHeight,
+    }).getPoints(24);
+    const outer = buildOpeningCutoutShape(grownOpening(opening, width), {
+        left: -halfWidth - width,
+        right: halfWidth + width,
+        bottom: -halfHeight,
+        top: halfHeight + width,
+    }).getPoints(24);
+    // Both profiles start along the bottom, left to right, and end back at their
+    // first point: the band runs up and over the outer one from its bottom right,
+    // then back over the inner one from its bottom left.
+    return new THREE.Shape([...outer.slice(1), ...inner.slice(1).reverse()]);
+}
+/**
+ * The opening a casing band's outer edge follows: its arch or its top corners
+ * grown by `width`, so the band keeps one width all round, and square at the
+ * bottom, where the band stops.
+ */
+function grownOpening(opening, width) {
+    if (opening.openingShape === 'arch') {
+        const archHeight = Math.min(Math.max(opening.archHeight ?? opening.width / 2, 0.01), opening.height);
+        return { ...opening, archHeight: archHeight + width };
+    }
+    const radii = getRoundedOpeningRadii(opening, opening.width, opening.height);
+    const grow = (radius) => (radius > 1e-6 ? radius + width : 0);
+    return opening.type === 'window'
+        ? {
+            ...opening,
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [grow(radii.topLeft), grow(radii.topRight), 0, 0],
+        }
+        : {
+            ...opening,
+            openingRadiusMode: 'individual',
+            openingTopRadii: [grow(radii.topLeft), grow(radii.topRight)],
+        };
+}

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

@@ -8,6 +8,12 @@ export type OpeningCutoutRect = {
     top: number;
 };
 export declare function getOpeningCutoutProxyDepth(wallThickness: number): number;
+type CornerRadii = {
+    topLeft: number;
+    topRight: number;
+    bottomRight: number;
+    bottomLeft: 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
@@ -28,4 +34,7 @@ export declare function hasFlatOpeningCutoutBottom(opening: OpeningCutoutNode):
  * subtract a face exactly coplanar with the wall base.
  */
 export declare function getOpeningCutoutBottomPadding(opening: OpeningCutoutNode, bottom: number): number;
+/** The corner radii a rounded opening's cutout is cut with, clamped to fit `width` × `height`. */
+export declare function getRoundedOpeningRadii(opening: OpeningCutoutNode, width: number, height: number): CornerRadii;
+export {};
 //# sourceMappingURL=opening-cutout-geometry.d.ts.map

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

@@ -1 +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"}
+{"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;AAE5D,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;AAED,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,iBAAiB,GACtB,KAAK,CAAC,KAAK,CAyCb;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;AAED,kGAAkG;AAClG,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,WAAW,CAyCb"}

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

@@ -1,3 +1,4 @@
+import { getDoorOpeningSize } from '@pascal-app/core';
 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
@@ -22,7 +23,9 @@ export function buildOpeningCutoutShape(opening, 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 size = getDoorOpeningSize(opening);
+    const fixedLights = size.width !== opening.width || size.height !== opening.height;
+    if (!fixedLights && 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);
@@ -41,7 +44,7 @@ export function buildOpeningCutoutShape(opening, rect) {
         shape.closePath();
         return shape;
     }
-    if (opening.openingShape === 'rounded') {
+    if (!fixedLights && opening.openingShape === 'rounded') {
         const radii = getRoundedOpeningRadii(opening, width, height);
         applyRoundedOpeningShape(shape, left, right, bottom, top, radii);
         return shape;
@@ -93,7 +96,8 @@ export function hasFlatOpeningCutoutBottom(opening) {
 export function getOpeningCutoutBottomPadding(opening, bottom) {
     return bottom < 0.005 && hasFlatOpeningCutoutBottom(opening) ? OPENING_CUTOUT_BOTTOM_PADDING : 0;
 }
-function getRoundedOpeningRadii(opening, width, height) {
+/** The corner radii a rounded opening's cutout is cut with, clamped to fit `width` × `height`. */
+export function getRoundedOpeningRadii(opening, width, height) {
     if (opening.type !== 'window') {
         if (opening.openingRadiusMode === 'individual') {
             const [topLeft = 0, topRight = 0] = opening.openingTopRadii ?? [0.15, 0.15];

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

@@ -1 +1 @@
-{"version":3,"file":"wall-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAUL,KAAK,aAAa,EAClB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAS5C,OAAO,EAEL,KAAK,WAAW,EAMhB,KAAK,aAAa,EAInB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAexE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,EAAE,CAAA;AAE1C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,iBAAiB,CAAA;IAC9B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAA;CAC1B;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM;QAAE,OAAO,EAAE,iBAAiB,CAAC;QAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAA;KAAE,CAAA;CACjE,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,aAAa,EACvB,QAAQ,CAAC,EAAE,OAAO,EAClB,WAAW,CAAC,EAAE,WAAW,EACzB,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,KAC3B,aAAa,CAAA;AA4SlB,wFAAwF;AACxF,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAS9F;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAS1F;AA4DD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,aAAa,EACtB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,GAAE,SAAS,MAAM,EAAO,EAClC,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAQR;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,GAAE,SAAS,MAAM,EAAO,EAClC,QAAQ,CAAC,EAAE,oBAAoB,GAC9B,aAAa,CAmFf;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,GAAE,SAAS,MAAM,EAAO,GACjC,iBAAiB,CAUnB"}
+{"version":3,"file":"wall-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,KAAK,aAAa,EAClB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAU5C,OAAO,EAEL,KAAK,WAAW,EAMhB,KAAK,aAAa,EAInB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAcxE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,EAAE,CAAA;AAE1C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,iBAAiB,CAAA;IAC9B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAA;CAC1B;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM;QAAE,OAAO,EAAE,iBAAiB,CAAC;QAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAA;KAAE,CAAA;CACjE,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,aAAa,EACvB,QAAQ,CAAC,EAAE,OAAO,EAClB,WAAW,CAAC,EAAE,WAAW,EACzB,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,KAC3B,aAAa,CAAA;AAiSlB,wFAAwF;AACxF,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAI9F;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAI1F;AA4DD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,aAAa,EACtB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,GAAE,SAAS,MAAM,EAAO,EAClC,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAQR;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,GAAE,SAAS,MAAM,EAAO,EAClC,QAAQ,CAAC,EAAE,oBAAoB,GAC9B,aAAa,CAmFf;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,GAAE,SAAS,MAAM,EAAO,GACjC,iBAAiB,CAUnB"}

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

@@ -1,7 +1,8 @@
-import { getEffectiveWallFaceMaterial, getMaterialPresetByRef, getWallSurfaceMaterialSignature, parseMaterialColor, parseMaterialRef, resolveMaterial, resolveWallExteriorSide, resolveWallFaceChain, WALL_SLOT_DEFAULT, wallAssemblyExposedStructure, wallAssemblyFinishRef, } from '@pascal-app/core';
+import { getEffectiveWallFaceMaterial, getMaterialPresetByRef, getWallFaceDefault, getWallSurfaceMaterialSignature, parseMaterialColor, parseMaterialRef, resolveMaterial, resolveWallExteriorSide, resolveWallFaceChain, WALL_SLOT_DEFAULT, wallAssemblyExposedStructure, wallAssemblyFaceFinish, } from '@pascal-app/core';
 import { Color } from 'three';
 import { Fn, float, fract, length, mix, positionLocal, smoothstep, step, uv, vec2 } from 'three/tsl';
 import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+import { markHighlight, tintEmissive } from '../../lib/editor-highlight';
 import { BLOCK_MASONRY, concreteMaterial, masonryMaterial, STRUCTURE_COLORS, } from '../../lib/foundation-materials';
 import { baseMaterial, createDefaultMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, materialPresetRefSignature, resolveMaterialRef, resolveSlotDefaultRef, resolveSurfaceColor, } from '../../lib/materials';
 const DEFAULT_WALL_COLOR = '#e9e7e3';
@@ -9,8 +10,7 @@ const WALL_HIGHLIGHT_PROFILES = {
     delete: {
         color: new Color('#dc2626'),
         blend: 0.76,
-        emissiveBlend: 0.92,
-        emissiveIntensity: 0.46,
+        emissive: 0.92,
     },
 };
 const wallMaterialCache = new Map();
@@ -43,11 +43,11 @@ function resolveWallSlotDefault(declaredDefault, shading) {
     }
     return createDefaultMaterial(slotDefault, 0.9, shading);
 }
-// The assembly cladding's ref when `face` is the wall's exterior face (a is the
-// +normal face; an unresolved side keeps the cladding on b, as legacy did).
+// The assembly's finish for `face`: its cladding when `face` is the wall's exterior face (a is the
+// +normal face; an unresolved side keeps the cladding on b, as legacy did), and the paint picked
+// for a lining while drafting on a lined face.
 function wallAssemblyFaceFinishRef(wallNode, face) {
-    const exteriorFace = resolveWallExteriorSide(wallNode) === 1 ? 'a' : 'b';
-    return face === exteriorFace ? wallAssemblyFinishRef(wallNode) : null;
+    return wallAssemblyFaceFinish(wallNode, face);
 }
 // What `face` shows when it is the exterior face of a wall with no cladding over a bare masonry or
 // concrete core: the structure itself (null otherwise, and for any face with a cladding).
@@ -57,7 +57,7 @@ function wallFaceExposedStructure(wallNode, face) {
     const exteriorFace = resolveWallExteriorSide(wallNode) === 1 ? 'a' : 'b';
     return face === exteriorFace ? wallAssemblyExposedStructure(wallNode) : null;
 }
-// The structure as the generic foundation draws it (same courses, joints and colours), made once:
+// The bare structure (courses, joints and colours), made once:
 // the block's bond runs along the face's world-planar U, the wall's own metres. Solid shading
 // keeps to a flat colour, like every other wall finish.
 const structureMaterials = new Map();
@@ -73,20 +73,22 @@ function exposedStructureMaterial(structure, shading) {
     return material;
 }
 // Slot-first resolution for one wall face, matching every other paintable kind:
-//   node.slots[face] ref → legacy inline finish → declared slot default.
+//   node.slots[face] ref → legacy inline finish → the face's default.
 // A dangling `scene:` ref (material deleted / copied across scenes) falls back
-// to the declared default — it never blocks rendering (the dangling-ref rule).
+// to the face's default — it never blocks rendering (the dangling-ref rule).
 function resolveWallFaceMaterial(wallNode, face, shading, sceneMaterials) {
     const finish = resolveWallFaceChain(wallNode, face);
     if (finish.kind === 'ref') {
         return (resolveMaterialRef(finish.ref, sceneMaterials, shading) ??
-            resolveWallSlotDefault(WALL_SLOT_DEFAULT[face], shading));
+            resolveWallSlotDefault(getWallFaceDefault(wallNode, face), shading));
     }
     if (finish.kind === 'legacy')
         return getSurfaceVisibleMaterial(finish.spec, shading);
     // No paint on this face: the wall ASSEMBLY's cladding (WS5) skins the
     // exterior — a "2x6 lap siding" wall reads as lap siding without the user
-    // painting it. Painting the face still wins.
+    // painting it. Painting the face still wins. Any other unpainted face wears
+    // its default (`getWallFaceDefault`): the interior paint
+    // (`DEFAULT_INTERIOR_WALL_PAINT`) inside, raw drywall on the exterior side.
     const assemblyRef = wallAssemblyFaceFinishRef(wallNode, face);
     const exposed = assemblyRef ? null : wallFaceExposedStructure(wallNode, face);
     if (exposed)
@@ -116,11 +118,15 @@ function refMaterialSignature(ref, sceneMaterials) {
 // Falls back to the legacy signature when the face has no slot ref.
 function wallFaceMaterialSignature(wallNode, face, sceneMaterials) {
     const ref = wallNode.slots?.[face];
+    // The face's default follows its side, so a room detected outside it re-skins
+    // an unpainted face (and the fallback of a dangling ref).
+    const fallback = getWallFaceDefault(wallNode, face);
     if (ref)
-        return refMaterialSignature(ref, sceneMaterials);
+        return JSON.stringify({ ref: refMaterialSignature(ref, sceneMaterials), fallback });
     const spec = getEffectiveWallFaceMaterial(wallNode, face);
     const assemblyRef = wallAssemblyFaceFinishRef(wallNode, face);
     return JSON.stringify({
+        fallback,
         legacy: getWallSurfaceMaterialSignature(spec),
         preset: spec.materialPreset ? materialPresetRefSignature(spec.materialPreset) : null,
         // Changing the assembly's cladding must re-skin the face.
@@ -178,16 +184,9 @@ function createHighlightedWallMaterial(material, kind) {
     if ('color' in highlightedMaterial && highlightedMaterial.color) {
         highlightedMaterial.color = getHighlightedColor(highlightedMaterial.color, kind);
     }
-    if ('emissive' in highlightedMaterial && highlightedMaterial.emissive) {
-        highlightedMaterial.emissive = highlightedMaterial.emissive
-            .clone()
-            .lerp(profile.color, profile.emissiveBlend);
-    }
-    if ('emissiveIntensity' in highlightedMaterial) {
-        highlightedMaterial.emissiveIntensity = Math.max(highlightedMaterial.emissiveIntensity ?? 0, profile.emissiveIntensity);
-    }
+    tintEmissive(highlightedMaterial, profile.color, profile.emissive);
     highlightedMaterial.needsUpdate = true;
-    return highlightedMaterial;
+    return markHighlight(highlightedMaterial);
 }
 // Light selection highlight for walls (walls are excluded from the generic
 // editor selection highlight, so they need their own). Adds a gentle indigo
@@ -199,15 +198,13 @@ function createHighlightedWallMaterial(material, kind) {
 //      cache keyed by the source `.map` and rebuild when it changes (self-heals
 //      once the texture lands).
 const SELECTION_HIGHLIGHT_COLOR = new Color('#818cf8');
-const SELECTION_EMISSIVE_BLEND = 0.4;
-const SELECTION_EMISSIVE_INTENSITY = 0.12;
+const SELECTION_EMISSIVE = 0.12;
 // Softer sibling of the selection glow, for HOVERING a hidden wall (the
 // X-ray nearest-first selection made hidden walls hover targets; without a
 // material affordance the only thing lighting up was the furniture behind
 // them). Same indigo so hover reads as "this will select", weaker so a
 // hovered-then-selected wall still steps up on click.
-const HOVER_EMISSIVE_BLEND = 0.4;
-const HOVER_EMISSIVE_INTENSITY = 0.2;
+const HOVER_EMISSIVE = 0.08;
 const SELECTION_TEXTURE_MAP_KEYS = [
     'map',
     'normalMap',
@@ -222,7 +219,7 @@ const SELECTION_TEXTURE_MAP_KEYS = [
 ];
 const selectionHighlightCache = new WeakMap();
 const hoverHighlightCache = new WeakMap();
-function getEmissiveHighlightMaterial(base, cache, emissiveBlend, emissiveIntensity) {
+function getEmissiveHighlightMaterial(base, cache, emissive) {
     const baseMap = base.map ?? null;
     const cached = cache.get(base);
     if (cached && cached.map === baseMap)
@@ -235,19 +232,15 @@ function getEmissiveHighlightMaterial(base, cache, emissiveBlend, emissiveIntens
         if (src[key])
             dst[key] = src[key];
     }
-    if ('emissive' in clone && clone.emissive) {
-        clone.emissive = clone.emissive.clone().lerp(SELECTION_HIGHLIGHT_COLOR, emissiveBlend);
-    }
-    if ('emissiveIntensity' in clone) {
-        clone.emissiveIntensity = Math.max(clone.emissiveIntensity ?? 0, emissiveIntensity);
-    }
+    tintEmissive(clone, SELECTION_HIGHLIGHT_COLOR, emissive);
     clone.needsUpdate = true;
+    markHighlight(clone);
     cache.set(base, { clone, map: baseMap });
     return clone;
 }
 /** Lazy light-emissive selection variant of a wall's material array (keeps texture). */
 export function getSelectionHighlightMaterials(materials) {
-    return materials.map((material) => getEmissiveHighlightMaterial(material, selectionHighlightCache, SELECTION_EMISSIVE_BLEND, SELECTION_EMISSIVE_INTENSITY));
+    return materials.map((material) => getEmissiveHighlightMaterial(material, selectionHighlightCache, SELECTION_EMISSIVE));
 }
 /**
  * Softer hover sibling of the selection variant — the affordance for a
@@ -255,7 +248,7 @@ export function getSelectionHighlightMaterials(materials) {
  * film so the wall the click would select reads under the cursor).
  */
 export function getHoverHighlightMaterials(materials) {
-    return materials.map((material) => getEmissiveHighlightMaterial(material, hoverHighlightCache, HOVER_EMISSIVE_BLEND, HOVER_EMISSIVE_INTENSITY));
+    return materials.map((material) => getEmissiveHighlightMaterial(material, hoverHighlightCache, HOVER_EMISSIVE));
 }
 function createInvisibleWallMaterial(color, shading) {
     const material = shading === 'solid'

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

@@ -55,6 +55,17 @@ export declare function markWallsForZoneFinishChanges(): void;
  */
 export declare function wallGeometryChildren(node: WallNode, nodes: Readonly<Record<string, AnyNode>>): AnyNode[];
 type WallTerrainBottomSampler = (x: number, z: number) => number | null;
+/** The wall's top in wall-local coordinates: `height` at the start, rising `slope` per metre of x. */
+type WallTopLine = {
+    height: number;
+    slope: number;
+};
+/**
+ * Wall-local Y of the sloped top at `x`. Mitered corners sample `x` outside
+ * [0, L], where the line can fall below the wall base; the top never drops
+ * under {@link MIN_WALL_END_HEIGHT} (or the flat height, if lower).
+ */
+export declare function wallTopYAt(wallTop: WallTopLine, x: number): number;
 export declare function generateExtrudedWall(wallNode: WallNode, childrenNodes: AnyNode[], miterData: WallMiterData, slabElevation?: number, baseElevation?: number, baseSegments?: readonly WallSlabSupportSegment[], storeyHeight?: number, terrainBottomAt?: WallTerrainBottomSampler, faceBase?: {
     a: readonly WallSlabSupportSegment[];
     b: readonly WallSlabSupportSegment[];

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

@@ -1 +1 @@
-{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"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"}

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

@@ -1,4 +1,4 @@
-import { buildWallFinishLayout, containsPoint, cornerPair, DEFAULT_LEVEL_HEIGHT, getAdjacentWallIds, getEffectiveNode, getOpeningWallCut, getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, getWallLevelZones, getWallMiterBoundaryPoints, getWallPlaneTop, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, isCutterName, pointToKey, resolveCutterHost, resolveLevelId, resolveWallFaceBottom, resolveWallFinish, resolveWallTop, sceneRegistry, spatialGridManager, terrainSupportLift, useLiveNodeOverrides, useLiveTransforms, useScene, WALL_SURFACE_SLOT_DEFAULTS, wallFinishMaterialIndex, zoneHasWallFinish, } from '@pascal-app/core';
+import { buildWallFinishLayout, clampWallEndHeightOffset, containsPoint, cornerPair, DEFAULT_LEVEL_HEIGHT, getAdjacentWallIds, getDoorOpeningSize, getEffectiveNode, getOpeningWallCut, getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, getWallLevelZones, getWallMiterBoundaryPoints, getWallPlaneTop, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, isCutterName, MIN_WALL_END_HEIGHT, openingHostFacing, pointToKey, resolveCutterHost, resolveLevelId, resolveWallFaceBottom, resolveWallFinish, resolveWallTop, sceneRegistry, spatialGridManager, terrainSupportLift, useLiveNodeOverrides, useLiveTransforms, useScene, WALL_SURFACE_SLOT_DEFAULTS, wallFinishMaterialIndex, zoneHasWallFinish, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect } from 'react';
 import * as THREE from 'three';
@@ -17,6 +17,7 @@ import { drainStats, endInitialBuild, initiallyBuiltWalls, isWallInitialBuildAct
 import { getWallFaceBaseAt, } from './wall-finish-data';
 import { sweepUnbuiltWalls, WALL_PLACEHOLDER_SWEEP_INTERVAL } from './wall-placeholder-sweep';
 import { notifyWallRebuilt } from './wall-rebuild-notifications';
+import { repairWallTJunctions } from './wall-t-junctions';
 export { isWallInitialBuildActive } from './wall-build-lifecycle';
 export { drainRebuiltWalls } from './wall-rebuild-notifications';
 // Reusable CSG evaluator for better performance
@@ -332,6 +333,9 @@ function interpolateSplitVertex(a, b, t) {
         z: a.z + (b.z - a.z) * t,
     };
 }
+function compareSplitVertices(a, b) {
+    return a.x - b.x || a.y - b.y || a.z - b.z;
+}
 function clipPolygonByPlane(polygon, axis, plane, keepBelow) {
     const out = [];
     if (polygon.length === 0)
@@ -345,9 +349,12 @@ function clipPolygonByPlane(polygon, axis, plane, keepBelow) {
         const currentInside = isInside(current);
         const previousInside = isInside(previous);
         if (currentInside !== previousInside) {
-            const denom = current[axis] - previous[axis];
+            // Interpolate from the same endpoint whichever way the edge is walked: the
+            // two triangles sharing it then get a bit-identical seam vertex.
+            const [from, to] = compareSplitVertices(previous, current) <= 0 ? [previous, current] : [current, previous];
+            const denom = to[axis] - from[axis];
             if (Math.abs(denom) > WALL_BAND_SPLIT_EPSILON) {
-                out.push(interpolateSplitVertex(previous, current, (plane - previous[axis]) / denom));
+                out.push(interpolateSplitVertex(from, to, (plane - from[axis]) / denom));
             }
         }
         if (currentInside)
@@ -1174,10 +1181,22 @@ function mergeWallTerrainFill(body, fills, wall, boundaryEdges, finish) {
     bodyGeometry.dispose();
     for (const fill of splitFills)
         fill.dispose();
-    merged.computeVertexNormals();
-    assignWallMaterialGroups(merged, wall, boundaryEdges, finish);
-    ensureRenderableGeometryAttributes(merged);
-    return merged;
+    return finishWallFaces(merged, wall, boundaryEdges, finish);
+}
+/**
+ * Classifies the faces into material groups, then removes the T-junctions that
+ * CSG cuts, finish-band splits and fill seams leave behind (they crack open
+ * once a bake quantizes positions). Classification runs first, on the source
+ * triangles, so the repair's sliver pieces inherit their material.
+ */
+function finishWallFaces(geometry, wall, boundaryEdges, finish) {
+    geometry.computeVertexNormals();
+    assignWallMaterialGroups(geometry, wall, boundaryEdges, finish);
+    const repaired = repairWallTJunctions(geometry);
+    if (repaired !== geometry)
+        repaired.computeVertexNormals();
+    ensureRenderableGeometryAttributes(repaired);
+    return repaired;
 }
 /** Wall-local x of a support-segment parameter (curve parameter on arcs). */
 function wallStationX(wall, t, length) {
@@ -1208,6 +1227,41 @@ function buildWallFinishContext(wall, layout, faceBase, slabElevation) {
         .sort((left, right) => left.start - right.start);
     return { layout, faceBase: { a: runs(faceBase.a), b: runs(faceBase.b) }, refs, foundation };
 }
+/**
+ * Wall-local Y of the sloped top at `x`. Mitered corners sample `x` outside
+ * [0, L], where the line can fall below the wall base; the top never drops
+ * under {@link MIN_WALL_END_HEIGHT} (or the flat height, if lower).
+ */
+export function wallTopYAt(wallTop, x) {
+    const { height, slope } = wallTop;
+    if (slope === 0)
+        return height;
+    return Math.max(height + slope * x, Math.min(height, MIN_WALL_END_HEIGHT));
+}
+/**
+ * Tilts a wall's top edge along its length so the `end` side sits taller (or
+ * shorter) than the `start` side — e.g. a knee wall following a single-pitch
+ * roof slope — instead of requiring a non-rectangular footprint. Only
+ * vertices sitting exactly at the flat extruded top (`topY`) move.
+ *
+ * Evaluates the linear plane equation `slope * localX` continuously across
+ * all top vertices (including mitered corner vertices extending beyond [0, L])
+ * so the extruded top face remains a single coplanar surface without corner
+ * creases or triangulation folds — except where {@link wallTopYAt} holds an
+ * extended miter vertex above the base.
+ */
+function applyWallEndHeightSlope(geometry, wallTop) {
+    const { height: topY, slope } = wallTop;
+    if (slope === 0)
+        return;
+    const position = geometry.getAttribute('position');
+    for (let i = 0; i < position.count; i++) {
+        if (Math.abs(position.getY(i) - topY) > 1e-4)
+            continue;
+        position.setY(i, wallTopYAt(wallTop, position.getX(i)));
+    }
+    position.needsUpdate = true;
+}
 export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabElevation = 0, baseElevation = slabElevation, baseSegments = [
     { start: 0, end: 1, elevation: baseElevation },
 ], storeyHeight = DEFAULT_LEVEL_HEIGHT, terrainBottomAt, faceBase, finishLayout = buildWallFinishLayout(wallNode, []), sceneNodes = useScene.getState().nodes) {
@@ -1217,6 +1271,7 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     const level = sceneNodes[levelId];
     const authoredStoreyHeight = level?.type === 'level' ? (level.height ?? null) : null;
     const topElevation = resolveWallTop(wallNode, storeyHeight, slabElevation, authoredStoreyHeight);
+    const effectiveWallHeight = topElevation - slabElevation;
     const faceDatum = faceBase;
     if (faceBase)
         faceBase = {
@@ -1247,6 +1302,10 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     if (L < 1e-9) {
         return new THREE.BufferGeometry();
     }
+    const wallTop = {
+        height: effectiveWallHeight,
+        slope: clampWallEndHeightOffset(wallNode.endHeightOffset, effectiveWallHeight) / L,
+    };
     const boundaryPoints = getWallMiterBoundaryPoints(wallNode, miterData);
     const polyPoints = isCurvedWall(wallNode)
         ? getWallSurfacePolygon(wallNode, 24, insetCurvedWallBoundaryPointsFor3D(wallNode, boundaryPoints, miterData) ?? undefined)
@@ -1293,10 +1352,10 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
         depth: height,
         bevelEnabled: false,
     });
-    // Rotate so extrusion direction (Z) becomes height direction (Y)
     geometry.rotateX(-Math.PI / 2);
     if (Math.abs(localBottom) > 1e-9)
         geometry.translate(0, localBottom, 0);
+    applyWallEndHeightSlope(geometry, wallTop);
     geometry.computeVertexNormals();
     assignWallMaterialGroups(geometry, wallNode, boundaryEdges, finish);
     ensureRenderableGeometryAttributes(geometry);
@@ -1412,13 +1471,10 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
     }
     const cutoutBrushes = [
         ...baseProfileCutouts,
-        ...collectCutoutBrushes(wallNode, childrenNodes, thickness, faceDatum, slabElevation, sceneNodes, baseSegments),
+        ...collectCutoutBrushes(wallNode, childrenNodes, thickness, wallTop, faceDatum, slabElevation, sceneNodes, baseSegments),
     ];
     if (cutoutBrushes.length === 0) {
-        const splitGeometry = splitGeometryAtPlanes(geometry, finishPlanes.y, finishPlanes.x);
-        splitGeometry.computeVertexNormals();
-        assignWallMaterialGroups(splitGeometry, wallNode, boundaryEdges, finish);
-        ensureRenderableGeometryAttributes(splitGeometry);
+        const splitGeometry = finishWallFaces(splitGeometryAtPlanes(geometry, finishPlanes.y, finishPlanes.x), wallNode, boundaryEdges, finish);
         return withWallFinishData(mergeWallTerrainFill(splitGeometry, belowBaseFills, wallNode, boundaryEdges, finish), finish);
     }
     // Create wall brush from geometry
@@ -1462,10 +1518,7 @@ export function generateExtrudedWall(wallNode, childrenNodes, miterData, slabEle
             csgGeometry(brush).dispose();
     }
     const resultGeometry = csgGeometry(resultBrush);
-    const splitResultGeometry = splitGeometryAtPlanes(resultGeometry, finishPlanes.y, finishPlanes.x);
-    splitResultGeometry.computeVertexNormals();
-    assignWallMaterialGroups(splitResultGeometry, wallNode, boundaryEdges, finish);
-    ensureRenderableGeometryAttributes(splitResultGeometry);
+    const splitResultGeometry = finishWallFaces(splitGeometryAtPlanes(resultGeometry, finishPlanes.y, finishPlanes.x), wallNode, boundaryEdges, finish);
     return withWallFinishData(mergeWallTerrainFill(splitResultGeometry, belowBaseFills, wallNode, boundaryEdges, finish), finish);
 }
 function withWallFinishData(geometry, finish) {
@@ -1514,7 +1567,7 @@ function authoredCutoutBrush(cutoutMesh, wallMatrixInverse, wallThickness, wallN
     computeGeometryBoundsTree(geometry);
     return new Brush(geometry);
 }
-function collectCutoutBrushes(wallNode, childrenNodes, wallThickness, faceBase, elevation = 0, sceneNodes = useScene.getState().nodes, baseSegments = [{ start: 0, end: 1, elevation }]) {
+function collectCutoutBrushes(wallNode, childrenNodes, wallThickness, wallTop, faceBase, elevation = 0, sceneNodes = useScene.getState().nodes, baseSegments = [{ start: 0, end: 1, elevation }]) {
     const brushes = [];
     const wallMesh = sceneRegistry.nodes.get(wallNode.id);
     if (!wallMesh)
@@ -1571,7 +1624,7 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness, faceBase,
                         child.position[1] + cut.datum - elevation,
                         child.position[2],
                     ],
-                }, wallThickness, getWallBodyCenterOffset(wallNode), cut.bottom - elevation, child.type === 'window' ? cornerPair(sceneNodes, child)?.end : undefined));
+                }, wallThickness, getWallBodyCenterOffset(wallNode), cut.bottom - elevation, child.type === 'window' ? cornerPair(sceneNodes, child)?.end : undefined, wallTop));
                 continue;
             }
             if (cut.band.length < 3)
@@ -1582,8 +1635,9 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness, faceBase,
                 return new THREE.Vector2(dx * Math.cos(angle) + dz * Math.sin(angle), dx * Math.sin(angle) - dz * Math.cos(angle));
             });
             const padding = getOpeningCutoutBottomPadding(child, cut.bottom - elevation);
+            const top = Math.min(cut.top - elevation, Math.min(...points.map((point) => wallTopYAt(wallTop, point.x))));
             const geometry = new THREE.ExtrudeGeometry(new THREE.Shape(points), {
-                depth: cut.top - cut.bottom + padding,
+                depth: top - (cut.bottom - elevation) + padding,
                 bevelEnabled: false,
             });
             geometry.rotateX(-Math.PI / 2);
@@ -1668,16 +1722,23 @@ function collectCutoutBrushes(wallNode, childrenNodes, wallThickness, faceBase,
  * cut only takes this wall's own geometry, so running past it touches nothing else.
  */
 const CORNER_CUT_REACH = 6;
-function createOpeningCutoutBrush(opening, wallThickness, centerOffset, cutBottom, cornerEnd) {
-    const halfWidth = opening.width / 2;
+function createOpeningCutoutBrush(opening, wallThickness, centerOffset, cutBottom, cornerEnd, wallTop) {
+    const size = getDoorOpeningSize(opening);
+    const centerX = opening.position[0] - size.leafOffsetX * openingHostFacing(opening);
+    const halfWidth = size.width / 2;
     const bottom = cutBottom ?? opening.position[1] - opening.height / 2;
     const bottomPadding = getOpeningCutoutBottomPadding(opening, bottom);
     const reach = CORNER_CUT_REACH * wallThickness;
+    const left = centerX - halfWidth;
+    const right = centerX + halfWidth;
+    const openingTop = opening.position[1] - opening.height / 2 + size.height;
     const geometry = buildOpeningCutoutGeometry(opening, {
-        left: opening.position[0] - halfWidth - (cornerEnd === 'start' ? reach : 0),
-        right: opening.position[0] + halfWidth + (cornerEnd === 'end' ? reach : 0),
+        left: left - (cornerEnd === 'start' ? reach : 0),
+        right: right + (cornerEnd === 'end' ? reach : 0),
         bottom: bottom - bottomPadding,
-        top: opening.position[1] + opening.height / 2,
+        top: wallTop
+            ? Math.min(openingTop, wallTopYAt(wallTop, wallTop.slope > 0 ? left : right))
+            : openingTop,
     }, wallThickness * 2, wallThickness);
     if (centerOffset !== 0)
         geometry.translate(0, 0, centerOffset);

package/dist/systems/wall/wall-t-junctions.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+/**
+ * Splits every triangle whose edge carries another triangle's vertex, so the
+ * neighbours share that vertex instead of meeting at a T-junction. CSG cuts and
+ * finish-band splits leave T-junctions on wall faces: they look closed at full
+ * float precision, but crack open into dotted light leaks once a GLB bake
+ * quantizes positions.
+ *
+ * Each piece keeps its source triangle's material group, so the repair never
+ * reclassifies a face. Geometry without T-junctions is returned untouched;
+ * otherwise the result is non-indexed and position-only (callers recompute
+ * normals) and the input is disposed.
+ */
+export declare function repairWallTJunctions(geometry: THREE.BufferGeometry): THREE.BufferGeometry;
+//# sourceMappingURL=wall-t-junctions.d.ts.map

package/dist/systems/wall/wall-t-junctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-t-junctions.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-t-junctions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAW9B;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,CAiHzF"}