@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1,170 @@
+import { getWallArcData } from './wall-curve.js';
+export function getWallFaceOffsets(wall) {
+    const thickness = wall.thickness ?? 0.1;
+    if (wall.justification === 'a')
+        return { a: thickness, b: 0 };
+    if (wall.justification === 'b')
+        return { a: 0, b: -thickness };
+    return { a: thickness / 2, b: -thickness / 2 };
+}
+export function getWallBodyCenterOffset(wall) {
+    const { a, b } = getWallFaceOffsets(wall);
+    return (a + b) / 2;
+}
+function offsetLine(wall, offset) {
+    const start = { x: wall.start[0], y: wall.start[1] };
+    const end = { x: wall.end[0], y: wall.end[1] };
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const length = Math.hypot(dx, dy);
+    if (offset === 0 || length < 1e-9)
+        return { start, end };
+    const nx = (-dy / length) * offset;
+    const ny = (dx / length) * offset;
+    return {
+        start: { x: start.x + nx, y: start.y + ny },
+        end: { x: end.x + nx, y: end.y + ny },
+    };
+}
+export function getWallBodyLine(wall) {
+    return offsetLine(wall, getWallBodyCenterOffset(wall));
+}
+export function getWallFaceLine(wall, face) {
+    return offsetLine(wall, getWallFaceOffsets(wall)[face]);
+}
+export function getWallLocalFaceZ(wall, face) {
+    // The viewer rotates XZ by -atan2(dy, dx), mapping the left normal to +z.
+    return getWallFaceOffsets(wall)[face];
+}
+/**
+ * Which physical face a point on the wall mesh lies on, from wall-local
+ * coordinates (x along the chord, z toward its left) — never from the material
+ * a face happens to draw with. Curved walls use the arc's own frame, so a point
+ * near an arc end is judged against the curve, not the chord. Returns null for
+ * caps and tops (the surface normal is not across the wall) and for points too
+ * close to the body centre to call.
+ */
+export function getWallFaceAtLocalPoint(wall, localPosition, localNormal) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-9)
+        return null;
+    const tangent = { x: dx / length, y: dz / length };
+    const left = { x: -tangent.y, y: tangent.x };
+    const toWorld = (x, z) => ({
+        x: tangent.x * x + left.x * z,
+        y: tangent.y * x + left.y * z,
+    });
+    const [localX, , localZ] = localPosition;
+    let across = localZ;
+    let faceNormal = left;
+    const arc = getWallArcData(wall);
+    if (arc) {
+        const offset = toWorld(localX, localZ);
+        const px = wall.start[0] + offset.x - arc.center.x;
+        const py = wall.start[1] + offset.y - arc.center.y;
+        const radius = Math.hypot(px, py);
+        if (radius < 1e-9)
+            return null;
+        // Left of a counter-clockwise arc points at its centre.
+        const inward = arc.direction > 0;
+        across = inward ? arc.radius - radius : radius - arc.radius;
+        faceNormal = inward ? { x: -px / radius, y: -py / radius } : { x: px / radius, y: py / radius };
+    }
+    if (localNormal) {
+        const normal = toWorld(localNormal[0], localNormal[2]);
+        if (Math.abs(normal.x * faceNormal.x + normal.y * faceNormal.y) < 0.65)
+            return null;
+    }
+    const fromCentre = across - getWallBodyCenterOffset(wall);
+    const thickness = wall.thickness ?? 0.1;
+    if (Math.abs(fromCentre) < Math.max(thickness * 0.2, 0.01))
+        return null;
+    return fromCentre >= 0 ? 'a' : 'b';
+}
+export function faceOnLine(wall) {
+    return wall.justification === 'a' ? 'b' : wall.justification === 'b' ? 'a' : 'center';
+}
+export function justificationForFaceOnLine(face) {
+    return face === 'a' ? 'b' : face === 'b' ? 'a' : undefined;
+}
+export function buildWallJustificationPatch(justification) {
+    return { justification };
+}
+const swapFace = (face) => (face === 'a' ? 'b' : 'a');
+function swapFaceSlotKey(key) {
+    if (key === 'a' || key === 'b')
+        return swapFace(key);
+    const match = /^([ab])([A-Z].*)$/.exec(key);
+    return match ? `${swapFace(match[1])}${match[2]}` : key;
+}
+// Legacy semantic sides draw on their canonical face (interior → a), so they turn too.
+const TRIM_FACE = { a: 'a', interior: 'a', b: 'b', exterior: 'b' };
+function reverseTrim(trim) {
+    const face = trim?.sides ? TRIM_FACE[trim.sides] : undefined;
+    if (!(trim && face))
+        return trim;
+    return { ...trim, sides: swapFace(face) };
+}
+/**
+ * Turns a wall around. Face `a` becomes `b`, so everything keyed by face swaps
+ * with it, and region stations are re-measured from the new start. Zone
+ * `wallOverrides` live on zones; callers reversing a wall swap those too.
+ */
+export function reverseWallDirection(wall) {
+    const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    const legacy = wall.legacyFaceMaterials;
+    return {
+        start: wall.end,
+        end: wall.start,
+        frontSide: wall.backSide,
+        backSide: wall.frontSide,
+        ...(wall.justification === undefined
+            ? {}
+            : { justification: wall.justification === 'a' ? 'b' : 'a' }),
+        ...(wall.curveOffset === undefined ? {} : { curveOffset: -wall.curveOffset }),
+        ...(wall.slots === undefined
+            ? {}
+            : {
+                slots: Object.fromEntries(Object.entries(wall.slots).map(([key, value]) => [swapFaceSlotKey(key), value])),
+            }),
+        ...(legacy === undefined
+            ? {}
+            : {
+                legacyFaceMaterials: {
+                    ...(legacy.b === undefined ? {} : { a: legacy.b }),
+                    ...(legacy.a === undefined ? {} : { b: legacy.a }),
+                },
+            }),
+        ...(wall.faceRegions === undefined
+            ? {}
+            : {
+                faceRegions: wall.faceRegions.map(({ u0, u1, ...region }) => ({
+                    ...region,
+                    face: swapFace(region.face),
+                    ...(u1 === undefined ? {} : { u0: length - u1 }),
+                    ...(u0 === undefined ? {} : { u1: length - u0 }),
+                })),
+            }),
+        ...(wall.finishScripts === undefined
+            ? {}
+            : {
+                finishScripts: {
+                    ...(wall.finishScripts.b === undefined ? {} : { a: wall.finishScripts.b }),
+                    ...(wall.finishScripts.a === undefined ? {} : { b: wall.finishScripts.a }),
+                },
+            }),
+        ...(wall.skirting === undefined ? {} : { skirting: reverseTrim(wall.skirting) }),
+        ...(wall.crown === undefined ? {} : { crown: reverseTrim(wall.crown) }),
+        ...(wall.chairRail === undefined ? {} : { chairRail: reverseTrim(wall.chairRail) }),
+    };
+}
+export function planWallJustification(nodes, wallId, justification) {
+    const wall = nodes[wallId];
+    if (wall?.type !== 'wall')
+        throw Error('Select a wall.');
+    if (wall.justification === justification)
+        return [];
+    return [{ id: wall.id, data: buildWallJustificationPatch(justification) }];
+}

package/dist/systems/wall/wall-layer-bands.d.ts

@@ -0,0 +1,38 @@
+import { type ResolvedAssembly } from '../../lib/assembly-stack.js';
+import type { Assembly, WallNode } from '../../schema/index.js';
+import { type Point2D, type WallMiterData } from './wall-mitering.js';
+/**
+ * One assembly layer's share of a wall's plan footprint (F2 band math).
+ * `back` and `front` are the band's faces as signed offsets from the wall
+ * centreline along the front normal (+n), so `back < front` and the front
+ * face of the wall is at +thickness/2.
+ */
+export type WallLayerBand = {
+    layerId: string;
+    back: number;
+    front: number;
+    /** The mitred footprint ∩ the band's offset strip, as counter-clockwise plan rings. */
+    polygons: Point2D[][];
+};
+export type WallLayerBands = ResolvedAssembly & {
+    bands: WallLayerBand[];
+};
+/**
+ * Slices a wall's mitred plan footprint into the bands of an assembly's layers
+ * (F2 band math). Pure: nothing reads it yet (WL-02 extrudes the bands).
+ *
+ * The stack sets the body, so the bands tile exactly the footprint that
+ * mitering, rooms and 2D already use once `thickness` holds the layer sum. A
+ * wall whose stored thickness disagrees gets the `assembly.thickness-mismatch`
+ * diagnostic and no bands: it keeps its plain body until a writer re-derives
+ * the thickness. Layers stack from the front face (+n), or from the exterior
+ * face with `face: 'exterior'` (`resolveWallExteriorSide`, back as fallback).
+ *
+ * Straight walls intersect the footprint with half-plane strips through the
+ * core polygon booleans, which handles the junction vertex a mitred end cap
+ * may carry. A curved footprint's end caps are single segments, so its bands
+ * resample the footprint's own arcs at the band offsets and interpolate along
+ * each cap.
+ */
+export declare function getWallLayerBands(wall: WallNode, assembly: Assembly, miterData: WallMiterData): WallLayerBands;
+//# sourceMappingURL=wall-layer-bands.d.ts.map

package/dist/systems/wall/wall-layer-bands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-layer-bands.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-layer-bands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAwB,MAAM,0BAA0B,CAAA;AAEtF,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAQtD,OAAO,EAA8B,KAAK,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAI9F;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,uFAAuF;IACvF,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG;IAAE,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,CAAA;AAE1E;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,aAAa,GACvB,cAAc,CA6BhB"}

package/dist/systems/wall/wall-layer-bands.js

@@ -0,0 +1,109 @@
+import { resolveAssemblyStack } from '../../lib/assembly-stack.js';
+import { subtractPolygonsFromPolygon } from '../../lib/polygon-union.js';
+import { resolveWallExteriorSide } from './wall-assembly.js';
+import { getWallCurveFrameAt, isCurvedWall } from './wall-curve.js';
+import { CURVED_WALL_SURFACE_SEGMENTS, getWallPlanFootprint, getWallThickness, } from './wall-footprint.js';
+import { getWallMiterBoundaryPoints } from './wall-mitering.js';
+const EPSILON = 1e-9;
+/**
+ * Slices a wall's mitred plan footprint into the bands of an assembly's layers
+ * (F2 band math). Pure: nothing reads it yet (WL-02 extrudes the bands).
+ *
+ * The stack sets the body, so the bands tile exactly the footprint that
+ * mitering, rooms and 2D already use once `thickness` holds the layer sum. A
+ * wall whose stored thickness disagrees gets the `assembly.thickness-mismatch`
+ * diagnostic and no bands: it keeps its plain body until a writer re-derives
+ * the thickness. Layers stack from the front face (+n), or from the exterior
+ * face with `face: 'exterior'` (`resolveWallExteriorSide`, back as fallback).
+ *
+ * Straight walls intersect the footprint with half-plane strips through the
+ * core polygon booleans, which handles the junction vertex a mitred end cap
+ * may carry. A curved footprint's end caps are single segments, so its bands
+ * resample the footprint's own arcs at the band offsets and interpolate along
+ * each cap.
+ */
+export function getWallLayerBands(wall, assembly, miterData) {
+    const thickness = getWallThickness(wall);
+    // Walls store the body as `thickness` and take no backing.
+    const stack = resolveAssemblyStack(assembly, { body: thickness });
+    if (stack.diagnostics.some((d) => d.code === 'assembly.thickness-mismatch')) {
+        return { ...stack, bands: [] };
+    }
+    const half = thickness / 2;
+    // +1 when the first listed layer is on the front face, −1 when it is on the back.
+    const sign = assembly.face === 'exterior' ? (resolveWallExteriorSide(wall) ?? -1) : 1;
+    const footprint = getWallPlanFootprint(wall, miterData);
+    const curved = isCurvedWall(wall);
+    const bands = [];
+    for (const layer of stack.layers) {
+        if (layer.thickness <= EPSILON)
+            continue;
+        const outer = sign * (half - layer.depth);
+        const inner = sign * (half - layer.depth - layer.thickness);
+        const back = Math.min(outer, inner);
+        const front = Math.max(outer, inner);
+        let polygons = [];
+        if (footprint.length >= 3) {
+            polygons = curved
+                ? curvedBand(wall, miterData, thickness, back, front)
+                : straightBand(wall, footprint, half, back, front);
+        }
+        bands.push({ layerId: layer.id, back, front, polygons });
+    }
+    return { ...stack, bands };
+}
+function straightBand(wall, footprint, half, back, front) {
+    const [sx, sy] = wall.start;
+    const dx = wall.end[0] - sx;
+    const dy = wall.end[1] - sy;
+    const length = Math.hypot(dx, dy);
+    const ux = dx / length;
+    const uy = dy / length;
+    const nx = -uy;
+    const ny = ux;
+    // Past every footprint point, mitre tips included.
+    const reach = 1 + Math.max(...footprint.map((point) => Math.hypot(point.x - sx, point.y - sy)));
+    const at = (along, offset) => [
+        sx + ux * along + nx * offset,
+        sy + uy * along + ny * offset,
+    ];
+    // Each cutter is the half-plane beyond one band face, clipped to a rectangle
+    // that contains the whole footprint. A face on the wall's own face needs none.
+    const strip = (from, to) => [
+        at(-reach, from),
+        at(length + reach, from),
+        at(length + reach, to),
+        at(-reach, to),
+    ];
+    const cutters = [];
+    if (front < half - EPSILON)
+        cutters.push(strip(front, half + reach));
+    if (back > -half + EPSILON)
+        cutters.push(strip(-half - reach, back));
+    const subject = footprint.map((point) => [point.x, point.y]);
+    return subtractPolygonsFromPolygon(subject, cutters).map((ring) => ring.map(([x, y]) => ({ x, y })));
+}
+function curvedBand(wall, miterData, thickness, back, front) {
+    const caps = getWallMiterBoundaryPoints(wall, miterData);
+    if (!caps)
+        return [];
+    const half = thickness / 2;
+    const along = (offset) => {
+        const points = [];
+        for (let index = 0; index <= CURVED_WALL_SURFACE_SEGMENTS; index++) {
+            const frame = getWallCurveFrameAt(wall, index / CURVED_WALL_SURFACE_SEGMENTS);
+            points.push({
+                x: frame.point.x + frame.normal.x * offset,
+                y: frame.point.y + frame.normal.y * offset,
+            });
+        }
+        const t = (offset + half) / thickness;
+        points[0] = lerp(caps.startRight, caps.startLeft, t);
+        points[points.length - 1] = lerp(caps.endRight, caps.endLeft, t);
+        return points;
+    };
+    return [[...along(back), ...along(front).reverse()]];
+}
+function lerp(a, b, t) {
+    return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}

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

@@ -1,4 +1,4 @@
-import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema/index.js';
+import { type AnyNode, type AnyNodeId, type WallFaceRegion, type WallNode, type ZoneNode } from '../../schema/index.js';
 import type { WallTopologyChanges } from './wall-topology.js';
 export type WallAttachmentUpdate = {
     id: AnyNodeId;
@@ -16,6 +16,25 @@ export declare function wallStyleMismatch(a: WallNode, b: WallNode, options: {
     sides: boolean;
     heightOf?: (wall: WallNode) => number;
 }): string | null;
+/**
+ * Both walls' paint regions in the merged wall's coordinates: faces read in its
+ * direction, stations measured from its start, each region clipped to the stretch
+ * its own wall covered (an open bound stays open only at a merged-wall end), and
+ * matching regions that meet at the joint joined into one. Null when a face would
+ * exceed the region limit.
+ */
+export declare function mergeWallFaceRegions(walls: readonly WallNode[], mergedStart: [number, number], mergedEnd: [number, number]): WallFaceRegion[] | null;
+/**
+ * Zone references after `secondary` is absorbed into `primary` (which spans
+ * `mergedStart → mergedEnd`): boundary ids follow the kept wall, and override
+ * entries move onto it with their face read in its direction. Null when the two
+ * walls disagree on a room's override for a face they both border — joining
+ * would repaint part of that room.
+ */
+export declare function planMergedZoneReferences(nodes: Record<AnyNodeId, AnyNode>, primary: WallNode, secondary: WallNode, mergedStart: [number, number], mergedEnd: [number, number]): Array<{
+    id: AnyNodeId;
+    data: Partial<ZoneNode>;
+}> | null;
 export declare function areWallStylesCompatible(a: WallNode, b: WallNode): boolean;
 export declare function areWallsCollinearAcrossPoint(a: WallNode, b: WallNode, sharedPoint: [number, number]): boolean;
 export declare function resolveMergedWallEndpoints(primary: WallNode, secondary: WallNode, sharedPoint: [number, number]): {

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

@@ -1 +1 @@
-{"version":3,"file":"wall-merge.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-merge.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,QAAQ,EACd,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAK1D,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAY5E,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,OAAO,GAAG,KAAK,GAAG,IAAI,CAIxB;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,OAAO,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAA;CAAE,GACjE,MAAM,GAAG,IAAI,CAuBf;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,WAE/D;AAED,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,WAgB9B;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAkBpD;AAyBD,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,YAAY,EAAE,SAAS,EACvB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,oBAAoB,EAAE,CAyDxB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,SAAS,EAAE,GAC5B;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;CAAE,CA4F1D"}
+{"version":3,"file":"wall-merge.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-merge.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAMd,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,cAAc,CAAA;AAGrB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAK1D,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAY5E,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,OAAO,GAAG,KAAK,GAAG,IAAI,CAIxB;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,OAAO,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAA;CAAE,GACjE,MAAM,GAAG,IAAI,CA+Bf;AA4CD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1B,cAAc,EAAE,GAAG,IAAI,CAqEzB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GAAG,IAAI,CA+C1D;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,WAE/D;AAED,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,WAgB9B;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAkBpD;AAyBD,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,YAAY,EAAE,SAAS,EACvB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,oBAAoB,EAAE,CAyDxB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,SAAS,EAAE,GAC5B;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;CAAE,CA8F1D"}

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

@@ -1,5 +1,7 @@
 import { getWallEffectiveHeightForNodes } from '../../hooks/spatial-grid/spatial-grid-manager.js';
-import { getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, } from '../../schema/index.js';
+import { getWallTrimFaces, getWallTrimSlotId, WALL_FACE_REGION_LIMIT, WALL_TRIM_DEFAULTS, } from '../../schema/index.js';
+import { getWallZoneSpans, resolveWallFaceChain } from './wall-finish.js';
+import { reverseWallDirection } from './wall-frame.js';
 function pointsEqual(a, b, tolerance = 1e-6) {
     const dx = a[0] - b[0];
     const dz = a[1] - b[1];
@@ -32,23 +34,192 @@ export function wallStyleMismatch(a, b, options) {
         return 'curve';
     if (Math.abs((a.thickness ?? 0.2) - (b.thickness ?? 0.2)) > 1e-6)
         return 'thickness';
+    const opposite = (a.end[0] - a.start[0]) * (b.end[0] - b.start[0]) +
+        (a.end[1] - a.start[1]) * (b.end[1] - b.start[1]) <
+        0;
+    const alignedB = opposite ? { ...b, ...reverseWallDirection(b) } : b;
+    if (a.justification !== alignedB.justification)
+        return 'justification';
     const { heightOf } = options;
     if (heightOf
         ? Math.abs(heightOf(a) - heightOf(b)) > 1e-6
         : (a.height == null) !== (b.height == null) ||
             Math.abs((a.height ?? 0) - (b.height ?? 0)) > 1e-6)
         return 'height';
-    for (const side of ['interior', 'exterior']) {
-        if (getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(a, side)) !==
-            getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(b, side)))
-            return `${side} finish`;
+    // Faces are compared as the merged wall will carry them: b read in a's direction.
+    for (const face of ['a', 'b']) {
+        if (JSON.stringify(resolveWallFaceChain(a, face)) !==
+            JSON.stringify(resolveWallFaceChain(alignedB, face)))
+            return `side ${face.toUpperCase()} finish`;
     }
+    if (wallTrimSignature(a) !== wallTrimSignature(alignedB))
+        return 'trim';
     if (options.sides && (a.frontSide !== b.frontSide || a.backSide !== b.backSide))
         return 'room sides';
     if (a.visible !== b.visible)
         return 'visibility';
     return null;
 }
+/** Every trim as it draws: which faces, which profile and size, which finish per face. */
+function wallTrimSignature(wall) {
+    return JSON.stringify(['skirting', 'crown', 'chairRail'].map((kind) => {
+        const trim = { ...WALL_TRIM_DEFAULTS[kind], ...(wall[kind] ?? {}) };
+        if (!trim.enabled)
+            return null;
+        const faces = getWallTrimFaces(trim.sides);
+        return {
+            faces,
+            profile: trim.profile,
+            height: trim.height,
+            proud: trim.proud,
+            offsetY: trim.offsetY ?? null,
+            finishes: faces.map((face) => wall.slots?.[getWallTrimSlotId(face, kind)] ?? null),
+        };
+    }));
+}
+function readsBackwards(wall, start, end) {
+    return ((wall.end[0] - wall.start[0]) * (end[0] - start[0]) +
+        (wall.end[1] - wall.start[1]) * (end[1] - start[1]) <
+        0);
+}
+const REGION_EPSILON = 1e-6;
+function sameRegionBody(left, right) {
+    return (left.face === right.face &&
+        left.finish === right.finish &&
+        left.v0 === right.v0 &&
+        left.v1 === right.v1);
+}
+/**
+ * Both walls' paint regions in the merged wall's coordinates: faces read in its
+ * direction, stations measured from its start, each region clipped to the stretch
+ * its own wall covered (an open bound stays open only at a merged-wall end), and
+ * matching regions that meet at the joint joined into one. Null when a face would
+ * exceed the region limit.
+ */
+export function mergeWallFaceRegions(walls, mergedStart, mergedEnd) {
+    const mergedLength = Math.hypot(mergedEnd[0] - mergedStart[0], mergedEnd[1] - mergedStart[1]);
+    if (mergedLength < 1e-9)
+        return [];
+    const tx = (mergedEnd[0] - mergedStart[0]) / mergedLength;
+    const tz = (mergedEnd[1] - mergedStart[1]) / mergedLength;
+    const station = (point) => (point[0] - mergedStart[0]) * tx + (point[1] - mergedStart[1]) * tz;
+    const seenIds = new Set();
+    const out = [];
+    for (const wall of walls) {
+        const regions = wall.faceRegions ?? [];
+        if (regions.length === 0)
+            continue;
+        const length = wallLength(wall);
+        const backwards = readsBackwards(wall, mergedStart, mergedEnd);
+        const from = Math.min(station(wall.start), station(wall.end));
+        const to = Math.max(station(wall.start), station(wall.end));
+        const toMerged = (u) => (backwards ? to - u : from + u);
+        for (const region of regions) {
+            const low = backwards ? region.u1 : region.u0;
+            const high = backwards ? region.u0 : region.u1;
+            const u0 = Math.max(from, low === undefined ? from : toMerged(low));
+            const u1 = Math.min(to, high === undefined ? to : toMerged(high));
+            if (u1 - u0 <= REGION_EPSILON && length > REGION_EPSILON)
+                continue;
+            let id = region.id;
+            if (seenIds.has(id))
+                id = `${region.id}-${wall.id}`;
+            seenIds.add(id);
+            const { u0: _u0, u1: _u1, ...body } = region;
+            out.push({
+                ...body,
+                id,
+                face: backwards ? (region.face === 'a' ? 'b' : 'a') : region.face,
+                ...(u0 <= REGION_EPSILON ? {} : { u0 }),
+                ...(u1 >= mergedLength - REGION_EPSILON ? {} : { u1 }),
+            });
+        }
+    }
+    // Coalesce a region that continues another across the joint.
+    const merged = [];
+    for (const region of out) {
+        const joined = merged.findIndex((other) => sameRegionBody(other, region) &&
+            ((other.u1 !== undefined &&
+                Math.abs(other.u1 - (region.u0 ?? 0)) <= REGION_EPSILON &&
+                region.u0 !== undefined) ||
+                (region.u1 !== undefined &&
+                    Math.abs(region.u1 - (other.u0 ?? 0)) <= REGION_EPSILON &&
+                    other.u0 !== undefined)));
+        if (joined < 0) {
+            merged.push(region);
+            continue;
+        }
+        const other = merged[joined];
+        const u0 = other.u0 === undefined || region.u0 === undefined ? undefined : Math.min(other.u0, region.u0);
+        const u1 = other.u1 === undefined || region.u1 === undefined ? undefined : Math.max(other.u1, region.u1);
+        const { u0: _a, u1: _b, ...body } = other;
+        merged[joined] = {
+            ...body,
+            ...(u0 === undefined ? {} : { u0 }),
+            ...(u1 === undefined ? {} : { u1 }),
+        };
+    }
+    for (const face of ['a', 'b']) {
+        if (merged.filter((region) => region.face === face).length > WALL_FACE_REGION_LIMIT)
+            return null;
+    }
+    return merged;
+}
+/**
+ * Zone references after `secondary` is absorbed into `primary` (which spans
+ * `mergedStart → mergedEnd`): boundary ids follow the kept wall, and override
+ * entries move onto it with their face read in its direction. Null when the two
+ * walls disagree on a room's override for a face they both border — joining
+ * would repaint part of that room.
+ */
+export function planMergedZoneReferences(nodes, primary, secondary, mergedStart, mergedEnd) {
+    const faceOf = (wall, face) => readsBackwards(wall, mergedStart, mergedEnd) ? (face === 'a' ? 'b' : 'a') : face;
+    const updates = [];
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'zone')
+            continue;
+        const touchesBoundary = node.boundaryWallIds?.includes(secondary.id) ?? false;
+        const entries = node.wallOverrides ?? [];
+        const touchesOverrides = entries.some((entry) => entry.wallId === secondary.id || entry.wallId === primary.id);
+        if (!(touchesBoundary || touchesOverrides))
+            continue;
+        const data = {};
+        if (touchesBoundary)
+            data.boundaryWallIds = [
+                ...new Set(node.boundaryWallIds.map((id) => (id === secondary.id ? primary.id : id))),
+            ];
+        if (touchesOverrides) {
+            const byFace = new Map();
+            for (const entry of entries) {
+                const wall = entry.wallId === primary.id ? primary : entry.wallId === secondary.id ? secondary : null;
+                if (!wall)
+                    continue;
+                const face = faceOf(wall, entry.face);
+                const faces = byFace.get(face) ?? new Map();
+                faces.set(wall.id, entry.finish);
+                byFace.set(face, faces);
+            }
+            const merged = entries.filter((entry) => entry.wallId !== primary.id && entry.wallId !== secondary.id);
+            for (const [face, finishes] of byFace) {
+                const values = [...new Set(finishes.values())];
+                if (values.length > 1)
+                    return null;
+                for (const wall of [primary, secondary]) {
+                    if (finishes.has(wall.id))
+                        continue;
+                    // The other wall borders this room on the same face without the override.
+                    const spans = getWallZoneSpans(wall, [node]);
+                    if (spans.some((span) => faceOf(wall, span.face) === face))
+                        return null;
+                }
+                merged.push({ wallId: primary.id, face, finish: values[0] });
+            }
+            data.wallOverrides = merged;
+        }
+        updates.push({ id: node.id, data });
+    }
+    return updates;
+}
 export function areWallStylesCompatible(a, b) {
     return wallStyleMismatch(a, b, { sides: true }) === null;
 }
@@ -80,9 +251,9 @@ export function resolveMergedWallEndpoints(primary, secondary, sharedPoint) {
     // where they are. Meeting start-to-start or end-to-end, the absorbed wall is
     // the one read backwards.
     if (primaryEndpoint === 'start' && secondaryEndpoint === 'start') {
-        return { start: secondary.end, end: primary.end };
+        return { start: reverseWallDirection(secondary).start, end: primary.end };
     }
-    return { start: primary.start, end: secondary.start };
+    return { start: primary.start, end: reverseWallDirection(secondary).end };
 }
 /**
  * Hosted nodes live in the wall's local frame (+X along it, +Z its front, yaw
@@ -198,11 +369,19 @@ export function planWallMerge(nodes, wallIds) {
         if (mismatch)
             throw Error(`These walls have a different ${mismatch}.`);
         const { start, end } = resolveMergedWallEndpoints(merged, next, joint);
+        const faceRegions = mergeWallFaceRegions([merged, next], start, end);
+        if (!faceRegions)
+            throw Error(`Merging would leave more than ${WALL_FACE_REGION_LIMIT} paint regions on a side.`);
+        const zoneUpdates = planMergedZoneReferences(virtual, merged, next, start, end);
+        if (!zoneUpdates)
+            throw Error('These walls have a different room finish.');
         for (const update of buildMergedWallAttachmentUpdates(merged, next, merged.id, start, end, virtual)) {
             virtual[update.id] = { ...virtual[update.id], ...update.data };
         }
+        const { faceRegions: _regions, ...kept } = merged;
         merged = {
-            ...merged,
+            ...kept,
+            ...(faceRegions.length > 0 ? { faceRegions } : {}),
             start,
             end,
             // Ids without a node are dropped rather than carried onto the kept wall.
@@ -215,16 +394,8 @@ export function planWallMerge(nodes, wallIds) {
         };
         virtual[merged.id] = merged;
         delete virtual[next.id];
-        for (const node of Object.values(virtual)) {
-            if (node?.type !== 'zone' || !node.boundaryWallIds?.includes(next.id))
-                continue;
-            virtual[node.id] = {
-                ...node,
-                boundaryWallIds: [
-                    ...new Set(node.boundaryWallIds.map((id) => (id === next.id ? merged.id : id))),
-                ],
-            };
-        }
+        for (const update of zoneUpdates)
+            virtual[update.id] = { ...virtual[update.id], ...update.data };
         remaining = remaining.filter((wall) => wall !== next);
     }
     return {

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

@@ -4,23 +4,24 @@ export interface Point2D {
     y: number;
 }
 export interface WallMiterBoundaryPoints {
-    startLeft: Point2D;
-    startRight: Point2D;
     endLeft: Point2D;
     endRight: Point2D;
+    startLeft: Point2D;
+    startRight: Point2D;
 }
 type WallIntersections = Map<string, {
     left?: Point2D;
     right?: Point2D;
+    closing?: Point2D;
 }>;
 type JunctionData = Map<string, WallIntersections>;
 declare function pointToKey(p: Point2D, tolerance?: number): string;
 interface Junction {
-    meetingPoint: Point2D;
     connectedWalls: Array<{
         wall: WallNode;
         endType: 'start' | 'end' | 'passthrough';
     }>;
+    meetingPoint: Point2D;
 }
 export interface WallMiterData {
     junctionData: JunctionData;
@@ -29,8 +30,8 @@ export interface WallMiterData {
 /**
  * Calculates miter data for all walls on a level
  */
-export declare function calculateLevelMiters(walls: WallNode[]): WallMiterData;
-export declare function getWallMiterBoundaryPoints(wall: WallNode, miterData: WallMiterData): WallMiterBoundaryPoints | null;
+export declare function calculateLevelMiters(walls: WallNode[], facePadding?: number): WallMiterData;
+export declare function getWallMiterBoundaryPoints(wall: WallNode, miterData: WallMiterData, facePadding?: number): WallMiterBoundaryPoints | null;
 /**
  * Gets wall IDs that share junctions with the given walls
  */

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

@@ -1 +1 @@
-{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAmBlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAyUD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAQ5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;CACpB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAG5F,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAmBlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;IACnF,YAAY,EAAE,OAAO,CAAA;CACtB;AA2XD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,SAAI,GAAG,aAAa,CAUtF;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,EACxB,WAAW,SAAI,GACd,uBAAuB,GAAG,IAAI,CA2BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}