@pascal-app/core 0.9.1 → 1.0.0-beta.1

package/dist/lib/space-detection.js

@@ -1,14 +1,30 @@
-import { CeilingNode, SlabNode, } from '../schema';
+import { GROUND_SUPPORT_ID } from '../hooks/spatial-grid/support-host-id';
+import { CeilingNode, SlabNode, ZoneNode, } from '../schema';
+import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height';
+import { CEILING_CLAMP_MARGIN, findLevelAboveId, getCeilingClampBound, getLevelElevations, getStoredLevelHeight, } from '../services/storey';
 import { getSceneHistoryPauseDepth, pauseSceneHistory, resumeSceneHistory, } from '../store/history-control';
+import { computeWallSlabSupport } from '../systems/slab/slab-support';
 import { getClampedWallCurveOffset, getWallCurveFrameAt, isCurvedWall, } from '../systems/wall/wall-curve';
+import { resolveWallTop } from '../systems/wall/wall-top';
 import { simplifyClosedPolygon } from './polygon-geometry';
+import { terrainSupportLift } from './terrain-support';
 const DEFAULT_AUTO_SLAB_ELEVATION = 0.05;
-const DEFAULT_AUTO_CEILING_HEIGHT = 2.5;
 const CEILING_HEIGHT_EPSILON = 1e-6;
 const ROOM_CURVE_TOLERANCE = 0.04;
 const MAX_CURVE_SUBDIVISION_DEPTH = 6;
 const AUTO_SLAB_POLYGON_SIMPLIFY_TOLERANCE = 0.08;
 const WALL_ROOM_BOUNDARY_TOLERANCE = 0.08;
+// A wall endpoint within this distance of another wall's interior is treated as a
+// T-junction and splits that wall (see `splitStraightWallAtVertices`).
+const WALL_JUNCTION_TOLERANCE = 0.08;
+// An unmatched auto slab/ceiling whose polygon is still substantially covered
+// by a detected room was absorbed by a room merge — the surviving auto surface
+// owns that area, so keeping it would z-fight and it is deleted. Below this
+// coverage the room genuinely ceased to exist (e.g. an enclosing wall was
+// deleted) and the node is demoted to manual so user data survives.
+const ORPHAN_MERGE_COVERAGE_THRESHOLD = 0.6;
+const COVERAGE_SAMPLE_STEPS = 12;
+const ROOM_VERTICAL_PLANE_EPSILON = 1e-3;
 function pointFromTuple(point) {
     return { x: point[0], y: point[1] };
 }
@@ -116,6 +132,46 @@ function bboxOverlapArea(a, b) {
     const iy = Math.max(0, Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY));
     return ix * iy;
 }
+// Fraction of `subject`'s area lying inside any of `covers`, estimated by
+// sampling a grid of cell centers over the subject's bbox. Cheap and robust
+// enough for the merge-vs-demote decision; exact polygon clipping would be a
+// heavy dependency for a 60% threshold.
+function polygonCoverageRatio(subject, covers) {
+    if (subject.length < 3 || covers.length === 0)
+        return 0;
+    const bbox = bboxOf(subject);
+    const width = bbox.maxX - bbox.minX;
+    const height = bbox.maxY - bbox.minY;
+    let inside = 0;
+    let covered = 0;
+    for (let i = 0; i < COVERAGE_SAMPLE_STEPS; i += 1) {
+        for (let j = 0; j < COVERAGE_SAMPLE_STEPS; j += 1) {
+            const point = {
+                x: bbox.minX + ((i + 0.5) / COVERAGE_SAMPLE_STEPS) * width,
+                y: bbox.minY + ((j + 0.5) / COVERAGE_SAMPLE_STEPS) * height,
+            };
+            if (!pointInPolygon(point, subject))
+                continue;
+            inside += 1;
+            if (pointInAnyPolygon(point, covers))
+                covered += 1;
+        }
+    }
+    if (inside === 0) {
+        return pointInAnyPolygon(polygonCentroid(subject), covers) ? 1 : 0;
+    }
+    return covered / inside;
+}
+// Demoted auto surfaces keep their polygon untouched, so a re-closed room
+// usually hits the exact-signature manual check. Coverage handles the rest:
+// a room split across multiple manual surfaces AND a single manual surface
+// spanning multiple rooms both suppress a replacement auto surface — what
+// matters is that the ROOM is already substantially covered, not that any
+// one manual surface belongs to it (a per-surface "mostly inside the room"
+// filter dropped multi-room slabs and resurrected deleted auto slabs).
+function matchesManualFootprint(roomPolygon, manualPolygons) {
+    return polygonCoverageRatio(roomPolygon, manualPolygons) >= ORPHAN_MERGE_COVERAGE_THRESHOLD;
+}
 function pointDistanceToPolygonBoundary(point, polygon) {
     let minDistance = Number.POSITIVE_INFINITY;
     for (let index = 0; index < polygon.length; index += 1) {
@@ -144,51 +200,56 @@ function wallBoundsRoom(wall, roomPolygon) {
     const matchingPoints = candidates.filter((point) => pointDistanceToPolygonBoundary(point, roomPolygon) <= WALL_ROOM_BOUNDARY_TOLERANCE);
     return matchingPoints.length >= 2;
 }
-function pointIsOnSlab(point, slab) {
-    if (slab.polygon.length < 3)
-        return false;
-    const slabPolygon = slab.polygon.map(pointFromTuple);
-    if (!pointInPolygon(point, slabPolygon))
-        return false;
-    for (const hole of slab.holes ?? []) {
-        if (hole.length >= 3 && pointInPolygon(point, hole.map(pointFromTuple))) {
-            return false;
-        }
-    }
-    return true;
+/**
+ * The clamp bound for a ceiling polygon under this planning context —
+ * the context's cross-level resolver when provided, else the plane-only
+ * `storeyHeight - CEILING_CLAMP_MARGIN` degradation.
+ */
+function resolveCeilingClampBound(polygon, context) {
+    if (context.ceilingClampBound)
+        return context.ceilingClampBound(polygon);
+    return (context.storeyHeight ?? DEFAULT_LEVEL_HEIGHT) - CEILING_CLAMP_MARGIN;
 }
-function slabSupportsRoom(roomPolygon, slab) {
-    if (slab.polygon.length < 3)
-        return false;
-    if (polygonSignature(slab.polygon.map(pointFromTuple)) === polygonSignature(roomPolygon)) {
-        return true;
-    }
-    return pointIsOnSlab(polygonCentroid(roomPolygon), slab);
+function consensusElevation(values) {
+    if (values.length === 0 || values.some((value) => !Number.isFinite(value)))
+        return undefined;
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    if (max - min > ROOM_VERTICAL_PLANE_EPSILON)
+        return undefined;
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
 }
-function resolveRoomSlabElevation(roomPolygon, slabs = []) {
-    let maxElevation = 0;
-    for (const slab of slabs) {
-        if (!slabSupportsRoom(roomPolygon, slab))
+function autoRoomVerticalPlacements(spaces, walls, supportSlabs, nodes, storeyHeight) {
+    const wallsById = new Map(walls.map((wall) => [wall.id, wall]));
+    const placements = new Map();
+    for (const space of spaces) {
+        const boundaryWalls = space.wallIds.flatMap((id) => {
+            const wall = wallsById.get(id);
+            return wall ? [wall] : [];
+        });
+        if (boundaryWalls.length !== space.wallIds.length)
             continue;
-        maxElevation = Math.max(maxElevation, slab.elevation ?? DEFAULT_AUTO_SLAB_ELEVATION);
-    }
-    return maxElevation;
-}
-function resolveRoomWallHeight(roomPolygon, walls = []) {
-    let maxHeight = 0;
-    for (const wall of walls) {
-        if (!wallBoundsRoom(wall, roomPolygon))
+        const wallBases = boundaryWalls.map((wall) => {
+            const offset = wall.supportOffset ?? 0;
+            if (wall.supportSlabId === GROUND_SUPPORT_ID) {
+                return ((terrainSupportLift(nodes, space.levelId, wall.start[0], wall.start[1]) ?? 0) + offset);
+            }
+            return (computeWallSlabSupport(wall, supportSlabs, walls, wall.supportSlabId ?? null).elevation +
+                offset);
+        });
+        const base = consensusElevation(wallBases);
+        if (base === undefined)
             continue;
-        const height = wall.height ?? DEFAULT_AUTO_CEILING_HEIGHT;
-        if (Number.isFinite(height)) {
-            maxHeight = Math.max(maxHeight, height);
-        }
+        const wallTops = boundaryWalls.map((wall, index) => resolveWallTop(wall, storeyHeight, wallBases[index] ?? base));
+        const top = consensusElevation(wallTops);
+        if (top === undefined)
+            continue;
+        placements.set(polygonSignature(space.polygon.map(pointFromTuple)), {
+            slabElevation: base + DEFAULT_AUTO_SLAB_ELEVATION,
+            ceilingHeight: top - CEILING_CLAMP_MARGIN,
+        });
     }
-    return maxHeight > 0 ? maxHeight : DEFAULT_AUTO_CEILING_HEIGHT;
-}
-function resolveAutoCeilingHeight(roomPolygon, context = {}) {
-    return (resolveRoomSlabElevation(roomPolygon, context.slabs) +
-        resolveRoomWallHeight(roomPolygon, context.walls));
+    return placements;
 }
 function getWallDirection(wall) {
     const dx = wall.end[0] - wall.start[0];
@@ -240,11 +301,52 @@ function sampleWallPointsForRoomDetection(wall, tolerance = ROOM_CURVE_TOLERANCE
     };
     return subdivide(0, start, 1, end, 0);
 }
-function getDirectedWallBoundaryPoints(wall, forward) {
-    const points = sampleWallPointsForRoomDetection(wall);
-    return forward ? points : [...points].reverse();
+function segmentProjection(point, start, end) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared < 1e-12) {
+        return { t: 0, distance: Math.hypot(point.x - start.x, point.y - start.y) };
+    }
+    const t = ((point.x - start.x) * dx + (point.y - start.y) * dy) / lengthSquared;
+    const clampedT = Math.max(0, Math.min(1, t));
+    const projX = start.x + clampedT * dx;
+    const projY = start.y + clampedT * dy;
+    return { t, distance: Math.hypot(point.x - projX, point.y - projY) };
 }
-function extractRoomPolygons(walls) {
+// Break a straight wall at any junction vertex (another wall's endpoint) that
+// lands on its interior, returning the ordered polyline [start, …splits, end].
+// Splitting at the *vertex* position (not the projection) keeps the split node's
+// key identical to the touching wall's endpoint so the two share a graph node.
+function splitStraightWallAtVertices(start, end, vertices) {
+    const length = Math.hypot(end.x - start.x, end.y - start.y);
+    if (length < 1e-9)
+        return [start, end];
+    const interior = [];
+    for (const vertex of vertices) {
+        const { t, distance } = segmentProjection(vertex, start, end);
+        if (distance > WALL_JUNCTION_TOLERANCE)
+            continue;
+        const along = t * length;
+        if (along <= WALL_JUNCTION_TOLERANCE || along >= length - WALL_JUNCTION_TOLERANCE)
+            continue;
+        interior.push({ point: vertex, t });
+    }
+    interior.sort((a, b) => a.t - b.t);
+    const ordered = [start];
+    let lastKey = pointKey(start);
+    for (const { point } of interior) {
+        const key = pointKey(point);
+        if (key === lastKey)
+            continue;
+        ordered.push(point);
+        lastKey = key;
+    }
+    if (lastKey !== pointKey(end))
+        ordered.push(end);
+    return ordered;
+}
+function extractRooms(walls) {
     if (walls.length < 3)
         return [];
     const graph = new Map();
@@ -256,35 +358,71 @@ function extractRoomPolygons(walls) {
         }
         return key;
     };
+    // Planarize first: collect every wall endpoint as a candidate graph vertex so
+    // straight walls can be split at T-junctions where another wall ends mid-span.
+    // Without this the touching wall's endpoint is a dangling degree-1 node and the
+    // enclosed area (e.g. a room added against the middle of an existing wall)
+    // never forms a cycle.
+    const vertexByKey = new Map();
+    for (const wall of walls) {
+        for (const tuple of [wall.start, wall.end]) {
+            const point = pointFromTuple(tuple);
+            const key = pointKey(point);
+            if (!vertexByKey.has(key))
+                vertexByKey.set(key, point);
+        }
+    }
+    const vertices = [...vertexByKey.values()];
     for (const wall of walls) {
         const start = pointFromTuple(wall.start);
         const end = pointFromTuple(wall.end);
-        const startKey = upsertNode(start);
-        const endKey = upsertNode(end);
-        if (startKey === endKey)
+        if (samePointWithinTolerance(start, end))
             continue;
-        const forwardDirection = getWallDirection(wall);
-        const reverseDirection = getWallDirection({ start: wall.end, end: wall.start });
-        const forwardId = `${wall.id}:f`;
-        const reverseId = `${wall.id}:r`;
-        halfEdges.set(forwardId, {
-            id: forwardId,
-            reverseId,
-            fromKey: startKey,
-            toKey: endKey,
-            angle: Math.atan2(forwardDirection.tangent.y, forwardDirection.tangent.x),
-            points: getDirectedWallBoundaryPoints(wall, true),
+        // Curved walls keep their sampled polyline as one edge; straight walls split
+        // into consecutive sub-edges at their interior junction vertices.
+        const subPolylines = isCurvedWall(wall)
+            ? [sampleWallPointsForRoomDetection(wall)]
+            : (() => {
+                const ordered = splitStraightWallAtVertices(start, end, vertices);
+                const parts = [];
+                for (let index = 0; index < ordered.length - 1; index += 1) {
+                    parts.push([ordered[index], ordered[index + 1]]);
+                }
+                return parts;
+            })();
+        subPolylines.forEach((points, subIndex) => {
+            const from = points[0];
+            const to = points[points.length - 1];
+            const fromKey = upsertNode(from);
+            const toKey = upsertNode(to);
+            if (fromKey === toKey)
+                return;
+            const reversePoints = [...points].reverse();
+            const forwardId = `${wall.id}#${subIndex}:f`;
+            const reverseId = `${wall.id}#${subIndex}:r`;
+            halfEdges.set(forwardId, {
+                id: forwardId,
+                reverseId,
+                fromKey,
+                toKey,
+                angle: Math.atan2(points[1].y - from.y, points[1].x - from.x),
+                points,
+                wallId: wall.id,
+                face: 'front',
+            });
+            halfEdges.set(reverseId, {
+                id: reverseId,
+                reverseId: forwardId,
+                fromKey: toKey,
+                toKey: fromKey,
+                angle: Math.atan2(reversePoints[1].y - to.y, reversePoints[1].x - to.x),
+                points: reversePoints,
+                wallId: wall.id,
+                face: 'back',
+            });
+            graph.get(fromKey)?.outgoing.push(forwardId);
+            graph.get(toKey)?.outgoing.push(reverseId);
         });
-        halfEdges.set(reverseId, {
-            id: reverseId,
-            reverseId: forwardId,
-            fromKey: endKey,
-            toKey: startKey,
-            angle: Math.atan2(reverseDirection.tangent.y, reverseDirection.tangent.x),
-            points: getDirectedWallBoundaryPoints(wall, false),
-        });
-        graph.get(startKey)?.outgoing.push(forwardId);
-        graph.get(endKey)?.outgoing.push(reverseId);
     }
     const sortedOutgoing = new Map();
     for (const [key, node] of graph.entries()) {
@@ -305,15 +443,49 @@ function extractRoomPolygons(walls) {
         const nextIdx = (idx - 1 + outgoing.length) % outgoing.length;
         return outgoing[nextIdx] ?? null;
     };
+    const splitIntoSimpleCycles = (walkEdgeIds) => {
+        const cycles = [];
+        const firstEdge = halfEdges.get(walkEdgeIds[0] ?? '');
+        if (!firstEdge)
+            return cycles;
+        const pathEdges = [];
+        const pathVertices = [firstEdge.fromKey];
+        const vertexIndex = new Map([[firstEdge.fromKey, 0]]);
+        for (const edgeId of walkEdgeIds) {
+            const edge = halfEdges.get(edgeId);
+            if (!edge || edge.fromKey !== pathVertices[pathVertices.length - 1])
+                return [];
+            pathEdges.push(edgeId);
+            const repeatedIndex = vertexIndex.get(edge.toKey);
+            if (repeatedIndex === undefined) {
+                pathVertices.push(edge.toKey);
+                vertexIndex.set(edge.toKey, pathVertices.length - 1);
+                continue;
+            }
+            const cycle = pathEdges.slice(repeatedIndex);
+            if (cycle.length >= 3)
+                cycles.push(cycle);
+            for (let index = repeatedIndex + 1; index < pathVertices.length; index += 1) {
+                vertexIndex.delete(pathVertices[index]);
+            }
+            pathVertices.length = repeatedIndex + 1;
+            pathEdges.length = repeatedIndex;
+        }
+        return pathEdges.length === 0 && pathVertices.length === 1 ? cycles : [];
+    };
     const visitedDirected = new Set();
-    const faces = [];
-    const maxSteps = Math.min(500, walls.length * 8 + 20);
+    const rooms = [];
+    // A face walk cannot revisit a half-edge, so the half-edge count bounds its
+    // length. It can revisit a vertex when dangling walls or other graph bridges
+    // are traced out and back; those excursions are removed below.
+    const maxSteps = Math.min(2000, halfEdges.size + 10);
     for (const edgeId of halfEdges.keys()) {
         if (visitedDirected.has(edgeId))
             continue;
         const cycleEdgeIds = [];
         let currentEdgeId = edgeId;
         let valid = true;
+        let closed = false;
         for (let step = 0; step < maxSteps; step += 1) {
             const currentEdge = halfEdges.get(currentEdgeId);
             if (!currentEdge) {
@@ -328,29 +500,64 @@ function extractRoomPolygons(walls) {
                 break;
             }
             currentEdgeId = next;
-            if (currentEdgeId === edgeId)
+            if (currentEdgeId === edgeId) {
+                closed = true;
                 break;
+            }
         }
-        if (!valid || cycleEdgeIds.length < 3)
-            continue;
-        const polygon = dedupeSequentialPoints(cycleEdgeIds.flatMap((id, index) => {
-            const points = halfEdges.get(id)?.points ?? [];
-            return index === cycleEdgeIds.length - 1 ? points : points.slice(0, -1);
-        }));
-        if (polygon.length < 3)
-            continue;
-        const signedArea = polygonArea(polygon);
-        if (signedArea <= 0)
+        if (!(valid && closed) || cycleEdgeIds.length < 3)
             continue;
-        if (signedArea < 0.5 || signedArea > 10_000)
-            continue;
-        const signature = polygonSignature(polygon);
-        if (faces.some((face) => polygonSignature(face) === signature))
-            continue;
-        faces.push(polygon);
+        for (const simpleCycleEdgeIds of splitIntoSimpleCycles(cycleEdgeIds)) {
+            const polygon = dedupeSequentialPoints(simpleCycleEdgeIds.flatMap((id, index) => {
+                const points = halfEdges.get(id)?.points ?? [];
+                return index === simpleCycleEdgeIds.length - 1 ? points : points.slice(0, -1);
+            }));
+            if (polygon.length < 3)
+                continue;
+            const signedArea = polygonArea(polygon);
+            if (signedArea <= 0)
+                continue;
+            if (signedArea < 0.5 || signedArea > 10_000)
+                continue;
+            const signature = polygonSignature(polygon);
+            if (rooms.some((room) => polygonSignature(room.polygon) === signature))
+                continue;
+            rooms.push({
+                polygon,
+                boundaryFaces: simpleCycleEdgeIds.flatMap((id) => {
+                    const edge = halfEdges.get(id);
+                    if (!edge)
+                        return [];
+                    return [
+                        {
+                            wallId: edge.wallId,
+                            face: edge.face,
+                            points: edge.points.map(pointToTuple),
+                        },
+                    ];
+                }),
+            });
+        }
     }
-    faces.sort((a, b) => Math.abs(polygonArea(b)) - Math.abs(polygonArea(a)));
-    return faces;
+    rooms.sort((a, b) => Math.abs(polygonArea(b.polygon)) - Math.abs(polygonArea(a.polygon)));
+    return rooms;
+}
+function extractRoomPolygons(walls) {
+    return extractRooms(walls).map((room) => room.polygon);
+}
+/**
+ * True when `wall` lies on the boundary of a room enclosed by `walls`, using the
+ * same planar room graph the auto slab/ceiling sync uses. The wall builder's
+ * "Room (auto-close)" mode calls this so drafting stops the moment a segment
+ * closes a room — whether the chain loops back to its own start or seals a bay
+ * against the middle of an existing wall (a T-junction). Sharing one graph means
+ * auto-close and auto-slab detection can never disagree about what is "closed".
+ */
+export function wallClosesRoom(walls, wall) {
+    const roomPolygons = extractRoomPolygons(walls);
+    if (roomPolygons.length === 0)
+        return false;
+    return roomPolygons.some((polygon) => wallBoundsRoom(wall, polygon));
 }
 export function resolveWallSurfaceSides(wall, roomPolygons) {
     if (roomPolygons.length === 0) {
@@ -416,62 +623,147 @@ function wallGeometrySignature(wall) {
         wall.end[0].toFixed(4),
         wall.end[1].toFixed(4),
         (wall.thickness ?? 0.2).toFixed(4),
-        (wall.height ?? DEFAULT_AUTO_CEILING_HEIGHT).toFixed(4),
+        // Plane-bound (no stored height) is a distinct state, not a default
+        // value: it resolves to the storey plane, so it must not alias an
+        // explicit height of the same magnitude in the trigger signature.
+        wall.height == null ? 'plane' : wall.height.toFixed(4),
+        wall.supportSlabId ?? 'elected',
+        (wall.supportOffset ?? 0).toFixed(4),
         getClampedWallCurveOffset(wall).toFixed(4),
     ].join('|');
 }
 function levelWallSnapshot(walls) {
     return walls.map(wallGeometrySignature).sort().join('||');
 }
-function slabGeometrySignature(slab) {
-    const polygon = slab.polygon
-        .map((point) => `${point[0].toFixed(4)},${point[1].toFixed(4)}`)
-        .join(';');
-    const holes = (slab.holes ?? [])
-        .map((hole) => hole.map((point) => `${point[0].toFixed(4)},${point[1].toFixed(4)}`).join(';'))
-        .join('/');
-    return [slab.id, (slab.elevation ?? DEFAULT_AUTO_SLAB_ELEVATION).toFixed(4), polygon, holes].join('|');
-}
-function levelSlabSnapshot(slabs) {
-    return slabs.map(slabGeometrySignature).sort().join('||');
+function zoneGeometrySignature(zone) {
+    return [
+        zone.id,
+        zone.autoFromWalls ? 'auto' : 'manual',
+        zone.boundaryWallIds.slice().sort().join(','),
+        zone.polygon.map(([x, z]) => `${x.toFixed(4)},${z.toFixed(4)}`).join(';'),
+    ].join('|');
 }
+// Slab/ceiling POLYGONS stay out of the trigger signature: including
+// generated footprints caused delete/recreate feedback. Zones are included
+// only so a newly traced room footprint can adopt its enclosing walls
+// without waiting for the next remodel. Slab ELEVATIONS and the level's
+// stored storey height ARE included — both feed the explicit-ceiling
+// re-clamp bound (the storey plane), and neither is rewritten by
+// the sync, so regeneration triggers when they change without feedback.
+// Stage 3-B adds the LEVEL-ABOVE's covering-slab undersides (elevation −
+// thickness, recessed pools excluded): a deck created, lowered, or
+// thickened above must re-run the sync below so ceilings re-clamp under
+// it. Same polygon exclusion applies — the level-above's own auto sync
+// rewrites its slab footprints, and hashing them here would re-trigger
+// this level on every remodel above.
 function levelStructureSnapshots(nodes) {
-    const byLevel = new Map();
-    const getEntry = (levelId) => {
-        const entry = byLevel.get(levelId) ?? { walls: [], slabs: [] };
-        byLevel.set(levelId, entry);
-        return entry;
-    };
+    const wallsByLevel = new Map();
+    const zonesByLevel = new Map();
+    const slabElevationsByLevel = new Map();
+    const coveringUndersidesByLevel = new Map();
     for (const node of Object.values(nodes)) {
         if (!(node && typeof node === 'object' && 'parentId' in node && node.parentId))
             continue;
+        const levelId = node.parentId;
         if (node.type === 'wall') {
-            getEntry(node.parentId).walls.push(node);
+            const walls = wallsByLevel.get(levelId) ?? [];
+            walls.push(node);
+            wallsByLevel.set(levelId, walls);
+        }
+        else if (node.type === 'zone') {
+            const zones = zonesByLevel.get(levelId) ?? [];
+            zones.push(ZoneNode.parse(node));
+            zonesByLevel.set(levelId, zones);
         }
         else if (node.type === 'slab') {
-            getEntry(node.parentId).slabs.push(SlabNode.parse(node));
+            const elevations = slabElevationsByLevel.get(levelId) ?? [];
+            elevations.push(`${node.id}:${(node.elevation ?? DEFAULT_AUTO_SLAB_ELEVATION).toFixed(4)}`);
+            slabElevationsByLevel.set(levelId, elevations);
+            if (node.recessed !== true) {
+                const undersides = coveringUndersidesByLevel.get(levelId) ?? [];
+                const elevation = node.elevation ?? 0.05;
+                const thickness = node.thickness ?? 0.05;
+                undersides.push(`${node.id}:${(elevation - thickness).toFixed(4)}`);
+                coveringUndersidesByLevel.set(levelId, undersides);
+            }
         }
     }
+    const levelElevations = getLevelElevations(nodes);
     const snapshots = new Map();
-    for (const [levelId, entry] of byLevel.entries()) {
-        snapshots.set(levelId, `${levelWallSnapshot(entry.walls)}##${levelSlabSnapshot(entry.slabs)}`);
+    const levelIds = new Set([...wallsByLevel.keys(), ...zonesByLevel.keys()]);
+    for (const levelId of levelIds) {
+        const walls = wallsByLevel.get(levelId) ?? [];
+        const zones = zonesByLevel.get(levelId) ?? [];
+        const level = nodes[levelId];
+        const storeyKey = level?.type === 'level' && typeof level.height === 'number' ? level.height.toFixed(4) : '';
+        const slabKey = (slabElevationsByLevel.get(levelId) ?? []).sort().join(';');
+        const aboveId = findLevelAboveId(levelId, levelElevations);
+        const aboveSlabKey = aboveId
+            ? (coveringUndersidesByLevel.get(aboveId) ?? []).sort().join(';')
+            : '';
+        snapshots.set(levelId, `${storeyKey}#${levelWallSnapshot(walls)}##${zones.map(zoneGeometrySignature).sort().join('||')}##${slabKey}##${aboveSlabKey}`);
     }
     return snapshots;
 }
-function buildSpace(levelId, polygon) {
-    const signature = polygonSignature(polygon);
+function buildSpace(levelId, room) {
+    const signature = polygonSignature(room.polygon);
     return {
         id: `space-${levelId}-${signature.slice(0, 12)}`,
         levelId,
-        polygon: polygon.map(pointToTuple),
-        wallIds: [],
+        polygon: room.polygon.map(pointToTuple),
+        wallIds: [...new Set(room.boundaryFaces.map((boundary) => boundary.wallId))],
+        boundaryFaces: room.boundaryFaces,
         isExterior: false,
     };
 }
-export function planAutoSlabsForLevel(roomPolygons, existingSlabs) {
+function sameStringSet(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const right = new Set(b);
+    return a.every((value) => right.has(value));
+}
+export function planAutoZonesForLevel(spaces, existingZones) {
+    const update = [];
+    for (const zone of existingZones) {
+        const storedSignature = polygonSignature(zone.polygon.map(pointFromTuple));
+        const matchingSpace = zone.autoFromWalls && zone.boundaryWallIds.length >= 3
+            ? spaces.find((space) => sameStringSet(space.wallIds, zone.boundaryWallIds))
+            : spaces.find((space) => polygonSignature(space.polygon.map(pointFromTuple)) === storedSignature);
+        if (!matchingSpace)
+            continue;
+        const data = {};
+        if (!zone.autoFromWalls)
+            data.autoFromWalls = true;
+        if (!sameStringSet(zone.boundaryWallIds, matchingSpace.wallIds)) {
+            data.boundaryWallIds = matchingSpace.wallIds;
+        }
+        if (!sameTuplePolygon(zone.polygon, matchingSpace.polygon)) {
+            data.polygon = matchingSpace.polygon;
+        }
+        if (Object.keys(data).length > 0)
+            update.push({ id: zone.id, data });
+    }
+    return { update };
+}
+export function resolveAutoZonePolygon(zone, resolve) {
+    if (!zone.autoFromWalls || zone.boundaryWallIds.length < 3)
+        return zone.polygon;
+    const walls = zone.boundaryWallIds.flatMap((id) => {
+        const node = resolve(id);
+        return node && typeof node === 'object' && 'type' in node && node.type === 'wall'
+            ? [node]
+            : [];
+    });
+    if (walls.length !== zone.boundaryWallIds.length)
+        return zone.polygon;
+    const room = extractRooms(walls).find((candidate) => sameStringSet([...new Set(candidate.boundaryFaces.map((boundary) => boundary.wallId))], zone.boundaryWallIds));
+    return room ? room.polygon.map(pointToTuple) : zone.polygon;
+}
+export function planAutoSlabsForLevel(roomPolygons, existingSlabs, context = {}) {
     const manualSlabs = existingSlabs.filter((slab) => !slab.autoFromWalls);
     const manualSignatures = new Set(manualSlabs.map((slab) => polygonSignature(slab.polygon.map(pointFromTuple))));
-    const detected = roomPolygons
+    const manualPolygons = manualSlabs.map((slab) => slab.polygon.map(pointFromTuple));
+    const detectedAll = roomPolygons
         .map((poly) => ({
         poly: simplifyClosedPolygon(poly.map(pointToTuple), AUTO_SLAB_POLYGON_SIMPLIFY_TOLERANCE).map(pointFromTuple),
         sig: '',
@@ -485,8 +777,8 @@ export function planAutoSlabsForLevel(roomPolygons, existingSlabs) {
         centroid: polygonCentroid(room.poly),
         area: Math.abs(polygonArea(room.poly)),
         bbox: bboxOf(room.poly),
-    }))
-        .filter(({ sig }) => !manualSignatures.has(sig));
+    }));
+    const detected = detectedAll.filter(({ sig, poly }) => !manualSignatures.has(sig) && !matchesManualFootprint(poly, manualPolygons));
     const existingAuto = existingSlabs.filter((slab) => slab.autoFromWalls);
     const existingAutoMeta = existingAuto.map((slab) => {
         const poly = slab.polygon.map(pointFromTuple);
@@ -503,15 +795,21 @@ export function planAutoSlabsForLevel(roomPolygons, existingSlabs) {
     const updatesById = new Map();
     const autoBySignature = new Map();
     for (const entry of existingAutoMeta) {
-        autoBySignature.set(entry.sig, entry);
+        const bucket = autoBySignature.get(entry.sig) ?? [];
+        bucket.push(entry);
+        autoBySignature.set(entry.sig, bucket);
     }
     detected.forEach((room, index) => {
-        const existing = autoBySignature.get(room.sig);
+        const existing = autoBySignature.get(room.sig)?.shift();
         if (!existing)
             return;
         matchedDetectedIdx.add(index);
         matchedSlabIds.add(existing.slab.id);
-        updatesById.set(existing.slab.id, room.poly.map(pointToTuple));
+        const polygon = room.poly.map(pointToTuple);
+        updatesById.set(existing.slab.id, {
+            polygon,
+            elevation: context.elevationForRoom?.(polygon),
+        });
     });
     const remainingDetected = detected
         .map((room, index) => ({ room, index }))
@@ -540,19 +838,46 @@ export function planAutoSlabsForLevel(roomPolygons, existingSlabs) {
             continue;
         matchedDetectedIdx.add(index);
         matchedSlabIds.add(bestMatch.entry.slab.id);
-        updatesById.set(bestMatch.entry.slab.id, room.poly.map(pointToTuple));
-    }
-    const slabsToDelete = existingAuto
-        .filter((slab) => !updatesById.has(slab.id))
-        .map((slab) => slab.id);
-    const slabsToUpdate = existingAuto
-        .filter((slab) => updatesById.has(slab.id))
-        .flatMap((slab) => {
-        const polygon = updatesById.get(slab.id);
-        if (!polygon)
-            return [];
-        return sameTuplePolygon(slab.polygon, polygon) ? [] : [{ id: slab.id, data: { polygon } }];
-    });
+        const polygon = room.poly.map(pointToTuple);
+        updatesById.set(bestMatch.entry.slab.id, {
+            polygon,
+            elevation: context.elevationForRoom?.(polygon),
+        });
+    }
+    const detectedRoomPolygons = detectedAll.map((room) => room.poly);
+    const slabsToDelete = [];
+    const slabDemotions = [];
+    for (const slab of existingAuto) {
+        if (updatesById.has(slab.id))
+            continue;
+        const coverage = polygonCoverageRatio(slab.polygon.map(pointFromTuple), detectedRoomPolygons);
+        if (coverage >= ORPHAN_MERGE_COVERAGE_THRESHOLD) {
+            slabsToDelete.push(slab.id);
+        }
+        else {
+            // Render offsets derive from level context at geometry build time, so
+            // demotion leaves the stored polygon untouched (same as ceilings).
+            slabDemotions.push({ id: slab.id, data: { autoFromWalls: false } });
+        }
+    }
+    const slabsToUpdate = [
+        ...existingAuto
+            .filter((slab) => updatesById.has(slab.id))
+            .flatMap((slab) => {
+            const update = updatesById.get(slab.id);
+            if (!update)
+                return [];
+            const data = {};
+            if (!sameTuplePolygon(slab.polygon, update.polygon))
+                data.polygon = update.polygon;
+            if (update.elevation !== undefined &&
+                Math.abs(slab.elevation - update.elevation) > ROOM_VERTICAL_PLANE_EPSILON) {
+                data.elevation = update.elevation;
+            }
+            return Object.keys(data).length > 0 ? [{ id: slab.id, data }] : [];
+        }),
+        ...slabDemotions,
+    ];
     const plannedSlabsForNaming = [...existingSlabs];
     const slabsToCreate = [];
     for (let index = 0; index < detected.length; index += 1) {
@@ -563,11 +888,15 @@ export function planAutoSlabsForLevel(roomPolygons, existingSlabs) {
             continue;
         const name = nextAutoRoomName(plannedSlabsForNaming, 'Slab');
         plannedSlabsForNaming.push({ name });
+        const polygon = room.poly.map(pointToTuple);
+        const elevation = context.elevationForRoom?.(polygon);
         slabsToCreate.push(SlabNode.parse({
             name,
-            polygon: room.poly.map(pointToTuple),
+            polygon,
             holes: [],
-            elevation: DEFAULT_AUTO_SLAB_ELEVATION,
+            elevation: elevation !== undefined && Number.isFinite(elevation)
+                ? elevation
+                : DEFAULT_AUTO_SLAB_ELEVATION,
             autoFromWalls: true,
         }));
     }
@@ -577,8 +906,8 @@ export function planAutoSlabsForLevel(roomPolygons, existingSlabs) {
         delete: slabsToDelete,
     };
 }
-function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore) {
-    const plan = planAutoSlabsForLevel(roomPolygons, existingSlabs);
+function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore, context = {}) {
+    const plan = planAutoSlabsForLevel(roomPolygons, existingSlabs, context);
     if (plan.delete.length > 0) {
         sceneStore.getState().deleteNodes(plan.delete);
     }
@@ -590,26 +919,11 @@ function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore)
     }
     return plan;
 }
-export function projectAutoSlabsForPlan(existingSlabs, plan) {
-    const slabsById = new Map(existingSlabs.map((slab) => [slab.id, slab]));
-    for (const id of plan.delete) {
-        slabsById.delete(id);
-    }
-    for (const update of plan.update) {
-        const slab = slabsById.get(update.id);
-        if (!slab)
-            continue;
-        slabsById.set(update.id, SlabNode.parse({ ...slab, ...update.data }));
-    }
-    for (const slab of plan.create) {
-        slabsById.set(slab.id, slab);
-    }
-    return [...slabsById.values()];
-}
 export function planAutoCeilingsForLevel(roomPolygons, existingCeilings, context = {}) {
     const manualCeilings = existingCeilings.filter((ceiling) => !ceiling.autoFromWalls);
     const manualSignatures = new Set(manualCeilings.map((ceiling) => polygonSignature(ceiling.polygon.map(pointFromTuple))));
-    const detected = roomPolygons
+    const manualPolygons = manualCeilings.map((ceiling) => ceiling.polygon.map(pointFromTuple));
+    const detectedAll = roomPolygons
         .map((poly) => ({
         poly: simplifyClosedPolygon(poly.map(pointToTuple), AUTO_SLAB_POLYGON_SIMPLIFY_TOLERANCE).map(pointFromTuple),
         sig: '',
@@ -623,9 +937,8 @@ export function planAutoCeilingsForLevel(roomPolygons, existingCeilings, context
         centroid: polygonCentroid(room.poly),
         area: Math.abs(polygonArea(room.poly)),
         bbox: bboxOf(room.poly),
-        ceilingHeight: resolveAutoCeilingHeight(room.poly, context),
-    }))
-        .filter(({ sig }) => !manualSignatures.has(sig));
+    }));
+    const detected = detectedAll.filter(({ sig, poly }) => !manualSignatures.has(sig) && !matchesManualFootprint(poly, manualPolygons));
     const existingAuto = existingCeilings.filter((ceiling) => ceiling.autoFromWalls);
     const existingAutoMeta = existingAuto.map((ceiling) => {
         const poly = ceiling.polygon.map(pointFromTuple);
@@ -642,17 +955,20 @@ export function planAutoCeilingsForLevel(roomPolygons, existingCeilings, context
     const updatesById = new Map();
     const autoBySignature = new Map();
     for (const entry of existingAutoMeta) {
-        autoBySignature.set(entry.sig, entry);
+        const bucket = autoBySignature.get(entry.sig) ?? [];
+        bucket.push(entry);
+        autoBySignature.set(entry.sig, bucket);
     }
     detected.forEach((room, index) => {
-        const existing = autoBySignature.get(room.sig);
+        const existing = autoBySignature.get(room.sig)?.shift();
         if (!existing)
             return;
         matchedDetectedIdx.add(index);
         matchedCeilingIds.add(existing.ceiling.id);
+        const polygon = room.poly.map(pointToTuple);
         updatesById.set(existing.ceiling.id, {
-            polygon: room.poly.map(pointToTuple),
-            height: room.ceilingHeight,
+            polygon,
+            height: context.heightForRoom?.(polygon),
         });
     });
     const remainingDetected = detected
@@ -682,30 +998,64 @@ export function planAutoCeilingsForLevel(roomPolygons, existingCeilings, context
             continue;
         matchedDetectedIdx.add(index);
         matchedCeilingIds.add(bestMatch.entry.ceiling.id);
+        const polygon = room.poly.map(pointToTuple);
         updatesById.set(bestMatch.entry.ceiling.id, {
-            polygon: room.poly.map(pointToTuple),
-            height: room.ceilingHeight,
+            polygon,
+            height: context.heightForRoom?.(polygon),
         });
     }
-    const ceilingsToDelete = existingAuto
-        .filter((ceiling) => !updatesById.has(ceiling.id))
-        .map((ceiling) => ceiling.id);
-    const ceilingsToUpdate = existingAuto
-        .filter((ceiling) => updatesById.has(ceiling.id))
-        .flatMap((ceiling) => {
-        const update = updatesById.get(ceiling.id);
-        if (!update)
-            return [];
-        const data = {};
-        if (!sameTuplePolygon(ceiling.polygon, update.polygon)) {
-            data.polygon = update.polygon;
+    const detectedRoomPolygons = detectedAll.map((room) => room.poly);
+    const ceilingsToDelete = [];
+    const ceilingDemotions = [];
+    for (const ceiling of existingAuto) {
+        if (updatesById.has(ceiling.id))
+            continue;
+        const coverage = polygonCoverageRatio(ceiling.polygon.map(pointFromTuple), detectedRoomPolygons);
+        if (coverage >= ORPHAN_MERGE_COVERAGE_THRESHOLD) {
+            ceilingsToDelete.push(ceiling.id);
         }
-        if (Math.abs((ceiling.height ?? DEFAULT_AUTO_CEILING_HEIGHT) - update.height) >
-            CEILING_HEIGHT_EPSILON) {
-            data.height = update.height;
+        else {
+            ceilingDemotions.push({ id: ceiling.id, data: { autoFromWalls: false } });
         }
-        return Object.keys(data).length === 0 ? [] : [{ id: ceiling.id, data }];
+    }
+    // Stage 3-B reactive re-clamp (clamp-never-ask): a covering slab
+    // created, moved, or thickened on the level above can leave an EXISTING
+    // manual explicit-height ceiling poking into its solid. Clamp explicit
+    // heights down to the bound; never raise them — a user-lowered ceiling
+    // is intent, only an over-bound one is a conflict. Follows-mode
+    // ceilings (absent height) derive under the bound by construction and
+    // are skipped, so the clamp can never convert one to an explicit
+    // height.
+    const manualClamps = manualCeilings.flatMap((ceiling) => {
+        if (ceiling.height == null)
+            return [];
+        const bound = resolveCeilingClampBound(ceiling.polygon, context);
+        if (!Number.isFinite(bound))
+            return [];
+        return ceiling.height > bound + CEILING_HEIGHT_EPSILON
+            ? [{ id: ceiling.id, data: { height: bound } }]
+            : [];
     });
+    const ceilingsToUpdate = [
+        ...existingAuto
+            .filter((ceiling) => updatesById.has(ceiling.id))
+            .flatMap((ceiling) => {
+            const update = updatesById.get(ceiling.id);
+            if (!update)
+                return [];
+            const data = {};
+            if (!sameTuplePolygon(ceiling.polygon, update.polygon))
+                data.polygon = update.polygon;
+            if (update.height !== undefined &&
+                (ceiling.height === undefined ||
+                    Math.abs(ceiling.height - update.height) > ROOM_VERTICAL_PLANE_EPSILON)) {
+                data.height = update.height;
+            }
+            return Object.keys(data).length > 0 ? [{ id: ceiling.id, data }] : [];
+        }),
+        ...ceilingDemotions,
+        ...manualClamps,
+    ];
     const plannedCeilingsForNaming = [...existingCeilings];
     const ceilingsToCreate = [];
     for (let index = 0; index < detected.length; index += 1) {
@@ -716,11 +1066,13 @@ export function planAutoCeilingsForLevel(roomPolygons, existingCeilings, context
             continue;
         const name = nextAutoRoomName(plannedCeilingsForNaming, 'Ceiling');
         plannedCeilingsForNaming.push({ name });
+        const polygon = room.poly.map(pointToTuple);
+        const height = context.heightForRoom?.(polygon);
         ceilingsToCreate.push(CeilingNode.parse({
             name,
-            polygon: room.poly.map(pointToTuple),
+            polygon,
             holes: [],
-            height: room.ceilingHeight,
+            ...(height !== undefined && Number.isFinite(height) ? { height } : {}),
             autoFromWalls: true,
         }));
     }
@@ -743,14 +1095,15 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
     }
 }
 function detectSpacesFromWalls(levelId, walls) {
-    const roomPolygons = extractRoomPolygons(walls);
+    const rooms = extractRooms(walls);
+    const roomPolygons = rooms.map((room) => room.polygon);
     const wallUpdates = walls.map((wall) => ({
         wallId: wall.id,
         ...resolveWallSurfaceSides(wall, roomPolygons),
     }));
     return {
         roomPolygons,
-        spaces: roomPolygons.map((polygon) => buildSpace(levelId, polygon)),
+        spaces: rooms.map((room) => buildSpace(levelId, room)),
         wallUpdates,
     };
 }
@@ -770,6 +1123,7 @@ function runSpaceDetection(levelIds, sceneStore, editorStore, nodes) {
         const walls = Object.values(nodes).filter((node) => node?.type === 'wall' && node.parentId === levelId);
         const slabs = Object.values(nodes).filter((node) => node?.type === 'slab' && node.parentId === levelId);
         const ceilings = Object.values(nodes).filter((node) => node?.type === 'ceiling' && node.parentId === levelId);
+        const zones = Object.values(nodes).filter((node) => node?.type === 'zone' && node.parentId === levelId);
         const { wallUpdates, spaces, roomPolygons } = detectSpacesFromWalls(levelId, walls);
         const changedWallUpdates = wallUpdates.filter((update) => {
             const wall = nodes[update.wallId];
@@ -784,10 +1138,27 @@ function runSpaceDetection(levelIds, sceneStore, editorStore, nodes) {
                 },
             })));
         }
+        const levelNode = nodes[levelId];
+        const storeyHeight = levelNode?.type === 'level'
+            ? getStoredLevelHeight(levelNode)
+            : DEFAULT_LEVEL_HEIGHT;
         const parsedSlabs = slabs.map((slab) => SlabNode.parse(slab));
-        const slabPlan = syncAutoSlabsForLevel(levelId, roomPolygons, parsedSlabs, sceneStore);
-        const projectedSlabs = projectAutoSlabsForPlan(parsedSlabs, slabPlan);
-        syncAutoCeilingsForLevel(levelId, roomPolygons, ceilings.map((ceiling) => CeilingNode.parse(ceiling)), sceneStore, { walls, slabs: projectedSlabs });
+        const verticalPlacements = autoRoomVerticalPlacements(spaces, walls, 
+        // A derived floor cannot be evidence for its own next elevation: that
+        // would lift unpinned walls, then lift the floor again on every pass.
+        parsedSlabs.filter((slab) => !slab.autoFromWalls), nodes, storeyHeight);
+        const placementFor = (polygon) => verticalPlacements.get(polygonSignature(polygon.map(pointFromTuple)));
+        syncAutoSlabsForLevel(levelId, roomPolygons, parsedSlabs, sceneStore, {
+            elevationForRoom: (polygon) => placementFor(polygon)?.slabElevation,
+        });
+        syncAutoCeilingsForLevel(levelId, roomPolygons, ceilings.map((ceiling) => CeilingNode.parse(ceiling)), sceneStore, {
+            storeyHeight,
+            ceilingClampBound: (polygon) => getCeilingClampBound(levelId, nodes, polygon),
+            heightForRoom: (polygon) => placementFor(polygon)?.ceilingHeight,
+        });
+        const zonePlan = planAutoZonesForLevel(spaces, zones.map((zone) => ZoneNode.parse(zone)));
+        if (zonePlan.update.length > 0)
+            updateNodes(zonePlan.update);
         for (const space of spaces) {
             nextSpaces[space.id] = space;
         }
@@ -815,7 +1186,11 @@ export function isSpaceDetectionPaused() {
     return spaceDetectionPauseDepth > 0;
 }
 export function initSpaceDetectionSync(sceneStore, editorStore) {
-    const previousSnapshots = new Map();
+    // Baseline from whatever is already in the store. Detection reacts to wall
+    // edits made IN-SESSION (create / move / delete); it must not re-litigate a
+    // scene that merely loaded — rerunning on hydration resurrected auto slabs
+    // the user had deleted in an earlier session.
+    const previousSnapshots = levelStructureSnapshots(sceneStore.getState().nodes);
     let isProcessing = false;
     const unsubscribe = sceneStore.subscribe((state) => {
         if (isProcessing)
@@ -836,7 +1211,14 @@ export function initSpaceDetectionSync(sceneStore, editorStore) {
         }
         const levelsToUpdate = new Set();
         for (const levelId of new Set([...previousSnapshots.keys(), ...currentSnapshots.keys()])) {
-            if ((previousSnapshots.get(levelId) ?? '') !== (currentSnapshots.get(levelId) ?? '')) {
+            // First sight of a level is a hydration baseline, not a wall edit —
+            // `setScene` delivers a loaded scene as one atomic update, and a level's
+            // first wall can't close a room anyway. Record it (below) and only
+            // react to subsequent changes.
+            const previous = previousSnapshots.get(levelId);
+            if (previous === undefined)
+                continue;
+            if (previous !== (currentSnapshots.get(levelId) ?? '')) {
                 levelsToUpdate.add(levelId);
             }
         }