@pascal-app/core 0.8.0 → 0.9.2

package/dist/lib/space-detection.js

@@ -1,12 +1,24 @@
-import { CeilingNode, SlabNode, } from '../schema';
+import { CeilingNode, SlabNode, ZoneNode, } from '../schema';
 import { getSceneHistoryPauseDepth, pauseSceneHistory, resumeSceneHistory, } from '../store/history-control';
 import { getClampedWallCurveOffset, getWallCurveFrameAt, isCurvedWall, } from '../systems/wall/wall-curve';
 import { simplifyClosedPolygon } from './polygon-geometry';
 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;
 function pointFromTuple(point) {
     return { x: point[0], y: point[1] };
 }
@@ -114,6 +126,120 @@ 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) {
+        const start = polygon[index];
+        const end = polygon[(index + 1) % polygon.length];
+        if (!(start && end))
+            continue;
+        minDistance = Math.min(minDistance, distanceToSegment(pointToTuple(point), pointToTuple(start), pointToTuple(end)));
+    }
+    return minDistance;
+}
+function wallBoundsRoom(wall, roomPolygon) {
+    const sampled = sampleWallPointsForRoomDetection(wall);
+    if (sampled.length === 0)
+        return false;
+    const candidates = sampled.length === 2
+        ? [
+            sampled[0],
+            {
+                x: (sampled[0].x + sampled[1].x) / 2,
+                y: (sampled[0].y + sampled[1].y) / 2,
+            },
+            sampled[1],
+        ]
+        : sampled;
+    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;
+}
+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 resolveRoomSlabElevation(roomPolygon, slabs = []) {
+    let maxElevation = 0;
+    for (const slab of slabs) {
+        if (!slabSupportsRoom(roomPolygon, slab))
+            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))
+            continue;
+        const height = wall.height ?? DEFAULT_AUTO_CEILING_HEIGHT;
+        if (Number.isFinite(height)) {
+            maxHeight = Math.max(maxHeight, height);
+        }
+    }
+    return maxHeight > 0 ? maxHeight : DEFAULT_AUTO_CEILING_HEIGHT;
+}
+function resolveAutoCeilingHeight(roomPolygon, context = {}) {
+    return (resolveRoomSlabElevation(roomPolygon, context.slabs) +
+        resolveRoomWallHeight(roomPolygon, context.walls));
+}
 function getWallDirection(wall) {
     const dx = wall.end[0] - wall.start[0];
     const dy = wall.end[1] - wall.start[1];
@@ -164,11 +290,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();
@@ -180,35 +347,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),
-        });
-        halfEdges.set(reverseId, {
-            id: reverseId,
-            reverseId: forwardId,
-            fromKey: endKey,
-            toKey: startKey,
-            angle: Math.atan2(reverseDirection.tangent.y, reverseDirection.tangent.x),
-            points: getDirectedWallBoundaryPoints(wall, false),
+        // 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);
         });
-        graph.get(startKey)?.outgoing.push(forwardId);
-        graph.get(endKey)?.outgoing.push(reverseId);
     }
     const sortedOutgoing = new Map();
     for (const [key, node] of graph.entries()) {
@@ -229,15 +432,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) {
@@ -252,29 +489,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)
+        if (!(valid && closed) || cycleEdgeIds.length < 3)
             continue;
-        const signedArea = polygonArea(polygon);
-        if (signedArea <= 0)
-            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) {
@@ -340,26 +612,111 @@ 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),
         getClampedWallCurveOffset(wall).toFixed(4),
     ].join('|');
 }
 function levelWallSnapshot(walls) {
     return walls.map(wallGeometrySignature).sort().join('||');
 }
-function buildSpace(levelId, polygon) {
-    const signature = polygonSignature(polygon);
+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('|');
+}
+// Slabs and ceilings stay out of the trigger signature: including generated
+// surfaces 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.
+function levelStructureSnapshots(nodes) {
+    const wallsByLevel = new Map();
+    const zonesByLevel = 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') {
+            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);
+        }
+    }
+    const snapshots = new Map();
+    const levelIds = new Set([...wallsByLevel.keys(), ...zonesByLevel.keys()]);
+    for (const levelId of levelIds) {
+        const walls = wallsByLevel.get(levelId) ?? [];
+        const zones = zonesByLevel.get(levelId) ?? [];
+        snapshots.set(levelId, `${levelWallSnapshot(walls)}##${zones.map(zoneGeometrySignature).sort().join('||')}`);
+    }
+    return snapshots;
+}
+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,
     };
 }
-function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore) {
+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) {
     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: '',
@@ -373,8 +730,8 @@ function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore)
         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);
@@ -391,10 +748,12 @@ function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore)
     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);
@@ -430,17 +789,33 @@ function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore)
         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 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 polygon = updatesById.get(slab.id);
+            if (!polygon)
+                return [];
+            return sameTuplePolygon(slab.polygon, polygon) ? [] : [{ id: slab.id, data: { polygon } }];
+        }),
+        ...slabDemotions,
+    ];
     const plannedSlabsForNaming = [...existingSlabs];
     const slabsToCreate = [];
     for (let index = 0; index < detected.length; index += 1) {
@@ -459,20 +834,46 @@ function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore)
             autoFromWalls: true,
         }));
     }
-    if (slabsToDelete.length > 0) {
-        sceneStore.getState().deleteNodes(slabsToDelete);
+    return {
+        create: slabsToCreate,
+        update: slabsToUpdate,
+        delete: slabsToDelete,
+    };
+}
+function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore) {
+    const plan = planAutoSlabsForLevel(roomPolygons, existingSlabs);
+    if (plan.delete.length > 0) {
+        sceneStore.getState().deleteNodes(plan.delete);
     }
-    if (slabsToUpdate.length > 0) {
-        sceneStore.getState().updateNodes(slabsToUpdate);
+    if (plan.update.length > 0) {
+        sceneStore.getState().updateNodes(plan.update);
     }
-    if (slabsToCreate.length > 0) {
-        sceneStore.getState().createNodes(slabsToCreate.map((node) => ({ node, parentId: levelId })));
+    if (plan.create.length > 0) {
+        sceneStore.getState().createNodes(plan.create.map((node) => ({ node, parentId: levelId })));
     }
+    return plan;
 }
-function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, sceneStore) {
+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: '',
@@ -486,8 +887,9 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
         centroid: polygonCentroid(room.poly),
         area: Math.abs(polygonArea(room.poly)),
         bbox: bboxOf(room.poly),
-    }))
-        .filter(({ sig }) => !manualSignatures.has(sig));
+        ceilingHeight: resolveAutoCeilingHeight(room.poly, context),
+    }));
+    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);
@@ -504,15 +906,20 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
     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);
-        updatesById.set(existing.ceiling.id, room.poly.map(pointToTuple));
+        updatesById.set(existing.ceiling.id, {
+            polygon: room.poly.map(pointToTuple),
+            height: room.ceilingHeight,
+        });
     });
     const remainingDetected = detected
         .map((room, index) => ({ room, index }))
@@ -541,21 +948,44 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
             continue;
         matchedDetectedIdx.add(index);
         matchedCeilingIds.add(bestMatch.entry.ceiling.id);
-        updatesById.set(bestMatch.entry.ceiling.id, room.poly.map(pointToTuple));
-    }
-    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 polygon = updatesById.get(ceiling.id);
-        if (!polygon)
-            return [];
-        return sameTuplePolygon(ceiling.polygon, polygon)
-            ? []
-            : [{ id: ceiling.id, data: { polygon } }];
-    });
+        updatesById.set(bestMatch.entry.ceiling.id, {
+            polygon: room.poly.map(pointToTuple),
+            height: room.ceilingHeight,
+        });
+    }
+    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);
+        }
+        else {
+            ceilingDemotions.push({ id: ceiling.id, data: { autoFromWalls: false } });
+        }
+    }
+    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 (Math.abs((ceiling.height ?? DEFAULT_AUTO_CEILING_HEIGHT) - update.height) >
+                CEILING_HEIGHT_EPSILON) {
+                data.height = update.height;
+            }
+            return Object.keys(data).length === 0 ? [] : [{ id: ceiling.id, data }];
+        }),
+        ...ceilingDemotions,
+    ];
     const plannedCeilingsForNaming = [...existingCeilings];
     const ceilingsToCreate = [];
     for (let index = 0; index < detected.length; index += 1) {
@@ -570,29 +1000,38 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
             name,
             polygon: room.poly.map(pointToTuple),
             holes: [],
-            height: DEFAULT_AUTO_CEILING_HEIGHT,
+            height: room.ceilingHeight,
             autoFromWalls: true,
         }));
     }
-    if (ceilingsToDelete.length > 0) {
-        sceneStore.getState().deleteNodes(ceilingsToDelete);
+    return {
+        create: ceilingsToCreate,
+        update: ceilingsToUpdate,
+        delete: ceilingsToDelete,
+    };
+}
+function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, sceneStore, context = {}) {
+    const plan = planAutoCeilingsForLevel(roomPolygons, existingCeilings, context);
+    if (plan.delete.length > 0) {
+        sceneStore.getState().deleteNodes(plan.delete);
     }
-    if (ceilingsToUpdate.length > 0) {
-        sceneStore.getState().updateNodes(ceilingsToUpdate);
+    if (plan.update.length > 0) {
+        sceneStore.getState().updateNodes(plan.update);
     }
-    if (ceilingsToCreate.length > 0) {
-        sceneStore.getState().createNodes(ceilingsToCreate.map((node) => ({ node, parentId: levelId })));
+    if (plan.create.length > 0) {
+        sceneStore.getState().createNodes(plan.create.map((node) => ({ node, parentId: levelId })));
     }
 }
 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,
     };
 }
@@ -612,6 +1051,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];
@@ -626,16 +1066,45 @@ function runSpaceDetection(levelIds, sceneStore, editorStore, nodes) {
                 },
             })));
         }
-        syncAutoSlabsForLevel(levelId, roomPolygons, slabs.map((slab) => SlabNode.parse(slab)), sceneStore);
-        syncAutoCeilingsForLevel(levelId, roomPolygons, ceilings.map((ceiling) => CeilingNode.parse(ceiling)), sceneStore);
+        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 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;
         }
     }
     editorStore.getState().setSpaces(nextSpaces);
 }
+// Refcount of outstanding pause requests, matching the pauseSceneHistory
+// pattern. The community editor flips this off while the AI is actively
+// mutating the scene so the wall-driven auto slab/ceiling sync doesn't race
+// `create_room`'s explicit slabs/ceilings (see plan
+// `ai-pause-space-detection`).
+let spaceDetectionPauseDepth = 0;
+/** Pause the wall-driven auto slab/ceiling sync. Refcounted — pair with `resumeSpaceDetection`. */
+export function pauseSpaceDetection() {
+    spaceDetectionPauseDepth += 1;
+}
+/** Resume the wall-driven auto slab/ceiling sync. No-op if not currently paused. */
+export function resumeSpaceDetection() {
+    if (spaceDetectionPauseDepth === 0)
+        return;
+    spaceDetectionPauseDepth -= 1;
+}
+/** True iff the wall-driven auto slab/ceiling sync is currently paused. */
+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)
@@ -643,22 +1112,27 @@ export function initSpaceDetectionSync(sceneStore, editorStore) {
         if (getSceneHistoryPauseDepth() > 0)
             return;
         const nodes = state.nodes;
-        const wallsByLevel = new Map();
-        for (const node of Object.values(nodes)) {
-            if (node && node.type === 'wall' && node.parentId) {
-                const levelId = node.parentId;
-                const levelWalls = wallsByLevel.get(levelId) ?? [];
-                levelWalls.push(node);
-                wallsByLevel.set(levelId, levelWalls);
+        const currentSnapshots = levelStructureSnapshots(nodes);
+        // Paused: roll the snapshot forward so we don't backfill (and re-duplicate)
+        // every paused change once detection resumes. Whatever the AI built while
+        // paused becomes the new baseline; only future changes will reconcile.
+        if (spaceDetectionPauseDepth > 0) {
+            previousSnapshots.clear();
+            for (const [levelId, snapshot] of currentSnapshots.entries()) {
+                previousSnapshots.set(levelId, snapshot);
             }
-        }
-        const currentSnapshots = new Map();
-        for (const [levelId, walls] of wallsByLevel.entries()) {
-            currentSnapshots.set(levelId, levelWallSnapshot(walls));
+            return;
         }
         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);
             }
         }
@@ -677,7 +1151,8 @@ export function initSpaceDetectionSync(sceneStore, editorStore) {
         finally {
             resumeSceneHistory(sceneStore);
             previousSnapshots.clear();
-            for (const [levelId, snapshot] of currentSnapshots.entries()) {
+            const postRunSnapshots = levelStructureSnapshots(sceneStore.getState().nodes);
+            for (const [levelId, snapshot] of postRunSnapshots.entries()) {
                 previousSnapshots.set(levelId, snapshot);
             }
             isProcessing = false;