@pascal-app/core 1.0.3 → 1.0.4

package/dist/utils/reconcile-structure-on-load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile-structure-on-load.d.ts","sourceRoot":"","sources":["../../src/utils/reconcile-structure-on-load.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,WAAW,CAAA;AAiF/D,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CnE;AA4MD,eAAO,MAAM,wBAAwB;;;6BAKG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ9C,CAAA"}

package/dist/utils/reconcile-structure-on-load.js

@@ -0,0 +1,307 @@
+import { automaticFloorHeight, floorPlateHoldsUnderside } from '../lib/floor-foundation-datum.js';
+import { upperStoreyFootprints } from '../lib/floor-foundation-stack.js';
+import { area, intersection } from '../lib/polygon-boolean.js';
+import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
+import { getCeilingClampBound } from '../services/storey.js';
+import { planOwnedFloorOpenings } from '../systems/owned-floor-openings.js';
+import { ensureSceneOpenings } from './ensure-scene-openings.js';
+import { migrateExteriorThresholds } from './exterior-threshold-migration.js';
+import { migrateFootprintFollowing } from './floor-follow-migration.js';
+import { migrateFloorOpeningNodes } from './floor-opening-migration.js';
+import { preserveLegacyWallDatums } from './legacy-wall-datums.js';
+import { loadMigration, loadNodeView } from './load-migration.js';
+import { materializeLegacyAutoOpenings, migrateOwnedFloorOpenings, } from './owned-floor-opening-migration.js';
+import { reconcileStructureWithStableIds } from './structure-id.js';
+function roomHoles(slab) {
+    return (slab.holes ?? []).filter((_, i) => slab.holeMetadata?.[i]?.source === 'room');
+}
+function discardOrphanLegacySlabCuts(source) {
+    let nodes = source;
+    for (const value of Object.values(source)) {
+        const slab = value;
+        if ((slab.type !== 'slab' && slab.type !== 'ceiling') || !slab.holes?.length)
+            continue;
+        const kept = slab.holes.flatMap((hole, index) => {
+            const metadata = slab.holeMetadata?.[index];
+            const ownerId = metadata?.source === 'stair' ? metadata.stairId : metadata?.elevatorId;
+            const orphan = (metadata?.source === 'stair' || metadata?.source === 'elevator') &&
+                (!ownerId || source[ownerId]?.type !== metadata.source);
+            if (orphan)
+                return [];
+            return [{ hole, metadata: metadata ?? { source: 'manual' } }];
+        });
+        if (kept.length === slab.holes.length)
+            continue;
+        if (nodes === source)
+            nodes = { ...source };
+        nodes[slab.id] = {
+            ...slab,
+            holes: kept.map((entry) => entry.hole),
+            holeMetadata: kept.map((entry) => entry.metadata),
+        };
+    }
+    return nodes;
+}
+function rehomeRetiredPlateCuts(source, legacy) {
+    let nodes = source;
+    const plates = Object.values(source).filter((node) => node.type === 'slab' && node.plateRole !== undefined);
+    for (const opening of Object.values(source)) {
+        if (opening.type !== 'floor-opening' || !opening.legacyPlateCuts)
+            continue;
+        let cuts;
+        for (const [sourceId, rings] of Object.entries(opening.legacyPlateCuts)) {
+            if (source[sourceId]?.type === 'slab')
+                continue;
+            const former = legacy[sourceId];
+            if (former?.type !== 'slab')
+                continue;
+            const target = plates
+                .filter((plate) => plate.parentId === former.parentId &&
+                Math.abs(plate.elevation - former.elevation) < 0.005 &&
+                rings.some((ring) => area(intersection(ring, plate.polygon)) > 1e-4))
+                .map((plate) => ({
+                plate,
+                overlap: area(intersection(former.polygon, plate.polygon)),
+            }))
+                .sort((a, b) => b.overlap - a.overlap || a.plate.id.localeCompare(b.plate.id))[0]?.plate;
+            if (!target)
+                continue;
+            cuts ??= { ...opening.legacyPlateCuts };
+            delete cuts[sourceId];
+            cuts[target.id] = [...(cuts[target.id] ?? []), ...rings];
+        }
+        if (!cuts)
+            continue;
+        if (nodes === source)
+            nodes = { ...source };
+        nodes[opening.id] = { ...opening, legacyPlateCuts: cuts };
+    }
+    return nodes;
+}
+export function alignLegacyStairCuts(source) {
+    let nodes = source;
+    const openings = Object.values(source).filter((node) => node.type === 'floor-opening');
+    for (const opening of openings) {
+        if (opening.source !== 'stair' || !opening.legacyPlateCuts)
+            continue;
+        const stair = opening.ownerId ? source[opening.ownerId] : undefined;
+        if (stair?.type !== 'stair')
+            continue;
+        const ceilings = openings.filter((other) => {
+            if (other === opening ||
+                other.source !== 'stair' ||
+                other.parentId !== opening.parentId ||
+                !other.ownerId ||
+                other.ownerId.localeCompare(opening.ownerId ?? '') >= 0)
+                return false;
+            const owner = other.ownerId ? source[other.ownerId] : undefined;
+            return (owner?.type === 'stair' &&
+                owner.fromLevelId === stair.fromLevelId &&
+                owner.toLevelId === stair.toLevelId &&
+                other.legacyCeilingCuts !== undefined);
+        });
+        if (!ceilings.length)
+            continue;
+        let cuts;
+        for (const [plateId, rings] of Object.entries(opening.legacyPlateCuts)) {
+            const matched = rings.map((ring) => {
+                const size = area([{ outer: ring, holes: [] }]);
+                const candidate = ceilings
+                    .flatMap((ceiling) => Object.values(ceiling.legacyCeilingCuts ?? {}).flat())
+                    .map((hole) => ({ hole, shared: area(intersection(ring, hole)) }))
+                    .sort((a, b) => b.shared - a.shared)[0];
+                return candidate && candidate.shared >= size * 0.6 ? candidate.hole : ring;
+            });
+            if (JSON.stringify(matched) === JSON.stringify(rings))
+                continue;
+            cuts ??= { ...opening.legacyPlateCuts };
+            cuts[plateId] = matched;
+        }
+        if (!cuts)
+            continue;
+        if (nodes === source)
+            nodes = { ...source };
+        nodes[opening.id] = { ...opening, legacyPlateCuts: cuts };
+    }
+    return nodes;
+}
+function reconcileStructureOnView(sourceNodes, legacyNodes, options) {
+    const legacyOpeningsPrepared = options.legacyOpeningsPrepared ||
+        Object.values(sourceNodes).some((node) => node.type === 'level' &&
+            node.metadata
+                ?.legacyAutoOpeningsMigrated === true);
+    const materialized = legacyOpeningsPrepared
+        ? sourceNodes
+        : materializeLegacyAutoOpenings(sourceNodes);
+    const legacyRecessed = Object.values(materialized).filter((node) => {
+        const slab = node;
+        return (slab.type === 'slab' &&
+            slab.recessed === true &&
+            slab.autoFromWalls === true &&
+            !slab.boundary);
+    });
+    const openings = migrateFloorOpeningNodes(materialized);
+    let input = legacyRecessed.length ? { ...openings.nodes } : openings.nodes;
+    input = ensureSceneOpenings(input).nodes;
+    for (const node of Object.values(sourceNodes)) {
+        const plate = node;
+        if (plate.type !== 'slab' ||
+            plate.plateRole !== 'base' ||
+            plate.floorHeight === undefined ||
+            !floorPlateHoldsUnderside(sourceNodes, plate))
+            continue;
+        const restingUnderside = automaticFloorHeight(sourceNodes, plate) - DEFAULT_SLAB_ELEVATION;
+        const { floorHeight, ...withoutLift } = plate;
+        if (input === openings.nodes)
+            input = { ...openings.nodes };
+        input[plate.id] = {
+            ...withoutLift,
+            elevation: floorHeight,
+            thickness: Math.max(plate.thickness, floorHeight - restingUnderside),
+            ...(plate.foundation?.type === 'solid'
+                ? { foundation: { ...plate.foundation, type: 'none' } }
+                : {}),
+        };
+    }
+    // M4 deliberately leaves these authored recesses intact. Let their coverage
+    // identify the room whose floor they supply without making them candidates for retirement.
+    for (const slab of legacyRecessed) {
+        input[slab.id] = { ...slab, autoFromWalls: false };
+        for (const zone of Object.values(input)) {
+            if (zone.type !== 'zone' ||
+                zone.parentId !== slab.parentId)
+                continue;
+            const room = zone;
+            if (room.floor?.sourceSlabId || room.hasFloor === false)
+                continue;
+            const covered = area(intersection(room.polygon, slab.polygon));
+            if (covered < area([{ outer: room.polygon, holes: room.holes }]) * 0.95)
+                continue;
+            input[room.id] = { ...room, floor: { ...room.floor, sourceSlabId: slab.id } };
+        }
+    }
+    input = migrateOwnedFloorOpenings(input).nodes;
+    input = rehomeRetiredPlateCuts(input, legacyNodes);
+    let result = reconcileStructureWithStableIds({ nodes: input });
+    if (result.patches.some((patch) => patch.op === 'update' &&
+        input[patch.id]?.type === 'slab' &&
+        'zoneIds' in patch.data)) {
+        for (let pass = 0; pass < 2; pass++) {
+            const settled = reconcileStructureWithStableIds({ nodes: result.nodes });
+            if (!settled.patches.length)
+                break;
+            result = settled;
+        }
+    }
+    let restoredNodes;
+    if (legacyRecessed.length) {
+        restoredNodes = { ...result.nodes };
+        for (const slab of legacyRecessed)
+            restoredNodes[slab.id] = { ...slab, autoFromWalls: false };
+    }
+    for (const [id, node] of Object.entries(result.nodes)) {
+        const before = input[id];
+        if (node === before ||
+            (node.type !== 'slab' && node.type !== 'ceiling') ||
+            before?.type !== node.type ||
+            node.boundary !== 'auto' ||
+            before.boundary !== 'auto' ||
+            node.holeMetadata?.some((entry) => entry.source === 'floor-opening') ||
+            before.holeMetadata?.some((entry) => entry.source === 'floor-opening') ||
+            JSON.stringify([
+                node.polygon,
+                node.type === 'slab' ? node.zoneIds : node.zoneId,
+                roomHoles(node),
+            ]) !==
+                JSON.stringify([
+                    before.polygon,
+                    before.type === 'slab' ? before.zoneIds : before.zoneId,
+                    roomHoles(before),
+                ]))
+            continue;
+        // Loading an unchanged plate must not clip or quantise saved user/stair holes.
+        const metadataKey = (metadata) => JSON.stringify(metadata && Object.entries(metadata).sort(([a], [b]) => a.localeCompare(b)));
+        const savedHoles = before.holes ?? [];
+        const savedMetadata = before.holeMetadata ?? [];
+        const derivedMetadata = node.holeMetadata ?? [];
+        const oldCuts = new Set(savedMetadata.map(metadataKey));
+        const added = (node.holes ?? []).flatMap((hole, index) => oldCuts.has(metadataKey(derivedMetadata[index]))
+            ? []
+            : [{ hole, metadata: derivedMetadata[index] ?? { source: 'manual' } }]);
+        const restored = {
+            ...node,
+            holes: [...savedHoles, ...added.map((entry) => entry.hole)],
+            holeMetadata: [...savedMetadata, ...added.map((entry) => entry.metadata)],
+        };
+        restoredNodes ??= { ...result.nodes };
+        restoredNodes[id] = JSON.stringify(restored) === JSON.stringify(before) ? before : restored;
+    }
+    const cleaned = discardOrphanLegacySlabCuts(restoredNodes ?? result.nodes);
+    const materializedOwned = legacyOpeningsPrepared
+        ? cleaned
+        : materializeLegacyAutoOpenings(cleaned);
+    const owned = migrateOwnedFloorOpenings(materializedOwned);
+    let nodes = owned.nodes;
+    const rehomed = rehomeRetiredPlateCuts(nodes, legacyNodes);
+    nodes = alignLegacyStairCuts(rehomed);
+    const intentChanges = planOwnedFloorOpenings(nodes, {
+        skipExistingSurfaces: true,
+        enforceReach: false,
+        materializedNodes: materializedOwned,
+    });
+    if (intentChanges.length) {
+        nodes = { ...nodes };
+        for (const change of intentChanges) {
+            if (change.op === 'create')
+                nodes[change.node.id] = change.node;
+            else if (change.op === 'delete')
+                delete nodes[change.id];
+            else
+                nodes[change.id] = { ...nodes[change.id], ...change.data };
+        }
+    }
+    if (owned.changed || nodes !== owned.nodes || intentChanges.length)
+        nodes = reconcileStructureWithStableIds({ nodes }).nodes;
+    nodes = ensureSceneOpenings(nodes).nodes;
+    nodes = preserveLegacyWallDatums(legacyNodes, nodes);
+    for (const level of Object.values(nodes)) {
+        if (level.type !== 'level' || !level.metadata?.legacyRoomMigrationPending)
+            continue;
+        const { legacyRoomMigrationPending: _pending, ...metadata } = level.metadata;
+        nodes = { ...nodes, [level.id]: { ...level, metadata } };
+    }
+    const followed = migrateFootprintFollowing(nodes);
+    // Walls that now follow the storey plane reach the ceilings, which stop at their faces.
+    if (followed !== nodes)
+        nodes = reconcileStructureWithStableIds({ nodes: followed }).nodes;
+    for (const ceiling of Object.values(nodes)) {
+        if (ceiling.type !== 'ceiling' || ceiling.height === undefined || !ceiling.parentId)
+            continue;
+        const saved = legacyNodes[ceiling.id];
+        // Loading never moves a saved height: the kernel's write clamp would drop a
+        // legacy ceiling stored above its storey, which the scene has always shown there.
+        if (saved?.type === 'ceiling' && saved.height !== undefined) {
+            if (ceiling.height === saved.height)
+                continue;
+            const restored = { ...ceiling, height: saved.height };
+            const loaded = sourceNodes[ceiling.id];
+            nodes = {
+                ...nodes,
+                [ceiling.id]: JSON.stringify(restored) === JSON.stringify(loaded) ? loaded : restored,
+            };
+            continue;
+        }
+        const bound = getCeilingClampBound(ceiling.parentId, nodes, ceiling.polygon);
+        if (ceiling.height > bound + 1e-6)
+            nodes = { ...nodes, [ceiling.id]: { ...ceiling, height: bound } };
+    }
+    nodes = migrateExteriorThresholds(nodes, legacyNodes);
+    if (Object.keys(nodes).length === Object.keys(sourceNodes).length &&
+        Object.entries(nodes).every(([id, node]) => node === sourceNodes[id])) {
+        nodes = sourceNodes;
+    }
+    // Build the support map during load so the first height gesture stays responsive.
+    upperStoreyFootprints(nodes);
+    return { nodes, changed: nodes !== sourceNodes };
+}
+export const reconcileStructureOnLoad = loadMigration('structure reconcile', (view, legacyNodes, options = {}) => reconcileStructureOnView(view, legacyNodes === undefined ? view : loadNodeView(legacyNodes).view, options), (nodes) => ({ nodes: nodes, changed: false }));

package/dist/utils/room-zone-migration.d.ts

@@ -0,0 +1,18 @@
+export type RoomZoneMigration = {
+    nodes: Record<string, unknown>;
+    createdZoneIds: string[];
+    adoptedZoneIds: string[];
+};
+export type CeilingRoomLinkMigration = {
+    nodes: Record<string, unknown>;
+    linkedCeilingIds: string[];
+    /** Rooms M3 just migrated on a never-reconciled level that no legacy ceiling served: `hasCeiling: false`. */
+    ceilinglessZoneIds: string[];
+};
+export declare const migrateRoomZones: (nodes: {
+    [x: string]: unknown;
+}) => RoomZoneMigration;
+export declare const migrateCeilingRoomLinks: (nodes: {
+    [x: string]: unknown;
+}) => CeilingRoomLinkMigration;
+//# sourceMappingURL=room-zone-migration.d.ts.map

package/dist/utils/room-zone-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-zone-migration.d.ts","sourceRoot":"","sources":["../../src/utils/room-zone-migration.ts"],"names":[],"mappings":"AAmCA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,cAAc,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,6GAA6G;IAC7G,kBAAkB,EAAE,MAAM,EAAE,CAAA;CAC7B,CAAA;AA2RD,eAAO,MAAM,gBAAgB;;uBAI1B,CAAA;AAEH,eAAO,MAAM,uBAAuB;;8BAInC,CAAA"}

package/dist/utils/room-zone-migration.js

@@ -0,0 +1,258 @@
+import { floorRoomFaces } from '../lib/floor-room-faces.js';
+import { area, difference, intersection, union, } from '../lib/polygon-boolean.js';
+import { polygonInteriorPoint } from '../lib/polygon-label.js';
+import { roomNameAllocator } from '../lib/room-name.js';
+import { adoptableFace, compareAdoptionFits, compareExistingRooms, existingRoomFace, ROOM_MATCH_IOU, zoneFaceFits, } from '../lib/room-zone-adoption.js';
+import { ZoneNode } from '../schema/nodes/zone.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+import { loadMigration } from './load-migration.js';
+import { omitUndefined } from './omit-undefined.js';
+/** Visible outline change (m²) above which a legacy ceiling is not handed to its room. */
+const LEGACY_CEILING_REDRAW_AREA = 0.01;
+function facesByLevel(nodes) {
+    const boundaries = new Map();
+    for (const node of Object.values(nodes)) {
+        if (!node || nodes[node.parentId]?.type !== 'level')
+            continue;
+        if (node.type !== 'wall' && node.type !== 'separator')
+            continue;
+        const level = boundaries.get(node.parentId) ?? { walls: [], separators: [] };
+        if (node.type === 'wall')
+            level.walls.push(node);
+        else
+            level.separators.push(node);
+        boundaries.set(node.parentId, level);
+    }
+    return new Map([...boundaries]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([levelId, level]) => [
+        levelId,
+        floorRoomFaces([...level.walls, ...level.separators]).map((room) => ({
+            key: room.id,
+            polygon: room.referencePolygon,
+            holes: room.holes,
+            boundaryWallIds: [
+                ...new Set(room.spans
+                    .filter((span) => span.kind === 'wall')
+                    .map((span) => span.boundaryId)),
+            ].sort(),
+            boundarySeparatorIds: [
+                ...new Set(room.spans
+                    .filter((span) => span.kind === 'separator')
+                    .map((span) => span.boundaryId)),
+            ].sort(),
+        })),
+    ]));
+}
+function polygonOf(footprint) {
+    return { outer: footprint.polygon, holes: footprint.holes ?? [] };
+}
+function footprintIoU(a, b) {
+    const left = polygonOf(a);
+    const right = polygonOf(b);
+    const combinedArea = area(union([left, right]));
+    return combinedArea > 0 ? area(intersection(left, right)) / combinedArea : 0;
+}
+function roomZoneId(levelId, face, attempt = 0) {
+    const identity = JSON.stringify([
+        levelId,
+        [...face.boundaryWallIds].sort(),
+        [...face.boundarySeparatorIds].sort(),
+        ...(attempt ? [attempt] : []),
+    ]);
+    // FNV-1a over UTF-8 is identical on the client and authority, including non-ASCII legacy IDs.
+    let hash = 0xcbf29ce484222325n;
+    for (const byte of new TextEncoder().encode(identity)) {
+        hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+    }
+    return `zone_${hash.toString(36).padStart(16, '0')}`;
+}
+function migrateRoomZonesOnView(sourceNodes) {
+    const nodes = { ...sourceNodes };
+    const createdZoneIds = [];
+    const adoptedZoneIds = [];
+    for (const [levelId, faces] of facesByLevel(nodes)) {
+        const createdBefore = createdZoneIds.length;
+        const adoptedBefore = adoptedZoneIds.length;
+        const zones = Object.values(nodes)
+            .filter((node) => node?.type === 'zone' && node.parentId === levelId && node.floor?.support !== 'open')
+            .sort((a, b) => a.id.localeCompare(b.id));
+        const walls = Object.values(nodes).filter((node) => node?.type === 'wall' && node.parentId === levelId);
+        const miters = calculateLevelMiters(walls);
+        const footprints = new Map(walls.map((wall) => [
+            wall.id,
+            getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y]),
+        ]));
+        const adoptionFaces = faces.map((face) => ({
+            key: face.key,
+            boundaryWallIds: face.boundaryWallIds,
+            boundarySeparatorIds: face.boundarySeparatorIds,
+            polygon: polygonOf(face),
+            clear: difference(polygonOf(face), union(face.boundaryWallIds.flatMap((id) => (footprints.has(id) ? [footprints.get(id)] : [])))).sort((a, b) => area([b]) - area([a]))[0] ?? { outer: [], holes: [] },
+        }));
+        // Existing rooms keep their faces under the kernel's identity rule first, so a
+        // reload never replaces one with a new room the kernel would then keep instead.
+        const zoneByFace = new Map();
+        const matched = new Set();
+        const keeping = new Map();
+        for (const zone of zones) {
+            if (zone.spaceRole !== 'room' || zone.autoFromWalls !== true)
+                continue;
+            matched.add(zone.id);
+            const index = existingRoomFace(zone, adoptionFaces);
+            if (index !== undefined)
+                keeping.set(index, [...(keeping.get(index) ?? []), zone]);
+        }
+        for (const [index, rooms] of keeping)
+            zoneByFace.set(index, rooms.sort(compareExistingRooms(adoptionFaces[index]))[0]);
+        const candidates = new Map();
+        for (const zone of zones) {
+            if (matched.has(zone.id))
+                continue;
+            const fit = adoptableFace(zoneFaceFits(zone, adoptionFaces));
+            if (!fit || zoneByFace.has(fit.face))
+                continue;
+            const list = candidates.get(fit.face) ?? [];
+            list.push({ id: zone.id, fit });
+            candidates.set(fit.face, list);
+        }
+        for (const [index, list] of candidates)
+            zoneByFace.set(index, nodes[list.sort(compareAdoptionFits)[0].id]);
+        const nextRoomName = roomNameAllocator(Object.values(nodes).filter((node) => node?.type === 'zone' && node.parentId === levelId));
+        faces.forEach((face, index) => {
+            const zone = zoneByFace.get(index);
+            if (zone) {
+                const adopted = {
+                    ...zone,
+                    spaceRole: 'room',
+                    autoFromWalls: true,
+                    boundaryWallIds: face.boundaryWallIds,
+                    boundarySeparatorIds: face.boundarySeparatorIds,
+                    seed: zone.seed ?? polygonInteriorPoint(face, true),
+                    polygon: face.polygon,
+                    holes: face.holes,
+                };
+                if (JSON.stringify(zone) !== JSON.stringify(adopted)) {
+                    nodes[zone.id] = omitUndefined(adopted);
+                    adoptedZoneIds.push(zone.id);
+                }
+                return;
+            }
+            let attempt = 0;
+            let id = roomZoneId(levelId, face);
+            while (nodes[id])
+                id = roomZoneId(levelId, face, ++attempt);
+            nodes[id] = omitUndefined(ZoneNode.parse({
+                id,
+                parentId: levelId,
+                name: nextRoomName(),
+                spaceRole: 'room',
+                autoFromWalls: true,
+                polygon: face.polygon,
+                holes: face.holes,
+                boundaryWallIds: face.boundaryWallIds,
+                boundarySeparatorIds: face.boundarySeparatorIds,
+                seed: polygonInteriorPoint(face, true),
+            }));
+            const level = nodes[levelId];
+            nodes[levelId] = omitUndefined({ ...level, children: [...(level.children ?? []), id] });
+            createdZoneIds.push(id);
+        });
+        if (createdZoneIds.length !== createdBefore || adoptedZoneIds.length !== adoptedBefore) {
+            const level = nodes[levelId];
+            nodes[levelId] = {
+                ...level,
+                metadata: { ...level.metadata, legacyRoomMigrationPending: true },
+            };
+        }
+    }
+    return {
+        nodes: createdZoneIds.length || adoptedZoneIds.length ? nodes : sourceNodes,
+        createdZoneIds,
+        adoptedZoneIds,
+    };
+}
+function migrateCeilingRoomLinksOnView(sourceNodes) {
+    const nodes = { ...sourceNodes };
+    const linkedCeilingIds = [];
+    const ceilinglessZoneIds = [];
+    const zones = Object.values(nodes)
+        .filter((node) => node?.type === 'zone' && node.spaceRole === 'room')
+        .sort((a, b) => a.id.localeCompare(b.id));
+    // Levels the room kernel has already written derived plates or ceilings on.
+    const reconciledLevels = new Set(Object.values(nodes).flatMap((node) => (node?.type === 'ceiling' || node?.type === 'slab') &&
+        (node.boundary === 'auto' || node.plateRole)
+        ? [node.parentId]
+        : []));
+    let faces;
+    const reachingWalls = new Map();
+    // What of the ceiling's outline would change if the room redrew it, outside the
+    // storey-high walls that hide it: the room face differs from the drawn outline there.
+    const redrawnArea = (ceiling, zone) => {
+        let walls = reachingWalls.get(ceiling.parentId);
+        if (!walls) {
+            const levelWalls = Object.values(nodes).filter((node) => node?.type === 'wall' && node.parentId === ceiling.parentId);
+            const miters = calculateLevelMiters(levelWalls);
+            walls = union(levelWalls
+                .filter((wall) => wall.height == null)
+                .map((wall) => getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y])));
+            reachingWalls.set(ceiling.parentId, walls);
+        }
+        // The room keeps the ceiling's own cutouts (stairs, manual holes) and adds its face's.
+        const drawn = { outer: ceiling.polygon, holes: ceiling.holes ?? [] };
+        const cuts = union(ceiling.holes ?? []);
+        const face = cuts.length ? difference(polygonOf(zone), cuts) : [polygonOf(zone)];
+        const changed = union([...difference(drawn, face), ...difference(face, drawn)]);
+        return area(walls.length ? difference(changed, walls) : changed);
+    };
+    for (const [id, ceiling] of Object.entries(nodes)) {
+        if (ceiling?.type !== 'ceiling' || nodes[ceiling.parentId]?.type !== 'level')
+            continue;
+        // Overlapping stacked rooms already have authoritative ceiling links.
+        if (ceiling.boundary === 'auto' && nodes[ceiling.zoneId]?.floor?.support === 'open')
+            continue;
+        if (ceiling.autoFromWalls !== true) {
+            if (ceiling.height !== undefined)
+                continue;
+            faces ??= facesByLevel(nodes);
+            if (!faces.get(ceiling.parentId)?.some((face) => footprintIoU(ceiling, face) >= ROOM_MATCH_IOU))
+                continue;
+        }
+        const zone = zones.find((candidate) => candidate.floor?.support !== 'open' &&
+            candidate.parentId === ceiling.parentId &&
+            footprintIoU(ceiling, candidate) >= ROOM_MATCH_IOU);
+        if (!zone || (ceiling.zoneId === zone.id && ceiling.boundary === 'auto'))
+            continue;
+        // Linking hands the outline to the room, which redraws it from the walls: a legacy
+        // ceiling drawn elsewhere than its room face would visibly move, so it stays manual.
+        if (ceiling.boundary !== 'auto' && redrawnArea(ceiling, zone) > LEGACY_CEILING_REDRAW_AREA)
+            continue;
+        nodes[id] = omitUndefined({ ...ceiling, zoneId: zone.id, boundary: 'auto' });
+        linkedCeilingIds.push(id);
+    }
+    // A legacy room keeps exactly the ceiling it had: one linked above, or none. Without
+    // this the kernel would give every room it never had a ceiling a new one on load.
+    // Only on the load that migrates the level (M3 marks it), so a reload writes nothing.
+    const linkedZoneIds = new Set(Object.values(nodes).flatMap((node) => node?.type === 'ceiling' && node.boundary === 'auto' && node.zoneId ? [node.zoneId] : []));
+    for (const zone of zones) {
+        if (nodes[zone.parentId]?.metadata?.legacyRoomMigrationPending !== true ||
+            reconciledLevels.has(zone.parentId) ||
+            zone.hasCeiling === false ||
+            zone.floor?.support === 'open' ||
+            linkedZoneIds.has(zone.id))
+            continue;
+        nodes[zone.id] = { ...zone, hasCeiling: false };
+        ceilinglessZoneIds.push(zone.id);
+    }
+    return {
+        nodes: linkedCeilingIds.length || ceilinglessZoneIds.length ? nodes : sourceNodes,
+        linkedCeilingIds,
+        ceilinglessZoneIds,
+    };
+}
+export const migrateRoomZones = loadMigration('room zones', migrateRoomZonesOnView, (nodes) => ({
+    nodes,
+    createdZoneIds: [],
+    adoptedZoneIds: [],
+}));
+export const migrateCeilingRoomLinks = loadMigration('ceiling room links', migrateCeilingRoomLinksOnView, (nodes) => ({ nodes, linkedCeilingIds: [], ceilinglessZoneIds: [] }));

package/dist/utils/scene-migrations.d.ts

@@ -1,4 +1,19 @@
-export { type HealSceneResult, healSceneNodes } from './heal-scene-graph.js';
+export type { NodePatch, SceneNodes, StructureEvent } from '../lib/structure-kernel.js';
+export { reconcileSceneStructure, type SceneStructureInput, type SceneStructureResult, type StructureIdFactory, } from '../lib/structure-reconcile.js';
+export { ensureSceneOpenings } from './ensure-scene-openings.js';
+export { migrateFloorOpeningNodes } from './floor-opening-migration.js';
+export { type FloorPlateMigrationReport, migrateFloorPlates, migrateSlabSlots, } from './floor-plate-migration.js';
+export { healScenePlanCoordinates } from './heal-plan-coordinates.js';
+export { type HealSceneResult, healSceneNodes, repairClaimedParentLinks, } from './heal-scene-graph.js';
+export { migrateStructuralMaterialSlots } from './legacy-material-slots.js';
+export { materializeNodeDefaults, STRUCTURE_NODE_KINDS } from './node-defaults.js';
+export { normalizeLegacyStructure } from './normalize-legacy-structure.js';
+export { materializeLegacyAutoOpenings, migrateOwnedFloorOpenings, } from './owned-floor-opening-migration.js';
+export { reconcileStructureOnLoad } from './reconcile-structure-on-load.js';
 export { type RetiredSceneNodeMigration, removeRetiredDrawingSheetNodes, } from './retired-scene-nodes.js';
+export { type CeilingRoomLinkMigration, migrateCeilingRoomLinks, migrateRoomZones, type RoomZoneMigration, } from './room-zone-migration.js';
+export { createStructureIdFactory, reconcileStructureWithStableIds } from './structure-id.js';
 export { migrateVerticalSceneNodes, type VerticalSceneMigration, } from './vertical-scene-migration.js';
+export { migrateLegacyWallAssemblies, type WallAssemblyMigration, } from './wall-assembly-migration.js';
+export { migrateWallFaceBands, migrateWallFaceKeys } from './wall-face-migration.js';
 //# sourceMappingURL=scene-migrations.d.ts.map

package/dist/utils/scene-migrations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-migrations.d.ts","sourceRoot":"","sources":["../../src/utils/scene-migrations.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,EACL,KAAK,yBAAyB,EAC9B,8BAA8B,GAC/B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,yBAAyB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,4BAA4B,CAAA"}
+{"version":3,"file":"scene-migrations.d.ts","sourceRoot":"","sources":["../../src/utils/scene-migrations.ts"],"names":[],"mappings":"AAKA,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AACpF,OAAO,EACL,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,GACxB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AACpE,OAAO,EACL,KAAK,yBAAyB,EAC9B,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAClE,OAAO,EACL,KAAK,eAAe,EACpB,cAAc,EACd,wBAAwB,GACzB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAA;AACxE,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,GAC1B,MAAM,iCAAiC,CAAA;AACxC,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EACL,KAAK,yBAAyB,EAC9B,8BAA8B,GAC/B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,KAAK,wBAAwB,EAC7B,uBAAuB,EACvB,gBAAgB,EAChB,KAAK,iBAAiB,GACvB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,wBAAwB,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAA;AAC1F,OAAO,EACL,yBAAyB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,4BAA4B,CAAA;AACnC,OAAO,EACL,2BAA2B,EAC3B,KAAK,qBAAqB,GAC3B,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/utils/scene-migrations.js

@@ -2,6 +2,20 @@
 // scene authority. Everything exported here must stay pure data logic with no
 // store, React, or Three.js imports so it can run in Server Components and
 // API routes.
-export { healSceneNodes } from './heal-scene-graph.js';
+export { reconcileSceneStructure, } from '../lib/structure-reconcile.js';
+export { ensureSceneOpenings } from './ensure-scene-openings.js';
+export { migrateFloorOpeningNodes } from './floor-opening-migration.js';
+export { migrateFloorPlates, migrateSlabSlots, } from './floor-plate-migration.js';
+export { healScenePlanCoordinates } from './heal-plan-coordinates.js';
+export { healSceneNodes, repairClaimedParentLinks, } from './heal-scene-graph.js';
+export { migrateStructuralMaterialSlots } from './legacy-material-slots.js';
+export { materializeNodeDefaults, STRUCTURE_NODE_KINDS } from './node-defaults.js';
+export { normalizeLegacyStructure } from './normalize-legacy-structure.js';
+export { materializeLegacyAutoOpenings, migrateOwnedFloorOpenings, } from './owned-floor-opening-migration.js';
+export { reconcileStructureOnLoad } from './reconcile-structure-on-load.js';
 export { removeRetiredDrawingSheetNodes, } from './retired-scene-nodes.js';
+export { migrateCeilingRoomLinks, migrateRoomZones, } from './room-zone-migration.js';
+export { createStructureIdFactory, reconcileStructureWithStableIds } from './structure-id.js';
 export { migrateVerticalSceneNodes, } from './vertical-scene-migration.js';
+export { migrateLegacyWallAssemblies, } from './wall-assembly-migration.js';
+export { migrateWallFaceBands, migrateWallFaceKeys } from './wall-face-migration.js';