@pascal-app/core 1.0.3 → 1.0.5

package/dist/systems/slab/slab-support.js

@@ -1,14 +1,20 @@
-import { getRenderableSlabPolygon } from '../../lib/slab-polygon.js';
+import { floorConstructionLift, liftedManualSlab } from '../../lib/floor-construction-lift.js';
+import { floorRoomFaces, roomPolygonKey } from '../../lib/floor-room-faces.js';
+import { area, intersection, union } from '../../lib/polygon-boolean.js';
+import { getRenderableSlabPolygon, prepareSlabPolygonContext, scopeSlabPolygonContext, } from '../../lib/slab-polygon.js';
+import { levelBaseElevationAt } from '../../lib/terrain-support-query.js';
 import { getWallCurveFrameAt, isCurvedWall } from '../wall/wall-curve.js';
-import { DEFAULT_WALL_THICKNESS } from '../wall/wall-footprint.js';
-import { MIN_WALL_HEIGHT } from '../wall/wall-top.js';
+import { DEFAULT_WALL_HEIGHT, DEFAULT_WALL_THICKNESS } from '../wall/wall-footprint.js';
+import { getWallFaceOffsets, } from '../wall/wall-frame.js';
+import { MIN_WALL_HEIGHT, wallFollowsStorey } from '../wall/wall-top.js';
 /**
  * Clamp-never-ask upper bound for a slab's elevation. A plane-bound wall
- * (no stored `height`) keeps its top at the storey plane, so a slab that
+ * (no stored `height`, or height equal to the authored storey) keeps its
+ * top at the storey plane, so a slab that
  * rises past `storeyHeight - MIN_WALL_HEIGHT` while electing as that
  * wall's base would squeeze the wall body below its minimum (and at the
- * plane, to nothing). Walls with explicit heights don't constrain — their
- * top rides the elected base, not the plane. Negative proposals (the
+ * plane, to nothing). Walls with other explicit heights don't constrain —
+ * their body height stays fixed above the elected base. Negative proposals (the
  * drag-through-zero path that commits the `recessed` intent) pass
  * through untouched: this is a purely numeric upper bound.
  *
@@ -17,30 +23,35 @@ import { MIN_WALL_HEIGHT } from '../wall/wall-top.js';
  * the proposed elevation still clamps, and a slab out-elected by a
  * sibling doesn't. Pure.
  */
-export function clampSlabElevationForWalls(proposedElevation, slab, levelWalls, levelSlabs, storeyHeight) {
+export function clampSlabElevationForWalls(proposedElevation, slab, levelWalls, levelSlabs, storeyHeight, nodes) {
     const bound = storeyHeight - MIN_WALL_HEIGHT;
     if (proposedElevation <= bound)
         return { elevation: proposedElevation, clamped: false };
     if (slab.polygon.length < 3)
         return { elevation: proposedElevation, clamped: false };
+    // Probed just past the bound: a wall electing the slab there elects it at any
+    // height above, whereas a slab past the storey plane reads as resting on the
+    // wall — the state this clamp exists to prevent.
+    const probed = Math.min(proposedElevation, bound + MIN_WALL_HEIGHT / 2);
     const substituted = levelSlabs.some((candidate) => candidate.id === slab.id)
-        ? levelSlabs.map((candidate) => candidate.id === slab.id ? { ...candidate, elevation: proposedElevation } : candidate)
-        : [...levelSlabs, { ...slab, elevation: proposedElevation }];
+        ? levelSlabs.map((candidate) => candidate.id === slab.id ? { ...candidate, elevation: probed } : candidate)
+        : [...levelSlabs, { ...slab, elevation: probed }];
     for (const wall of levelWalls) {
-        if (wall.height != null)
+        if (!wallFollowsStorey(wall, storeyHeight))
             continue;
         const wallLike = {
             start: wall.start,
             end: wall.end,
             curveOffset: wall.curveOffset,
             thickness: wall.thickness,
+            justification: wall.justification,
         };
         // Cheap pre-filter: a wall that never reaches the slab's footprint
         // can't elect it, whatever the election says about sibling slabs.
         if (!wallOverlapsPolygon(wallLike, slab.polygon))
             continue;
-        const support = computeWallSlabSupport(wallLike, substituted, levelWalls);
-        if (Math.abs(support.elevation - proposedElevation) <= WALL_SLAB_ELEVATION_POOL_EPSILON) {
+        const support = computeWallSlabSupport(wallLike, substituted, levelWalls, undefined, undefined, 0, nodes);
+        if (Math.abs(support.elevation - probed) <= WALL_SLAB_ELEVATION_POOL_EPSILON) {
             return { elevation: bound, clamped: true };
         }
     }
@@ -52,9 +63,10 @@ export function clampSlabElevationForWalls(proposedElevation, slab, levelWalls,
  * plane-bound wall would elect it there, the drag may not pass
  * `storeyHeight - MIN_WALL_HEIGHT`; otherwise it is unbounded above.
  */
-export function getSlabElevationUpperBound(slab, levelWalls, levelSlabs, storeyHeight) {
+export function getSlabElevationUpperBound(slab, levelWalls, levelSlabs, storeyHeight, nodes) {
     const probe = Math.max(storeyHeight, ...levelSlabs.map((candidate) => candidate.elevation ?? 0.05)) + 1;
-    return clampSlabElevationForWalls(probe, slab, levelWalls, levelSlabs, storeyHeight).clamped
+    return clampSlabElevationForWalls(probe, slab, levelWalls, levelSlabs, storeyHeight, nodes)
+        .clamped
         ? storeyHeight - MIN_WALL_HEIGHT
         : Number.POSITIVE_INFINITY;
 }
@@ -235,8 +247,12 @@ const WALL_SLAB_MIN_OVERLAP = 0.05;
  * just outside the slab boundary but whose body reaches onto the slab —
  * e.g. slab polygons drawn to the room's interior faces.
  */
-function wallTestPolylines(start, end, curveOffset, halfThickness) {
+function wallTestPolylines(start, end, curveOffset, wall) {
     const wallLike = { start, end, curveOffset };
+    const { a, b } = getWallFaceOffsets({
+        ...wall,
+        thickness: Math.max(wall.thickness ?? DEFAULT_WALL_THICKNESS, 0),
+    });
     if (curveOffset !== 0 && isCurvedWall(wallLike)) {
         const count = 16;
         const center = [];
@@ -246,15 +262,15 @@ function wallTestPolylines(start, end, curveOffset, halfThickness) {
             const frame = getWallCurveFrameAt(wallLike, i / count);
             center.push(frame.point);
             left.push({
-                x: frame.point.x + frame.normal.x * halfThickness,
-                y: frame.point.y + frame.normal.y * halfThickness,
+                x: frame.point.x + frame.normal.x * a,
+                y: frame.point.y + frame.normal.y * a,
             });
             right.push({
-                x: frame.point.x - frame.normal.x * halfThickness,
-                y: frame.point.y - frame.normal.y * halfThickness,
+                x: frame.point.x - frame.normal.x * -b,
+                y: frame.point.y - frame.normal.y * -b,
             });
         }
-        return halfThickness > 0 ? [center, left, right] : [center];
+        return a - b > 0 ? [center, left, right] : [center];
     }
     const center = [
         { x: start[0], y: start[1] },
@@ -263,10 +279,12 @@ function wallTestPolylines(start, end, curveOffset, halfThickness) {
     const dx = end[0] - start[0];
     const dz = end[1] - start[1];
     const len = Math.hypot(dx, dz);
-    if (len < 1e-10 || halfThickness <= 0)
+    if (len < 1e-10 || a - b <= 0)
         return [center];
-    const nx = (-dz / len) * halfThickness;
-    const nz = (dx / len) * halfThickness;
+    const nx = (-dz / len) * a;
+    const nz = (dx / len) * a;
+    const rx = (-dz / len) * -b;
+    const rz = (dx / len) * -b;
     return [
         center,
         [
@@ -274,8 +292,8 @@ function wallTestPolylines(start, end, curveOffset, halfThickness) {
             { x: end[0] + nx, y: end[1] + nz },
         ],
         [
-            { x: start[0] - nx, y: start[1] - nz },
-            { x: end[0] - nx, y: end[1] - nz },
+            { x: start[0] - rx, y: start[1] - rz },
+            { x: end[0] - rx, y: end[1] - rz },
         ],
     ];
 }
@@ -302,6 +320,7 @@ export function wallOverlapsPolygon(startOrWall, endOrPolygon, polygonArg) {
     let polygon;
     let curveOffset = 0;
     let thickness = DEFAULT_WALL_THICKNESS;
+    let justification;
     if (Array.isArray(startOrWall)) {
         start = startOrWall;
         end = endOrPolygon;
@@ -312,9 +331,10 @@ export function wallOverlapsPolygon(startOrWall, endOrPolygon, polygonArg) {
         end = startOrWall.end;
         curveOffset = startOrWall.curveOffset ?? 0;
         thickness = startOrWall.thickness ?? DEFAULT_WALL_THICKNESS;
+        justification = startOrWall.justification;
         polygon = endOrPolygon;
     }
-    return wallOverlapsSlabFootprint({ start, end, curveOffset, thickness }, polygon);
+    return wallOverlapsSlabFootprint({ start, end, curveOffset, thickness, justification }, polygon);
 }
 /**
  * {@link wallOverlapsPolygon} with the slab's stored holes subtracted from
@@ -325,9 +345,8 @@ export function wallOverlapsPolygon(startOrWall, endOrPolygon, polygonArg) {
  * on every side of the slab. Pure.
  */
 export function wallOverlapsSlabFootprint(wallLike, polygon, holes) {
-    const { start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS } = wallLike;
-    const halfThickness = Math.max(thickness / 2, 0);
-    const polylines = wallTestPolylines(start, end, curveOffset, halfThickness);
+    const { start, end, curveOffset = 0 } = wallLike;
+    const polylines = wallTestPolylines(start, end, curveOffset, wallLike);
     const centerLength = polylineLength(polylines[0]);
     if (centerLength < 1e-9)
         return false;
@@ -395,6 +414,10 @@ const WALL_SLAB_ELEVATION_POOL_EPSILON = 1e-4;
  * recessed slab up to `0` so a wall over a pool didn't sink — generalizes to
  * "never below the ground", which is the same rule with the ground no longer
  * assumed flat.
+ *
+ * `baseAt` optionally supplies the live level-base sampler for geometry face
+ * profiles. The spatial grid keeps it stable until its support inputs change;
+ * pure callers default to persisted terrain from `nodes`.
  */
 // A rendered slab polygon depends only on the slab set and the level's walls,
 // never on the wall being tested — but a per-frame pass asks for support once
@@ -404,27 +427,323 @@ const WALL_SLAB_ELEVATION_POOL_EPSILON = 1e-4;
 // live preview changes, so a hit means the inputs are the same objects.
 let polygonMemoSlabs = null;
 let polygonMemoWalls = null;
+let polygonMemoNodes;
+const polygonSets = new Map();
 let polygonMemo = new Map();
-function renderedSlabPolygon(slab, slabs, levelWalls) {
-    if (polygonMemoSlabs !== slabs || polygonMemoWalls !== levelWalls) {
+let supportSlabs = [];
+let preparedPolygons;
+function renderedSlabPolygon(slab, slabs, levelWalls, nodes) {
+    if (polygonMemoSlabs !== slabs || polygonMemoWalls !== levelWalls || polygonMemoNodes !== nodes) {
         polygonMemoSlabs = slabs;
         polygonMemoWalls = levelWalls;
-        polygonMemo = new Map();
+        polygonMemoNodes = nodes;
+        const signature = JSON.stringify([
+            slabs,
+            levelWalls.map((wall) => [
+                wall.id,
+                wall.start,
+                wall.end,
+                wall.curveOffset,
+                wall.thickness,
+                wall.justification,
+            ]),
+            slabs.flatMap((slab) => slab.boundary === 'auto' && !slab.plateRole
+                ? (slab.zoneIds ?? []).map((id) => {
+                    const zone = nodes?.[id];
+                    return zone?.type === 'zone' ? [id, zone.polygon, zone.holes] : id;
+                })
+                : []),
+        ]);
+        const hit = polygonSets.get(signature);
+        if (hit) {
+            polygonMemo = hit.polygons;
+            supportSlabs = hit.slabs;
+            preparedPolygons = hit.prepared;
+        }
+        else {
+            polygonMemo = new Map();
+            supportSlabs = slabs.flatMap((source) => {
+                if (source.support === 'open' ||
+                    source.plateRole === 'platform' ||
+                    source.plateRole === 'sunken')
+                    return [];
+                if (source.plateRole === 'base')
+                    return [source];
+                const zones = source.boundary === 'auto'
+                    ? (source.zoneIds ?? []).flatMap((id) => {
+                        const zone = nodes?.[id];
+                        return zone?.type === 'zone'
+                            ? [{ outer: zone.polygon, holes: zone.holes ?? [] }]
+                            : [];
+                    })
+                    : [];
+                if (!zones.length)
+                    return [source];
+                return intersection({ outer: source.polygon, holes: source.holes ?? [] }, union(zones)).map((part) => ({
+                    ...source,
+                    boundary: undefined,
+                    polygon: part.outer,
+                    holes: part.holes,
+                }));
+            });
+            preparedPolygons = prepareSlabPolygonContext({
+                walls: levelWalls,
+                siblingSlabs: supportSlabs,
+            });
+            if (polygonSets.size >= 64)
+                polygonSets.delete(polygonSets.keys().next().value);
+            polygonSets.set(signature, {
+                polygons: polygonMemo,
+                slabs: supportSlabs,
+                prepared: preparedPolygons,
+            });
+        }
     }
     const cached = polygonMemo.get(slab.id);
     if (cached)
         return cached;
-    const polygon = getRenderableSlabPolygon(slab, {
-        walls: levelWalls,
-        siblingSlabs: slabs.filter((other) => other.id !== slab.id),
-    });
-    polygonMemo.set(slab.id, polygon);
-    return polygon;
+    if (slab.plateRole === 'base') {
+        const polygon = [{ outer: slab.polygon, holes: slab.holes ?? [] }];
+        polygonMemo.set(slab.id, polygon);
+        return polygon;
+    }
+    // Keep the pre-plate face/seam election. Full wall coverage belongs to rendering.
+    const polygons = supportSlabs
+        .filter((source) => source.id === slab.id)
+        .map((source) => ({
+        outer: getRenderableSlabPolygon(source, scopeSlabPolygonContext(source, preparedPolygons)),
+        holes: source.holes ?? [],
+    }));
+    polygonMemo.set(slab.id, polygons);
+    return polygons;
+}
+function appendBaseSegment(segments, start, end, elevation) {
+    const previous = segments.at(-1);
+    if (previous &&
+        previous.endElevation === undefined &&
+        Math.abs(previous.elevation - elevation) <= WALL_SLAB_ELEVATION_POOL_EPSILON)
+        previous.end = end;
+    else
+        segments.push({ start, end, elevation });
+}
+const supportMemo = new WeakMap();
+function roomFaceBases(slabs, walls, nodes, memo) {
+    if (memo.roomBases)
+        return memo.roomBases;
+    const result = new Map();
+    memo.roomBases = result;
+    if (!nodes || !walls.length)
+        return result;
+    const levels = new Set(walls.map((wall) => wall.parentId));
+    const zones = Object.values(nodes).filter((node) => node.type === 'zone' &&
+        node.spaceRole === 'room' &&
+        node.floor?.support !== 'open' &&
+        levels.has(node.parentId));
+    if (!zones.length)
+        return result;
+    const separators = Object.values(nodes).filter((node) => node.type === 'separator' && levels.has(node.parentId));
+    const exactZones = new Map([...zones]
+        .sort((a, b) => b.id.localeCompare(a.id))
+        .map((zone) => [roomPolygonKey(zone.polygon, zone.holes), zone]));
+    const zoneBounds = new Map(zones.map((zone) => [zone.id, polygonBounds([{ outer: zone.polygon, holes: [] }])]));
+    for (const room of floorRoomFaces([...walls, ...separators])) {
+        const polygon = { outer: room.referencePolygon, holes: room.holes };
+        const bounds = polygonBounds([polygon]);
+        const zone = exactZones.get(roomPolygonKey(room.referencePolygon, room.holes)) ??
+            zones
+                .filter((zone) => {
+                const other = zoneBounds.get(zone.id);
+                return (bounds.minX < other.maxX &&
+                    other.minX < bounds.maxX &&
+                    bounds.minZ < other.maxZ &&
+                    other.minZ < bounds.maxZ);
+            })
+                .map((zone) => ({
+                zone,
+                overlap: area(intersection(polygon, { outer: zone.polygon, holes: zone.holes ?? [] })),
+            }))
+                .filter(({ overlap }) => overlap > 1e-6)
+                .sort((a, b) => b.overlap - a.overlap || a.zone.id.localeCompare(b.zone.id))[0]?.zone;
+        if (!zone)
+            continue;
+        const plate = slabs.find((slab) => slab.boundary === 'auto' && slab.plateRole !== 'base' && slab.zoneIds?.includes(zone.id)) ?? slabs.find((slab) => slab.plateRole === 'base' && slab.zoneIds?.includes(zone.id));
+        const elevation = plate
+            ? plate.plateRole
+                ? (zone.floor?.elevation ?? plate.elevation)
+                : plate.elevation
+            : undefined;
+        if (elevation === undefined || zone.hasFloor === false)
+            continue;
+        for (const span of room.spans) {
+            const wall = walls.find((wall) => wall.id === span.boundaryId);
+            if (!wall)
+                continue;
+            // Topology stations are chord parameters; support profiles use arc parameters.
+            const station = (t) => {
+                if (!isCurvedWall(wall) || t <= 0 || t >= 1)
+                    return t;
+                const dx = wall.end[0] - wall.start[0], dz = wall.end[1] - wall.start[1];
+                let low = 0, high = 1;
+                for (let i = 0; i < 40; i++) {
+                    const mid = (low + high) / 2, point = getWallCurveFrameAt(wall, mid).point;
+                    if (((point.x - wall.start[0]) * dx + (point.y - wall.start[1]) * dz) /
+                        (dx * dx + dz * dz) <
+                        t)
+                        low = mid;
+                    else
+                        high = mid;
+                }
+                return (low + high) / 2;
+            };
+            const bases = result.get(wall.id) ?? { a: [], b: [] };
+            bases[span.face].push({
+                start: station(span.t0),
+                end: station(span.t1),
+                elevation,
+                thickness: plate?.thickness ?? 0.05,
+            });
+            result.set(wall.id, bases);
+        }
+    }
+    return result;
+}
+export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSlabId, maxElevation, levelBase = 0, nodes, baseAt, terrainRevision) {
+    let memo = supportMemo.get(levelWalls);
+    if (!memo || memo.slabs !== slabs || memo.nodes !== nodes || memo.baseAt !== baseAt) {
+        memo = { slabs, nodes, baseAt, results: new Map() };
+        supportMemo.set(levelWalls, memo);
+    }
+    const key = JSON.stringify([
+        wallLike.start,
+        wallLike.end,
+        wallLike.curveOffset,
+        wallLike.thickness,
+        wallLike.justification,
+        wallLike.supportOffset,
+        wallLike.height,
+        preferredSlabId,
+        maxElevation,
+        levelBase,
+    ]);
+    if (terrainRevision && memo.terrainResults?.revision !== terrainRevision)
+        memo.terrainResults = { revision: terrainRevision, results: new Map() };
+    const results = terrainRevision ? memo.terrainResults.results : memo.results;
+    const cached = results.get(key);
+    if (cached)
+        return cached;
+    let support = computeWallSlabSupportUncached(memo, wallLike, slabs, levelWalls, preferredSlabId, maxElevation, levelBase, nodes);
+    const groundWall = preferredSlabId === 'ground' && nodes && slabs.some((slab) => slab.plateRole === 'base')
+        ? levelWalls.find((wall) => wall.start[0] === wallLike.start[0] &&
+            wall.start[1] === wallLike.start[1] &&
+            wall.end[0] === wallLike.end[0] &&
+            wall.end[1] === wallLike.end[1])
+        : undefined;
+    const offset = (wallLike.supportOffset ?? 0) + (groundWall ? floorConstructionLift(nodes, groundWall) : 0);
+    if (offset || preferredSlabId === 'ground') {
+        const raw = support;
+        const ground = preferredSlabId === 'ground';
+        const elevation = (ground ? levelBase : raw.elevation) + offset;
+        const shift = (segments) => segments.map((run) => ({
+            ...run,
+            elevation: run.elevation + offset,
+            ...(run.endElevation === undefined ? {} : { endElevation: run.endElevation + offset }),
+        }));
+        const baseSegments = ground ? [{ start: 0, end: 1, elevation }] : shift(raw.baseSegments);
+        const wall = levelWalls.find((wall) => wall.start[0] === wallLike.start[0] &&
+            wall.start[1] === wallLike.start[1] &&
+            wall.end[0] === wallLike.end[0] &&
+            wall.end[1] === wallLike.end[1]);
+        const rooms = wall && slabs.some((slab) => slab.plateRole === 'base')
+            ? roomFaceBases(slabs, levelWalls, nodes, memo).get(wall.id)
+            : undefined;
+        const datum = (face) => raw.faceDatum[face].map((run) => {
+            const room = rooms?.[face].find((room) => room.start <= (run.start + run.end) / 2 && room.end >= (run.start + run.end) / 2);
+            return room
+                ? { ...run, elevation: room.elevation, endElevation: undefined }
+                : ground
+                    ? { ...run, elevation, endElevation: undefined }
+                    : shift([run])[0];
+        });
+        const faceDatum = { a: datum('a'), b: datum('b') };
+        support = {
+            elevation,
+            electedSlabId: ground ? null : raw.electedSlabId,
+            baseElevation: Math.min(...baseSegments.map((run) => run.elevation)),
+            baseSegments,
+            faceDatum,
+            faceBottom: {
+                a: resolveWallFaceBottom(faceDatum.a, baseSegments, elevation),
+                b: resolveWallFaceBottom(faceDatum.b, baseSegments, elevation),
+            },
+        };
+    }
+    if (results.size >= 512)
+        results.clear();
+    results.set(key, support);
+    return support;
+}
+const supportBounds = new WeakMap();
+function polygonBounds(polygon) {
+    const cached = supportBounds.get(polygon);
+    if (cached)
+        return cached;
+    const bounds = { minX: Infinity, minZ: Infinity, maxX: -Infinity, maxZ: -Infinity };
+    for (const part of polygon)
+        for (const [x, z] of part.outer) {
+            bounds.minX = Math.min(bounds.minX, x);
+            bounds.maxX = Math.max(bounds.maxX, x);
+            bounds.minZ = Math.min(bounds.minZ, z);
+            bounds.maxZ = Math.max(bounds.maxZ, z);
+        }
+    supportBounds.set(polygon, bounds);
+    return bounds;
+}
+/** A cap may run this far past the wall's faces and ends and still be its cap. */
+const WALL_CAP_SLACK = 0.05;
+/** Whether every corner of the footprint lies on the wall body: between its faces, within its length. */
+function footprintOnWallBody(polygon, center, offsets) {
+    const onBody = ([px, pz]) => {
+        let nearest = Number.POSITIVE_INFINITY;
+        let fits = false;
+        for (let i = 1; i < center.length; i++) {
+            const s = center[i - 1], e = center[i];
+            const dx = e.x - s.x, dz = e.y - s.y;
+            const length = Math.hypot(dx, dz);
+            if (length < 1e-9)
+                continue;
+            const along = ((px - s.x) * dx + (pz - s.y) * dz) / length;
+            const across = ((px - s.x) * -dz + (pz - s.y) * dx) / length;
+            const distance = Math.hypot(Math.max(0, -along, along - length), Math.max(0, across - offsets.a, offsets.b - across));
+            if (distance < nearest) {
+                nearest = distance;
+                fits = distance <= WALL_CAP_SLACK;
+            }
+        }
+        return fits;
+    };
+    return polygon.every((part) => [part.outer, ...part.holes].every((ring) => ring.every(onBody)));
+}
+/**
+ * Level-local Y of the wall's top when it stands at `base`: an authored height
+ * above it, else the storey plane of the level the walls belong to, else the
+ * legacy default (a level deriving its first height has no plane yet).
+ */
+function resolveWallTopAbove(base, wallLike, levelWalls, nodes) {
+    const height = wallLike.height ??
+        levelWalls.find((wall) => wall.start[0] === wallLike.start[0] &&
+            wall.start[1] === wallLike.start[1] &&
+            wall.end[0] === wallLike.end[0] &&
+            wall.end[1] === wallLike.end[1])?.height;
+    if (height !== undefined)
+        return base + height;
+    const level = nodes?.[levelWalls[0]?.parentId ?? ''];
+    return level?.type === 'level' && level.height !== undefined
+        ? level.height
+        : base + DEFAULT_WALL_HEIGHT;
 }
-export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSlabId, maxElevation, levelBase = 0) {
-    const { start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS } = wallLike;
-    const halfThickness = Math.max(thickness / 2, 0);
-    const polylines = wallTestPolylines(start, end, curveOffset, halfThickness);
+function computeWallSlabSupportUncached(memo, wallLike, slabs, levelWalls, preferredSlabId, maxElevation, levelBase = 0, nodes) {
+    const { start, end, curveOffset = 0 } = wallLike;
+    const polylines = wallTestPolylines(start, end, curveOffset, wallLike);
     const polylineLengths = polylines.map(polylineLength);
     const wallLength = polylineLengths[0];
     if (wallLength < 1e-9) {
@@ -433,32 +752,71 @@ export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSla
             electedSlabId: null,
             baseElevation: levelBase,
             baseSegments: [],
+            faceDatum: { a: [], b: [] },
+            faceBottom: { a: [], b: [] },
         };
     }
+    const points = polylines.flat();
+    const band = {
+        minX: Math.min(...points.map((point) => point.x)) - ON_BOUNDARY_EPSILON,
+        maxX: Math.max(...points.map((point) => point.x)) + ON_BOUNDARY_EPSILON,
+        minZ: Math.min(...points.map((point) => point.y)) - ON_BOUNDARY_EPSILON,
+        maxZ: Math.max(...points.map((point) => point.y)) + ON_BOUNDARY_EPSILON,
+    };
     const minSupport = Math.max(1e-3, Math.min(WALL_SLAB_MIN_OVERLAP, wallLength * 0.5));
     const groups = [];
     let preferredElevation = null;
     let preferredElectedSlabId = null;
+    const candidates = [];
     for (const slab of slabs) {
-        if (slab.polygon.length < 3)
+        if (slab.support === 'open' ||
+            ((slab.plateRole === 'platform' || slab.plateRole === 'sunken') &&
+                slab.id !== preferredSlabId) ||
+            slab.polygon.length < 3)
+            continue;
+        const renderedPolygon = renderedSlabPolygon(slab, slabs, levelWalls, nodes);
+        const bounds = polygonBounds(renderedPolygon);
+        if (bounds.minX > band.maxX ||
+            bounds.maxX < band.minX ||
+            bounds.minZ > band.maxZ ||
+            bounds.maxZ < band.minZ)
             continue;
-        const renderedPolygon = renderedSlabPolygon(slab, slabs, levelWalls);
         let supported = 0;
         const perPolyline = polylines.map((line) => {
-            let intervals = polylineInsideIntervals(line, renderedPolygon);
-            for (const hole of slab.holes || []) {
-                if (intervals.length === 0)
-                    break;
-                if (hole.length < 3)
-                    continue;
-                intervals = subtractIntervals(intervals, polylineInsideIntervals(line, hole, false));
-            }
+            const intervals = mergeIntervals(renderedPolygon.flatMap(({ outer, holes }) => {
+                let covered = polylineInsideIntervals(line, outer);
+                for (const hole of holes) {
+                    if (hole.length >= 3)
+                        covered = subtractIntervals(covered, polylineInsideIntervals(line, hole, false));
+                }
+                return covered;
+            }));
             supported = Math.max(supported, intervalsLength(intervals));
             return intervals;
         });
         if (supported < minSupport)
             continue;
-        const elevation = slab.elevation ?? 0.05;
+        const elevation = nodes && slabs.some((slab) => slab.plateRole === 'base')
+            ? liftedManualSlab(nodes, slab).elevation
+            : (slab.elevation ?? 0.05);
+        candidates.push({ slab, elevation, perPolyline, polygon: renderedPolygon });
+    }
+    // A slab lying on the wall body with its underside at the wall's own top is
+    // a cap the wall carries (an importer's 12 mm "wall caps"), never a support.
+    // The top is measured from the lowest candidate, since the base being
+    // elected cannot decide it. A floor or terrace reaching past the wall keeps
+    // carrying it however short the wall, and an explicit host is the user's choice.
+    const floor = Math.min(levelBase, ...candidates.map((candidate) => candidate.elevation));
+    const wallTop = resolveWallTopAbove(floor, wallLike, levelWalls, nodes);
+    const offsets = getWallFaceOffsets({
+        ...wallLike,
+        thickness: Math.max(wallLike.thickness ?? DEFAULT_WALL_THICKNESS, 0),
+    });
+    for (const { slab, elevation, perPolyline, polygon } of candidates) {
+        if (slab.id !== preferredSlabId &&
+            elevation - slab.thickness >= wallTop - 1e-6 &&
+            footprintOnWallBody(polygon, polylines[0], offsets))
+            continue;
         if (preferredSlabId != null && slab.id === preferredSlabId) {
             preferredElevation = elevation;
             preferredElectedSlabId = slab.id;
@@ -512,6 +870,7 @@ export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSla
     const electableNormalizedGroups = maxElevation == null
         ? normalizedByGroup
         : normalizedByGroup.filter((group) => group.elevation <= maxElevation + SUPPORT_ELEVATION_EPSILON);
+    const faceDatum = { a: [], b: [] };
     const baseSegments = [];
     const carryCandidates = [];
     const accumulateCarry = (elevation, length) => {
@@ -533,6 +892,12 @@ export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSla
         const rightElevation = polylines.length >= 3 ? highestAt(normalizedByGroup, 2, midpoint) : Number.NEGATIVE_INFINITY;
         const faceElevations = [leftElevation, rightElevation].filter(Number.isFinite);
         const segmentElevation = faceElevations.length > 0 ? Math.min(...faceElevations) : Math.max(centerElevation, levelBase);
+        for (const [face, value] of [
+            ['a', leftElevation],
+            ['b', rightElevation],
+        ]) {
+            appendBaseSegment(faceDatum[face], start, end, Number.isFinite(value) ? value : segmentElevation);
+        }
         if (electableNormalizedGroups === normalizedByGroup) {
             if (faceElevations.length > 0 || Number.isFinite(centerElevation)) {
                 accumulateCarry(segmentElevation, end - start);
@@ -573,13 +938,13 @@ export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSla
             bestElevation = candidate.elevation;
         }
     }
-    const elevation = preferredElevation !== null
-        ? preferredElevation
-        : majorityElevation !== Number.NEGATIVE_INFINITY
-            ? majorityElevation
-            : bestElevation === Number.NEGATIVE_INFINITY
+    const elevation = preferredElevation === null
+        ? majorityElevation === Number.NEGATIVE_INFINITY
+            ? bestElevation === Number.NEGATIVE_INFINITY
                 ? levelBase
-                : bestElevation;
+                : bestElevation
+            : majorityElevation
+        : preferredElevation;
     const electedSlabId = preferredElectedSlabId ??
         evaluatedGroups
             .filter((group) => maxElevation == null || group.elevation <= maxElevation + SUPPORT_ELEVATION_EPSILON)
@@ -590,8 +955,128 @@ export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSla
     if (baseSegments.length === 0)
         baseSegments.push({ start: 0, end: 1, elevation });
     const baseElevation = Math.min(...baseSegments.map((segment) => segment.elevation));
-    return { elevation, electedSlabId, baseElevation, baseSegments };
+    let resolvedFaceDatum;
+    const resolveFaceDatum = () => {
+        const wall = levelWalls.find((candidate) => candidate.start[0] === start[0] &&
+            candidate.start[1] === start[1] &&
+            candidate.end[0] === end[0] &&
+            candidate.end[1] === end[1] &&
+            (candidate.curveOffset ?? 0) === curveOffset &&
+            candidate.justification === wallLike.justification);
+        const roomBases = wall ? roomFaceBases(slabs, levelWalls, nodes, memo).get(wall.id) : undefined;
+        if (roomBases)
+            for (const face of ['a', 'b']) {
+                const spans = roomBases[face];
+                const cuts = [
+                    ...new Set([
+                        0,
+                        1,
+                        ...faceDatum[face].flatMap((segment) => [segment.start, segment.end]),
+                        ...spans.flatMap((segment) => [segment.start, segment.end]),
+                        ...roomBases[face === 'a' ? 'b' : 'a'].flatMap((segment) => [
+                            segment.start,
+                            segment.end,
+                        ]),
+                    ]),
+                ].sort((a, b) => a - b);
+                const result = [];
+                for (let i = 1; i < cuts.length; i++) {
+                    const start = cuts[i - 1], end = cuts[i], mid = (start + end) / 2;
+                    const room = spans.find((span) => span.start <= mid && mid < span.end);
+                    const elected = faceDatum[face].find((span) => span.start <= mid && mid < span.end);
+                    if (!elected)
+                        continue;
+                    const opposite = roomBases[face === 'a' ? 'b' : 'a'].find((span) => span.start <= mid && mid < span.end);
+                    const groundAt = (t) => {
+                        const frame = getWallCurveFrameAt(wall, t);
+                        const offset = getWallFaceOffsets(wall)[face];
+                        const x = frame.point.x + frame.normal.x * offset;
+                        const z = frame.point.y + frame.normal.y * offset;
+                        if (memo.baseAt)
+                            return memo.baseAt(x, z);
+                        return nodes && wall.parentId && nodes[wall.parentId]
+                            ? levelBaseElevationAt(nodes, wall.parentId, x, z)
+                            : levelBase;
+                    };
+                    // Raised and sunken rooms never carry their exterior face with them.
+                    // A flush floor follows depressed terrain only when explicitly opted in.
+                    const count = Math.max(1, Math.ceil(((end - start) * wallLength) / 0.25));
+                    const ground = !slabs.some((slab) => slab.plateRole === 'base') &&
+                        !room &&
+                        opposite &&
+                        (opposite.elevation - opposite.thickness > 1e-4 || opposite.elevation < -1e-4)
+                        ? Array.from({ length: count + 1 }, (_, i) => groundAt(start + ((end - start) * i) / count))
+                        : [];
+                    if (ground.length) {
+                        for (let j = 0; j < count; j++) {
+                            const from = start + ((end - start) * j) / count;
+                            const to = start + ((end - start) * (j + 1)) / count;
+                            const elevation = ground[j], endElevation = ground[j + 1];
+                            if (Math.abs(elevation - endElevation) < 1e-6)
+                                appendBaseSegment(result, from, to, elevation);
+                            else {
+                                const previous = result.at(-1);
+                                if (previous?.endElevation !== undefined &&
+                                    Math.abs(previous.endElevation - elevation) < 1e-6 &&
+                                    Math.abs((previous.endElevation - previous.elevation) / (previous.end - previous.start) -
+                                        (endElevation - elevation) / (to - from)) < 1e-6) {
+                                    previous.end = to;
+                                    previous.endElevation = endElevation;
+                                }
+                                else
+                                    result.push({ start: from, end: to, elevation, endElevation });
+                            }
+                        }
+                    }
+                    else
+                        appendBaseSegment(result, start, end, slabs.some((slab) => slab.plateRole === 'base')
+                            ? (room?.elevation ?? elected.elevation)
+                            : Math.min(room?.elevation ?? elected.elevation, elected.elevation));
+                }
+                faceDatum[face] = result;
+            }
+        return faceDatum;
+    };
+    let faceBottom;
+    const datum = () => (resolvedFaceDatum ??= resolveFaceDatum());
+    const bottom = (segments) => resolveWallFaceBottom(segments, baseSegments, elevation);
+    return Object.defineProperties({ elevation, electedSlabId, baseElevation, baseSegments }, {
+        faceDatum: { get: datum },
+        faceBottom: { get: () => (faceBottom ??= { a: bottom(datum().a), b: bottom(datum().b) }) },
+    });
 }
-export function computeWallSlabElevation(wallLike, slabs, levelWalls) {
-    return computeWallSlabSupport(wallLike, slabs, levelWalls).elevation;
+export function computeWallSlabElevation(wallLike, slabs, levelWalls, nodes) {
+    return computeWallSlabSupport(wallLike, slabs, levelWalls, undefined, undefined, 0, nodes)
+        .elevation;
+}
+export function resolveWallFaceBottom(datums, support, fallback) {
+    const at = (run, t) => run.elevation +
+        ((t - run.start) / (run.end - run.start)) *
+            ((run.endElevation ?? run.elevation) - run.elevation);
+    const cuts = [...new Set([...datums, ...support].flatMap((run) => [run.start, run.end]))].sort((a, b) => a - b);
+    const result = [];
+    for (let i = 1; i < cuts.length; i++) {
+        const start = cuts[i - 1], end = cuts[i], mid = (start + end) / 2;
+        const datum = datums.find((run) => run.start <= mid && run.end >= mid);
+        if (!datum)
+            continue;
+        const carrier = support.find((run) => run.start <= mid && run.end >= mid);
+        const d0 = at(datum, start), d1 = at(datum, end), w0 = carrier ? at(carrier, start) : fallback, w1 = carrier ? at(carrier, end) : fallback;
+        const crossing = (d0 - w0) * (d1 - w1) < 0
+            ? start + ((end - start) * (w0 - d0)) / (d1 - d0 - w1 + w0)
+            : undefined;
+        const pieces = crossing === undefined ? [start, end] : [start, crossing, end];
+        for (let j = 1; j < pieces.length; j++) {
+            const from = pieces[j - 1], to = pieces[j];
+            const height = (t) => Math.min(at(datum, t), carrier ? at(carrier, t) : fallback);
+            const elevation = height(from), endElevation = height(to);
+            result.push({
+                start: from,
+                end: to,
+                elevation,
+                ...(Math.abs(elevation - endElevation) < 1e-9 ? {} : { endElevation }),
+            });
+        }
+    }
+    return result;
 }