@pascal-app/core 1.0.1 → 1.0.4

package/dist/utils/ensure-scene-openings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-scene-openings.d.ts","sourceRoot":"","sources":["../../src/utils/ensure-scene-openings.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAA"}

package/dist/utils/ensure-scene-openings.js

@@ -0,0 +1,29 @@
+import { syncStairRises } from '../systems/stair/stair-rise-query.js';
+import { loadMigration } from './load-migration.js';
+function ensureSceneOpeningsOnView(sourceNodes) {
+    let nodes = sourceNodes;
+    const patches = new Map();
+    const kinds = new Set(Object.values(nodes).map((node) => node.type));
+    const steps = kinds.has('stair') ? [syncStairRises] : [];
+    let pending = true;
+    while (pending) {
+        pending = false;
+        for (const derive of steps) {
+            const updates = derive(nodes);
+            if (!updates.length)
+                continue;
+            pending = true;
+            nodes = { ...nodes };
+            for (const { id, data } of updates) {
+                nodes[id] = { ...nodes[id], ...data };
+                patches.set(id, { ...patches.get(id), ...data });
+            }
+        }
+    }
+    return {
+        nodes,
+        changed: nodes !== sourceNodes,
+        updates: [...patches].map(([id, data]) => ({ id, data })),
+    };
+}
+export const ensureSceneOpenings = loadMigration('stair and elevator openings', ensureSceneOpeningsOnView, (nodes) => ({ nodes: nodes, changed: false, updates: [] }));

package/dist/utils/exterior-threshold-migration.d.ts

@@ -0,0 +1,4 @@
+import type { AnyNode } from '../schema/index.js';
+/** Preserve the formerly plate-owned finish as ordinary, editable room paint. */
+export declare function migrateExteriorThresholds(source: Record<string, AnyNode>, legacy?: Record<string, unknown>): Record<string, AnyNode>;
+//# sourceMappingURL=exterior-threshold-migration.d.ts.map

package/dist/utils/exterior-threshold-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exterior-threshold-migration.d.ts","sourceRoot":"","sources":["../../src/utils/exterior-threshold-migration.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,OAAO,EAAsD,MAAM,WAAW,CAAA;AA6C5F,iFAAiF;AACjF,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAU,GACvC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwEzB"}

package/dist/utils/exterior-threshold-migration.js

@@ -0,0 +1,114 @@
+import { parseSlabConstruction } from '../lib/floor-plates.js';
+import { computePlateSurfacePartition, parseRoomFinishRole, plateFinishKey, plateLevelContext, plateOpeningLandings, } from '../lib/plate-surface.js';
+import { area, difference, intersection, } from '../lib/polygon-boolean.js';
+import { getRenderableSlabPolygon, prepareSlabPolygonContext } from '../lib/slab-polygon.js';
+function slabFinish(slab) {
+    return slab.slots?.surface ?? slab.material ?? slab.materialPreset ?? 'library:wood-woodplank48';
+}
+function legacySurfaces(legacy, levelId) {
+    const children = Object.values(legacy).filter((node) => node.parentId === levelId);
+    const slabs = children.filter((node) => node.type === 'slab');
+    if (slabs.some((slab) => slab.plateRole))
+        return [];
+    const context = prepareSlabPolygonContext({
+        walls: children.filter((node) => node.type === 'wall'),
+        siblingSlabs: slabs,
+    });
+    return slabs
+        .filter((slab) => slab.visible !== false && !slab.recessed)
+        .map(parseSlabConstruction)
+        .sort((a, b) => b.elevation - a.elevation || a.id.localeCompare(b.id))
+        .map((slab) => ({
+        elevation: slab.elevation,
+        polygons: { outer: getRenderableSlabPolygon(slab, context), holes: slab.holes },
+        finish: slabFinish(slab),
+    }));
+}
+function regionRings(polygon) {
+    if (!polygon.holes.length)
+        return [polygon.outer];
+    const xs = [...new Set([...polygon.outer, ...polygon.holes.flat()].map(([x]) => x))].sort((a, b) => a - b);
+    const zs = polygon.outer.map(([, z]) => z);
+    const minZ = Math.min(...zs), maxZ = Math.max(...zs);
+    return xs.slice(1).flatMap((x, i) => intersection(polygon, [
+        [xs[i], minZ],
+        [x, minZ],
+        [x, maxZ],
+        [xs[i], maxZ],
+    ]).map((part) => part.outer));
+}
+/** Preserve the formerly plate-owned finish as ordinary, editable room paint. */
+export function migrateExteriorThresholds(source, legacy = source) {
+    const pending = new Set(Object.values(source)
+        .filter((node) => (node.type === 'door' || node.type === 'window') &&
+        legacy[node.id]?.floorThresholdVersion !== 1)
+        .map((node) => node.id));
+    if (!pending.size)
+        return source;
+    const nodes = { ...source };
+    for (const level of Object.values(source)) {
+        if (level.type !== 'level')
+            continue;
+        const context = plateLevelContext(level, (id) => source[id]);
+        if (!context.openings?.some((opening) => pending.has(opening.id)))
+            continue;
+        const landings = plateOpeningLandings(context).filter((landing) => landing.exterior && pending.has(landing.openingId));
+        if (!landings.length)
+            continue;
+        const original = legacySurfaces(legacy, level.id);
+        for (const plate of context.slabs) {
+            if (plate.visible === false)
+                continue;
+            const partition = computePlateSurfacePartition(plate, context);
+            if (!partition)
+                continue;
+            const fallback = slabFinish(plate);
+            for (const landing of landings) {
+                let index = 0;
+                for (const cell of partition.cells) {
+                    if (parseRoomFinishRole(cell.role)?.zoneId !== landing.zoneId)
+                        continue;
+                    let remaining = intersection(cell.polygons, landing.polygons);
+                    if (area(remaining) < 1e-6)
+                        continue;
+                    const preserved = [];
+                    // Raw pre-plate scenes still have their original slabs. Reading only
+                    // the merged plate would preserve an earlier migration's lost finish.
+                    for (const surface of original) {
+                        if (Math.abs(surface.elevation - plate.elevation) > 0.02 + 1e-9)
+                            continue;
+                        const polygons = intersection(remaining, surface.polygons);
+                        if (area(polygons) < 1e-6)
+                            continue;
+                        preserved.push({ polygons, finish: surface.finish });
+                        remaining = difference(remaining, polygons);
+                    }
+                    if (area(remaining) >= 1e-6)
+                        preserved.push({ polygons: remaining, finish: fallback });
+                    const regions = preserved.flatMap(({ polygons, finish }) => plateFinishKey(cell.finish ?? fallback) === plateFinishKey(finish)
+                        ? []
+                        : polygons.flatMap(regionRings).map((polygon) => ({
+                            id: `threshold:${landing.openingId}:${plate.id}:${index++}`,
+                            polygon,
+                            finish,
+                        })));
+                    if (!regions.length)
+                        continue;
+                    const zone = nodes[landing.zoneId];
+                    nodes[zone.id] = {
+                        ...zone,
+                        floor: {
+                            ...zone.floor,
+                            regions: [...(zone.floor?.regions ?? []), ...regions],
+                        },
+                    };
+                }
+            }
+        }
+    }
+    // Stamp every existing opening, even interior ones: a later room deletion
+    // must not turn a newly exterior doorway into another legacy migration.
+    for (const id of pending)
+        nodes[id] = { ...nodes[id], floorThresholdVersion: 1 };
+    return nodes;
+}

package/dist/utils/floor-follow-migration.d.ts

@@ -0,0 +1,3 @@
+import type { AnyNode } from '../schema/index.js';
+export declare function migrateFootprintFollowing(nodes: Record<string, AnyNode>): Record<string, AnyNode>;
+//# sourceMappingURL=floor-follow-migration.d.ts.map

package/dist/utils/floor-follow-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-follow-migration.d.ts","sourceRoot":"","sources":["../../src/utils/floor-follow-migration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAIxC,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8BjG"}

package/dist/utils/floor-follow-migration.js

@@ -0,0 +1,29 @@
+import { footprintLift } from '../lib/floor-foundation-datum.js';
+import { wallSupportForNodes } from '../lib/opening-floor-datum.js';
+import { getWallPlaneTop } from '../services/storey.js';
+import { wallOverlapsSlabFootprint } from '../systems/slab/slab-support.js';
+export function migrateFootprintFollowing(nodes) {
+    const bases = Object.values(nodes).filter((node) => node.type === 'slab' &&
+        node.plateRole === 'base' &&
+        Math.abs(footprintLift(nodes, node)) > 1e-6);
+    if (!bases.length)
+        return nodes;
+    let result = nodes;
+    for (const wall of Object.values(nodes)) {
+        if (wall.type !== 'wall' ||
+            wall.height === undefined ||
+            wall.supportSlabId === 'ground' ||
+            !bases.some((base) => base.type === 'slab' &&
+                base.parentId === wall.parentId &&
+                wallOverlapsSlabFootprint(wall, base.polygon)))
+            continue;
+        const following = getWallPlaneTop(wall, wall.parentId, nodes) - wallSupportForNodes(wall, nodes).elevation;
+        if (Math.abs(following - wall.height) > 1e-6)
+            continue;
+        const { height: _height, ...next } = wall;
+        if (result === nodes)
+            result = { ...nodes };
+        result[wall.id] = next;
+    }
+    return result;
+}

package/dist/utils/floor-opening-migration.d.ts

@@ -0,0 +1,13 @@
+export declare const migrateFloorOpeningNodes: (nodes: {
+    [x: string]: unknown;
+}) => {
+    nodes: {
+        [x: string]: unknown;
+    };
+    changed: boolean;
+    adoptedHoles: number;
+    created: number;
+    dedupes: number;
+    unions: number;
+};
+//# sourceMappingURL=floor-opening-migration.d.ts.map

package/dist/utils/floor-opening-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-opening-migration.d.ts","sourceRoot":"","sources":["../../src/utils/floor-opening-migration.ts"],"names":[],"mappings":"AAiKA,eAAO,MAAM,wBAAwB;;;;;;;;;;;CAWpC,CAAA"}

package/dist/utils/floor-opening-migration.js

@@ -0,0 +1,148 @@
+import { adjacentLevelId } from '../lib/floor-opening-intent.js';
+import { area, intersection, union } from '../lib/polygon-boolean.js';
+import { FloorOpeningNode } from '../schema/nodes/floor-opening.js';
+import { loadMigration } from './load-migration.js';
+function polygonKey(polygon) {
+    return polygon.map(([x, z]) => [Math.round(x * 10_000), Math.round(z * 10_000)]);
+}
+function openingId(levelId, hostZoneId, polygon) {
+    const seed = JSON.stringify([levelId, hostZoneId ?? '', polygonKey(polygon)]);
+    let hash = 0xcbf29ce484222325n;
+    for (const byte of new TextEncoder().encode(seed))
+        hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+    return `floor-opening_${hash.toString(36).padStart(16, '0')}`;
+}
+function matchingCeilingHole(nodes, levelId, polygon) {
+    const below = adjacentLevelId(nodes, levelId, -1);
+    if (!below)
+        return false;
+    const size = area([{ outer: polygon, holes: [] }]);
+    if (size < 1e-4)
+        return false;
+    return Object.values(nodes).some((value) => {
+        const ceiling = value;
+        return (ceiling.type === 'ceiling' &&
+            ceiling.parentId === below &&
+            (ceiling.boundary === 'auto' || ceiling.autoFromWalls) &&
+            ceiling.holes?.some((hole) => Math.abs(area(intersection(polygon, hole)) - size) < 1e-4 &&
+                Math.abs(area([{ outer: hole, holes: [] }]) - size) < 1e-4));
+    });
+}
+function migrateFloorOpeningNodesOnView(sourceNodes) {
+    let nodes = sourceNodes;
+    const groups = new Map();
+    let adoptedHoles = 0;
+    let dedupes = 0;
+    let unions = 0;
+    for (const value of Object.values(sourceNodes)) {
+        const slab = value;
+        if (slab.type !== 'slab' ||
+            !(slab.boundary === 'auto' || slab.autoFromWalls) ||
+            (slab.recessed === true && slab.autoFromWalls && !slab.boundary) ||
+            !slab.parentId ||
+            !Array.isArray(slab.holes))
+            continue;
+        const kept = slab.holes.flatMap((hole, index) => {
+            const metadata = slab.holeMetadata?.[index];
+            if ((metadata?.source ?? 'manual') !== 'manual')
+                return [{ hole, metadata }];
+            if (area([{ outer: hole, holes: [] }]) < 1e-4)
+                return [];
+            const hostZoneId = slab.support === 'open' && slab.zoneIds?.length === 1 ? slab.zoneIds[0] : undefined;
+            const managed = slab.metadata?.poolManagedOpenings;
+            const pool = Array.isArray(managed)
+                ? managed.find((entry) => {
+                    const candidate = entry;
+                    return (typeof candidate.poolId === 'string' &&
+                        (candidate.holeIndex === index ||
+                            JSON.stringify(candidate.polygon) === JSON.stringify(hole)));
+                })
+                : undefined;
+            const ownerId = pool?.poolId;
+            const key = JSON.stringify([slab.parentId, hostZoneId ?? '', ownerId ?? '']);
+            const group = groups.get(key) ?? {
+                levelId: slab.parentId,
+                hostZoneId,
+                ownerId,
+                cuts: [],
+            };
+            group.cuts.push({ plateId: slab.id, polygon: hole });
+            groups.set(key, group);
+            adoptedHoles++;
+            return [];
+        });
+        if (kept.length === slab.holes.length)
+            continue;
+        if (nodes === sourceNodes)
+            nodes = { ...sourceNodes };
+        nodes[slab.id] = {
+            ...slab,
+            holes: kept.map(({ hole }) => hole),
+            holeMetadata: kept.map(({ metadata }) => metadata ?? { source: 'manual' }),
+        };
+    }
+    let created = 0;
+    for (const group of [...groups.values()].sort((a, b) => JSON.stringify([a.levelId, a.hostZoneId, a.ownerId]).localeCompare(JSON.stringify([b.levelId, b.hostZoneId, b.ownerId])))) {
+        const unique = [
+            ...new Map(group.cuts.map(({ polygon }) => [JSON.stringify(polygonKey(polygon)), polygon])).values(),
+        ];
+        const parts = union(unique);
+        dedupes += group.cuts.length - unique.length;
+        unions += unique.length - parts.length;
+        for (const part of parts) {
+            if (area([part]) < 1e-4)
+                continue;
+            const id = openingId(group.levelId, group.hostZoneId, part.outer);
+            const legacyPlateCuts = {};
+            for (const cut of group.cuts) {
+                if (area(intersection(cut.polygon, part)) < 1e-6)
+                    continue;
+                const stored = legacyPlateCuts[cut.plateId] ?? [];
+                if (!stored.some((ring) => JSON.stringify(ring) === JSON.stringify(cut.polygon)))
+                    stored.push(cut.polygon);
+                legacyPlateCuts[cut.plateId] = stored;
+            }
+            const existing = nodes[id];
+            if (existing?.type === 'floor-opening') {
+                if (nodes === sourceNodes)
+                    nodes = { ...sourceNodes };
+                nodes[id] = {
+                    ...existing,
+                    legacyPlateCuts: { ...existing.legacyPlateCuts, ...legacyPlateCuts },
+                    ...(group.ownerId ? { source: 'plugin:pool', ownerId: group.ownerId } : {}),
+                };
+                continue;
+            }
+            if (nodes === sourceNodes)
+                nodes = { ...sourceNodes };
+            nodes[id] = FloorOpeningNode.parse({
+                id,
+                parentId: group.levelId,
+                name: 'Floor opening',
+                polygon: part.outer,
+                ...(group.hostZoneId ? { hostZoneId: group.hostZoneId } : {}),
+                legacyPlateCuts,
+                source: group.ownerId ? 'plugin:pool' : 'manual',
+                ownerId: group.ownerId,
+                drawnOn: 'floor',
+                cutsPrimary: true,
+                cutsAdjacent: !group.ownerId &&
+                    !group.hostZoneId &&
+                    matchingCeilingHole(sourceNodes, group.levelId, part.outer),
+            });
+            const level = nodes[group.levelId];
+            if (level?.type === 'level' && !level.children.includes(id))
+                nodes[group.levelId] = { ...level, children: [...level.children, id] };
+            created++;
+        }
+    }
+    return { nodes, changed: nodes !== sourceNodes, adoptedHoles, created, dedupes, unions };
+}
+export const migrateFloorOpeningNodes = loadMigration('floor openings', migrateFloorOpeningNodesOnView, (nodes) => ({
+    nodes,
+    changed: false,
+    adoptedHoles: 0,
+    created: 0,
+    dedupes: 0,
+    unions: 0,
+}));

package/dist/utils/floor-piece-adoption.d.ts

@@ -0,0 +1,50 @@
+import { type Polygon, type Ring } from '../lib/polygon-boolean.js';
+import type { AnyNode, SlabNode } from '../schema/index.js';
+/**
+ * Hand-drawn floor pieces: legacy manual slabs someone drew to be the house
+ * floor before rooms generated one. A level's pieces are adopted, all or
+ * nothing, when they are the level's only floor inside its rooms: one top and
+ * one construction, grounded, no platform or step at another height, nothing
+ * reaching more than PIECE_TRIM_DEPTH past the rooms and walls. The load
+ * migration then treats them like legacy wall-generated slabs, so one plate
+ * replaces the patchwork and each room keeps the finish its piece showed.
+ * Drawing noise is the only visible change: strips at most PIECE_TRIM_DEPTH
+ * past a facade go, cracks at most PIECE_GAP_WIDTH wide close, and wider
+ * uncovered room floor stays open as a hole in the plate.
+ */
+export declare const PIECE_TRIM_DEPTH = 0.1;
+export declare const PIECE_GAP_WIDTH = 0.05;
+export type FloorPieceAdoption = {
+    /** Adopted piece id → its level id. */
+    pieces: Map<string, string>;
+    /** Per adopted level: uncovered room floor wider than a crack (plate holes). */
+    levels: Map<string, {
+        voids: Ring[];
+    }>;
+};
+export declare function floorPieceFinish(slab: SlabNode): string | {
+    id?: string | undefined;
+    preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+    properties?: {
+        color: string;
+        roughness: number;
+        metalness: number;
+        opacity: number;
+        transparent: boolean;
+        side: "front" | "back" | "double";
+    } | undefined;
+    texture?: {
+        url: string;
+        repeat?: [number, number] | undefined;
+        scale?: number | undefined;
+    } | undefined;
+} | undefined;
+/** Mean width of a part: 2·area / perimeter (the width of a long strip). */
+export declare function partWidth(part: Polygon): number;
+/**
+ * Plans which legacy manual slabs the floor-plate migration adopts. Runs only
+ * on scenes that have no floor plates yet (the same guard as the legacy floor
+ * migration), so a migrated scene never re-plans.
+ */
+export declare function planFloorPieceAdoption(nodes: Readonly<Record<string, AnyNode>>, skipLevels?: ReadonlySet<string>): FloorPieceAdoption;
+//# sourceMappingURL=floor-piece-adoption.d.ts.map

package/dist/utils/floor-piece-adoption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-piece-adoption.d.ts","sourceRoot":"","sources":["../../src/utils/floor-piece-adoption.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,OAAO,EACZ,KAAK,IAAI,EAEV,MAAM,wBAAwB,CAAA;AAE/B,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAsB,MAAM,WAAW,CAAA;AAGtE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAA;AACnC,eAAO,MAAM,eAAe,OAAO,CAAA;AAEnC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,uCAAuC;IACvC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3B,gFAAgF;IAChF,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,IAAI,EAAE,CAAA;KAAE,CAAC,CAAA;CACvC,CAAA;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ;;;;;;;;;;;;;;;;cAE9C;AAUD,4EAA4E;AAC5E,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,UAQtC;AAwID;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,GAAE,WAAW,CAAC,MAAM,CAAa,GAC1C,kBAAkB,CA+BpB"}

package/dist/utils/floor-piece-adoption.js

@@ -0,0 +1,182 @@
+import { area, containsPoint, difference, distanceToBoundary, intersection, union, } from '../lib/polygon-boolean.js';
+import { getRenderableSlabPolygon, prepareSlabPolygonContext } from '../lib/slab-polygon.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+/**
+ * Hand-drawn floor pieces: legacy manual slabs someone drew to be the house
+ * floor before rooms generated one. A level's pieces are adopted, all or
+ * nothing, when they are the level's only floor inside its rooms: one top and
+ * one construction, grounded, no platform or step at another height, nothing
+ * reaching more than PIECE_TRIM_DEPTH past the rooms and walls. The load
+ * migration then treats them like legacy wall-generated slabs, so one plate
+ * replaces the patchwork and each room keeps the finish its piece showed.
+ * Drawing noise is the only visible change: strips at most PIECE_TRIM_DEPTH
+ * past a facade go, cracks at most PIECE_GAP_WIDTH wide close, and wider
+ * uncovered room floor stays open as a hole in the plate.
+ */
+export const PIECE_TRIM_DEPTH = 0.1;
+export const PIECE_GAP_WIDTH = 0.05;
+export function floorPieceFinish(slab) {
+    return slab.slots?.surface ?? slab.material ?? slab.materialPreset;
+}
+function tryArea(compute) {
+    try {
+        return area(compute());
+    }
+    catch {
+        return Number.NaN;
+    }
+}
+/** Mean width of a part: 2·area / perimeter (the width of a long strip). */
+export function partWidth(part) {
+    let perimeter = 0;
+    for (const ring of [part.outer, ...part.holes])
+        for (const [i, [x, z]] of ring.entries()) {
+            const [nx, nz] = ring[(i + 1) % ring.length];
+            perimeter += Math.hypot(nx - x, nz - z);
+        }
+    return perimeter > 0 ? (2 * area([part])) / perimeter : 0;
+}
+function depthOutside(part, from) {
+    let depth = 0;
+    for (const point of part.outer)
+        if (!containsPoint(from, point))
+            depth = Math.max(depth, distanceToBoundary(from, point));
+    return depth;
+}
+function planLevel(children) {
+    const slabs = children.filter((node) => node.type === 'slab');
+    const walls = children.filter((node) => node.type === 'wall');
+    const rooms = children.filter((node) => node.type === 'zone' &&
+        node.spaceRole === 'room' &&
+        node.enclosureStatus !== 'open' &&
+        node.hasFloor !== false &&
+        node.floor?.support !== 'open' &&
+        node.polygon.length >= 3);
+    if (!rooms.length || !walls.length)
+        return;
+    const floorish = slabs.filter((slab) => slab.visible !== false &&
+        slab.support !== 'open' &&
+        !slab.recessed &&
+        !slab.plateRole &&
+        slab.polygon.length >= 3 &&
+        slab.elevation - slab.thickness <= 0.01);
+    const miters = calculateLevelMiters(walls);
+    const wallArea = union(walls.map((wall) => ({
+        outer: getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y]),
+        holes: [],
+    })));
+    const roomArea = union(rooms.map((room) => ({ outer: room.polygon, holes: room.holes ?? [] })));
+    const context = prepareSlabPolygonContext({ walls, siblingSlabs: slabs });
+    const rendered = new Map(floorish.map((slab) => [
+        slab.id,
+        { outer: getRenderableSlabPolygon(slab, context), holes: slab.holes ?? [] },
+    ]));
+    const weights = new Map();
+    const cover = new Map();
+    for (const slab of floorish) {
+        const inRooms = area(intersection(rendered.get(slab.id), roomArea));
+        cover.set(slab.id, inRooms);
+        if (inRooms <= 1e-3)
+            continue;
+        const top = Math.round(slab.elevation * 1e6) / 1e6;
+        weights.set(top, (weights.get(top) ?? 0) + inRooms);
+    }
+    const [datum] = [...weights].sort((a, b) => b[1] - a[1] || a[0] - b[0])[0] ?? [];
+    if (datum === undefined)
+        return;
+    const floor = floorish.filter((slab) => (cover.get(slab.id) ?? 0) > 1e-3);
+    // A second floor height inside the rooms (a platform, a step, a raised floor
+    // reaching down to the floor) is custom construction.
+    const stepped = slabs.some((slab) => slab.visible !== false &&
+        slab.support !== 'open' &&
+        !slab.recessed &&
+        slab.polygon.length >= 3 &&
+        Math.abs(slab.elevation - datum) > 1e-3 &&
+        slab.elevation - slab.thickness <= datum + 1e-3 &&
+        area(intersection(rendered.get(slab.id) ?? { outer: slab.polygon, holes: slab.holes ?? [] }, roomArea)) > 1e-3);
+    if (stepped)
+        return;
+    // One construction: the generated plate has one thickness and foundation.
+    const [first] = floor;
+    if (!first ||
+        floor.some((slab) => Math.abs(slab.thickness - first.thickness) > 1e-3 ||
+            !!slab.fillToTerrain !== !!first.fillToTerrain))
+        return;
+    const decks = new Set(children.flatMap((node) => {
+        const deck = node.deckSlabId;
+        return deck ? [deck] : [];
+    }));
+    const autos = floor.filter((slab) => slab.autoFromWalls || slab.boundary === 'auto');
+    const autoArea = union(autos.map((slab) => rendered.get(slab.id)));
+    const inside = union([roomArea, wallArea]);
+    const pieces = [];
+    for (const slab of floor) {
+        if (slab.autoFromWalls || slab.boundary === 'auto')
+            continue;
+        if (slab.metadata?.plateMigration !== undefined || decks.has(slab.id))
+            return;
+        const surface = rendered.get(slab.id);
+        // A finish laid on a wall-generated slab: the finish migration owns it.
+        if (autos.length && tryArea(() => difference(surface, autoArea)) <= 1e-4)
+            continue;
+        const outside = difference(surface, inside);
+        // The whole floor or nothing: a level keeping one hand-drawn floor keeps them all.
+        if (outside.some((part) => partWidth(part) > PIECE_TRIM_DEPTH ||
+            depthOutside(part, inside) > PIECE_TRIM_DEPTH + 1e-9))
+            return;
+        pieces.push(slab);
+    }
+    if (!pieces.length)
+        return;
+    const covered = union([...autos, ...pieces].map((slab) => rendered.get(slab.id)));
+    const floored = union(rooms
+        .filter((room) => area(intersection({ outer: room.polygon, holes: room.holes ?? [] }, covered)) > 1e-3)
+        .map((room) => ({ outer: room.polygon, holes: room.holes ?? [] })));
+    const uncovered = difference(difference(floored, covered), wallArea).filter((part) => area([part]) > 1e-4);
+    return {
+        pieces,
+        voids: uncovered
+            .filter((part) => partWidth(part) > PIECE_GAP_WIDTH + 1e-9)
+            .map((part) => part.outer),
+    };
+}
+/**
+ * Plans which legacy manual slabs the floor-plate migration adopts. Runs only
+ * on scenes that have no floor plates yet (the same guard as the legacy floor
+ * migration), so a migrated scene never re-plans.
+ */
+export function planFloorPieceAdoption(nodes, skipLevels = new Set()) {
+    const adoption = { pieces: new Map(), levels: new Map() };
+    const all = Object.values(nodes);
+    if (all.some((node) => node.type === 'slab' && node.plateRole))
+        return adoption;
+    const byParent = new Map();
+    for (const node of all) {
+        if (!node.parentId)
+            continue;
+        const list = byParent.get(node.parentId) ?? [];
+        list.push(node);
+        byParent.set(node.parentId, list);
+    }
+    for (const level of all) {
+        // Levels the floor migration already settled (a saved, migrated scene) never re-plan.
+        if (level.type !== 'level' ||
+            skipLevels.has(level.id) ||
+            level.metadata?.floorOwnershipMigrated === true)
+            continue;
+        const children = byParent.get(level.id) ?? [];
+        let planned;
+        try {
+            planned = planLevel(children);
+        }
+        catch {
+            continue;
+        }
+        if (!planned)
+            continue;
+        adoption.levels.set(level.id, { voids: planned.voids });
+        for (const piece of planned.pieces)
+            adoption.pieces.set(piece.id, level.id);
+    }
+    return adoption;
+}