@pascal-app/core 1.0.6 → 1.1.0

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

@@ -25,7 +25,8 @@ function getWallFreeEndpoint(wall, sharedPoint) {
  * 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.
+ * leaves the sides to room detection, which reclassifies the merged wall. Sloped
+ * tops are matched by `mergedWallTop`, which also builds the merged top.
  */
 export function wallStyleMismatch(a, b, options) {
     if ((a.parentId ?? null) !== (b.parentId ?? null))
@@ -41,15 +42,18 @@ export function wallStyleMismatch(a, b, options) {
     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)
+    if (!(a.endHeightOffset || b.endHeightOffset) &&
+        (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.
+    // Faces are compared as the merged wall will carry them: b read in a's direction. An unpainted
+    // face's default follows its room side, which room detection reclassifies, so it is set aside.
+    const painted = (wall) => ({ ...wall, frontSide: undefined, backSide: undefined });
     for (const face of ['a', 'b']) {
-        if (JSON.stringify(resolveWallFaceChain(a, face)) !==
-            JSON.stringify(resolveWallFaceChain(alignedB, face)))
+        if (JSON.stringify(resolveWallFaceChain(painted(a), face)) !==
+            JSON.stringify(resolveWallFaceChain(painted(alignedB), face)))
             return `side ${face.toUpperCase()} finish`;
     }
     if (wallTrimSignature(a) !== wallTrimSignature(alignedB))
@@ -223,6 +227,32 @@ export function planMergedZoneReferences(nodes, primary, secondary, mergedStart,
 export function areWallStylesCompatible(a, b) {
     return wallStyleMismatch(a, b, { sides: true }) === null;
 }
+/**
+ * The kept wall's top once `secondary` joins it at `joint`: nothing changes between flat walls;
+ * sloped ones take the start height and the summed end offset along the kept wall. Null when the
+ * tops don't continue one line — a step at the joint or a different rise per metre.
+ * `heightAt` reads a wall's body height at a chord fraction.
+ */
+export function mergedWallTop(primary, secondary, joint, heightAt) {
+    if (!(primary.endHeightOffset || secondary.endHeightOffset))
+        return {};
+    const reversed = readsBackwards(secondary, primary.start, primary.end);
+    const along = (wall, backwards) => {
+        const heights = [heightAt(wall, 0), heightAt(wall, 1)];
+        const [from, to] = backwards ? [heights[1], heights[0]] : [heights[0], heights[1]];
+        return { from, to, rise: (to - from) / Math.max(wallLength(wall), 1e-9) };
+    };
+    const primaryFirst = getWallEndpointAtPoint(primary, joint) === 'end';
+    const first = primaryFirst ? along(primary, false) : along(secondary, reversed);
+    const second = primaryFirst ? along(secondary, reversed) : along(primary, false);
+    if (Math.abs(first.to - second.from) > 1e-6 || Math.abs(first.rise - second.rise) > 1e-6)
+        return null;
+    return {
+        // A start that stays where it was keeps its height mode, storey-bound included.
+        height: primaryFirst ? primary.height : reversed ? first.from : secondary.height,
+        endHeightOffset: first.to - first.from + (second.to - second.from),
+    };
+}
 export function areWallsCollinearAcrossPoint(a, b, sharedPoint) {
     const freeA = getWallFreeEndpoint(a, sharedPoint);
     const freeB = getWallFreeEndpoint(b, sharedPoint);
@@ -260,13 +290,19 @@ export function resolveMergedWallEndpoints(primary, secondary, sharedPoint) {
  * 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.
+ * so they stay as stored. Door and window casing is kept per wall face, so it
+ * swaps faces too and stays on the same side of the wall.
  */
 function reversedWallChildPatch(child) {
     const patch = {};
     if ('side' in child && (child.side === 'front' || child.side === 'back')) {
         patch.side = child.side === 'front' ? 'back' : 'front';
     }
+    if (child.type === 'door' || child.type === 'window') {
+        const [faceA, faceB] = [child.casingFaceA === true, child.casingFaceB === true];
+        if (faceA !== faceB)
+            Object.assign(patch, { casingFaceA: faceB, casingFaceB: faceA });
+    }
     if ('rotation' in child && Array.isArray(child.rotation)) {
         const yaw = child.rotation[1] + Math.PI;
         patch.rotation = [
@@ -355,19 +391,35 @@ export function planWallMerge(nodes, wallIds) {
         }
         if (!(next && joint))
             throw Error('Merge walls that touch end to end.');
+        if (!areWallsCollinearAcrossPoint(merged, next, joint))
+            throw Error('Merge walls that continue in a straight line.');
+        // A wall meeting the joint from the side stays T'd into the merged wall's
+        // body there; one running along the line would be buried in it.
+        const runX = merged.end[0] - merged.start[0];
+        const runZ = merged.end[1] - merged.start[1];
+        const alongRun = (wall) => {
+            const free = getWallFreeEndpoint(wall, joint);
+            const x = free[0] - joint[0];
+            const z = free[1] - joint[1];
+            const length = Math.hypot(x, z) * Math.hypot(runX, runZ);
+            return length < 1e-12 || Math.abs(x * runZ - z * runX) / length < 1e-4;
+        };
         const atJoint = Object.values(virtual).filter((node) => node?.type === 'wall' &&
+            node.id !== merged.id &&
+            node.id !== next.id &&
             (node.parentId ?? null) === levelId &&
             getWallEndpointAtPoint(node, joint) !== null);
-        if (atJoint.length !== 2)
+        if (atJoint.some(alongRun))
             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),
+            heightOf: (wall) => getWallEffectiveHeightForNodes(wall, virtual, 0),
         });
         if (mismatch)
             throw Error(`These walls have a different ${mismatch}.`);
+        const top = mergedWallTop(merged, next, joint, (wall, t) => getWallEffectiveHeightForNodes(wall, virtual, t));
+        if (!top)
+            throw Error('These walls have a different slope.');
         const { start, end } = resolveMergedWallEndpoints(merged, next, joint);
         const faceRegions = mergeWallFaceRegions([merged, next], start, end);
         if (!faceRegions)
@@ -381,6 +433,7 @@ export function planWallMerge(nodes, wallIds) {
         const { faceRegions: _regions, ...kept } = merged;
         merged = {
             ...kept,
+            ...top,
             ...(faceRegions.length > 0 ? { faceRegions } : {}),
             start,
             end,

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

@@ -13,6 +13,7 @@ type WallIntersections = Map<string, {
     left?: Point2D;
     right?: Point2D;
     closing?: Point2D;
+    closingPath?: Point2D[];
 }>;
 type JunctionData = Map<string, WallIntersections>;
 declare function pointToKey(p: Point2D, tolerance?: number): string;

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;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"}
+{"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;AAWD,KAAK,iBAAiB,GAAG,GAAG,CAC1B,MAAM,EACN;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,EAAE,CAAA;CAAE,CAChF,CAAA;AAGD,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;AA4fD,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

@@ -208,6 +208,125 @@ function getWallBoundaryFrame(wall, endType) {
         normal: { x: -direction.y / length, y: direction.x / length },
     };
 }
+function isOutsideWall(wall) {
+    return wall.frontSide === 'exterior' || wall.backSide === 'exterior';
+}
+/** Each wall's joint with its neighbours round the junction (sorted by angle). */
+function miterAdjacentWalls(processedWalls, meetingPoint) {
+    const wallIntersections = new Map();
+    const n = processedWalls.length;
+    // Calculate intersections between adjacent walls (exactly like demo)
+    for (let i = 0; i < n; i++) {
+        const wall1 = processedWalls[i];
+        const wall2 = processedWalls[(i + 1) % n];
+        // Intersect left edge of wall1 with right edge of wall2
+        const det = wall1.edgeA.a * wall2.edgeB.b - wall2.edgeB.a * wall1.edgeA.b;
+        // If lines are parallel (det ≈ 0), skip this intersection - walls will use defaults
+        if (Math.abs(det) < 1e-9) {
+            continue;
+        }
+        const p = {
+            x: (wall1.edgeA.b * wall2.edgeB.c - wall2.edgeB.b * wall1.edgeA.c) / det,
+            y: (wall2.edgeB.a * wall1.edgeA.c - wall1.edgeA.a * wall2.edgeB.c) / det,
+        };
+        // Miter limit: `det` only catches walls that are *exactly* parallel. Two
+        // walls meeting at a shallow angle have a small-but-nonzero `det`, so `p`
+        // lands far from the junction (∝ 1/sin θ) and the wall renders as an
+        // infinite spike. Reject any joint farther than MITER_LIMIT half-thicknesses
+        // from the meeting point — those walls fall back to a square joint.
+        const maxMiter = MITER_LIMIT * Math.max(wall1.halfThickness, wall2.halfThickness);
+        const dx = p.x - meetingPoint.x;
+        const dy = p.y - meetingPoint.y;
+        if (!(Number.isFinite(p.x) && Number.isFinite(p.y)) ||
+            dx * dx + dy * dy > maxMiter * maxMiter) {
+            continue;
+        }
+        // Only assign intersection to non-passthrough walls
+        // Passthrough walls don't receive junction data (their geometry doesn't change)
+        if (!wall1.isPassthrough) {
+            if (!wallIntersections.has(wall1.wallId)) {
+                wallIntersections.set(wall1.wallId, {});
+            }
+            wallIntersections.get(wall1.wallId).left = p;
+        }
+        if (!wall2.isPassthrough) {
+            if (!wallIntersections.has(wall2.wallId)) {
+                wallIntersections.set(wall2.wallId, {});
+            }
+            wallIntersections.get(wall2.wallId).right = p;
+        }
+    }
+    return wallIntersections;
+}
+// Walls within about 15° of each other don't make an outside corner.
+const CORNER_MIN_SINE = Math.sin(Math.PI / 12);
+// Walls within about 1° of each other run in line.
+const IN_LINE_SINE = Math.sin(Math.PI / 180);
+const dot2 = (a, b) => a.x * b.x + a.y * b.y;
+const cross2 = (a, b) => a.x * b.y - a.y * b.x;
+/**
+ * An outside corner keeps its own miter when a partition carries one of its
+ * walls on past the corner (two outside walls at an angle, one inside wall in
+ * line with one of them): the outside faces miter to the corner, the partition
+ * stops square at the other outside wall's inside face, and the in-line outside
+ * wall fills the corner on the partition's room side. So each room's own walls
+ * cover its side of the corner, and its floor and ceiling stop at them, where a
+ * three-way miter would notch the corner. Null for any other junction.
+ */
+function outsideCornerIntersections(processedWalls, meetingPoint) {
+    if (processedWalls.length !== 3 || processedWalls.some((wall) => wall.isPassthrough))
+        return null;
+    const outside = processedWalls.filter((wall) => wall.outside);
+    const inside = processedWalls.find((wall) => !wall.outside);
+    if (outside.length !== 2 || !inside)
+        return null;
+    const inLine = outside.find((wall) => Math.abs(cross2(wall.dir, inside.dir)) < IN_LINE_SINE && dot2(wall.dir, inside.dir) < 0);
+    const across = outside.find((wall) => wall !== inLine);
+    if (!(inLine && across) || Math.abs(cross2(inLine.dir, across.dir)) < CORNER_MIN_SINE) {
+        return null;
+    }
+    const corner = miterAdjacentWalls(outside, meetingPoint);
+    const inLineEnds = corner.get(inLine.wallId);
+    const acrossEnds = corner.get(across.wallId);
+    if (!(inLineEnds?.left && inLineEnds.right && acrossEnds?.left && acrossEnds.right))
+        return null;
+    // Of the L's two joints, the one toward the partition is its inside corner.
+    const toward = (point) => dot2({ x: point.x - meetingPoint.x, y: point.y - meetingPoint.y }, inside.dir);
+    // Where a line parallel to the partition, `offset` across it, meets the
+    // across wall's face toward the partition.
+    const face = dot2(inside.dir, across.normal) > 0 ? across.hi : across.lo;
+    const rate = dot2(inside.dir, across.normal);
+    const onFace = (offset) => {
+        const origin = {
+            x: meetingPoint.x + inside.normal.x * offset,
+            y: meetingPoint.y + inside.normal.y * offset,
+        };
+        const along = (face - offset * dot2(inside.normal, across.normal)) / rate;
+        return { x: origin.x + inside.dir.x * along, y: origin.y + inside.dir.y * along };
+    };
+    // The shared line's point on that face: the in-line wall fills the corner up to it.
+    const heel = onFace(0);
+    corner.set(inLine.wallId, {
+        left: inLineEnds.left,
+        right: inLineEnds.right,
+        closingPath: toward(inLineEnds.left) > toward(inLineEnds.right)
+            ? [heel, meetingPoint]
+            : [meetingPoint, heel],
+    });
+    corner.set(across.wallId, toward(acrossEnds.left) > toward(acrossEnds.right)
+        ? { left: heel, right: acrossEnds.right }
+        : { left: acrossEnds.left, right: heel });
+    const left = onFace(inside.hi);
+    const right = onFace(inside.lo);
+    corner.set(inside.wallId, {
+        left,
+        right,
+        // Square across the partition: closing through the junction would reach
+        // back into the corner.
+        closing: { x: (left.x + right.x) / 2, y: (left.y + right.y) / 2 },
+    });
+    return corner;
+}
 function calculateJunctionIntersections(junction, facePadding) {
     const { meetingPoint, connectedWalls } = junction;
     const processedWalls = [];
@@ -239,6 +358,11 @@ function calculateJunctionIntersections(junction, facePadding) {
                     edgeB,
                     isPassthrough: true,
                     halfThickness: halfT,
+                    outside: isOutsideWall(wall),
+                    dir: { x: v.x / L, y: v.y / L },
+                    normal: nUnit,
+                    lo: b,
+                    hi: a,
                 });
             }
         }
@@ -263,6 +387,11 @@ function calculateJunctionIntersections(junction, facePadding) {
                 edgeB,
                 isPassthrough: false,
                 halfThickness: halfT,
+                outside: isOutsideWall(wall),
+                dir: { x: v.x / L, y: v.y / L },
+                normal: nUnit,
+                lo: b,
+                hi: a,
             });
         }
     }
@@ -274,68 +403,39 @@ function calculateJunctionIntersections(junction, facePadding) {
             return angleOrder;
         return a.wallId < b.wallId ? -1 : a.wallId > b.wallId ? 1 : 0;
     });
-    const wallIntersections = new Map();
-    const n = processedWalls.length;
-    if (n < 2)
-        return wallIntersections;
-    // Calculate intersections between adjacent walls (exactly like demo)
-    for (let i = 0; i < n; i++) {
-        const wall1 = processedWalls[i];
-        const wall2 = processedWalls[(i + 1) % n];
-        // Intersect left edge of wall1 with right edge of wall2
-        const det = wall1.edgeA.a * wall2.edgeB.b - wall2.edgeB.a * wall1.edgeA.b;
-        // If lines are parallel (det ≈ 0), skip this intersection - walls will use defaults
-        if (Math.abs(det) < 1e-9) {
-            continue;
-        }
-        const p = {
-            x: (wall1.edgeA.b * wall2.edgeB.c - wall2.edgeB.b * wall1.edgeA.c) / det,
-            y: (wall2.edgeB.a * wall1.edgeA.c - wall1.edgeA.a * wall2.edgeB.c) / det,
-        };
-        // Miter limit: `det` only catches walls that are *exactly* parallel. Two
-        // walls meeting at a shallow angle have a small-but-nonzero `det`, so `p`
-        // lands far from the junction (∝ 1/sin θ) and the wall renders as an
-        // infinite spike. Reject any joint farther than MITER_LIMIT half-thicknesses
-        // from the meeting point — those walls fall back to a square joint.
-        const maxMiter = MITER_LIMIT * Math.max(wall1.halfThickness, wall2.halfThickness);
-        const dx = p.x - meetingPoint.x;
-        const dy = p.y - meetingPoint.y;
-        if (!(Number.isFinite(p.x) && Number.isFinite(p.y)) ||
-            dx * dx + dy * dy > maxMiter * maxMiter) {
-            continue;
-        }
-        // Only assign intersection to non-passthrough walls
-        // Passthrough walls don't receive junction data (their geometry doesn't change)
-        if (!wall1.isPassthrough) {
-            if (!wallIntersections.has(wall1.wallId)) {
-                wallIntersections.set(wall1.wallId, {});
-            }
-            wallIntersections.get(wall1.wallId).left = p;
-        }
-        if (!wall2.isPassthrough) {
-            if (!wallIntersections.has(wall2.wallId)) {
-                wallIntersections.set(wall2.wallId, {});
-            }
-            wallIntersections.get(wall2.wallId).right = p;
-        }
+    if (processedWalls.length < 2)
+        return new Map();
+    if (!connectedWalls.some(({ wall }) => wall.justification !== undefined)) {
+        const corner = outsideCornerIntersections(processedWalls, meetingPoint);
+        if (corner)
+            return corner;
     }
-    if (connectedWalls.some(({ wall }) => wall.justification !== undefined)) {
-        const host = connectedWalls.find(({ endType }) => endType === 'passthrough');
+    const wallIntersections = miterAdjacentWalls(processedWalls, meetingPoint);
+    const host = connectedWalls.find(({ endType }) => endType === 'passthrough');
+    if (host) {
+        // A wall T'd into another's body ends square on its face: both edges
+        // already meet the host's near face, and closing through the reference
+        // vertex would add a triangular sliver inside the host.
         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.
+            if (edges?.left && edges.right) {
                 edges.closing = {
                     x: (edges.left.x + edges.right.x) / 2,
                     y: (edges.left.y + edges.right.y) / 2,
                 };
             }
-            else if (connectedWalls.length === 2) {
+        }
+    }
+    if (connectedWalls.some(({ wall }) => wall.justification !== undefined)) {
+        for (const entry of connectedWalls) {
+            if (entry.endType === 'passthrough')
+                continue;
+            const edges = wallIntersections.get(entry.wall.id);
+            if (!edges || (host && edges.left && edges.right))
+                continue;
+            if (connectedWalls.length === 2) {
                 const other = connectedWalls.find((candidate) => candidate !== entry);
                 if (other.endType === 'passthrough')
                     continue;

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

@@ -2,17 +2,21 @@ import type { WallNode } from '../../schema/index.js';
 export type WallPlanPoint = [number, number];
 export type WallMoveAxis = [number, number];
 export type WallMoveEndpoint = 'start' | 'end';
-export type WallMoveBridgePlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+/** A wall's line as the move planners read it: invisible walls move by the same rules. */
+export type WallMoveLine = Pick<WallNode, 'start' | 'end'> & {
+    id: string;
+};
+export type WallMoveBridgePlan<TWall extends WallMoveLine> = {
     wall: TWall;
     originalPoint: WallPlanPoint;
     movedEndpoint: WallMoveEndpoint;
 };
-export type WallMoveLinkedWallTargetPlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+export type WallMoveLinkedWallTargetPlan<TWall extends WallMoveLine> = {
     wall: TWall;
     originalPoint: WallPlanPoint;
     targetPoint: WallPlanPoint;
 };
-export type WallMoveJunctionPlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+export type WallMoveJunctionPlan<TWall extends WallMoveLine> = {
     linkedWallsToMove: TWall[];
     linkedWallTargetPlans: Array<WallMoveLinkedWallTargetPlan<TWall>>;
     bridgePlans: Array<WallMoveBridgePlan<TWall>>;
@@ -30,7 +34,7 @@ export declare function constrainWallMoveDeltaToAxis(deltaX: number, deltaZ: num
  * matchPoint/targetPoint pair encodes the pivot, not the original ↔ next
  * endpoint mapping.
  */
-export declare function getLinkedWallUpdates<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(linkedWalls: Array<{
+export declare function getLinkedWallUpdates<TWall extends WallMoveLine>(linkedWalls: Array<{
     wall: TWall;
     matchPoint?: WallPlanPoint;
     targetPoint?: WallPlanPoint;
@@ -39,10 +43,23 @@ export declare function getLinkedWallUpdates<TWall extends Pick<WallNode, 'id' |
     start: WallPlanPoint;
     end: WallPlanPoint;
 }>;
-export declare function getPlannedLinkedWallUpdates<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(plan: WallMoveJunctionPlan<TWall>, originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): Array<{
+export declare function getPlannedLinkedWallUpdates<TWall extends WallMoveLine>(plan: WallMoveJunctionPlan<TWall>, originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): Array<{
+    id: TWall['id'];
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+}>;
+export declare function planWallMoveJunctions<TWall extends WallMoveLine>(linkedWalls: TWall[], originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): WallMoveJunctionPlan<TWall>;
+/**
+ * Walls T'd into a moving wall (an end on its reference line, between its
+ * ends) stay on it: each such end slides along its own wall onto the moved
+ * line, so a partition stretches or shortens with the wall it meets, as a
+ * framed partition stays nailed to it. An end the move would carry past the
+ * moved wall's ends lets go and stays where it was; walls joined at the moving
+ * wall's ends are the junction planner's (`planWallMoveJunctions`).
+ */
+export declare function planAttachedWallUpdates<TWall extends WallMoveLine & Pick<WallNode, 'curveOffset'>>(walls: readonly TWall[], originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): Array<{
     id: TWall['id'];
     start: WallPlanPoint;
     end: WallPlanPoint;
 }>;
-export declare function planWallMoveJunctions<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(linkedWalls: TWall[], originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): WallMoveJunctionPlan<TWall>;
 //# sourceMappingURL=wall-move.d.ts.map

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

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

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

@@ -191,3 +191,68 @@ export function planWallMoveJunctions(linkedWalls, originalStart, originalEnd, n
         wallsToDelete: Array.from(wallsToDelete.values()),
     };
 }
+// An end within this of a wall's reference line is T'd into it.
+const ATTACH_TOLERANCE = 1e-3;
+// Walls within about 1° of each other run alongside, never T'd.
+const ATTACH_MIN_SINE = Math.sin(Math.PI / 180);
+const ATTACHED_MIN_LENGTH = 0.01;
+/**
+ * Walls T'd into a moving wall (an end on its reference line, between its
+ * ends) stay on it: each such end slides along its own wall onto the moved
+ * line, so a partition stretches or shortens with the wall it meets, as a
+ * framed partition stays nailed to it. An end the move would carry past the
+ * moved wall's ends lets go and stays where it was; walls joined at the moving
+ * wall's ends are the junction planner's (`planWallMoveJunctions`).
+ */
+export function planAttachedWallUpdates(walls, originalStart, originalEnd, nextStart, nextEnd) {
+    const dx = originalEnd[0] - originalStart[0];
+    const dz = originalEnd[1] - originalStart[1];
+    const length = Math.hypot(dx, dz);
+    const mx = nextEnd[0] - nextStart[0];
+    const mz = nextEnd[1] - nextStart[1];
+    const movedLength = Math.hypot(mx, mz);
+    if (length < AXIS_EPSILON || movedLength < AXIS_EPSILON)
+        return [];
+    const ux = dx / length;
+    const uz = dz / length;
+    const updates = [];
+    for (const wall of walls) {
+        if ((wall.curveOffset ?? 0) !== 0)
+            continue;
+        if (wallTouchesPoint(wall, originalStart) || wallTouchesPoint(wall, originalEnd))
+            continue;
+        const next = { start: wall.start, end: wall.end };
+        let moved = false;
+        for (const end of ['start', 'end']) {
+            const point = wall[end];
+            const along = (point[0] - originalStart[0]) * ux + (point[1] - originalStart[1]) * uz;
+            const across = (point[1] - originalStart[1]) * ux - (point[0] - originalStart[0]) * uz;
+            if (Math.abs(across) > ATTACH_TOLERANCE ||
+                along <= ATTACH_TOLERANCE ||
+                along >= length - ATTACH_TOLERANCE) {
+                continue;
+            }
+            const other = end === 'start' ? wall.end : wall.start;
+            const wx = point[0] - other[0];
+            const wz = point[1] - other[1];
+            const denominator = wx * mz - wz * mx;
+            if (Math.abs(denominator) <= ATTACH_MIN_SINE * Math.hypot(wx, wz) * movedLength)
+                continue;
+            // other + w·s meets nextStart + m·t.
+            const ox = nextStart[0] - other[0];
+            const oz = nextStart[1] - other[1];
+            const s = (ox * mz - oz * mx) / denominator;
+            const t = (ox * wz - oz * wx) / denominator;
+            if (t < -AXIS_EPSILON || t > 1 + AXIS_EPSILON)
+                continue;
+            const target = [other[0] + wx * s, other[1] + wz * s];
+            if (Math.hypot(target[0] - other[0], target[1] - other[1]) < ATTACHED_MIN_LENGTH)
+                continue;
+            next[end] = target;
+            moved = true;
+        }
+        if (moved)
+            updates.push({ id: wall.id, start: next.start, end: next.end });
+    }
+    return updates;
+}

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

@@ -7,7 +7,13 @@ import type { WallNode } from '../../schema/nodes/wall.js';
  * would collapse below this minimum.
  */
 export declare const MIN_WALL_HEIGHT = 0.5;
-export declare function wallFollowsStorey(wall: Pick<WallNode, 'height' | 'supportSlabId'>, authoredStoreyHeight: number | null): boolean;
+export declare const MIN_WALL_END_HEIGHT = 0.01;
+/**
+ * Clamps a wall's end-height offset so the lower end of the wall never
+ * collapses below `minEndHeight` (0.01 m by default).
+ */
+export declare function clampWallEndHeightOffset(endHeightOffset: number | undefined, bodyHeight: number, minEndHeight?: number): number;
+export declare function wallFollowsStorey(wall: Pick<WallNode, 'height' | 'supportSlabId' | 'wallType'>, authoredStoreyHeight: number | null): boolean;
 /**
  * Wall-top inversion (vertical building model): a wall with no stored
  * `height` is plane-bound — its top sits at the storey plane (level-local
@@ -18,9 +24,10 @@ export declare function wallFollowsStorey(wall: Pick<WallNode, 'height' | 'suppo
  * Other explicit walls stand on their elected support; ground-hosted walls
  * always retain their authored body height.
  *
- * Returns the top in level-local Y (same frame as `electedBase`).
+ * Returns the top in level-local Y (same frame as `electedBase`) at chord fraction `t`
+ * ($t = 0$ is the start, $t = 1$ the end); a sloped top differs along the wall.
  */
-export declare function resolveWallTop(wall: Pick<WallNode, 'height' | 'supportSlabId'>, storeyHeight: number, electedBase: number, authoredStoreyHeight?: number | null): number;
+export declare function resolveWallTop(wall: Pick<WallNode, 'height' | 'supportSlabId' | 'wallType' | 'endHeightOffset'>, storeyHeight: number, electedBase: number, authoredStoreyHeight?: number | null, t?: number): number;
 /**
  * Extruded height of the wall body: {@link resolveWallTop} minus the
  * elected base. Base convention: the elected slab-support elevation itself
@@ -35,5 +42,5 @@ export declare function resolveWallTop(wall: Pick<WallNode, 'height' | 'supportS
  * slab reaches the storey plane; callers own the degenerate-geometry
  * policy.
  */
-export declare function resolveWallEffectiveHeight(wall: Pick<WallNode, 'height' | 'supportSlabId'>, storeyHeight: number, electedBase: number, authoredStoreyHeight?: number | null): number;
+export declare function resolveWallEffectiveHeight(wall: Pick<WallNode, 'height' | 'supportSlabId' | 'wallType' | 'endHeightOffset'>, storeyHeight: number, electedBase: number, authoredStoreyHeight?: number | null, t?: number): number;
 //# sourceMappingURL=wall-top.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wall-top.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-top.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,MAAM,CAAA;AAElC,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,oBAAoB,EAAE,MAAM,GAAG,IAAI,GAClC,OAAO,CAOT;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,oBAAoB,GAAE,MAAM,GAAG,IAAmB,GACjD,MAAM,CAGR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,oBAAoB,GAAE,MAAM,GAAG,IAAmB,GACjD,MAAM,CAER"}
+{"version":3,"file":"wall-top.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-top.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,MAAM,CAAA;AAClC,eAAO,MAAM,mBAAmB,OAAO,CAAA;AAEvC;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,UAAU,EAAE,MAAM,EAClB,YAAY,SAAsB,GACjC,MAAM,CAKR;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,GAAG,UAAU,CAAC,EAC7D,oBAAoB,EAAE,MAAM,GAAG,IAAI,GAClC,OAAO,CAST;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,GAAG,UAAU,GAAG,iBAAiB,CAAC,EACjF,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,oBAAoB,GAAE,MAAM,GAAG,IAAmB,EAClD,CAAC,SAAI,GACJ,MAAM,CAOR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,GAAG,UAAU,GAAG,iBAAiB,CAAC,EACjF,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,oBAAoB,GAAE,MAAM,GAAG,IAAmB,EAClD,CAAC,SAAI,GACJ,MAAM,CAER"}

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

@@ -1,3 +1,4 @@
+import { RAILING_GUARD_HEIGHT } from '../../schema/nodes/railing-wall.js';
 /**
  * Minimum wall body height in meters. Governs both the wall height
  * arrow's lower drag bound and the slab-elevation clamp: a slab may not
@@ -6,7 +7,22 @@
  * would collapse below this minimum.
  */
 export const MIN_WALL_HEIGHT = 0.5;
+export const MIN_WALL_END_HEIGHT = 0.01;
+/**
+ * Clamps a wall's end-height offset so the lower end of the wall never
+ * collapses below `minEndHeight` (0.01 m by default).
+ */
+export function clampWallEndHeightOffset(endHeightOffset, bodyHeight, minEndHeight = MIN_WALL_END_HEIGHT) {
+    if (!endHeightOffset)
+        return 0;
+    const maxNegativeOffset = -(Math.max(minEndHeight, bodyHeight) - minEndHeight);
+    const clamped = Math.max(endHeightOffset, maxNegativeOffset);
+    return clamped === 0 ? 0 : clamped;
+}
 export function wallFollowsStorey(wall, authoredStoreyHeight) {
+    // A railing is a guard as tall as itself, never the storey (36 in when it says nothing).
+    if (wall.wallType === 'railing')
+        return false;
     return (wall.height == null ||
         (authoredStoreyHeight !== null &&
             wall.supportSlabId !== 'ground' &&
@@ -22,12 +38,17 @@ export function wallFollowsStorey(wall, authoredStoreyHeight) {
  * Other explicit walls stand on their elected support; ground-hosted walls
  * always retain their authored body height.
  *
- * Returns the top in level-local Y (same frame as `electedBase`).
+ * Returns the top in level-local Y (same frame as `electedBase`) at chord fraction `t`
+ * ($t = 0$ is the start, $t = 1$ the end); a sloped top differs along the wall.
  */
-export function resolveWallTop(wall, storeyHeight, electedBase, authoredStoreyHeight = storeyHeight) {
-    if (wallFollowsStorey(wall, authoredStoreyHeight))
-        return storeyHeight;
-    return electedBase + wall.height;
+export function resolveWallTop(wall, storeyHeight, electedBase, authoredStoreyHeight = storeyHeight, t = 0) {
+    // Only a railing reaches the fallback with no height of its own.
+    const top = wallFollowsStorey(wall, authoredStoreyHeight)
+        ? storeyHeight
+        : electedBase + (wall.height ?? RAILING_GUARD_HEIGHT);
+    if (!wall.endHeightOffset)
+        return top;
+    return top + clampWallEndHeightOffset(wall.endHeightOffset, top - electedBase) * t;
 }
 /**
  * Extruded height of the wall body: {@link resolveWallTop} minus the
@@ -43,6 +64,6 @@ export function resolveWallTop(wall, storeyHeight, electedBase, authoredStoreyHe
  * slab reaches the storey plane; callers own the degenerate-geometry
  * policy.
  */
-export function resolveWallEffectiveHeight(wall, storeyHeight, electedBase, authoredStoreyHeight = storeyHeight) {
-    return resolveWallTop(wall, storeyHeight, electedBase, authoredStoreyHeight) - electedBase;
+export function resolveWallEffectiveHeight(wall, storeyHeight, electedBase, authoredStoreyHeight = storeyHeight, t = 0) {
+    return resolveWallTop(wall, storeyHeight, electedBase, authoredStoreyHeight, t) - electedBase;
 }