@pascal-app/core 1.0.1 → 1.0.4

package/dist/lib/room-name.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Names rooms nobody named: "Room N" with the lowest number no zone on the level
+ * uses yet. Only exact "Room N" names count. Called once per level, in a
+ * deterministic room order, and only when a room zone is created, so an existing
+ * room is never renamed and a name the user cleared stays cleared.
+ */
+export declare function roomNameAllocator(levelZones: Iterable<{
+    name?: string;
+}>): () => string;
+//# sourceMappingURL=room-name.d.ts.map

package/dist/lib/room-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-name.d.ts","sourceRoot":"","sources":["../../src/lib/room-name.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,gBAYxE"}

package/dist/lib/room-name.js

@@ -0,0 +1,22 @@
+const NUMBERED_ROOM = /^Room (\d+)$/;
+/**
+ * Names rooms nobody named: "Room N" with the lowest number no zone on the level
+ * uses yet. Only exact "Room N" names count. Called once per level, in a
+ * deterministic room order, and only when a room zone is created, so an existing
+ * room is never renamed and a name the user cleared stays cleared.
+ */
+export function roomNameAllocator(levelZones) {
+    const used = new Set();
+    for (const zone of levelZones) {
+        const match = NUMBERED_ROOM.exec(zone.name ?? '');
+        if (match)
+            used.add(Number(match[1]));
+    }
+    let next = 1;
+    return () => {
+        while (used.has(next))
+            next++;
+        used.add(next);
+        return `Room ${next}`;
+    };
+}

package/dist/lib/room-topology-index.d.ts

@@ -1,16 +1,55 @@
-import type { WallNode } from '../schema/index.js';
+import type { SeparatorNode, WallNode } from '../schema/index.js';
+import { type Ring } from './polygon-boolean.js';
+export type BoundaryNode = WallNode | SeparatorNode;
+export type BoundarySpan = {
+    roomId: string;
+    boundaryId: string;
+    kind: 'wall' | 'separator';
+    face: 'a' | 'b';
+    t0: number;
+    t1: number;
+};
+export type ExteriorBoundarySpan = Omit<BoundarySpan, 'roomId'> & {
+    roomId: null;
+};
+export type LevelFootprintContext = {
+    revision: number;
+    walls: ReadonlyMap<string, WallNode>;
+    wallFootprints: ReadonlyMap<string, Ring>;
+};
+export type TopologyRoom = {
+    id: string;
+    polygon: Ring;
+    holes: Ring[];
+    spans: BoundarySpan[];
+    context: LevelFootprintContext;
+};
+export type LevelTopology = {
+    revision: number;
+    rooms: TopologyRoom[];
+    exteriorSpans: ExteriorBoundarySpan[];
+    spansByBoundary: ReadonlyMap<string, BoundarySpan[]>;
+};
 type SceneNodes = Record<string, any>;
 type Point = [number, number];
 type IndexedRoom = {
+    id: string;
+    referencePolygon: Ring;
+    holes: Ring[];
+    spans: BoundarySpan[];
     boundaryFaces: Array<{
         wallId: WallNode['id'];
     }>;
 };
 type IndexedLevelTopology<TRoom extends IndexedRoom> = {
-    walls: Map<string, WallNode>;
+    revision: number;
+    topology?: LevelTopology;
+    walls: Map<string, BoundaryNode>;
     rooms: TRoom[];
     wallIdsByCell: Map<string, Set<string>>;
     cellKeysByWallId: Map<string, string[]>;
+    cellEntries: number;
+    flat: boolean;
 };
 export type IndexedTopologyDelta<TRoom extends IndexedRoom> = {
     strategy: 'indexed' | 'fallback';
@@ -22,19 +61,28 @@ export type IndexedTopologyDelta<TRoom extends IndexedRoom> = {
     examinedWallIds: string[];
 };
 type RoomTopologyIndexOptions<TRoom extends IndexedRoom> = {
-    detectRooms: (walls: WallNode[]) => TRoom[];
-    sampleWall: (wall: WallNode) => Point[];
+    includeSeparators?: boolean;
+    includeHoles?: boolean;
+    detectRooms: (walls: BoundaryNode[]) => TRoom[];
+    sampleWall: (wall: BoundaryNode) => Point[];
     junctionTolerance: number;
 };
 export declare function distanceToSegment(point: Point, segStart: Point, segEnd: Point): number;
 export declare class RoomTopologyIndex<TRoom extends IndexedRoom> {
-    private readonly options;
     private readonly levels;
     private readonly queryMargin;
+    private readonly options;
+    private revision;
     constructor(options: RoomTopologyIndexOptions<TRoom>);
     rebuild(nodes: SceneNodes): void;
     rebuildLevel(levelId: string, nodes: SceneNodes): IndexedLevelTopology<TRoom>;
     applyWallDelta(levelId: string, changedWallIds: ReadonlySet<string>, beforeNodes: SceneNodes, currentNodes: SceneNodes): IndexedTopologyDelta<TRoom>;
+    private isBoundary;
+    getLevelTopology(levelId: string): LevelTopology | undefined;
+    spansForWall(levelId: string, wallId: string): readonly BoundarySpan[];
+    roomAtPoint(levelId: string, point: Point): TopologyRoom | null;
+    /** At a junction, intervals own their start; the final interval also owns t=1. */
+    roomForWallHit(levelId: string, wallId: string, face: 'a' | 'b', t: number): TopologyRoom | null;
     private wallsForLevel;
     private wallsFromNodes;
     private createLevel;

package/dist/lib/room-topology-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"room-topology-index.d.ts","sourceRoot":"","sources":["../../src/lib/room-topology-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAGzC,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AACrC,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE7B,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC,CAAA;CACjD,CAAA;AAED,KAAK,oBAAoB,CAAC,KAAK,SAAS,WAAW,IAAI;IACrD,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC5B,KAAK,EAAE,KAAK,EAAE,CAAA;IACd,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IACvC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,oBAAoB,CAAC,KAAK,SAAS,WAAW,IAAI;IAC5D,QAAQ,EAAE,SAAS,GAAG,UAAU,CAAA;IAChC,WAAW,EAAE,KAAK,EAAE,CAAA;IACpB,YAAY,EAAE,KAAK,EAAE,CAAA;IACrB,eAAe,EAAE,KAAK,EAAE,CAAA;IACxB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,YAAY,EAAE,QAAQ,EAAE,CAAA;IACxB,eAAe,EAAE,MAAM,EAAE,CAAA;CAC1B,CAAA;AAED,KAAK,wBAAwB,CAAC,KAAK,SAAS,WAAW,IAAI;IACzD,WAAW,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,KAAK,EAAE,CAAA;IAC3C,UAAU,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,KAAK,EAAE,CAAA;IACvC,iBAAiB,EAAE,MAAM,CAAA;CAC1B,CAAA;AAqCD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,UAY7E;AAkBD,qBAAa,iBAAiB,CAAC,KAAK,SAAS,WAAW;IAI1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiD;IACxE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;gBAEP,OAAO,EAAE,wBAAwB,CAAC,KAAK,CAAC;IAIrE,OAAO,CAAC,KAAK,EAAE,UAAU;IAczB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU;IAM/C,cAAc,CACZ,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,WAAW,EAAE,UAAU,EACvB,YAAY,EAAE,UAAU,GACvB,oBAAoB,CAAC,KAAK,CAAC;IAuD9B,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,OAAO;IAYf,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,UAAU;IAoBlB,OAAO,CAAC,gBAAgB;CAiBzB"}
+{"version":3,"file":"room-topology-index.d.ts","sourceRoot":"","sources":["../../src/lib/room-topology-index.ts"],"names":[],"mappings":"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"}

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

@@ -1,5 +1,9 @@
 import { getClampedWallCurveOffset } from '../systems/wall/wall-curve.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+import { containsPoint } from './polygon-boolean.js';
+import { boundariesCross, junctionReach, TEE_REACH } from './room-graph.js';
 const CELL_SIZE = 2;
+const MAX_CELL_ENTRIES = 4096;
 function bboxOf(points) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
@@ -22,9 +26,17 @@ function expandedBbox(box, margin) {
     };
 }
 function cellKeysForBbox(box) {
+    const minX = Math.floor(box.minX / CELL_SIZE);
+    const maxX = Math.floor(box.maxX / CELL_SIZE);
+    const minY = Math.floor(box.minY / CELL_SIZE);
+    const maxY = Math.floor(box.maxY / CELL_SIZE);
+    // Unsafe integer coordinates can make x += 1 stall even for a tiny bbox.
+    if (![minX, maxX, minY, maxY].every(Number.isSafeInteger) ||
+        (maxX - minX + 1) * (maxY - minY + 1) > MAX_CELL_ENTRIES)
+        return null;
     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) {
+    for (let x = minX; x <= maxX; x += 1) {
+        for (let y = minY; y <= maxY; y += 1) {
             keys.push(`${x},${y}`);
         }
     }
@@ -43,31 +55,37 @@ export function distanceToSegment(point, segStart, segEnd) {
     return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
 }
 function roomUsesAnyWall(room, wallIds) {
-    return room.boundaryFaces.some((boundary) => wallIds.has(boundary.wallId));
+    return room.spans.some((span) => wallIds.has(span.boundaryId));
 }
 function sameIndexedWall(left, right) {
     if (!(left && right))
         return left === right;
-    return (left.parentId === right.parentId &&
+    return (left.type === right.type &&
+        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));
+        getClampedWallCurveOffset(left) === getClampedWallCurveOffset(right) &&
+        (left.type === 'separator' ||
+            (right.type === 'wall' &&
+                left.thickness === right.thickness &&
+                left.justification === right.justification)));
 }
 export class RoomTopologyIndex {
-    options;
     levels = new Map();
     queryMargin;
+    options;
+    revision = 0;
     constructor(options) {
         this.options = options;
-        this.queryMargin = options.junctionTolerance + 0.02;
+        this.queryMargin = Math.max(options.junctionTolerance, TEE_REACH) + 0.02;
     }
     rebuild(nodes) {
         this.levels.clear();
         const wallsByLevel = new Map();
         for (const node of Object.values(nodes)) {
-            if (node?.type !== 'wall' || !node.parentId)
+            if (!(this.isBoundary(node) && node.parentId))
                 continue;
             const walls = wallsByLevel.get(node.parentId) ?? [];
             walls.push(node);
@@ -92,7 +110,7 @@ export class RoomTopologyIndex {
         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;
+            const previousWall = this.isBoundary(previous) && previous.parentId === levelId ? previous : undefined;
             if (!sameIndexedWall(cached, previousWall)) {
                 level = this.rebuildLevel(levelId, beforeNodes);
                 strategy = 'fallback';
@@ -102,7 +120,7 @@ export class RoomTopologyIndex {
         const beforeComponentIds = this.connectedWallIds(level, changedWallIds);
         for (const wallId of changedWallIds) {
             const current = currentNodes[wallId];
-            if (current?.type === 'wall' && current.parentId === levelId) {
+            if (this.isBoundary(current) && current.parentId === levelId) {
                 this.setWall(level, current);
             }
             else {
@@ -119,12 +137,17 @@ export class RoomTopologyIndex {
         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 currentRooms = this.options.detectRooms([...examinedIds].flatMap((id) => {
+            const boundary = level.walls.get(id);
+            return boundary ? [boundary] : [];
+        }));
         const allCurrentRooms = [
             ...level.rooms.filter((room) => !roomUsesAnyWall(room, examinedIds)),
             ...currentRooms,
         ];
         level.rooms = allCurrentRooms;
+        level.revision = ++this.revision;
+        level.topology = undefined;
         return {
             strategy,
             beforeRooms,
@@ -135,13 +158,93 @@ export class RoomTopologyIndex {
             examinedWallIds: [...examinedIds].sort(),
         };
     }
+    isBoundary(node) {
+        return (node?.type === 'wall' ||
+            (this.options.includeSeparators !== false && node?.type === 'separator'));
+    }
+    getLevelTopology(levelId) {
+        const level = this.levels.get(levelId);
+        if (!level)
+            return;
+        if (level.topology)
+            return level.topology;
+        const walls = [...level.walls.values()].filter((node) => node.type === 'wall');
+        const miters = calculateLevelMiters(walls);
+        const context = {
+            revision: level.revision,
+            walls: new Map(walls.map((wall) => [wall.id, wall])),
+            wallFootprints: new Map(walls.map((wall) => [
+                wall.id,
+                getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y]),
+            ])),
+        };
+        const rooms = level.rooms
+            .map((room) => ({
+            id: room.id,
+            polygon: room.referencePolygon,
+            holes: room.holes,
+            spans: room.spans,
+            context,
+        }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+        const spansByBoundary = new Map();
+        for (const room of rooms) {
+            for (const span of room.spans) {
+                const spans = spansByBoundary.get(span.boundaryId) ?? [];
+                spans.push(span);
+                spansByBoundary.set(span.boundaryId, spans);
+            }
+        }
+        const exteriorSpans = [];
+        for (const boundary of [...level.walls.values()].sort((a, b) => a.id.localeCompare(b.id))) {
+            if (boundary.start[0] === boundary.end[0] && boundary.start[1] === boundary.end[1])
+                continue;
+            const spans = spansByBoundary.get(boundary.id) ?? [];
+            spans.sort((a, b) => a.face.localeCompare(b.face) || a.t0 - b.t0 || a.roomId.localeCompare(b.roomId));
+            const cuts = [...new Set([0, 1, ...spans.flatMap((span) => [span.t0, span.t1])])].sort((a, b) => a - b);
+            for (const face of ['a', 'b']) {
+                for (let i = 0; i < cuts.length - 1; i++) {
+                    const t0 = cuts[i], t1 = cuts[i + 1];
+                    const mid = (t0 + t1) / 2;
+                    if (!spans.some((span) => span.face === face && span.t0 <= mid && mid < span.t1)) {
+                        exteriorSpans.push({
+                            roomId: null,
+                            boundaryId: boundary.id,
+                            kind: boundary.type,
+                            face,
+                            t0,
+                            t1,
+                        });
+                    }
+                }
+            }
+        }
+        level.topology = { revision: level.revision, rooms, exteriorSpans, spansByBoundary };
+        return level.topology;
+    }
+    spansForWall(levelId, wallId) {
+        return this.getLevelTopology(levelId)?.spansByBoundary.get(wallId) ?? [];
+    }
+    roomAtPoint(levelId, point) {
+        return (this.getLevelTopology(levelId)?.rooms.find((room) => containsPoint([{ outer: room.polygon, holes: room.holes }], point)) ?? null);
+    }
+    /** At a junction, intervals own their start; the final interval also owns t=1. */
+    roomForWallHit(levelId, wallId, face, t) {
+        const topology = this.getLevelTopology(levelId);
+        const span = topology?.spansByBoundary
+            .get(wallId)
+            ?.find((candidate) => candidate.face === face &&
+            t >= candidate.t0 &&
+            (t < candidate.t1 || (t === 1 && candidate.t1 === 1)));
+        return topology?.rooms.find((room) => room.id === span?.roomId) ?? null;
+    }
     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] : [];
+            return this.isBoundary(node) && node.parentId === levelId ? [node] : [];
         });
     }
     wallsFromNodes(nodes, levelId, ids) {
@@ -152,10 +255,13 @@ export class RoomTopologyIndex {
     }
     createLevel(walls) {
         const level = {
+            revision: ++this.revision,
             walls: new Map(),
             rooms: this.options.detectRooms(walls),
             wallIdsByCell: new Map(),
             cellKeysByWallId: new Map(),
+            cellEntries: 0,
+            flat: false,
         };
         for (const wall of walls)
             this.setWall(level, wall);
@@ -168,6 +274,7 @@ export class RoomTopologyIndex {
         return cellKeysForBbox(expandedBbox(this.wallBbox(wall), this.queryMargin));
     }
     removeWall(level, wallId) {
+        level.cellEntries -= level.cellKeysByWallId.get(wallId)?.length ?? 0;
         for (const key of level.cellKeysByWallId.get(wallId) ?? []) {
             const ids = level.wallIdsByCell.get(key);
             ids?.delete(wallId);
@@ -180,7 +287,17 @@ export class RoomTopologyIndex {
     setWall(level, wall) {
         this.removeWall(level, wall.id);
         level.walls.set(wall.id, wall);
+        if (level.flat)
+            return;
         const keys = this.cellKeysForWall(wall);
+        if (!keys || level.cellEntries + keys.length > MAX_CELL_ENTRIES) {
+            level.flat = true;
+            level.wallIdsByCell.clear();
+            level.cellKeysByWallId.clear();
+            level.cellEntries = 0;
+            return;
+        }
+        level.cellEntries += keys.length;
         level.cellKeysByWallId.set(wall.id, keys);
         for (const key of keys) {
             const ids = level.wallIdsByCell.get(key) ?? new Set();
@@ -189,8 +306,13 @@ export class RoomTopologyIndex {
         }
     }
     queryWalls(level, wall) {
+        if (level.flat)
+            return new Set(level.walls.keys());
+        const keys = this.cellKeysForWall(wall);
+        if (!keys)
+            return new Set(level.walls.keys());
         const ids = new Set();
-        for (const key of this.cellKeysForWall(wall)) {
+        for (const key of keys) {
             for (const id of level.wallIdsByCell.get(key) ?? [])
                 ids.add(id);
         }
@@ -199,39 +321,63 @@ export class RoomTopologyIndex {
     wallsTouch(left, right) {
         const leftPoints = this.options.sampleWall(left);
         const rightPoints = this.options.sampleWall(right);
+        // Detection joins a wall end to another wall's body as far as the bodies can touch.
+        const reach = Math.max(this.options.junctionTolerance, junctionReach(left, 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) {
+                    if (distanceToSegment(endpoint, other[index], other[index + 1]) <= reach) {
                         return true;
                     }
                 }
             }
             return false;
         };
-        return touchesPolyline(leftPoints, rightPoints) || touchesPolyline(rightPoints, leftPoints);
+        // Crossing walls share a component too: detection declines near-miss joins on a
+        // wall that crosses another, so an incremental rebuild must see the same crossing.
+        return (touchesPolyline(leftPoints, rightPoints) ||
+            touchesPolyline(rightPoints, leftPoints) ||
+            boundariesCross(left, right));
     }
     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))
+        do {
+            while (queue.length > 0) {
+                const wallId = queue.pop();
+                if (connected.has(wallId))
                     continue;
-                const neighbor = level.walls.get(neighborId);
-                if (neighbor && this.wallsTouch(wall, neighbor))
-                    queue.push(neighborId);
+                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);
+                }
             }
-        }
+            if (this.options.includeHoles === false || !connected.size)
+                break;
+            // Disconnected enclosures still share a face. Bounds conservatively expand
+            // the affected component; extraction decides actual containment by booleans.
+            const bounds = bboxOf([...connected].flatMap((id) => this.options.sampleWall(level.walls.get(id))));
+            for (const room of level.rooms) {
+                const box = bboxOf(room.referencePolygon);
+                if (box.minX > bounds.maxX ||
+                    box.maxX < bounds.minX ||
+                    box.minY > bounds.maxY ||
+                    box.maxY < bounds.minY)
+                    continue;
+                for (const span of room.spans) {
+                    if (!connected.has(span.boundaryId) && level.walls.has(span.boundaryId))
+                        queue.push(span.boundaryId);
+                }
+            }
+        } while (queue.length > 0);
         return connected;
     }
 }

package/dist/lib/room-vertical-placement.d.ts

@@ -0,0 +1,12 @@
+import type { AnyNode } from '../schema/index.js';
+import type { PlateRoom } from './floor-plates.js';
+/**
+ * Automatic floor datum per room: 0.05 m above the highest ground (terrain +
+ * `supportOffset`) under its boundary walls.
+ *
+ * Manual slabs are deliberately not supports here. Load migration explicitly
+ * associates a retained authored floor with its room. Other manual slabs are
+ * separate terraces, pads or platforms and must not elect the house datum.
+ */
+export declare function autoRoomVerticalPlacements(rooms: Pick<PlateRoom, 'zone' | 'spans'>[], nodes: Readonly<Record<string, AnyNode>>): Map<`zone_${string}`, number>;
+//# sourceMappingURL=room-vertical-placement.d.ts.map

package/dist/lib/room-vertical-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-vertical-placement.d.ts","sourceRoot":"","sources":["../../src/lib/room-vertical-placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,WAAW,CAAA;AAElD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG/C;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAC1C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,iCAsBzC"}

package/dist/lib/room-vertical-placement.js

@@ -0,0 +1,28 @@
+import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
+import { levelBaseElevationAt } from './terrain-support-query.js';
+/**
+ * Automatic floor datum per room: 0.05 m above the highest ground (terrain +
+ * `supportOffset`) under its boundary walls.
+ *
+ * Manual slabs are deliberately not supports here. Load migration explicitly
+ * associates a retained authored floor with its room. Other manual slabs are
+ * separate terraces, pads or platforms and must not elect the house datum.
+ */
+export function autoRoomVerticalPlacements(rooms, nodes) {
+    const boundaryIds = new Set(rooms.flatMap((room) => room.spans.map((span) => span.boundaryId)));
+    const bases = new Map();
+    for (const id of boundaryIds) {
+        const wall = nodes[id];
+        if (wall?.type !== 'wall' || wall.parentId !== rooms[0]?.zone.parentId)
+            continue;
+        bases.set(wall.id, levelBaseElevationAt(nodes, wall.parentId, wall.start[0], wall.start[1]) +
+            (wall.supportOffset ?? 0));
+    }
+    return new Map(rooms.map((room) => {
+        const heights = room.spans.flatMap((span) => {
+            const base = bases.get(span.boundaryId);
+            return base === undefined ? [] : [base];
+        });
+        return [room.zone.id, (heights.length ? Math.max(...heights) : 0) + DEFAULT_SLAB_ELEVATION];
+    }));
+}

package/dist/lib/room-zone-adoption.d.ts

@@ -0,0 +1,74 @@
+import { type Polygon, type Ring } from './polygon-boolean.js';
+/**
+ * Which existing zone becomes the room of an enclosed face. Shared by the M3 load
+ * migration and the structure kernel so both load paths and live edits agree.
+ *
+ * Hand-drawn zones are loose: drawn to wall centre lines, inner or outer faces,
+ * tens of centimetres off, sometimes spanning a closet or a second space behind a
+ * wall. A zone is its face's room when the face holds most of the zone and the zone
+ * covers most of the face's clear floor, or when the two simply match (IoU).
+ */
+export declare const ROOM_MATCH_IOU = 0.9;
+/** Part of the face's clear floor the zone must cover. */
+export declare const ROOM_ADOPT_COVER = 0.5;
+/** Part of the zone that must lie in the face (its dominant face). */
+export declare const ROOM_ADOPT_SHARE = 0.5;
+/** `key` is the face's canonical id (its room id), so ties never depend on face order. */
+export type AdoptionFace = {
+    key: string;
+    polygon: Polygon;
+    clear: Polygon;
+};
+export type IdentityFace = AdoptionFace & {
+    boundaryWallIds: readonly string[];
+    boundarySeparatorIds: readonly string[];
+};
+export type ExistingRoom = {
+    id: string;
+    polygon: Ring;
+    holes?: Ring[];
+    seed?: [number, number];
+    boundaryWallIds?: readonly string[];
+    boundarySeparatorIds?: readonly string[];
+};
+export type AdoptionZone = {
+    id: string;
+    polygon: Ring;
+    holes?: Ring[];
+};
+export type ZoneFaceFit = {
+    face: number;
+    key: string;
+    /** Zone area inside the face reference polygon / zone area. */
+    share: number;
+    /** Zone area inside the face clear polygon / clear area. */
+    cover: number;
+    /** Best IoU against the reference or the clear polygon. */
+    iou: number;
+};
+/** Every face the zone overlaps, with its fit numbers, in face order. */
+export declare function zoneFaceFits(zone: AdoptionZone, faces: readonly AdoptionFace[]): ZoneFaceFit[];
+/** The face holding most of the zone, when the zone is that face's room. */
+export declare function adoptableFace(fits: readonly ZoneFaceFit[]): ZoneFaceFit | undefined;
+/** Orders two candidates for one face: the zone covering more of it wins. */
+export declare function compareAdoptionFits(a: {
+    id: string;
+    fit: ZoneFaceFit;
+}, b: {
+    id: string;
+    fit: ZoneFaceFit;
+}): number;
+/** Face index → adopted zone id; at most one zone per face, one face per zone. */
+export declare function electAdoptedZones(faces: readonly AdoptionFace[], zones: readonly AdoptionZone[]): Map<number, string>;
+/**
+ * The face an existing room keeps: the face with exactly its boundaries (nothing
+ * about it changed, even where degenerate faces overlap), then the outer face when
+ * its separators just carved an island, then the face holding its seed, then the
+ * largest overlap.
+ * Shared by the load migration and the structure kernel, so a reload never trades an
+ * existing room for a newly created one.
+ */
+export declare function existingRoomFace(room: ExistingRoom, faces: readonly IdentityFace[], overlaps?: readonly number[]): number | undefined;
+/** Among existing rooms keeping one face, the one covering most of it survives. */
+export declare function compareExistingRooms(face: IdentityFace): (a: ExistingRoom, b: ExistingRoom) => number;
+//# sourceMappingURL=room-zone-adoption.d.ts.map

package/dist/lib/room-zone-adoption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-zone-adoption.d.ts","sourceRoot":"","sources":["../../src/lib/room-zone-adoption.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAE9F;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,MAAM,CAAA;AACjC,0DAA0D;AAC1D,eAAO,MAAM,gBAAgB,MAAM,CAAA;AACnC,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAEnC,0FAA0F;AAC1F,MAAM,MAAM,YAAY,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAA;AAC5E,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG;IACxC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAA;CACxC,CAAA;AACD,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;IACd,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACnC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACzC,CAAA;AACD,MAAM,MAAM,YAAY,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CAAE,CAAA;AACxE,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAA;IACb,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAA;IACb,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAuBD,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,WAAW,EAAE,CAyB9F;AAED,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,GAAG,SAAS,CAgBnF;AAED,6EAA6E;AAC7E,wBAAgB,mBAAmB,CACjC,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAE,EACnC,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAE,UAKpC;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAYrB;AAWD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,QAAQ,GAAE,SAAS,MAAM,EAExB,GACA,MAAM,GAAG,SAAS,CA8BpB;AAED,mFAAmF;AACnF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,IAU7C,GAAG,YAAY,EAAE,GAAG,YAAY,YAEzC"}