@pascal-app/core 1.0.3 → 1.0.5

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

@@ -13,7 +13,7 @@ export declare function planWallRectangle(nodes: Record<AnyNodeId, AnyNode>, arg
     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): {
+export declare function planWallDivision(nodes: Record<AnyNodeId, AnyNode>, wallId: WallNode['id'], distance: number, mintId?: () => string): {
     changes: WallTopologyChanges;
     point: WallPlanPoint;
 };

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

@@ -1 +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;;WAsD+B,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"}
+{"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"}

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

@@ -60,7 +60,7 @@ export function planWallRectangle(nodes, args) {
     };
 }
 /** Explicit split keeps the first wall's identity and reuses the junction planner's host migration. */
-export function planWallDivision(nodes, wallId, distance) {
+export function planWallDivision(nodes, wallId, distance, mintId) {
     const wall = nodes[wallId];
     if (wall?.type !== 'wall' || !wall.parentId)
         throw Error('Select a wall.');
@@ -72,6 +72,7 @@ export function planWallDivision(nodes, wallId, distance) {
         levelId: wall.parentId,
         point: [point.x, point.y],
         radius: 0.001,
+        mintId,
         ignoreWallIds: Object.values(nodes)
             .filter((n) => n.type === 'wall' && n.id !== wallId)
             .map((n) => n.id),

package/dist/systems/wall/wall-paint-plan.d.ts

@@ -0,0 +1,30 @@
+import type { AnyNode } from '../../schema/index.js';
+import type { WallFace, WallNode } from '../../schema/nodes/wall.js';
+import { type WallPaintRole } from './wall-finish.js';
+/**
+ * What one wall paint click changes, as plain node updates — the commit writes
+ * it and the hover preview draws it, so the preview is the commit.
+ *
+ * Painting writes the one finish the role names: a region, a face inside a
+ * room (the room's override for that face), the room's wall finish (every face
+ * turned to the room takes it, so the room's overrides go), or a slot.
+ * Erasing clears everything that makes the surface look painted, on the side
+ * that faces the room and nothing across it:
+ *   - a face in a room: that room's override, the face's own paint and the
+ *     paint regions over the room's part of the face — and, when the room has
+ *     a wall finish, an override back to the face's own look;
+ *   - a room: its wall finish, every override, and on each face turned to it
+ *     the face's own paint and the regions over the room's part of the face.
+ */
+type Nodes = Readonly<Record<string, AnyNode | undefined>>;
+/** The zone whose part of `face` holds station `u` (m), if any. */
+export declare function wallZoneAt(wall: WallNode, face: WallFace, u: number, nodes: Nodes): string | null;
+/**
+ * The node updates one wall paint makes. `ref` is the finish written (a
+ * material ref); undefined erases. Returns only the nodes that change.
+ */
+export declare function planWallPaint(nodes: Nodes, wall: WallNode, role: WallPaintRole, ref: string | undefined): Record<string, AnyNode>;
+/** The walls whose look a plan changes: every wall it writes, and every wall of a room it writes. */
+export declare function plannedWallIds(nodes: Nodes, plan: Record<string, AnyNode>): string[];
+export {};
+//# sourceMappingURL=wall-paint-plan.d.ts.map

package/dist/systems/wall/wall-paint-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-paint-plan.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-paint-plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAkB,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEjF,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,eAAe,CAAA;AAEtB;;;;;;;;;;;;;;GAcG;AAEH,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,CAAA;AA8B1D,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CASjG;AAyBD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,MAAM,GAAG,SAAS,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA+FzB;AAED,qGAAqG;AACrG,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CAapF"}

package/dist/systems/wall/wall-paint-plan.js

@@ -0,0 +1,167 @@
+import { getWallLevelZones, getWallZoneSpans, resolveWallFaceChain, } from './wall-finish.js';
+function zoneNode(nodes, zoneId) {
+    const node = nodes[zoneId];
+    return node?.type === 'zone' ? node : null;
+}
+function wallLength(wall) {
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+/** The part of each face of `wall` turned to `zone`, in metres along the wall. */
+function roomSpans(wall, zone) {
+    const length = wallLength(wall);
+    return getWallZoneSpans(wall, [zone]).map((span) => ({
+        wallId: wall.id,
+        face: span.face,
+        u0: span.t0 * length,
+        u1: span.t1 * length,
+    }));
+}
+function regionOverlaps(region, span, length) {
+    if (region.face !== span.face)
+        return false;
+    const low = Math.max(region.u0 ?? 0, span.u0);
+    const high = Math.min(region.u1 ?? length, span.u1);
+    return high - low > 1e-6;
+}
+/** The zone whose part of `face` holds station `u` (m), if any. */
+export function wallZoneAt(wall, face, u, nodes) {
+    const length = wallLength(wall);
+    if (length < 1e-9)
+        return null;
+    const t = u / length;
+    return (getWallZoneSpans(wall, getWallLevelZones(wall, nodes)).find((span) => span.face === face && t >= span.t0 - 1e-6 && t <= span.t1 + 1e-6)?.zoneId ?? null);
+}
+/** Clears a wall face's own paint and the regions over `spans` of it. */
+function clearFaces(wall, spans) {
+    const length = wallLength(wall);
+    const faces = new Set(spans.map((span) => span.face));
+    const regions = (wall.faceRegions ?? []).filter((region) => !spans.some((span) => regionOverlaps(region, span, length)));
+    const slots = { ...wall.slots };
+    for (const face of faces)
+        delete slots[face];
+    const next = { ...wall, slots };
+    if (regions.length)
+        next.faceRegions = regions;
+    else
+        delete next.faceRegions;
+    if (!Object.keys(slots).length)
+        delete next.slots;
+    return next;
+}
+function withOverrides(zone, overrides) {
+    const next = { ...zone };
+    if (overrides?.length)
+        next.wallOverrides = overrides;
+    else
+        delete next.wallOverrides;
+    return next;
+}
+/**
+ * The node updates one wall paint makes. `ref` is the finish written (a
+ * material ref); undefined erases. Returns only the nodes that change.
+ */
+export function planWallPaint(nodes, wall, role, ref) {
+    const out = {};
+    const current = (id) => (out[id] ?? nodes[id]);
+    if (role.kind === 'slot') {
+        const slotId = role.slotId;
+        const face = slotId === 'a' || slotId === 'b' ? slotId : null;
+        if (ref || !face) {
+            const slots = { ...wall.slots };
+            if (ref)
+                slots[slotId] = ref;
+            else
+                delete slots[slotId];
+            out[wall.id] = { ...wall, slots };
+            return out;
+        }
+        // Erasing a face no room owns: its own paint and every region on it.
+        out[wall.id] = clearFaces(wall, [
+            { wallId: wall.id, face, u0: Number.NEGATIVE_INFINITY, u1: Number.POSITIVE_INFINITY },
+        ]);
+        return out;
+    }
+    if (role.kind === 'region') {
+        const region = wall.faceRegions?.find((entry) => entry.id === role.regionId);
+        if (!region)
+            return out;
+        if (ref) {
+            out[wall.id] = {
+                ...wall,
+                faceRegions: wall.faceRegions.map((entry) => entry.id === region.id ? { ...entry, finish: ref } : entry),
+            };
+            return out;
+        }
+        // Erasing a painted part clears the face it sits on, inside its room.
+        const length = wallLength(wall);
+        const middle = ((region.u0 ?? 0) + (region.u1 ?? length)) / 2;
+        const zoneId = wallZoneAt(wall, region.face, middle, nodes);
+        return planWallPaint(nodes, wall, zoneId
+            ? { kind: 'room-face', zoneId, face: region.face }
+            : { kind: 'slot', slotId: region.face }, undefined);
+    }
+    const zone = zoneNode(nodes, role.zoneId);
+    if (!zone)
+        return out;
+    if (role.kind === 'room-face') {
+        const others = (zone.wallOverrides ?? []).filter((entry) => !(entry.wallId === wall.id && entry.face === role.face));
+        if (ref) {
+            out[zone.id] = withOverrides(zone, [
+                ...others,
+                { wallId: wall.id, face: role.face, finish: ref },
+            ]);
+            return out;
+        }
+        const spans = roomSpans(wall, zone).filter((span) => span.face === role.face);
+        const cleared = clearFaces(wall, spans);
+        out[wall.id] = cleared;
+        // The room's own finish would still show here: hold the face to its own look.
+        const chain = resolveWallFaceChain(cleared, role.face);
+        const own = chain.kind === 'legacy' ? null : chain.ref;
+        out[zone.id] = withOverrides(zone, zone.wallMaterial !== undefined && own
+            ? [...others, { wallId: wall.id, face: role.face, finish: own }]
+            : others);
+        return out;
+    }
+    // The room's walls: every face turned to the room takes the finish, so the
+    // room's per-face overrides give way (painted parts stay on top).
+    if (ref) {
+        out[zone.id] = withOverrides({ ...zone, wallMaterial: ref }, undefined);
+        return out;
+    }
+    const next = withOverrides({ ...zone }, undefined);
+    delete next.wallMaterial;
+    out[zone.id] = next;
+    const wallIds = new Set([wall.id, ...zone.boundaryWallIds]);
+    for (const id of wallIds) {
+        const target = current(id);
+        if (target?.type !== 'wall')
+            continue;
+        const spans = roomSpans(target, zone);
+        if (!spans.length)
+            continue;
+        const cleared = clearFaces(target, spans);
+        if (JSON.stringify(cleared) !== JSON.stringify(target))
+            out[target.id] = cleared;
+    }
+    return out;
+}
+/** The walls whose look a plan changes: every wall it writes, and every wall of a room it writes. */
+export function plannedWallIds(nodes, plan) {
+    const ids = new Set();
+    for (const node of Object.values(plan)) {
+        if (node.type === 'wall')
+            ids.add(node.id);
+        if (node.type === 'zone') {
+            for (const id of node.boundaryWallIds)
+                ids.add(id);
+            for (const entry of node.wallOverrides ?? [])
+                ids.add(entry.wallId);
+            const before = nodes[node.id];
+            if (before?.type === 'zone')
+                for (const entry of before.wallOverrides ?? [])
+                    ids.add(entry.wallId);
+        }
+    }
+    return [...ids];
+}

package/dist/systems/wall/wall-room-sides.d.ts

@@ -0,0 +1,14 @@
+import type { SceneNodes } from '../../lib/structure-kernel.js';
+/** How much of a wall face rooms stand on: none of it, part of it, or all of it. */
+export type RoomFaceCover = 'none' | 'part' | 'whole';
+/**
+ * How much of each face of a wall its rooms stand on: one face for an outside wall, both for a
+ * partition, part of a face where the wall runs on past its rooms (into a garden, say). A gap shorter
+ * than the junction tolerance, measured along the wall, is no gap.
+ */
+export declare function roomFaceCover(nodes: SceneNodes, wallId: string): Record<'a' | 'b', RoomFaceCover>;
+export declare function roomSideFaces(nodes: SceneNodes, wallId: string): {
+    inside: 'a' | 'b' | null;
+    outside: 'a' | 'b' | null;
+};
+//# sourceMappingURL=wall-room-sides.d.ts.map

package/dist/systems/wall/wall-room-sides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-room-sides.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-room-sides.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAgC5D,oFAAoF;AACpF,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAErD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,GAAG,GAAG,EAAE,aAAa,CAAC,CAuBjG;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,GACb;IAAE,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAA;CAAE,CAMzD"}

package/dist/systems/wall/wall-room-sides.js

@@ -0,0 +1,67 @@
+import { extractRooms, WALL_JUNCTION_TOLERANCE } from '../../lib/room-graph.js';
+import { getWallArcData, getWallCurveFrameAt } from './wall-curve.js';
+/**
+ * Metres along a wall's reference line at a station of its chord, as room spans give them: on a
+ * curve the chord's stations crowd toward the ends, where a short stretch of chord is a long one
+ * of wall. An arc's point at a station is found by bisection (its stations rise along it, an arc
+ * being no wider than a half circle), its length in proportion to its angle.
+ */
+function metresAlong(wall) {
+    const [x0, z0] = wall.start;
+    const [dx, dz] = [wall.end[0] - x0, wall.end[1] - z0];
+    const chord2 = dx * dx + dz * dz;
+    const arc = getWallArcData(wall);
+    if (!arc)
+        return (t) => t * Math.sqrt(chord2);
+    const station = (s) => {
+        const { point } = getWallCurveFrameAt(wall, s);
+        return ((point.x - x0) * dx + (point.y - z0) * dz) / chord2;
+    };
+    const length = Math.abs(arc.delta) * arc.radius;
+    return (t) => {
+        let [low, high] = [0, 1];
+        for (let step = 0; step < 40; step += 1) {
+            const middle = (low + high) / 2;
+            if (station(middle) < t)
+                low = middle;
+            else
+                high = middle;
+        }
+        return high * length;
+    };
+}
+/**
+ * How much of each face of a wall its rooms stand on: one face for an outside wall, both for a
+ * partition, part of a face where the wall runs on past its rooms (into a garden, say). A gap shorter
+ * than the junction tolerance, measured along the wall, is no gap.
+ */
+export function roomFaceCover(nodes, wallId) {
+    const wall = nodes[wallId];
+    if (wall?.type !== 'wall')
+        throw Error('Select a wall.');
+    const boundaries = Object.values(nodes).filter((node) => node.parentId === wall.parentId && (node.type === 'wall' || node.type === 'separator'));
+    const spans = extractRooms(boundaries).flatMap((room) => room.spans.filter((span) => span.boundaryId === wallId && span.t1 > span.t0));
+    const along = metresAlong(wall);
+    const gap = (from, to) => along(to) - along(from) > WALL_JUNCTION_TOLERANCE;
+    const cover = (face) => {
+        const onFace = spans.filter((span) => span.face === face).sort((p, q) => p.t0 - q.t0);
+        if (!onFace.length)
+            return 'none';
+        let reach = 0;
+        for (const span of onFace) {
+            if (gap(reach, span.t0))
+                return 'part';
+            reach = Math.max(reach, span.t1);
+        }
+        return gap(reach, 1) ? 'part' : 'whole';
+    };
+    return { a: cover('a'), b: cover('b') };
+}
+export function roomSideFaces(nodes, wallId) {
+    const cover = roomFaceCover(nodes, wallId);
+    const sides = ['a', 'b'].filter((face) => cover[face] !== 'none');
+    if (sides.length !== 1)
+        return { inside: null, outside: null };
+    const inside = sides[0];
+    return { inside, outside: inside === 'a' ? 'b' : 'a' };
+}

package/dist/systems/wall/wall-step-openings.d.ts

@@ -0,0 +1,17 @@
+import type { WallNode } from '../../schema/index.js';
+import type { WallSlabSupportSegment } from '../slab/slab-support.js';
+export declare function wallDoorStepRuns(wall: WallNode, opening: {
+    type: string;
+    width?: number;
+    height?: number;
+    position?: [number, number, number];
+}, faceBase: {
+    a: readonly WallSlabSupportSegment[];
+    b: readonly WallSlabSupportSegment[];
+}, elevation: number): Array<{
+    start: number;
+    end: number;
+    bottom: number;
+    top: number;
+}>;
+//# sourceMappingURL=wall-step-openings.d.ts.map

package/dist/systems/wall/wall-step-openings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-step-openings.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-step-openings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAGlE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,EAC/F,QAAQ,EAAE;IAAE,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAAC,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAE,EACxF,SAAS,EAAE,MAAM,GAChB,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAoCpE"}

package/dist/systems/wall/wall-step-openings.js

@@ -0,0 +1,32 @@
+import { getWallCurveFrameAt } from './wall-curve.js';
+export function wallDoorStepRuns(wall, opening, faceBase, elevation) {
+    if ((opening.type !== 'door' && opening.type !== 'window') || !opening.position)
+        return [];
+    const sill = opening.position[1] - (opening.height ?? 0) / 2;
+    if (sill > 0.01)
+        return [];
+    const dx = wall.end[0] - wall.start[0];
+    const dy = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dy);
+    if (length < 1e-9)
+        return [];
+    const station = (t) => {
+        const { point } = getWallCurveFrameAt(wall, t);
+        return ((point.x - wall.start[0]) * dx + (point.y - wall.start[1]) * dy) / length;
+    };
+    const runs = [];
+    for (const a of faceBase.a)
+        for (const b of faceBase.b) {
+            const from = Math.max(a.start, b.start);
+            const to = Math.min(a.end, b.end);
+            const low = Math.min(a.elevation, a.endElevation ?? a.elevation, b.elevation, b.endElevation ?? b.elevation);
+            const high = Math.max(a.elevation, a.endElevation ?? a.elevation, b.elevation, b.endElevation ?? b.elevation);
+            if (to <= from || high - low < 1e-6)
+                continue;
+            const start = Math.max(station(from), opening.position[0] - (opening.width ?? 0) / 2);
+            const end = Math.min(station(to), opening.position[0] + (opening.width ?? 0) / 2);
+            if (end > start)
+                runs.push({ start, end, bottom: low - elevation, top: Math.max(sill, high - elevation) });
+        }
+    return runs;
+}

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

@@ -7,21 +7,20 @@ 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;
 /**
  * Wall-top inversion (vertical building model): a wall with no stored
  * `height` is plane-bound — its top sits at the storey plane (level-local
  * Y = the level's stored height), so a slab lifting the wall's base makes
  * the wall shorter, never taller, and no gap can open at the top of a
- * level. A wall WITH `height` is an explicit exception (half wall,
- * parapet) and keeps the legacy semantics: the top rides a raised elected
- * base (`electedBase + height`), while a zero or sunken slab base leaves
- * the top at `height` (the legacy negative-slab constraint). Explicit
- * ground-hosted walls are the terrain exception: `height` is always body
- * height, including below datum, so sculpting cannot stretch the wall.
+ * level. An explicit height equal to the authored storey height expresses the
+ * same storey-top intent, even when the resolved plane is clamped or lifted.
+ * 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`).
  */
-export declare function resolveWallTop(wall: Pick<WallNode, 'height' | 'supportSlabId'>, storeyHeight: number, electedBase: number): number;
+export declare function resolveWallTop(wall: Pick<WallNode, 'height' | 'supportSlabId'>, storeyHeight: number, electedBase: number, authoredStoreyHeight?: number | null): number;
 /**
  * Extruded height of the wall body: {@link resolveWallTop} minus the
  * elected base. Base convention: the elected slab-support elevation itself
@@ -36,5 +35,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): number;
+export declare function resolveWallEffectiveHeight(wall: Pick<WallNode, 'height' | 'supportSlabId'>, storeyHeight: number, electedBase: number, authoredStoreyHeight?: number | null): 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;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAIR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAER"}
+{"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"}

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

@@ -6,26 +6,28 @@
  * would collapse below this minimum.
  */
 export const MIN_WALL_HEIGHT = 0.5;
+export function wallFollowsStorey(wall, authoredStoreyHeight) {
+    return (wall.height == null ||
+        (authoredStoreyHeight !== null &&
+            wall.supportSlabId !== 'ground' &&
+            Math.abs(wall.height - authoredStoreyHeight) <= 1e-6));
+}
 /**
  * Wall-top inversion (vertical building model): a wall with no stored
  * `height` is plane-bound — its top sits at the storey plane (level-local
  * Y = the level's stored height), so a slab lifting the wall's base makes
  * the wall shorter, never taller, and no gap can open at the top of a
- * level. A wall WITH `height` is an explicit exception (half wall,
- * parapet) and keeps the legacy semantics: the top rides a raised elected
- * base (`electedBase + height`), while a zero or sunken slab base leaves
- * the top at `height` (the legacy negative-slab constraint). Explicit
- * ground-hosted walls are the terrain exception: `height` is always body
- * height, including below datum, so sculpting cannot stretch the wall.
+ * level. An explicit height equal to the authored storey height expresses the
+ * same storey-top intent, even when the resolved plane is clamped or lifted.
+ * 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`).
  */
-export function resolveWallTop(wall, storeyHeight, electedBase) {
-    if (wall.height == null)
+export function resolveWallTop(wall, storeyHeight, electedBase, authoredStoreyHeight = storeyHeight) {
+    if (wallFollowsStorey(wall, authoredStoreyHeight))
         return storeyHeight;
-    if (wall.supportSlabId === 'ground')
-        return electedBase + wall.height;
-    return electedBase > 0 ? electedBase + wall.height : wall.height;
+    return electedBase + wall.height;
 }
 /**
  * Extruded height of the wall body: {@link resolveWallTop} minus the
@@ -41,6 +43,6 @@ export function resolveWallTop(wall, storeyHeight, electedBase) {
  * slab reaches the storey plane; callers own the degenerate-geometry
  * policy.
  */
-export function resolveWallEffectiveHeight(wall, storeyHeight, electedBase) {
-    return resolveWallTop(wall, storeyHeight, electedBase) - electedBase;
+export function resolveWallEffectiveHeight(wall, storeyHeight, electedBase, authoredStoreyHeight = storeyHeight) {
+    return resolveWallTop(wall, storeyHeight, electedBase, authoredStoreyHeight) - electedBase;
 }