@pascal-app/core 0.5.0 → 0.6.0

package/dist/lib/space-detection.js

@@ -1,471 +1,693 @@
-// ============================================================================
-// SYNC INITIALIZATION
-// ============================================================================
-/**
- * Initializes space detection sync with scene and editor stores
- * Call this once during app initialization
- */
-export function initSpaceDetectionSync(sceneStore, // useScene store
-editorStore) {
-    const prevWallsByLevel = new Map();
-    let isProcessing = false; // Prevent re-entrant calls
-    // Subscribe to scene changes (standard Zustand subscribe, not selector-based)
-    const unsubscribe = sceneStore.subscribe((state) => {
-        // Skip if already processing to avoid infinite loops
-        if (isProcessing)
-            return;
-        const nodes = state.nodes;
-        const currentWallsByLevel = new Map();
-        // Group walls by level
-        for (const node of Object.values(nodes)) {
-            if (node.type === 'wall' && node.parentId) {
-                const levelId = node.parentId;
-                if (!currentWallsByLevel.has(levelId)) {
-                    currentWallsByLevel.set(levelId, new Set());
-                }
-                currentWallsByLevel.get(levelId)?.add(node.id);
-            }
+import { getClampedWallCurveOffset, getWallCurveFrameAt, isCurvedWall, } from '../systems/wall/wall-curve';
+import { CeilingNode, SlabNode } from '../schema';
+import { getSceneHistoryPauseDepth, pauseSceneHistory, resumeSceneHistory, } from '../store/history-control';
+import { simplifyClosedPolygon } from './polygon-geometry';
+const DEFAULT_AUTO_SLAB_ELEVATION = 0.05;
+const DEFAULT_AUTO_CEILING_HEIGHT = 2.5;
+const ROOM_CURVE_TOLERANCE = 0.04;
+const MAX_CURVE_SUBDIVISION_DEPTH = 6;
+const AUTO_SLAB_POLYGON_SIMPLIFY_TOLERANCE = 0.08;
+function pointFromTuple(point) {
+    return { x: point[0], y: point[1] };
+}
+function pointToTuple(point) {
+    return [point.x, point.y];
+}
+function pointKey(point) {
+    return `${point.x.toFixed(3)},${point.y.toFixed(3)}`;
+}
+function polygonArea(points) {
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        if (!(a && b))
+            continue;
+        area += a.x * b.y - b.x * a.y;
+    }
+    return area / 2;
+}
+function minRotationSignature(keys) {
+    if (keys.length === 0)
+        return '';
+    let best = '';
+    for (let i = 0; i < keys.length; i++) {
+        const rotated = [...keys.slice(i), ...keys.slice(0, i)];
+        const value = rotated.join('|');
+        if (!best || value < best)
+            best = value;
+    }
+    return best;
+}
+function polygonSignature(points) {
+    const keys = points.map(pointKey);
+    const forward = minRotationSignature(keys);
+    const reversed = minRotationSignature([...keys].reverse());
+    return forward < reversed ? forward : reversed;
+}
+function samePointWithinTolerance(a, b, tolerance = 1e-4) {
+    return Math.hypot(a.x - b.x, a.y - b.y) <= tolerance;
+}
+function dedupeSequentialPoints(points, tolerance = 1e-4) {
+    const deduped = [];
+    for (const point of points) {
+        const previous = deduped[deduped.length - 1];
+        if (previous && samePointWithinTolerance(previous, point, tolerance)) {
+            continue;
         }
-        // Check each level for changes
-        const levelsToUpdate = new Set();
-        // Check for new walls (created)
-        for (const [levelId, wallIds] of currentWallsByLevel.entries()) {
-            const prevWallIds = prevWallsByLevel.get(levelId);
-            if (!prevWallIds) {
-                // New level with walls - run detection if there are multiple walls
-                if (wallIds.size > 1) {
-                    levelsToUpdate.add(levelId);
-                }
-                continue;
+        deduped.push(point);
+    }
+    const firstPoint = deduped[0];
+    const lastPoint = deduped[deduped.length - 1];
+    if (deduped.length > 2 &&
+        firstPoint &&
+        lastPoint &&
+        samePointWithinTolerance(firstPoint, lastPoint, tolerance)) {
+        deduped.pop();
+    }
+    return deduped;
+}
+function pointInPolygon(point, polygon) {
+    if (polygon.length < 3)
+        return false;
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const xi = polygon[i]?.x ?? 0;
+        const yi = polygon[i]?.y ?? 0;
+        const xj = polygon[j]?.x ?? 0;
+        const yj = polygon[j]?.y ?? 0;
+        const intersect = yi > point.y !== yj > point.y &&
+            point.x < ((xj - xi) * (point.y - yi)) / (yj - yi + 1e-12) + xi;
+        if (intersect)
+            inside = !inside;
+    }
+    return inside;
+}
+function pointInAnyPolygon(point, polygons) {
+    return polygons.some((polygon) => pointInPolygon(point, polygon));
+}
+function polygonCentroid(points) {
+    const sum = points.reduce((acc, point) => ({ x: acc.x + point.x, y: acc.y + point.y }), {
+        x: 0,
+        y: 0,
+    });
+    return {
+        x: sum.x / Math.max(points.length, 1),
+        y: sum.y / Math.max(points.length, 1),
+    };
+}
+function bboxOf(points) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const point of points) {
+        minX = Math.min(minX, point.x);
+        minY = Math.min(minY, point.y);
+        maxX = Math.max(maxX, point.x);
+        maxY = Math.max(maxY, point.y);
+    }
+    return { minX, minY, maxX, maxY };
+}
+function bboxOverlapArea(a, b) {
+    const ix = Math.max(0, Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX));
+    const iy = Math.max(0, Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY));
+    return ix * iy;
+}
+function getWallDirection(wall) {
+    const dx = wall.end[0] - wall.start[0];
+    const dy = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dy);
+    if (length < 1e-9) {
+        return {
+            point: pointFromTuple(wall.start),
+            tangent: { x: 1, y: 0 },
+            normal: { x: 0, y: 1 },
+        };
+    }
+    const tangent = { x: dx / length, y: dy / length };
+    return {
+        point: {
+            x: (wall.start[0] + wall.end[0]) / 2,
+            y: (wall.start[1] + wall.end[1]) / 2,
+        },
+        tangent,
+        normal: { x: -tangent.y, y: tangent.x },
+    };
+}
+function pointLineDistance(point, start, end) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared < 1e-9) {
+        return Math.hypot(point.x - start.x, point.y - start.y);
+    }
+    const cross = (point.x - start.x) * dy - (point.y - start.y) * dx;
+    return Math.abs(cross) / Math.sqrt(lengthSquared);
+}
+function sampleWallPointsForRoomDetection(wall, tolerance = ROOM_CURVE_TOLERANCE) {
+    const start = { x: wall.start[0], y: wall.start[1] };
+    const end = { x: wall.end[0], y: wall.end[1] };
+    if (!isCurvedWall(wall)) {
+        return [start, end];
+    }
+    const subdivide = (t0, p0, t1, p1, depth) => {
+        const midT = (t0 + t1) / 2;
+        const midPoint = getWallCurveFrameAt(wall, midT).point;
+        const deviation = pointLineDistance(midPoint, p0, p1);
+        if (depth >= MAX_CURVE_SUBDIVISION_DEPTH || deviation <= tolerance) {
+            return [p0, p1];
+        }
+        const left = subdivide(t0, p0, midT, midPoint, depth + 1);
+        const right = subdivide(midT, midPoint, t1, p1, depth + 1);
+        return [...left.slice(0, -1), ...right];
+    };
+    return subdivide(0, start, 1, end, 0);
+}
+function getDirectedWallBoundaryPoints(wall, forward) {
+    const points = sampleWallPointsForRoomDetection(wall);
+    return forward ? points : [...points].reverse();
+}
+function extractRoomPolygons(walls) {
+    if (walls.length < 3)
+        return [];
+    const graph = new Map();
+    const halfEdges = new Map();
+    const upsertNode = (point) => {
+        const key = pointKey(point);
+        if (!graph.has(key)) {
+            graph.set(key, { point: { ...point }, outgoing: [] });
+        }
+        return key;
+    };
+    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)
+            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),
+        });
+        graph.get(startKey)?.outgoing.push(forwardId);
+        graph.get(endKey)?.outgoing.push(reverseId);
+    }
+    const sortedOutgoing = new Map();
+    for (const [key, node] of graph.entries()) {
+        const outgoing = [...node.outgoing];
+        outgoing.sort((a, b) => (halfEdges.get(a)?.angle ?? 0) - (halfEdges.get(b)?.angle ?? 0));
+        sortedOutgoing.set(key, outgoing);
+    }
+    const nextEdge = (edgeId) => {
+        const edge = halfEdges.get(edgeId);
+        if (!edge)
+            return null;
+        const outgoing = sortedOutgoing.get(edge.toKey);
+        if (!outgoing || outgoing.length === 0)
+            return null;
+        const idx = outgoing.indexOf(edge.reverseId);
+        if (idx === -1)
+            return null;
+        const nextIdx = (idx - 1 + outgoing.length) % outgoing.length;
+        return outgoing[nextIdx] ?? null;
+    };
+    const visitedDirected = new Set();
+    const faces = [];
+    const maxSteps = Math.min(500, walls.length * 8 + 20);
+    for (const edgeId of halfEdges.keys()) {
+        if (visitedDirected.has(edgeId))
+            continue;
+        const cycleEdgeIds = [];
+        let currentEdgeId = edgeId;
+        let valid = true;
+        for (let step = 0; step < maxSteps; step += 1) {
+            const currentEdge = halfEdges.get(currentEdgeId);
+            if (!currentEdge) {
+                valid = false;
+                break;
             }
-            // Find newly added walls
-            for (const wallId of wallIds) {
-                if (!prevWallIds.has(wallId)) {
-                    // Wall was added - check if it touches other walls
-                    const wall = nodes[wallId];
-                    const otherWalls = Array.from(wallIds)
-                        .filter((id) => id !== wallId)
-                        .map((id) => nodes[id])
-                        .filter(Boolean);
-                    if (wallTouchesOthers(wall, otherWalls)) {
-                        levelsToUpdate.add(levelId);
-                        break;
-                    }
-                }
+            visitedDirected.add(currentEdgeId);
+            cycleEdgeIds.push(currentEdgeId);
+            const next = nextEdge(currentEdgeId);
+            if (!next) {
+                valid = false;
+                break;
             }
+            currentEdgeId = next;
+            if (currentEdgeId === edgeId)
+                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)
+            continue;
+        if (signedArea < 0.5 || signedArea > 10000)
+            continue;
+        const signature = polygonSignature(polygon);
+        if (faces.some((face) => polygonSignature(face) === signature))
+            continue;
+        faces.push(polygon);
+    }
+    faces.sort((a, b) => Math.abs(polygonArea(b)) - Math.abs(polygonArea(a)));
+    return faces;
+}
+export function resolveWallSurfaceSides(wall, roomPolygons) {
+    if (roomPolygons.length === 0) {
+        return {
+            frontSide: 'unknown',
+            backSide: 'unknown',
+        };
+    }
+    const frame = getWallDirection(wall);
+    const normalLength = Math.hypot(frame.normal.x, frame.normal.y);
+    if (normalLength < 1e-9) {
+        return {
+            frontSide: wall.frontSide,
+            backSide: wall.backSide,
+        };
+    }
+    const normalX = frame.normal.x / normalLength;
+    const normalY = frame.normal.y / normalLength;
+    const sampleDistance = Math.max((wall.thickness ?? 0.2) / 2 + 0.08, 0.16);
+    const frontPoint = {
+        x: frame.point.x + normalX * sampleDistance,
+        y: frame.point.y + normalY * sampleDistance,
+    };
+    const backPoint = {
+        x: frame.point.x - normalX * sampleDistance,
+        y: frame.point.y - normalY * sampleDistance,
+    };
+    const frontInside = pointInAnyPolygon(frontPoint, roomPolygons);
+    const backInside = pointInAnyPolygon(backPoint, roomPolygons);
+    if (frontInside === backInside) {
+        return {
+            frontSide: wall.frontSide,
+            backSide: wall.backSide,
+        };
+    }
+    return {
+        frontSide: frontInside ? 'interior' : 'exterior',
+        backSide: backInside ? 'interior' : 'exterior',
+    };
+}
+function nextAutoRoomName(nodes, suffix) {
+    let maxIndex = 0;
+    for (const node of nodes) {
+        const match = /^Room\s+(\d+)(?:\s+(?:Slab|Ceiling))?$/i.exec((node.name ?? '').trim());
+        if (!match)
+            continue;
+        const index = Number(match[1]);
+        if (Number.isFinite(index)) {
+            maxIndex = Math.max(maxIndex, index);
         }
-        // Check for deleted walls
-        for (const [levelId, prevWallIds] of prevWallsByLevel.entries()) {
-            const currentWallIds = currentWallsByLevel.get(levelId);
-            if (!currentWallIds) {
-                // All walls deleted from level - clear spaces
-                if (prevWallIds.size > 0) {
-                    levelsToUpdate.add(levelId);
-                }
+    }
+    return `Room ${maxIndex + 1} ${suffix}`;
+}
+function sameTuplePolygon(current, next) {
+    return (current.length === next.length &&
+        current.every((point, index) => point[0] === next[index]?.[0] && point[1] === next[index]?.[1]));
+}
+function wallGeometrySignature(wall) {
+    return [
+        wall.id,
+        wall.start[0].toFixed(4),
+        wall.start[1].toFixed(4),
+        wall.end[0].toFixed(4),
+        wall.end[1].toFixed(4),
+        (wall.thickness ?? 0.2).toFixed(4),
+        getClampedWallCurveOffset(wall).toFixed(4),
+    ].join('|');
+}
+function levelWallSnapshot(walls) {
+    return walls.map(wallGeometrySignature).sort().join('||');
+}
+function buildSpace(levelId, polygon) {
+    const signature = polygonSignature(polygon);
+    return {
+        id: `space-${levelId}-${signature.slice(0, 12)}`,
+        levelId,
+        polygon: polygon.map(pointToTuple),
+        wallIds: [],
+        isExterior: false,
+    };
+}
+function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore) {
+    const manualSlabs = existingSlabs.filter((slab) => !slab.autoFromWalls);
+    const manualSignatures = new Set(manualSlabs.map((slab) => polygonSignature(slab.polygon.map(pointFromTuple))));
+    const detected = roomPolygons
+        .map((poly) => ({
+        poly: simplifyClosedPolygon(poly.map(pointToTuple), AUTO_SLAB_POLYGON_SIMPLIFY_TOLERANCE).map(pointFromTuple),
+        sig: '',
+        centroid: { x: 0, y: 0 },
+        area: 0,
+        bbox: bboxOf([]),
+    }))
+        .map((room) => ({
+        ...room,
+        sig: polygonSignature(room.poly),
+        centroid: polygonCentroid(room.poly),
+        area: Math.abs(polygonArea(room.poly)),
+        bbox: bboxOf(room.poly),
+    }))
+        .filter(({ sig }) => !manualSignatures.has(sig));
+    const existingAuto = existingSlabs.filter((slab) => slab.autoFromWalls);
+    const existingAutoMeta = existingAuto.map((slab) => {
+        const poly = slab.polygon.map(pointFromTuple);
+        return {
+            slab,
+            sig: polygonSignature(poly),
+            centroid: polygonCentroid(poly),
+            area: Math.abs(polygonArea(poly)),
+            bbox: bboxOf(poly),
+        };
+    });
+    const matchedSlabIds = new Set();
+    const matchedDetectedIdx = new Set();
+    const updatesById = new Map();
+    const autoBySignature = new Map();
+    for (const entry of existingAutoMeta) {
+        autoBySignature.set(entry.sig, entry);
+    }
+    detected.forEach((room, index) => {
+        const existing = autoBySignature.get(room.sig);
+        if (!existing)
+            return;
+        matchedDetectedIdx.add(index);
+        matchedSlabIds.add(existing.slab.id);
+        updatesById.set(existing.slab.id, room.poly.map(pointToTuple));
+    });
+    const remainingDetected = detected
+        .map((room, index) => ({ room, index }))
+        .filter(({ index }) => !matchedDetectedIdx.has(index))
+        .sort((a, b) => b.room.area - a.room.area);
+    const remainingAuto = existingAutoMeta.filter((entry) => !matchedSlabIds.has(entry.slab.id));
+    for (const { room, index } of remainingDetected) {
+        let bestMatch = null;
+        for (const entry of remainingAuto) {
+            if (matchedSlabIds.has(entry.slab.id))
                 continue;
-            }
-            // Check if any walls were deleted
-            for (const wallId of prevWallIds) {
-                if (!currentWallIds.has(wallId)) {
-                    // Wall was deleted - run detection
-                    levelsToUpdate.add(levelId);
-                    break;
-                }
+            const dx = room.centroid.x - entry.centroid.x;
+            const dy = room.centroid.y - entry.centroid.y;
+            const dist = Math.hypot(dx, dy);
+            const areaRatio = entry.area > 1e-6 ? room.area / entry.area : 999;
+            const areaPenalty = Math.abs(Math.log(Math.max(1e-6, areaRatio)));
+            const overlap = bboxOverlapArea(room.bbox, entry.bbox);
+            if (overlap <= 0.0001 && dist > 1.5)
+                continue;
+            const score = dist + areaPenalty * 0.35;
+            if (!bestMatch || score < bestMatch.score) {
+                bestMatch = { entry, score };
             }
         }
-        // Run detection for affected levels
-        if (levelsToUpdate.size > 0) {
-            isProcessing = true;
-            sceneStore.temporal.getState().pause();
-            try {
-                runSpaceDetection(Array.from(levelsToUpdate), sceneStore, editorStore, nodes);
-            }
-            finally {
-                sceneStore.temporal.getState().resume();
-                isProcessing = false;
+        if (!bestMatch)
+            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 plannedSlabsForNaming = [...existingSlabs];
+    const slabsToCreate = [];
+    for (let index = 0; index < detected.length; index += 1) {
+        if (matchedDetectedIdx.has(index))
+            continue;
+        const room = detected[index];
+        if (!room)
+            continue;
+        const name = nextAutoRoomName(plannedSlabsForNaming, 'Slab');
+        plannedSlabsForNaming.push({ name });
+        slabsToCreate.push(SlabNode.parse({
+            name,
+            polygon: room.poly.map(pointToTuple),
+            holes: [],
+            elevation: DEFAULT_AUTO_SLAB_ELEVATION,
+            autoFromWalls: true,
+        }));
+    }
+    if (slabsToDelete.length > 0) {
+        sceneStore.getState().deleteNodes(slabsToDelete);
+    }
+    if (slabsToUpdate.length > 0) {
+        sceneStore.getState().updateNodes(slabsToUpdate);
+    }
+    if (slabsToCreate.length > 0) {
+        sceneStore.getState().createNodes(slabsToCreate.map((node) => ({ node, parentId: levelId })));
+    }
+}
+function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, sceneStore) {
+    const manualCeilings = existingCeilings.filter((ceiling) => !ceiling.autoFromWalls);
+    const manualSignatures = new Set(manualCeilings.map((ceiling) => polygonSignature(ceiling.polygon.map(pointFromTuple))));
+    const detected = roomPolygons
+        .map((poly) => ({
+        poly: simplifyClosedPolygon(poly.map(pointToTuple), AUTO_SLAB_POLYGON_SIMPLIFY_TOLERANCE).map(pointFromTuple),
+        sig: '',
+        centroid: { x: 0, y: 0 },
+        area: 0,
+        bbox: bboxOf([]),
+    }))
+        .map((room) => ({
+        ...room,
+        sig: polygonSignature(room.poly),
+        centroid: polygonCentroid(room.poly),
+        area: Math.abs(polygonArea(room.poly)),
+        bbox: bboxOf(room.poly),
+    }))
+        .filter(({ sig }) => !manualSignatures.has(sig));
+    const existingAuto = existingCeilings.filter((ceiling) => ceiling.autoFromWalls);
+    const existingAutoMeta = existingAuto.map((ceiling) => {
+        const poly = ceiling.polygon.map(pointFromTuple);
+        return {
+            ceiling,
+            sig: polygonSignature(poly),
+            centroid: polygonCentroid(poly),
+            area: Math.abs(polygonArea(poly)),
+            bbox: bboxOf(poly),
+        };
+    });
+    const matchedCeilingIds = new Set();
+    const matchedDetectedIdx = new Set();
+    const updatesById = new Map();
+    const autoBySignature = new Map();
+    for (const entry of existingAutoMeta) {
+        autoBySignature.set(entry.sig, entry);
+    }
+    detected.forEach((room, index) => {
+        const existing = autoBySignature.get(room.sig);
+        if (!existing)
+            return;
+        matchedDetectedIdx.add(index);
+        matchedCeilingIds.add(existing.ceiling.id);
+        updatesById.set(existing.ceiling.id, room.poly.map(pointToTuple));
+    });
+    const remainingDetected = detected
+        .map((room, index) => ({ room, index }))
+        .filter(({ index }) => !matchedDetectedIdx.has(index))
+        .sort((a, b) => b.room.area - a.room.area);
+    const remainingAuto = existingAutoMeta.filter((entry) => !matchedCeilingIds.has(entry.ceiling.id));
+    for (const { room, index } of remainingDetected) {
+        let bestMatch = null;
+        for (const entry of remainingAuto) {
+            if (matchedCeilingIds.has(entry.ceiling.id))
+                continue;
+            const dx = room.centroid.x - entry.centroid.x;
+            const dy = room.centroid.y - entry.centroid.y;
+            const dist = Math.hypot(dx, dy);
+            const areaRatio = entry.area > 1e-6 ? room.area / entry.area : 999;
+            const areaPenalty = Math.abs(Math.log(Math.max(1e-6, areaRatio)));
+            const overlap = bboxOverlapArea(room.bbox, entry.bbox);
+            if (overlap <= 0.0001 && dist > 1.5)
+                continue;
+            const score = dist + areaPenalty * 0.35;
+            if (!bestMatch || score < bestMatch.score) {
+                bestMatch = { entry, score };
             }
         }
-        // Update previous walls reference
-        prevWallsByLevel.clear();
-        for (const [levelId, wallIds] of currentWallsByLevel.entries()) {
-            prevWallsByLevel.set(levelId, wallIds);
-        }
+        if (!bestMatch)
+            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 } }];
     });
-    return unsubscribe;
+    const plannedCeilingsForNaming = [...existingCeilings];
+    const ceilingsToCreate = [];
+    for (let index = 0; index < detected.length; index += 1) {
+        if (matchedDetectedIdx.has(index))
+            continue;
+        const room = detected[index];
+        if (!room)
+            continue;
+        const name = nextAutoRoomName(plannedCeilingsForNaming, 'Ceiling');
+        plannedCeilingsForNaming.push({ name });
+        ceilingsToCreate.push(CeilingNode.parse({
+            name,
+            polygon: room.poly.map(pointToTuple),
+            holes: [],
+            height: DEFAULT_AUTO_CEILING_HEIGHT,
+            autoFromWalls: true,
+        }));
+    }
+    if (ceilingsToDelete.length > 0) {
+        sceneStore.getState().deleteNodes(ceilingsToDelete);
+    }
+    if (ceilingsToUpdate.length > 0) {
+        sceneStore.getState().updateNodes(ceilingsToUpdate);
+    }
+    if (ceilingsToCreate.length > 0) {
+        sceneStore.getState().createNodes(ceilingsToCreate.map((node) => ({ node, parentId: levelId })));
+    }
+}
+function detectSpacesFromWalls(levelId, walls) {
+    const roomPolygons = extractRoomPolygons(walls);
+    const wallUpdates = walls.map((wall) => ({
+        wallId: wall.id,
+        ...resolveWallSurfaceSides(wall, roomPolygons),
+    }));
+    return {
+        roomPolygons,
+        spaces: roomPolygons.map((polygon) => buildSpace(levelId, polygon)),
+        wallUpdates,
+    };
+}
+export function detectSpacesForLevel(levelId, walls) {
+    return detectSpacesFromWalls(levelId, walls);
 }
-/**
- * Runs space detection for the given levels
- * Updates wall nodes and editor spaces
- */
 function runSpaceDetection(levelIds, sceneStore, editorStore, nodes) {
-    const { updateNode } = sceneStore.getState();
-    const { setSpaces } = editorStore.getState();
-    const allSpaces = {};
-    for (const levelId of levelIds) {
-        // Get walls for this level
-        const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === levelId);
-        if (walls.length === 0) {
-            // No walls - clear any spaces for this level
-            continue;
+    const { updateNodes } = sceneStore.getState();
+    const existingSpaces = editorStore.getState().spaces;
+    const nextSpaces = {};
+    for (const [spaceId, space] of Object.entries(existingSpaces)) {
+        if (!levelIds.includes(space.levelId)) {
+            nextSpaces[spaceId] = space;
         }
-        // Run detection
-        const { wallUpdates, spaces } = detectSpacesForLevel(levelId, walls);
-        // Update wall nodes (only if values changed to avoid infinite loop)
-        for (const update of wallUpdates) {
+    }
+    for (const levelId of levelIds) {
+        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 { wallUpdates, spaces, roomPolygons } = detectSpacesFromWalls(levelId, walls);
+        const changedWallUpdates = wallUpdates.filter((update) => {
             const wall = nodes[update.wallId];
-            if (wall.frontSide !== update.frontSide || wall.backSide !== update.backSide) {
-                updateNode(update.wallId, {
+            return wall && (wall.frontSide !== update.frontSide || wall.backSide !== update.backSide);
+        });
+        if (changedWallUpdates.length > 0) {
+            updateNodes(changedWallUpdates.map((update) => ({
+                id: update.wallId,
+                data: {
                     frontSide: update.frontSide,
                     backSide: update.backSide,
-                });
-            }
+                },
+            })));
         }
-        // Store spaces
+        syncAutoSlabsForLevel(levelId, roomPolygons, slabs.map((slab) => SlabNode.parse(slab)), sceneStore);
+        syncAutoCeilingsForLevel(levelId, roomPolygons, ceilings.map((ceiling) => CeilingNode.parse(ceiling)), sceneStore);
         for (const space of spaces) {
-            allSpaces[space.id] = space;
+            nextSpaces[space.id] = space;
         }
     }
-    // Update editor spaces
-    setSpaces(allSpaces);
-}
-// ============================================================================
-// MAIN DETECTION FUNCTION
-// ============================================================================
-/**
- * Detects spaces for a level by flood-filling a grid from the edges
- * Returns wall side updates and detected spaces
- */
-export function detectSpacesForLevel(levelId, walls, gridResolution = 0.5) {
-    if (walls.length === 0) {
-        return { wallUpdates: [], spaces: [] };
-    }
-    // Build grid from walls
-    const grid = buildGrid(walls, gridResolution);
-    // Flood fill from edges to mark exterior
-    floodFillFromEdges(grid);
-    // Find interior spaces
-    const interiorSpaces = findInteriorSpaces(grid, levelId);
-    // Assign wall sides
-    const wallUpdates = assignWallSides(walls, grid);
-    return {
-        wallUpdates,
-        spaces: interiorSpaces,
-    };
+    editorStore.getState().setSpaces(nextSpaces);
 }
-// ============================================================================
-// GRID BUILDING
-// ============================================================================
-/**
- * Builds a discrete grid and marks cells occupied by walls
- */
-function buildGrid(walls, resolution) {
-    // Find bounds
-    let minX = Number.POSITIVE_INFINITY;
-    let minZ = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let maxZ = Number.NEGATIVE_INFINITY;
-    for (const wall of walls) {
-        minX = Math.min(minX, wall.start[0], wall.end[0]);
-        minZ = Math.min(minZ, wall.start[1], wall.end[1]);
-        maxX = Math.max(maxX, wall.start[0], wall.end[0]);
-        maxZ = Math.max(maxZ, wall.start[1], wall.end[1]);
-    }
-    // Add padding around bounds
-    const padding = 2; // meters
-    minX -= padding;
-    minZ -= padding;
-    maxX += padding;
-    maxZ += padding;
-    const width = Math.ceil((maxX - minX) / resolution);
-    const height = Math.ceil((maxZ - minZ) / resolution);
-    const grid = {
-        cells: new Map(),
-        resolution,
-        minX,
-        minZ,
-        maxX,
-        maxZ,
-        width,
-        height,
-    };
-    // Mark wall cells
-    for (const wall of walls) {
-        markWallCells(grid, wall);
-    }
-    return grid;
-}
-/**
- * Marks all grid cells occupied by a wall using line rasterization
- * Uses denser sampling to ensure continuous barriers
- */
-function markWallCells(grid, wall) {
-    const thickness = wall.thickness ?? 0.2;
-    const halfThickness = thickness / 2;
-    const [x1, z1] = wall.start;
-    const [x2, z2] = wall.end;
-    // Wall direction vector
-    const dx = x2 - x1;
-    const dz = z2 - z1;
-    const len = Math.sqrt(dx * dx + dz * dz);
-    if (len < 0.001)
-        return;
-    // Normalized direction and perpendicular
-    const dirX = dx / len;
-    const dirZ = dz / len;
-    const perpX = -dirZ;
-    const perpZ = dirX;
-    // Denser sampling along wall length (at least 2x resolution)
-    const steps = Math.max(Math.ceil(len / (grid.resolution * 0.5)), 2);
-    for (let i = 0; i <= steps; i++) {
-        const t = i / steps;
-        const x = x1 + dx * t;
-        const z = z1 + dz * t;
-        // Denser sampling across wall thickness
-        const thicknessSteps = Math.max(Math.ceil(thickness / (grid.resolution * 0.5)), 2);
-        for (let j = 0; j <= thicknessSteps; j++) {
-            const offset = (j / thicknessSteps - 0.5) * thickness;
-            const wx = x + perpX * offset;
-            const wz = z + perpZ * offset;
-            const key = getCellKey(grid, wx, wz);
-            if (key) {
-                grid.cells.set(key, 'wall');
+export function initSpaceDetectionSync(sceneStore, editorStore) {
+    const previousSnapshots = new Map();
+    let isProcessing = false;
+    const unsubscribe = sceneStore.subscribe((state) => {
+        if (isProcessing)
+            return;
+        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);
             }
         }
-    }
-}
-// ============================================================================
-// FLOOD FILL
-// ============================================================================
-/**
- * Flood fills from all edge cells to mark exterior space
- */
-function floodFillFromEdges(grid) {
-    const queue = [];
-    // Add all edge cells to queue
-    for (let x = 0; x < grid.width; x++) {
-        for (let z = 0; z < grid.height; z++) {
-            // Only process edge cells
-            if (x === 0 || x === grid.width - 1 || z === 0 || z === grid.height - 1) {
-                const key = getCellKeyFromIndex(x, z, grid.width);
-                const cell = grid.cells.get(key);
-                if (cell !== 'wall') {
-                    grid.cells.set(key, 'exterior');
-                    queue.push(key);
-                }
-            }
+        const currentSnapshots = new Map();
+        for (const [levelId, walls] of wallsByLevel.entries()) {
+            currentSnapshots.set(levelId, levelWallSnapshot(walls));
         }
-    }
-    // Flood fill
-    while (queue.length > 0) {
-        const key = queue.shift();
-        const [x, z] = parseCellKey(key);
-        // Check 4 neighbors
-        const neighbors = [
-            [x + 1, z],
-            [x - 1, z],
-            [x, z + 1],
-            [x, z - 1],
-        ];
-        for (const [nx, nz] of neighbors) {
-            if (nx < 0 || nx >= grid.width || nz < 0 || nz >= grid.height)
-                continue;
-            const nKey = getCellKeyFromIndex(nx, nz, grid.width);
-            const cell = grid.cells.get(nKey);
-            if (cell !== 'wall' && cell !== 'exterior') {
-                grid.cells.set(nKey, 'exterior');
-                queue.push(nKey);
+        const levelsToUpdate = new Set();
+        for (const levelId of new Set([...previousSnapshots.keys(), ...currentSnapshots.keys()])) {
+            if ((previousSnapshots.get(levelId) ?? '') !== (currentSnapshots.get(levelId) ?? '')) {
+                levelsToUpdate.add(levelId);
             }
         }
-    }
-}
-// ============================================================================
-// INTERIOR SPACE DETECTION
-// ============================================================================
-/**
- * Finds all interior spaces (connected regions not marked as exterior or wall)
- */
-function findInteriorSpaces(grid, levelId) {
-    const spaces = [];
-    const visited = new Set();
-    // Scan grid for interior cells
-    for (let x = 0; x < grid.width; x++) {
-        for (let z = 0; z < grid.height; z++) {
-            const key = getCellKeyFromIndex(x, z, grid.width);
-            if (visited.has(key))
-                continue;
-            const cell = grid.cells.get(key);
-            if (cell === 'wall' || cell === 'exterior') {
-                visited.add(key);
-                continue;
+        if (levelsToUpdate.size === 0) {
+            previousSnapshots.clear();
+            for (const [levelId, snapshot] of currentSnapshots.entries()) {
+                previousSnapshots.set(levelId, snapshot);
             }
-            // Found interior cell - flood fill to find full space
-            const spaceCells = new Set();
-            const queue = [key];
-            visited.add(key);
-            spaceCells.add(key);
-            // Mark the seed cell as interior in the grid
-            grid.cells.set(key, 'interior');
-            while (queue.length > 0) {
-                const curKey = queue.shift();
-                const [cx, cz] = parseCellKey(curKey);
-                const neighbors = [
-                    [cx + 1, cz],
-                    [cx - 1, cz],
-                    [cx, cz + 1],
-                    [cx, cz - 1],
-                ];
-                for (const [nx, nz] of neighbors) {
-                    if (nx < 0 || nx >= grid.width || nz < 0 || nz >= grid.height)
-                        continue;
-                    const nKey = getCellKeyFromIndex(nx, nz, grid.width);
-                    if (visited.has(nKey))
-                        continue;
-                    const nCell = grid.cells.get(nKey);
-                    if (nCell === 'wall' || nCell === 'exterior') {
-                        visited.add(nKey);
-                        continue;
-                    }
-                    visited.add(nKey);
-                    spaceCells.add(nKey);
-                    // Mark as interior in grid
-                    grid.cells.set(nKey, 'interior');
-                    queue.push(nKey);
-                }
+            return;
+        }
+        isProcessing = true;
+        pauseSceneHistory(sceneStore);
+        try {
+            runSpaceDetection([...levelsToUpdate], sceneStore, editorStore, nodes);
+        }
+        finally {
+            resumeSceneHistory(sceneStore);
+            previousSnapshots.clear();
+            for (const [levelId, snapshot] of currentSnapshots.entries()) {
+                previousSnapshots.set(levelId, snapshot);
             }
-            // Create space from cells
-            const polygon = extractPolygonFromCells(spaceCells, grid);
-            spaces.push({
-                id: `space-${spaces.length}`,
-                levelId,
-                polygon,
-                wallIds: [],
-                isExterior: false,
-            });
+            isProcessing = false;
         }
-    }
-    return spaces;
-}
-/**
- * Extracts a simplified polygon from a set of grid cells
- * Returns bounding box for now (can be improved to trace actual boundary)
- */
-function extractPolygonFromCells(cells, grid) {
-    let minX = Number.POSITIVE_INFINITY;
-    let minZ = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let maxZ = Number.NEGATIVE_INFINITY;
-    for (const key of cells) {
-        const [x, z] = parseCellKey(key);
-        const worldX = grid.minX + x * grid.resolution;
-        const worldZ = grid.minZ + z * grid.resolution;
-        minX = Math.min(minX, worldX);
-        minZ = Math.min(minZ, worldZ);
-        maxX = Math.max(maxX, worldX);
-        maxZ = Math.max(maxZ, worldZ);
-    }
-    // Return bounding box as polygon
-    return [
-        [minX, minZ],
-        [maxX, minZ],
-        [maxX, maxZ],
-        [minX, maxZ],
-    ];
-}
-// ============================================================================
-// WALL SIDE ASSIGNMENT
-// ============================================================================
-/**
- * Assigns front/back side classification to each wall based on grid
- */
-function assignWallSides(walls, grid) {
-    const updates = [];
-    for (const wall of walls) {
-        const thickness = wall.thickness ?? 0.2;
-        const [x1, z1] = wall.start;
-        const [x2, z2] = wall.end;
-        // Wall direction and perpendicular
-        const dx = x2 - x1;
-        const dz = z2 - z1;
-        const len = Math.sqrt(dx * dx + dz * dz);
-        if (len < 0.001)
-            continue;
-        const perpX = -dz / len;
-        const perpZ = dx / len;
-        // Sample point on front side (perpendicular direction)
-        const midX = (x1 + x2) / 2;
-        const midZ = (z1 + z2) / 2;
-        // Sample beyond wall thickness + one full grid cell to ensure we're in the next cell
-        const offset = thickness / 2 + grid.resolution;
-        const frontX = midX + perpX * offset;
-        const frontZ = midZ + perpZ * offset;
-        const backX = midX - perpX * offset;
-        const backZ = midZ - perpZ * offset;
-        // Check what space each side faces
-        const frontKey = getCellKey(grid, frontX, frontZ);
-        const backKey = getCellKey(grid, backX, backZ);
-        const frontCell = frontKey ? grid.cells.get(frontKey) : undefined;
-        const backCell = backKey ? grid.cells.get(backKey) : undefined;
-        const frontSide = classifySide(frontCell);
-        const backSide = classifySide(backCell);
-        updates.push({
-            wallId: wall.id,
-            frontSide,
-            backSide,
-        });
-    }
-    return updates;
-}
-/**
- * Classifies a cell as interior, exterior, or unknown
- */
-function classifySide(cell) {
-    if (cell === 'exterior')
-        return 'exterior';
-    if (cell === 'interior')
-        return 'interior';
-    // Wall cells or out-of-bounds (undefined) are unknown
-    return 'unknown';
-}
-// ============================================================================
-// GRID UTILITIES
-// ============================================================================
-/**
- * Gets grid cell key from world coordinates
- */
-function getCellKey(grid, x, z) {
-    const cellX = Math.floor((x - grid.minX) / grid.resolution);
-    const cellZ = Math.floor((z - grid.minZ) / grid.resolution);
-    if (cellX < 0 || cellX >= grid.width || cellZ < 0 || cellZ >= grid.height) {
-        return null;
-    }
-    return `${cellX},${cellZ}`;
-}
-/**
- * Gets cell key from grid indices
- */
-function getCellKeyFromIndex(x, z, width) {
-    return `${x},${z}`;
-}
-/**
- * Parses cell key back to indices
- */
-function parseCellKey(key) {
-    const parts = key.split(',');
-    return [Number.parseInt(parts[0], 10), Number.parseInt(parts[1], 10)];
-}
-// ============================================================================
-// WALL CONNECTIVITY DETECTION
-// ============================================================================
-/**
- * Checks if a wall touches any other walls
- * Used to determine if space detection should run
- */
+    });
+    return unsubscribe;
+}
 export function wallTouchesOthers(wall, otherWalls) {
-    const threshold = 0.1; // 10cm connection threshold
+    const threshold = 0.1;
     for (const other of otherWalls) {
         if (other.id === wall.id)
             continue;
-        // Check if any endpoint of wall is close to any endpoint or segment of other
         if (distanceToSegment(wall.start, other.start, other.end) < threshold ||
             distanceToSegment(wall.end, other.start, other.end) < threshold ||
             distanceToSegment(other.start, wall.start, wall.end) < threshold ||
@@ -475,27 +697,18 @@ export function wallTouchesOthers(wall, otherWalls) {
     }
     return false;
 }
-/**
- * Distance from point to line segment
- */
 function distanceToSegment(point, segStart, segEnd) {
-    const [px, pz] = point;
-    const [x1, z1] = segStart;
-    const [x2, z2] = segEnd;
+    const [px, py] = point;
+    const [x1, y1] = segStart;
+    const [x2, y2] = segEnd;
     const dx = x2 - x1;
-    const dz = z2 - z1;
-    const lenSq = dx * dx + dz * dz;
+    const dy = y2 - y1;
+    const lenSq = dx * dx + dy * dy;
     if (lenSq < 0.0001) {
-        // Segment is a point
-        const dpx = px - x1;
-        const dpz = pz - z1;
-        return Math.sqrt(dpx * dpx + dpz * dpz);
+        return Math.hypot(px - x1, py - y1);
     }
-    // Project point onto line
-    const t = Math.max(0, Math.min(1, ((px - x1) * dx + (pz - z1) * dz) / lenSq));
+    const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lenSq));
     const projX = x1 + t * dx;
-    const projZ = z1 + t * dz;
-    const distX = px - projX;
-    const distZ = pz - projZ;
-    return Math.sqrt(distX * distX + distZ * distZ);
+    const projY = y1 + t * dy;
+    return Math.hypot(px - projX, py - projY);
 }