@pascal-app/core 1.0.1 → 1.0.4

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

@@ -0,0 +1,411 @@
+import { getWallEffectiveHeightForNodes } from '../../hooks/spatial-grid/spatial-grid-manager.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];
+    return dx * dx + dz * dz <= tolerance * tolerance;
+}
+function wallLength(wall) {
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+export function getWallEndpointAtPoint(wall, point) {
+    if (pointsEqual(wall.start, point))
+        return 'start';
+    if (pointsEqual(wall.end, point))
+        return 'end';
+    return null;
+}
+function getWallFreeEndpoint(wall, sharedPoint) {
+    return pointsEqual(wall.start, sharedPoint) ? wall.end : wall.start;
+}
+/**
+ * The first thing two walls disagree on (for the merge's explanation), or null.
+ * The delete heal is strict: room sides must match, and a wall following the
+ * storey never joins one with an explicit height. An explicit merge compares
+ * what is visible instead — `heightOf` resolves each wall's actual height — and
+ * leaves the sides to room detection, which reclassifies the merged wall.
+ */
+export function wallStyleMismatch(a, b, options) {
+    if ((a.parentId ?? null) !== (b.parentId ?? null))
+        return 'floor';
+    if (Math.abs((a.curveOffset ?? 0) - (b.curveOffset ?? 0)) > 1e-6)
+        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';
+    // 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;
+}
+export function areWallsCollinearAcrossPoint(a, b, sharedPoint) {
+    const freeA = getWallFreeEndpoint(a, sharedPoint);
+    const freeB = getWallFreeEndpoint(b, sharedPoint);
+    const ax = freeA[0] - sharedPoint[0];
+    const az = freeA[1] - sharedPoint[1];
+    const bx = freeB[0] - sharedPoint[0];
+    const bz = freeB[1] - sharedPoint[1];
+    const lenA = Math.hypot(ax, az);
+    const lenB = Math.hypot(bx, bz);
+    if (lenA < 1e-6 || lenB < 1e-6)
+        return false;
+    const cross = (ax * bz - az * bx) / (lenA * lenB);
+    const dot = (ax * bx + az * bz) / (lenA * lenB);
+    return Math.abs(cross) <= 1e-4 && dot < -0.999;
+}
+export function resolveMergedWallEndpoints(primary, secondary, sharedPoint) {
+    const primaryEndpoint = getWallEndpointAtPoint(primary, sharedPoint);
+    const secondaryEndpoint = getWallEndpointAtPoint(secondary, sharedPoint);
+    if (primaryEndpoint === 'end' && secondaryEndpoint === 'start') {
+        return { start: primary.start, end: secondary.end };
+    }
+    if (primaryEndpoint === 'start' && secondaryEndpoint === 'end') {
+        return { start: secondary.start, end: primary.end };
+    }
+    // The kept wall never turns around: its sides, finishes and hosted faces stay
+    // 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: reverseWallDirection(secondary).start, end: primary.end };
+    }
+    return { start: primary.start, end: reverseWallDirection(secondary).end };
+}
+/**
+ * Hosted nodes live in the wall's local frame (+X along it, +Z its front, yaw
+ * 0 front / π back). A wall read backwards turns that frame by 180° about Y,
+ * so the face and the yaw swap and the caller mirrors depth. Hinges, handles
+ * and swing hang off the node's own yaw (the plan symbol flips them from it),
+ * so they stay as stored.
+ */
+function reversedWallChildPatch(child) {
+    const patch = {};
+    if ('side' in child && (child.side === 'front' || child.side === 'back')) {
+        patch.side = child.side === 'front' ? 'back' : 'front';
+    }
+    if ('rotation' in child && Array.isArray(child.rotation)) {
+        const yaw = child.rotation[1] + Math.PI;
+        patch.rotation = [
+            child.rotation[0],
+            Math.atan2(Math.sin(yaw), Math.cos(yaw)),
+            child.rotation[2],
+        ];
+    }
+    return patch;
+}
+export function buildMergedWallAttachmentUpdates(primary, secondary, mergedWallId, mergedStart, mergedEnd, nodes) {
+    const mergedLength = Math.max(Math.hypot(mergedEnd[0] - mergedStart[0], mergedEnd[1] - mergedStart[1]), 1e-6);
+    const tangentX = (mergedEnd[0] - mergedStart[0]) / mergedLength;
+    const tangentZ = (mergedEnd[1] - mergedStart[1]) / mergedLength;
+    const updates = [];
+    const wallChildren = [...(primary.children ?? []), ...(secondary.children ?? [])];
+    for (const childId of wallChildren) {
+        const child = nodes[childId];
+        if (!child)
+            continue;
+        // Every child moves to the kept wall: deleting the absorbed wall would
+        // otherwise take a child left on it along. Only positioned ones re-place.
+        const rehost = { parentId: mergedWallId, wallId: mergedWallId };
+        if (!('position' in child && Array.isArray(child.position))) {
+            updates.push({ id: childId, data: rehost });
+            continue;
+        }
+        const sourceWall = child.parentId === secondary.id ? secondary : primary;
+        const sourceLength = Math.max(wallLength(sourceWall), 1e-6);
+        const reversed = (sourceWall.end[0] - sourceWall.start[0]) * tangentX +
+            (sourceWall.end[1] - sourceWall.start[1]) * tangentZ <
+            0;
+        const mirrored = reversed ? reversedWallChildPatch(child) : {};
+        const localX = typeof child.position[0] === 'number' ? child.position[0] : 0;
+        const worldX = sourceWall.start[0] + ((sourceWall.end[0] - sourceWall.start[0]) * localX) / sourceLength;
+        const worldZ = sourceWall.start[1] + ((sourceWall.end[1] - sourceWall.start[1]) * localX) / sourceLength;
+        const nextLocalX = Math.max(0, Math.min(mergedLength, (worldX - mergedStart[0]) * tangentX + (worldZ - mergedStart[1]) * tangentZ));
+        updates.push({
+            id: childId,
+            data: {
+                ...rehost,
+                ...mirrored,
+                position: [
+                    nextLocalX,
+                    child.position[1],
+                    reversed ? -child.position[2] : child.position[2],
+                ],
+                ...('wallT' in child ? { wallT: nextLocalX / mergedLength } : {}),
+            },
+        });
+    }
+    return updates;
+}
+/**
+ * Merges a straight run of adjoining walls into one — the inverse of a split.
+ * Every joint must hold exactly these walls (a T or a cross stays split), and
+ * neighbours must continue in line and look alike (`wallStyleMismatch`: same
+ * thickness, visible height and finish). The wall with the most attachments
+ * keeps its id and height mode; openings and wall items keep their world
+ * position on it.
+ */
+export function planWallMerge(nodes, wallIds) {
+    const walls = [...new Set(wallIds)]
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'wall');
+    if (walls.length < 2 || walls.length !== new Set(wallIds).size)
+        throw Error('Select two or more walls to merge.');
+    if (walls.some((wall) => (wall.curveOffset ?? 0) !== 0))
+        throw Error('Only straight walls can be merged.');
+    const levelId = walls[0].parentId ?? null;
+    if (walls.some((wall) => (wall.parentId ?? null) !== levelId))
+        throw Error('Merge walls on the same floor.');
+    const virtual = { ...nodes };
+    const [primary, ...rest] = [...walls].sort((a, b) => (b.children?.length ?? 0) - (a.children?.length ?? 0) || a.id.localeCompare(b.id));
+    let merged = primary;
+    let remaining = rest;
+    while (remaining.length > 0) {
+        let next;
+        let joint;
+        for (const wall of remaining) {
+            joint = [merged.start, merged.end].find((end) => getWallEndpointAtPoint(wall, end) !== null);
+            if (joint) {
+                next = wall;
+                break;
+            }
+        }
+        if (!(next && joint))
+            throw Error('Merge walls that touch end to end.');
+        const atJoint = Object.values(virtual).filter((node) => node?.type === 'wall' &&
+            (node.parentId ?? null) === levelId &&
+            getWallEndpointAtPoint(node, joint) !== null);
+        if (atJoint.length !== 2)
+            throw Error('Another wall meets this joint, so merging would disconnect it.');
+        if (!areWallsCollinearAcrossPoint(merged, next, joint))
+            throw Error('Merge walls that continue in a straight line.');
+        const mismatch = wallStyleMismatch(merged, next, {
+            sides: false,
+            heightOf: (wall) => getWallEffectiveHeightForNodes(wall, virtual),
+        });
+        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 = {
+            ...kept,
+            ...(faceRegions.length > 0 ? { faceRegions } : {}),
+            start,
+            end,
+            // Ids without a node are dropped rather than carried onto the kept wall.
+            children: [
+                ...new Set([
+                    ...(merged.children ?? []),
+                    ...(next.children ?? []).filter((id) => virtual[id]),
+                ]),
+            ],
+        };
+        virtual[merged.id] = merged;
+        delete virtual[next.id];
+        for (const update of zoneUpdates)
+            virtual[update.id] = { ...virtual[update.id], ...update.data };
+        remaining = remaining.filter((wall) => wall !== next);
+    }
+    return {
+        changes: {
+            create: [],
+            update: Object.values(virtual)
+                .filter((node) => nodes[node.id] && node !== nodes[node.id])
+                .map((node) => ({ id: node.id, data: node })),
+            delete: walls.filter((wall) => !virtual[wall.id]).map((wall) => wall.id),
+        },
+        wallId: merged.id,
+    };
+}

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"}

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

@@ -1,4 +1,5 @@
 import { getWallCurveFrameAt, isCurvedWall } from './wall-curve.js';
+import { getWallBodyCenterOffset, getWallFaceOffsets } from './wall-frame.js';
 // ============================================================================
 // UTILITY FUNCTIONS
 // ============================================================================
@@ -207,11 +208,13 @@ function getWallBoundaryFrame(wall, endType) {
         normal: { x: -direction.y / length, y: direction.x / length },
     };
 }
-function calculateJunctionIntersections(junction, getThickness) {
+function calculateJunctionIntersections(junction, facePadding) {
     const { meetingPoint, connectedWalls } = junction;
     const processedWalls = [];
     for (const { wall, endType } of connectedWalls) {
-        const halfT = getThickness(wall) / 2;
+        const faces = getWallFaceOffsets(wall);
+        const offsets = facePadding === 0 ? faces : { a: faces.a + facePadding, b: faces.b - facePadding };
+        const halfT = Math.max(offsets.a, -offsets.b);
         if (endType === 'passthrough') {
             // For passthrough walls (T-junctions), add both directions
             // This allows walls meeting the middle of this wall to miter against it
@@ -222,8 +225,10 @@ function calculateJunctionIntersections(junction, getThickness) {
                 if (L < 1e-9)
                     continue;
                 const nUnit = { x: -v.y / L, y: v.x / L };
-                const pA = { x: meetingPoint.x + nUnit.x * halfT, y: meetingPoint.y + nUnit.y * halfT };
-                const pB = { x: meetingPoint.x - nUnit.x * halfT, y: meetingPoint.y - nUnit.y * halfT };
+                const a = v === v1 ? offsets.a : -offsets.b;
+                const b = v === v1 ? offsets.b : -offsets.a;
+                const pA = { x: meetingPoint.x + nUnit.x * a, y: meetingPoint.y + nUnit.y * a };
+                const pB = { x: meetingPoint.x - nUnit.x * -b, y: meetingPoint.y - nUnit.y * -b };
                 const edgeA = createLineFromPointAndVector(pA, v);
                 const edgeB = createLineFromPointAndVector(pB, v);
                 const angle = Math.atan2(v.y, v.x);
@@ -244,8 +249,10 @@ function calculateJunctionIntersections(junction, getThickness) {
             if (L < 1e-9)
                 continue;
             const nUnit = { x: -v.y / L, y: v.x / L };
-            const pA = { x: meetingPoint.x + nUnit.x * halfT, y: meetingPoint.y + nUnit.y * halfT };
-            const pB = { x: meetingPoint.x - nUnit.x * halfT, y: meetingPoint.y - nUnit.y * halfT };
+            const a = endType === 'start' ? offsets.a : -offsets.b;
+            const b = endType === 'start' ? offsets.b : -offsets.a;
+            const pA = { x: meetingPoint.x + nUnit.x * a, y: meetingPoint.y + nUnit.y * a };
+            const pB = { x: meetingPoint.x - nUnit.x * -b, y: meetingPoint.y - nUnit.y * -b };
             const edgeA = createLineFromPointAndVector(pA, v);
             const edgeB = createLineFromPointAndVector(pB, v);
             const angle = Math.atan2(v.y, v.x);
@@ -312,44 +319,87 @@ function calculateJunctionIntersections(junction, getThickness) {
             wallIntersections.get(wall2.wallId).right = p;
         }
     }
+    if (connectedWalls.some(({ wall }) => wall.justification !== undefined)) {
+        const host = connectedWalls.find(({ endType }) => endType === 'passthrough');
+        for (const entry of connectedWalls) {
+            if (entry.endType === 'passthrough')
+                continue;
+            const edges = wallIntersections.get(entry.wall.id);
+            if (!edges)
+                continue;
+            if (host && edges.left && edges.right) {
+                // Both edges already meet the host's near face. Closing through the
+                // reference vertex would add a triangular sliver inside the host.
+                edges.closing = {
+                    x: (edges.left.x + edges.right.x) / 2,
+                    y: (edges.left.y + edges.right.y) / 2,
+                };
+            }
+            else if (connectedWalls.length === 2) {
+                const other = connectedWalls.find((candidate) => candidate !== entry);
+                if (other.endType === 'passthrough')
+                    continue;
+                const bodyLine = (candidate) => {
+                    const frame = getWallBoundaryFrame(candidate.wall, candidate.endType);
+                    const offset = getWallBodyCenterOffset(candidate.wall);
+                    return createLineFromPointAndVector({
+                        x: frame.point.x + frame.normal.x * offset,
+                        y: frame.point.y + frame.normal.y * offset,
+                    }, frame.tangent);
+                };
+                const first = bodyLine(entry);
+                const second = bodyLine(other);
+                const det = first.a * second.b - second.a * first.b;
+                if (Math.abs(det) < 1e-9)
+                    continue;
+                const closing = {
+                    x: (first.b * second.c - second.b * first.c) / det,
+                    y: (second.a * first.c - first.a * second.c) / det,
+                };
+                const limit = MITER_LIMIT * Math.max(...processedWalls.map((wall) => wall.halfThickness));
+                if (Math.hypot(closing.x - meetingPoint.x, closing.y - meetingPoint.y) <= limit) {
+                    edges.closing = closing;
+                }
+            }
+        }
+    }
     return wallIntersections;
 }
 /**
  * Calculates miter data for all walls on a level
  */
-export function calculateLevelMiters(walls) {
-    const getThickness = (wall) => wall.thickness ?? 0.1;
+export function calculateLevelMiters(walls, facePadding = 0) {
     const junctions = findJunctions(walls);
     const junctionData = new Map();
     for (const [key, junction] of junctions.entries()) {
-        const wallIntersections = calculateJunctionIntersections(junction, getThickness);
+        const wallIntersections = calculateJunctionIntersections(junction, facePadding);
         junctionData.set(key, wallIntersections);
     }
     return { junctionData, junctions };
 }
-export function getWallMiterBoundaryPoints(wall, miterData) {
-    const thickness = wall.thickness ?? 0.1;
-    const halfThickness = thickness / 2;
+export function getWallMiterBoundaryPoints(wall, miterData, facePadding = 0) {
+    const faces = getWallFaceOffsets(wall);
+    const { a, b } = facePadding === 0 ? faces : { a: faces.a + facePadding, b: faces.b - facePadding };
     const startFrame = getWallBoundaryFrame(wall, 'start');
     const endFrame = getWallBoundaryFrame(wall, 'end');
     const startJunction = miterData.junctionData.get(pointToKey(startFrame.point))?.get(wall.id);
     const endJunction = miterData.junctionData.get(pointToKey(endFrame.point))?.get(wall.id);
     return {
         startLeft: startJunction?.left ?? {
-            x: startFrame.point.x + startFrame.normal.x * halfThickness,
-            y: startFrame.point.y + startFrame.normal.y * halfThickness,
+            x: startFrame.point.x + startFrame.normal.x * a,
+            y: startFrame.point.y + startFrame.normal.y * a,
         },
         startRight: startJunction?.right ?? {
-            x: startFrame.point.x - startFrame.normal.x * halfThickness,
-            y: startFrame.point.y - startFrame.normal.y * halfThickness,
+            x: startFrame.point.x - startFrame.normal.x * -b,
+            y: startFrame.point.y - startFrame.normal.y * -b,
         },
         endLeft: endJunction?.right ?? {
-            x: endFrame.point.x + endFrame.normal.x * halfThickness,
-            y: endFrame.point.y + endFrame.normal.y * halfThickness,
+            x: endFrame.point.x + endFrame.normal.x * a,
+            y: endFrame.point.y + endFrame.normal.y * a,
         },
         endRight: endJunction?.left ?? {
-            x: endFrame.point.x - endFrame.normal.x * halfThickness,
-            y: endFrame.point.y - endFrame.normal.y * halfThickness,
+            x: endFrame.point.x - endFrame.normal.x * -b,
+            y: endFrame.point.y - endFrame.normal.y * -b,
         },
     };
 }

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

@@ -0,0 +1,28 @@
+import type { AnyNode, AnyNodeId, WallNode } from '../../schema/index.js';
+import type { WallPlanPoint } from './wall-move.js';
+import { type WallTopologyChanges } from './wall-topology.js';
+export declare function wallRectangleCorners(a: WallPlanPoint, b: WallPlanPoint): WallPlanPoint[];
+/** Plan against a scratch graph so four sides commit atomically, including junction splits. */
+export declare function planWallRectangle(nodes: Record<AnyNodeId, AnyNode>, args: {
+    levelId: AnyNodeId;
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+    wallDefaults?: Partial<WallNode>;
+}): {
+    changes: WallTopologyChanges;
+    walls: WallNode[];
+};
+/** Explicit split keeps the first wall's identity and reuses the junction planner's host migration. */
+export declare function planWallDivision(nodes: Record<AnyNodeId, AnyNode>, wallId: WallNode['id'], distance: number, mintId?: () => string): {
+    changes: WallTopologyChanges;
+    point: WallPlanPoint;
+};
+/**
+ * Several cuts as one edit. Cutting farthest first keeps the first wall's
+ * identity at every step, so the nearer distances stay valid on it.
+ */
+export declare function planWallDivisions(nodes: Record<AnyNodeId, AnyNode>, wallId: WallNode['id'], distances: readonly number[]): {
+    changes: WallTopologyChanges;
+    points: WallPlanPoint[];
+};
+//# sourceMappingURL=wall-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-operations.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,iBAAiB,CAAA;AAExB,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,EAAE,CAiBxF;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjC,GACA;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,QAAQ,EAAE,CAAA;CAAE,CAyCrD;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,EACtB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,MAAM;;WAuD0B,aAAa;EAC7D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,EACtB,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,aAAa,EAAE,CAAA;CAAE,CAyB3D"}