@pascal-app/core 1.0.0-beta.4 → 1.0.0

package/dist/lib/room-topology-index.js

@@ -0,0 +1,237 @@
+import { getClampedWallCurveOffset } from '../systems/wall/wall-curve';
+const CELL_SIZE = 2;
+function bboxOf(points) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const [x, y] of points) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    }
+    return { minX, minY, maxX, maxY };
+}
+function expandedBbox(box, margin) {
+    return {
+        minX: box.minX - margin,
+        minY: box.minY - margin,
+        maxX: box.maxX + margin,
+        maxY: box.maxY + margin,
+    };
+}
+function cellKeysForBbox(box) {
+    const keys = [];
+    for (let x = Math.floor(box.minX / CELL_SIZE); x <= Math.floor(box.maxX / CELL_SIZE); x += 1) {
+        for (let y = Math.floor(box.minY / CELL_SIZE); y <= Math.floor(box.maxY / CELL_SIZE); y += 1) {
+            keys.push(`${x},${y}`);
+        }
+    }
+    return keys;
+}
+export function distanceToSegment(point, segStart, segEnd) {
+    const [px, py] = point;
+    const [x1, y1] = segStart;
+    const [x2, y2] = segEnd;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const lenSq = dx * dx + dy * dy;
+    if (lenSq < 0.0001)
+        return Math.hypot(px - x1, py - y1);
+    const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lenSq));
+    return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
+}
+function roomUsesAnyWall(room, wallIds) {
+    return room.boundaryFaces.some((boundary) => wallIds.has(boundary.wallId));
+}
+function sameIndexedWall(left, right) {
+    if (!(left && right))
+        return left === right;
+    return (left.parentId === right.parentId &&
+        left.start[0] === right.start[0] &&
+        left.start[1] === right.start[1] &&
+        left.end[0] === right.end[0] &&
+        left.end[1] === right.end[1] &&
+        getClampedWallCurveOffset(left) === getClampedWallCurveOffset(right));
+}
+export class RoomTopologyIndex {
+    options;
+    levels = new Map();
+    queryMargin;
+    constructor(options) {
+        this.options = options;
+        this.queryMargin = options.junctionTolerance + 0.02;
+    }
+    rebuild(nodes) {
+        this.levels.clear();
+        const wallsByLevel = new Map();
+        for (const node of Object.values(nodes)) {
+            if (node?.type !== 'wall' || !node.parentId)
+                continue;
+            const walls = wallsByLevel.get(node.parentId) ?? [];
+            walls.push(node);
+            wallsByLevel.set(node.parentId, walls);
+        }
+        for (const [levelId, walls] of wallsByLevel) {
+            this.levels.set(levelId, this.createLevel(walls));
+        }
+    }
+    rebuildLevel(levelId, nodes) {
+        const level = this.createLevel(this.wallsForLevel(nodes, levelId));
+        this.levels.set(levelId, level);
+        return level;
+    }
+    applyWallDelta(levelId, changedWallIds, beforeNodes, currentNodes) {
+        let strategy = 'indexed';
+        let level = this.levels.get(levelId);
+        if (!level) {
+            level = this.rebuildLevel(levelId, beforeNodes);
+            strategy = 'fallback';
+        }
+        for (const wallId of changedWallIds) {
+            const cached = level.walls.get(wallId);
+            const previous = beforeNodes[wallId];
+            const previousWall = previous?.type === 'wall' && previous.parentId === levelId ? previous : undefined;
+            if (!sameIndexedWall(cached, previousWall)) {
+                level = this.rebuildLevel(levelId, beforeNodes);
+                strategy = 'fallback';
+                break;
+            }
+        }
+        const beforeComponentIds = this.connectedWallIds(level, changedWallIds);
+        for (const wallId of changedWallIds) {
+            const current = currentNodes[wallId];
+            if (current?.type === 'wall' && current.parentId === levelId) {
+                this.setWall(level, current);
+            }
+            else {
+                this.removeWall(level, wallId);
+            }
+        }
+        const currentSeedIds = new Set(changedWallIds);
+        for (const wallId of beforeComponentIds) {
+            if (level.walls.has(wallId))
+                currentSeedIds.add(wallId);
+        }
+        const currentComponentIds = this.connectedWallIds(level, currentSeedIds);
+        const examinedIds = new Set([...changedWallIds, ...beforeComponentIds, ...currentComponentIds]);
+        const beforeRooms = level.rooms.filter((room) => roomUsesAnyWall(room, examinedIds));
+        const previousWalls = this.wallsFromNodes(beforeNodes, levelId, examinedIds);
+        const currentWalls = this.wallsFromNodes(currentNodes, levelId, examinedIds);
+        const currentRooms = this.options.detectRooms(currentWalls);
+        const allCurrentRooms = [
+            ...level.rooms.filter((room) => !roomUsesAnyWall(room, examinedIds)),
+            ...currentRooms,
+        ];
+        level.rooms = allCurrentRooms;
+        return {
+            strategy,
+            beforeRooms,
+            currentRooms,
+            allCurrentRooms,
+            previousWalls,
+            currentWalls,
+            examinedWallIds: [...examinedIds].sort(),
+        };
+    }
+    wallsForLevel(nodes, levelId) {
+        const level = nodes[levelId];
+        if (level?.type !== 'level')
+            return [];
+        return level.children.flatMap((id) => {
+            const node = nodes[id];
+            return node?.type === 'wall' && node.parentId === levelId ? [node] : [];
+        });
+    }
+    wallsFromNodes(nodes, levelId, ids) {
+        return [...ids].flatMap((wallId) => {
+            const node = nodes[wallId];
+            return node?.type === 'wall' && node.parentId === levelId ? [node] : [];
+        });
+    }
+    createLevel(walls) {
+        const level = {
+            walls: new Map(),
+            rooms: this.options.detectRooms(walls),
+            wallIdsByCell: new Map(),
+            cellKeysByWallId: new Map(),
+        };
+        for (const wall of walls)
+            this.setWall(level, wall);
+        return level;
+    }
+    wallBbox(wall) {
+        return bboxOf(this.options.sampleWall(wall));
+    }
+    cellKeysForWall(wall) {
+        return cellKeysForBbox(expandedBbox(this.wallBbox(wall), this.queryMargin));
+    }
+    removeWall(level, wallId) {
+        for (const key of level.cellKeysByWallId.get(wallId) ?? []) {
+            const ids = level.wallIdsByCell.get(key);
+            ids?.delete(wallId);
+            if (ids?.size === 0)
+                level.wallIdsByCell.delete(key);
+        }
+        level.cellKeysByWallId.delete(wallId);
+        level.walls.delete(wallId);
+    }
+    setWall(level, wall) {
+        this.removeWall(level, wall.id);
+        level.walls.set(wall.id, wall);
+        const keys = this.cellKeysForWall(wall);
+        level.cellKeysByWallId.set(wall.id, keys);
+        for (const key of keys) {
+            const ids = level.wallIdsByCell.get(key) ?? new Set();
+            ids.add(wall.id);
+            level.wallIdsByCell.set(key, ids);
+        }
+    }
+    queryWalls(level, wall) {
+        const ids = new Set();
+        for (const key of this.cellKeysForWall(wall)) {
+            for (const id of level.wallIdsByCell.get(key) ?? [])
+                ids.add(id);
+        }
+        return ids;
+    }
+    wallsTouch(left, right) {
+        const leftPoints = this.options.sampleWall(left);
+        const rightPoints = this.options.sampleWall(right);
+        const touchesPolyline = (points, other) => {
+            const endpoints = [points[0], points.at(-1)].filter((point) => Boolean(point));
+            for (const endpoint of endpoints) {
+                for (let index = 0; index < other.length - 1; index += 1) {
+                    if (distanceToSegment(endpoint, other[index], other[index + 1]) <=
+                        this.options.junctionTolerance) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        return touchesPolyline(leftPoints, rightPoints) || touchesPolyline(rightPoints, leftPoints);
+    }
+    connectedWallIds(level, seedIds) {
+        const connected = new Set();
+        const queue = [...seedIds];
+        while (queue.length > 0) {
+            const wallId = queue.pop();
+            if (connected.has(wallId))
+                continue;
+            const wall = level.walls.get(wallId);
+            if (!wall)
+                continue;
+            connected.add(wallId);
+            for (const neighborId of this.queryWalls(level, wall)) {
+                if (connected.has(neighborId))
+                    continue;
+                const neighbor = level.walls.get(neighborId);
+                if (neighbor && this.wallsTouch(wall, neighbor))
+                    queue.push(neighborId);
+            }
+        }
+        return connected;
+    }
+}

package/dist/lib/slab-polygon.d.ts

@@ -1,18 +1,36 @@
 import type { GeometryContext } from '../registry/types';
-import type { SlabNode, WallNode } from '../schema';
+import type { AnyNode, AnyNodeId, SlabNode, WallNode } from '../schema';
 export type SlabPolygonContext = {
     /** Walls on the slab's level. */
     walls: WallNode[];
     /** Other slabs on the same level — the slab itself must be excluded. */
     siblingSlabs: SlabNode[];
 };
+/** [ax, az, bx, bz] segment in plan space. */
+type Segment = [number, number, number, number];
+/** A sibling slab edge and the direction of its polygon interior. */
+type NeighborSegment = {
+    slab: SlabNode;
+    segment: Segment;
+    bounds: Bounds;
+    elevation: number;
+    /** Unit normal pointing into the sibling polygon at this edge. */
+    inwardX: number;
+    inwardZ: number;
+};
 /**
  * Derive a {@link SlabPolygonContext} from a registry `GeometryContext`:
  * sibling slabs come from `ctx.siblings` (same kind, same parent, self
  * excluded) and walls from the parent level's children.
  */
 export declare function slabPolygonContextFromGeometry(ctx: GeometryContext | undefined): SlabPolygonContext;
-export declare function getRenderableSlabPolygon(slabNode: SlabNode, context: SlabPolygonContext): Array<[number, number]>;
+export declare function slabPolygonContextForLevel(parent: AnyNode | null, resolve: (id: AnyNodeId) => AnyNode | undefined, fallbackSlabs?: SlabNode[]): SlabPolygonContext;
+export declare function getRenderableSlabPolygon(slabNode: SlabNode, context: SlabPolygonContext | PreparedSlabPolygonContext): Array<[number, number]>;
+type WallCandidate = {
+    wall: WallNode;
+    segments: Segment[];
+    halfThickness: number;
+};
 export type SlabEdgeWallBandSnap = {
     wallId: WallNode['id'];
     /** The candidate edge translated perpendicular onto the wall centerline. */
@@ -29,4 +47,19 @@ export type SlabEdgeWallBandSnap = {
 export declare function snapSlabEdgeToWallBand(a: [number, number], b: [number, number], walls: readonly WallNode[], options?: {
     maxLateral?: number;
 }): SlabEdgeWallBandSnap | null;
+type Bounds = [number, number, number, number];
+export declare function scopeSlabPolygonContext(slab: SlabNode, context: PreparedSlabPolygonContext): PreparedSlabPolygonContext;
+export declare function slabPolygonContextChanges(before: PreparedSlabPolygonContext, after: PreparedSlabPolygonContext): (slab: SlabNode) => boolean;
+type PreparedWallCandidate = WallCandidate & {
+    bounds: Bounds;
+};
+type PreparedSlabPolygonContext = SlabPolygonContext & {
+    wallCache: WeakMap<WallNode, PreparedWallCandidate>;
+    neighborCache: WeakMap<SlabNode, NeighborSegment[]>;
+    wallCandidates: PreparedWallCandidate[];
+    neighborSegments: NeighborSegment[];
+    siblingBreakTolerance: number;
+};
+export declare function prepareSlabPolygonContext(context: SlabPolygonContext, previous?: PreparedSlabPolygonContext): PreparedSlabPolygonContext;
+export {};
 //# sourceMappingURL=slab-polygon.d.ts.map

package/dist/lib/slab-polygon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slab-polygon.d.ts","sourceRoot":"","sources":["../../src/lib/slab-polygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAa,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAwG9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iCAAiC;IACjC,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,wEAAwE;IACxE,YAAY,EAAE,QAAQ,EAAE,CAAA;CACzB,CAAA;AAuBD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,eAAe,GAAG,SAAS,GAC/B,kBAAkB,CAmBpB;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgBzB;AAuID,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,4EAA4E;IAC5E,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAC3C,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACnB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACnB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,oBAAoB,GAAG,IAAI,CA4B7B"}
+{"version":3,"file":"slab-polygon.d.ts","sourceRoot":"","sources":["../../src/lib/slab-polygon.ts"],"names":[],"mappings":"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"}

package/dist/lib/slab-polygon.js

@@ -114,16 +114,24 @@ function polygonWindingSign(polygon) {
 export function slabPolygonContextFromGeometry(ctx) {
     if (!ctx)
         return { walls: [], siblingSlabs: [] };
-    const siblingSlabs = ctx.siblings.filter((node) => node.type === 'slab');
+    return {
+        ...slabPolygonContextForLevel(ctx.parent, ctx.resolve),
+        siblingSlabs: ctx.siblings.filter((node) => node.type === 'slab'),
+    };
+}
+export function slabPolygonContextForLevel(parent, resolve, fallbackSlabs = []) {
     const walls = [];
-    const parentChildIds = ctx.parent?.children;
-    if (Array.isArray(parentChildIds)) {
-        for (const childId of parentChildIds) {
-            const child = ctx.resolve(childId);
-            if (child?.type === 'wall') {
-                walls.push(child);
-            }
-        }
+    const siblingSlabs = [];
+    const childIds = parent?.children;
+    if (!Array.isArray(childIds)) {
+        return { walls, siblingSlabs: parent ? fallbackSlabs : [] };
+    }
+    for (const id of childIds) {
+        const child = resolve(id);
+        if (child?.type === 'wall')
+            walls.push(child);
+        else if (child?.type === 'slab')
+            siblingSlabs.push(child);
     }
     return { walls, siblingSlabs };
 }
@@ -132,7 +140,7 @@ export function getRenderableSlabPolygon(slabNode, context) {
     if (polygon.length < 3 || isFloatingSlab(slabNode)) {
         return polygon.map(([x, z]) => [x, z]);
     }
-    const subSpans = computeEdgeSubSpans(polygon, slabNode.elevation ?? DEFAULT_SLAB_ELEVATION, context);
+    const subSpans = computeEdgeSubSpans(polygon, slabNode.elevation ?? DEFAULT_SLAB_ELEVATION, 'wallCandidates' in context ? context : prepareSlabPolygonContext(context), slabNode.id);
     if (subSpans.every((spans) => spans.length === 1 && spans[0].offset === 0)) {
         return polygon.map(([x, z]) => [x, z]);
     }
@@ -254,17 +262,71 @@ export function snapSlabEdgeToWallBand(a, b, walls, options) {
         ],
     };
 }
-/**
- * Split every polygon edge at candidate span boundaries and classify
- * each sub-span independently. Returns one non-empty span list per
- * edge, covering [0, edgeLength] without gaps.
- */
-function computeEdgeSubSpans(polygon, selfElevation, context) {
-    const n = polygon.length;
-    // Winding sign: the outward normal of an edge with direction `dir` is
-    // `s * (dirZ, -dirX)`, so a target lateral `L` measured along
-    // `(dirZ, -dirX)` is `s * L` along the outward normal.
-    const s = polygonWindingSign(polygon);
+function polygonBounds(polygon) {
+    const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const [x, z] of polygon) {
+        bounds[0] = Math.min(bounds[0], x);
+        bounds[1] = Math.min(bounds[1], z);
+        bounds[2] = Math.max(bounds[2], x);
+        bounds[3] = Math.max(bounds[3], z);
+    }
+    return bounds;
+}
+function boundsOverlap(a, b, padding) {
+    return (a[0] <= b[2] + padding &&
+        a[2] >= b[0] - padding &&
+        a[1] <= b[3] + padding &&
+        a[3] >= b[1] - padding);
+}
+export function scopeSlabPolygonContext(slab, context) {
+    const bounds = polygonBounds(slab.polygon);
+    const wallCandidates = context.wallCandidates.filter((candidate) => boundsOverlap(bounds, candidate.bounds, candidate.halfThickness + WALL_ADOPTION_TOLERANCE));
+    // Keep the level-wide tolerance: even an unadopted wall can widen sibling
+    // breakpoint collection, which may affect short-span fusion.
+    const neighborSegments = context.neighborSegments.filter((neighbor) => neighbor.slab.id !== slab.id &&
+        boundsOverlap(bounds, neighbor.bounds, context.siblingBreakTolerance));
+    return {
+        ...context,
+        walls: wallCandidates.map((candidate) => candidate.wall),
+        siblingSlabs: [...new Set(neighborSegments.map((neighbor) => neighbor.slab))],
+        wallCandidates,
+        neighborSegments,
+        siblingBreakTolerance: context.siblingBreakTolerance,
+    };
+}
+export function slabPolygonContextChanges(before, after) {
+    if (before.siblingBreakTolerance !== after.siblingBreakTolerance)
+        return () => true;
+    const changedWalls = new Set();
+    const changedSlabs = new Set();
+    for (let i = 0; i < Math.max(before.walls.length, after.walls.length); i++) {
+        if (before.walls[i] === after.walls[i])
+            continue;
+        if (before.walls[i])
+            changedWalls.add(before.walls[i]);
+        if (after.walls[i])
+            changedWalls.add(after.walls[i]);
+    }
+    for (let i = 0; i < Math.max(before.siblingSlabs.length, after.siblingSlabs.length); i++) {
+        if (before.siblingSlabs[i] === after.siblingSlabs[i])
+            continue;
+        if (before.siblingSlabs[i])
+            changedSlabs.add(before.siblingSlabs[i]);
+        if (after.siblingSlabs[i])
+            changedSlabs.add(after.siblingSlabs[i]);
+    }
+    const walls = [...before.wallCandidates, ...after.wallCandidates].filter((candidate) => changedWalls.has(candidate.wall));
+    const neighbors = [...before.neighborSegments, ...after.neighborSegments].filter((neighbor) => changedSlabs.has(neighbor.slab));
+    return (slab) => {
+        const bounds = polygonBounds(slab.polygon);
+        return (walls.some((candidate) => boundsOverlap(bounds, candidate.bounds, candidate.halfThickness + WALL_ADOPTION_TOLERANCE)) ||
+            neighbors.some((neighbor) => neighbor.slab.id !== slab.id &&
+                boundsOverlap(bounds, neighbor.bounds, after.siblingBreakTolerance)));
+    };
+}
+export function prepareSlabPolygonContext(context, previous) {
+    const wallCache = previous?.wallCache ?? new WeakMap();
+    const neighborCache = previous?.neighborCache ?? new WeakMap();
     const neighborSegments = [];
     for (const sibling of context.siblingSlabs) {
         // A floating deck keeps its drawn polygon, so it can't be a seam
@@ -273,6 +335,12 @@ function computeEdgeSubSpans(polygon, selfElevation, context) {
         // only describe room floors meeting under a wall.
         if (isFloatingSlab(sibling))
             continue;
+        const cached = neighborCache.get(sibling);
+        if (cached) {
+            neighborSegments.push(...cached);
+            continue;
+        }
+        const segments = [];
         const siblingPolygon = sibling.polygon;
         if (siblingPolygon.length < 2)
             continue;
@@ -286,19 +354,35 @@ function computeEdgeSubSpans(polygon, selfElevation, context) {
             const length = Math.hypot(dx, dz);
             if (length < 1e-9)
                 continue;
-            neighborSegments.push({
+            segments.push({
+                slab: sibling,
+                bounds: polygonBounds([from, to]),
                 segment: [from[0], from[1], to[0], to[1]],
                 elevation,
                 inwardX: (-siblingWinding * dz) / length,
                 inwardZ: (siblingWinding * dx) / length,
             });
         }
+        neighborCache.set(sibling, segments);
+        neighborSegments.push(...segments);
     }
-    const wallCandidates = context.walls.map((wall) => ({
-        wall,
-        segments: wallCenterlineSegments(wall),
-        halfThickness: getWallThickness(wall) / 2,
-    }));
+    const wallCandidates = context.walls.map((wall) => {
+        const cached = wallCache.get(wall);
+        if (cached)
+            return cached;
+        const segments = wallCenterlineSegments(wall);
+        const candidate = {
+            wall,
+            segments,
+            halfThickness: getWallThickness(wall) / 2,
+            bounds: polygonBounds(segments.flatMap(([ax, az, bx, bz]) => [
+                [ax, az],
+                [bx, bz],
+            ])),
+        };
+        wallCache.set(wall, candidate);
+        return candidate;
+    });
     // Sibling breakpoints also matter for legacy face-aligned polygons up
     // to a full wall band away from the edge (the band-sibling interior
     // rule in classifySpan), so clip them with the widest band reach any
@@ -308,6 +392,28 @@ function computeEdgeSubSpans(polygon, selfElevation, context) {
     for (const candidate of wallCandidates) {
         siblingBreakTolerance = Math.max(siblingBreakTolerance, 2 * (candidate.halfThickness + WALL_ADOPTION_TOLERANCE));
     }
+    return {
+        ...context,
+        wallCache,
+        neighborCache,
+        wallCandidates,
+        neighborSegments,
+        siblingBreakTolerance,
+    };
+}
+/**
+ * Split every polygon edge at candidate span boundaries and classify
+ * each sub-span independently. Returns one non-empty span list per
+ * edge, covering [0, edgeLength] without gaps.
+ */
+function computeEdgeSubSpans(polygon, selfElevation, context, slabId) {
+    const n = polygon.length;
+    // Winding sign: the outward normal of an edge with direction `dir` is
+    // `s * (dirZ, -dirX)`, so a target lateral `L` measured along
+    // `(dirZ, -dirX)` is `s * L` along the outward normal.
+    const s = polygonWindingSign(polygon);
+    const { wallCandidates, siblingBreakTolerance } = context;
+    const neighborSegments = context.neighborSegments.filter((segment) => segment.slab.id !== slabId);
     const subSpans = [];
     for (let index = 0; index < n; index += 1) {
         const a = polygon[index];

package/dist/lib/space-detection.d.ts

@@ -16,6 +16,20 @@ export type Space = {
     boundaryFaces: SpaceBoundaryFace[];
     isExterior: boolean;
 };
+export type SpaceTopologyReconcileEvent = {
+    levelId: string;
+    strategy: 'indexed' | 'fallback';
+    examinedWallIds: string[];
+    affectedBeforeRoomCount: number;
+    affectedCurrentRoomCount: number;
+};
+export type SpaceDetectionSyncOptions = {
+    onTopologyReconcile?: (event: SpaceTopologyReconcileEvent) => void;
+};
+type ExtractedRoom = {
+    polygon: Point2D[];
+    boundaryFaces: SpaceBoundaryFace[];
+};
 type WallSideUpdate = {
     wallId: string;
     frontSide: 'interior' | 'exterior' | 'unknown';
@@ -31,6 +45,7 @@ export type AutoSlabSyncPlan = {
 };
 export type AutoSlabPlanningContext = {
     elevationForRoom?: (polygon: Array<[number, number]>) => number | undefined;
+    previousElevationForRoom?: (polygon: Array<[number, number]>) => number | undefined;
 };
 export type AutoCeilingSyncPlan = {
     create: CeilingNodeType[];
@@ -39,6 +54,10 @@ export type AutoCeilingSyncPlan = {
         data: Partial<CeilingNodeType>;
     }>;
     delete: Array<CeilingNodeType['id']>;
+    reparent: Array<{
+        id: AnyNodeId;
+        parentId: CeilingNodeType['id'];
+    }>;
 };
 export type AutoZoneSyncPlan = {
     update: Array<{
@@ -58,6 +77,14 @@ export type AutoCeilingPlanningContext = {
      */
     ceilingClampBound?: (polygon: Array<[number, number]>) => number;
     heightForRoom?: (polygon: Array<[number, number]>) => number | undefined;
+    previousHeightForRoom?: (polygon: Array<[number, number]>) => number | undefined;
+    childPosition?: (childId: AnyNodeId) => [number, number] | undefined;
+};
+declare function bboxOf(points: Point2D[]): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
 };
 /**
  * True when `wall` lies on the boundary of a room enclosed by `walls`, using the
@@ -69,11 +96,21 @@ export type AutoCeilingPlanningContext = {
  */
 export declare function wallClosesRoom(walls: WallNode[], wall: WallNode): boolean;
 export declare function resolveWallSurfaceSides(wall: Pick<WallNode, 'start' | 'end' | 'thickness' | 'frontSide' | 'backSide'>, roomPolygons: Point2D[][]): Pick<WallSideUpdate, 'frontSide' | 'backSide'>;
+type BoundedPolygon = {
+    polygon: Point2D[];
+    bbox: ReturnType<typeof bboxOf>;
+};
+export declare function surfaceTouchesRooms(surface: BoundedPolygon, rooms: BoundedPolygon[]): boolean;
 export declare function planAutoZonesForLevel(spaces: readonly Space[], existingZones: readonly ZoneNodeType[]): AutoZoneSyncPlan;
 export declare function resolveAutoZonePolygon(zone: Pick<ZoneNodeType, 'autoFromWalls' | 'boundaryWallIds' | 'polygon'>, resolve: (id: AnyNodeId) => unknown): ZoneNodeType['polygon'];
-export declare function planAutoSlabsForLevel(roomPolygons: Point2D[][], existingSlabs: SlabNodeType[], context?: AutoSlabPlanningContext): AutoSlabSyncPlan;
-export declare function planAutoCeilingsForLevel(roomPolygons: Point2D[][], existingCeilings: CeilingNodeType[], context?: AutoCeilingPlanningContext): AutoCeilingSyncPlan;
+export declare function planAutoSlabsForLevel(roomPolygons: Point2D[][], existingSlabs: SlabNodeType[], context?: AutoSlabPlanningContext, namingSlabs?: Array<{
+    name?: string;
+}>): AutoSlabSyncPlan;
+export declare function planAutoCeilingsForLevel(roomPolygons: Point2D[][], existingCeilings: CeilingNodeType[], context?: AutoCeilingPlanningContext, namingCeilings?: Array<{
+    name?: string;
+}>): AutoCeilingSyncPlan;
 export declare function detectSpacesForLevel(levelId: string, walls: WallNode[]): {
+    rooms: ExtractedRoom[];
     roomPolygons: Point2D[][];
     spaces: Space[];
     wallUpdates: WallSideUpdate[];
@@ -84,7 +121,7 @@ export declare function pauseSpaceDetection(): void;
 export declare function resumeSpaceDetection(): void;
 /** True iff the wall-driven auto slab/ceiling sync is currently paused. */
 export declare function isSpaceDetectionPaused(): boolean;
-export declare function initSpaceDetectionSync(sceneStore: any, editorStore: any): () => void;
+export declare function initSpaceDetectionSync(sceneStore: any, editorStore: any, options?: SpaceDetectionSyncOptions): () => void;
 export declare function wallTouchesOthers(wall: WallNode, otherWalls: WallNode[]): boolean;
 export {};
 //# sourceMappingURL=space-detection.d.ts.map

package/dist/lib/space-detection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"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"}