@pascal-app/core 1.0.3 → 1.0.4

package/dist/utils/legacy-wall-datums.js

@@ -0,0 +1,199 @@
+import { floorConstructionLift } from '../lib/floor-construction-lift.js';
+import { isFloorAnchoredOpening } from '../lib/floor-opening-footprints.js';
+import { getOpeningFloorDatum, getOpeningFloorTarget, wallSupportForNodes, } from '../lib/opening-floor-datum.js';
+import { levelBaseElevationAt } from '../lib/terrain-support-query.js';
+import { findLevelBelowId, getAuthoredLevelElevations, getWallPlaneTops } from '../services/storey.js';
+import { computeWallSlabSupport } from '../systems/slab/slab-support.js';
+import { resolveWallTop } from '../systems/wall/wall-top.js';
+const legacySupports = new Map();
+export function legacyWallElevations(walls, slabs, nodes, levelId) {
+    const orderedWalls = [...walls].sort((a, b) => a.id.localeCompare(b.id));
+    const orderedSlabs = [...slabs].sort((a, b) => a.id.localeCompare(b.id));
+    const signature = JSON.stringify([
+        orderedWalls.map((wall) => [
+            wall.id,
+            wall.start,
+            wall.end,
+            wall.thickness,
+            wall.justification,
+            wall.curveOffset,
+            wall.supportOffset,
+            wall.supportSlabId,
+            levelBaseElevationAt(nodes, levelId, ...wall.start),
+        ]),
+        orderedSlabs.map((slab) => [
+            slab.id,
+            slab.polygon,
+            slab.holes,
+            slab.elevation,
+            slab.thickness,
+            slab.autoFromWalls,
+            slab.recessed,
+        ]),
+    ]);
+    const cached = legacySupports.get(signature);
+    if (cached)
+        return cached;
+    const legacySlabs = orderedSlabs.map((slab) => ({
+        ...slab,
+        boundary: undefined,
+        plateRole: undefined,
+        support: undefined,
+    }));
+    const supports = new Map(orderedWalls.map((wall) => [
+        wall.id,
+        computeWallSlabSupport(wall, legacySlabs, orderedWalls, wall.supportSlabId, undefined, levelBaseElevationAt(nodes, levelId, ...wall.start)),
+    ]));
+    legacySupports.set(signature, supports);
+    if (legacySupports.size > 32)
+        legacySupports.delete(legacySupports.keys().next().value);
+    return supports;
+}
+/** Preserve production datums once, before a level first acquires derived plates. */
+export function preserveLegacyWallDatums(before, after) {
+    const values = Object.values(before);
+    const migrated = Object.values(after).some((node) => node.type === 'level' &&
+        node.metadata?.floorOwnershipMigrated === true &&
+        before[node.id]?.metadata?.floorOwnershipMigrated !== true);
+    const newBaseLevels = new Set(Object.values(after).flatMap((node) => node.type === 'slab' && node.plateRole === 'base' && node.parentId && !before[node.id]
+        ? [node.parentId]
+        : []));
+    const legacyRoomPlate = !migrated &&
+        Object.values(after).some((node) => node.type === 'zone' &&
+            node.autoFromWalls &&
+            !before[node.id] &&
+            node.parentId &&
+            newBaseLevels.has(node.parentId));
+    const pendingLegacyRoomPlate = !migrated &&
+        [...newBaseLevels].some((id) => before[id]?.type === 'level' && before[id].metadata?.legacyRoomMigrationPending);
+    if (!migrated &&
+        !legacyRoomPlate &&
+        !pendingLegacyRoomPlate &&
+        !values.some((node) => node.type === 'slab' && node.autoFromWalls && !node.plateRole))
+        return after;
+    const existing = new Set(values.flatMap((node) => (node.type === 'slab' && node.plateRole ? [node.parentId] : [])));
+    const legacyLevels = [
+        ...new Set(values.flatMap((node) => node.type === 'wall' && node.parentId && !existing.has(node.parentId)
+            ? [node.parentId]
+            : [])),
+    ];
+    for (const slab of values) {
+        if (slab.type === 'slab' &&
+            slab.autoFromWalls &&
+            !slab.plateRole &&
+            slab.parentId &&
+            !legacyLevels.includes(slab.parentId))
+            legacyLevels.push(slab.parentId);
+    }
+    const elevations = getAuthoredLevelElevations(before);
+    for (const levelId of [...legacyLevels]) {
+        const below = findLevelBelowId(levelId, elevations);
+        if (below && !existing.has(below) && !legacyLevels.includes(below))
+            legacyLevels.push(below);
+    }
+    let nodes = after;
+    const write = (node) => {
+        if (nodes === after)
+            nodes = { ...after };
+        nodes[node.id] = node;
+    };
+    for (const levelId of legacyLevels) {
+        const walls = values.filter((n) => n.type === 'wall' && n.parentId === levelId);
+        const slabs = values
+            .filter((n) => n.type === 'slab' && n.parentId === levelId)
+            .map((slab) => ({ ...slab, boundary: undefined, support: undefined }));
+        const oldSupports = legacyWallElevations(walls, slabs, before, levelId);
+        const oldPlanes = getWallPlaneTops(walls.filter((wall) => wall.height === undefined), levelId, before);
+        const currentWalls = walls
+            .map((wall) => after[wall.id])
+            .filter((wall) => wall?.type === 'wall' && wall.height === undefined);
+        const newPlanes = getWallPlaneTops(currentWalls, levelId, after);
+        for (const wall of walls) {
+            let current = after[wall.id];
+            if (current?.type !== 'wall')
+                continue;
+            const old = oldSupports.get(wall.id);
+            let next = wallSupportForNodes(current, after);
+            if (Math.abs(next.elevation - old.elevation) > 1e-3) {
+                const oldSupport = old.electedSlabId ? after[old.electedSlabId] : undefined;
+                const keepSlab = oldSupport?.type === 'slab' &&
+                    Math.abs(oldSupport.elevation - old.elevation) <= 1e-3 &&
+                    Math.abs(wallSupportForNodes({
+                        ...current,
+                        supportSlabId: oldSupport.id,
+                        supportOffset: old.elevation - oldSupport.elevation,
+                    }, after).elevation - old.elevation) <= 1e-3;
+                const ground = levelBaseElevationAt(after, levelId, ...current.start);
+                current = {
+                    ...current,
+                    supportSlabId: keepSlab ? oldSupport.id : 'ground',
+                    supportOffset: keepSlab
+                        ? old.elevation - oldSupport.elevation
+                        : old.elevation - ground - floorConstructionLift(after, current),
+                };
+                write(current);
+                next = wallSupportForNodes(current, nodes);
+            }
+            // Datums read the wall as it now stands (a kept legacy support included).
+            const datumWall = current;
+            const oldTop = wall.height === undefined
+                ? oldPlanes.get(wall.id)
+                : (wall.supportSlabId === 'ground' ? old.elevation : Math.max(0, old.elevation)) +
+                    wall.height;
+            const newTop = resolveWallTop(current, newPlanes.get(current.id) ?? 0, next.elevation);
+            const patch = {};
+            if (Math.abs(oldTop - newTop) > 1e-6)
+                patch.height = oldTop - next.elevation;
+            const delta = old.elevation - next.elevation;
+            if (current.faceRegions?.length && Math.abs(delta) > 1e-6)
+                patch.faceRegions = current.faceRegions.map((region) => {
+                    // Existing regions may already have moved in M4; converted bands have not.
+                    const source = wall.faceRegions?.find((old) => old.id === region.id) ?? region;
+                    const { v0: _v0, v1: _v1, ...rest } = region;
+                    return {
+                        ...rest,
+                        ...(source.v0 === undefined ? {} : { v0: Math.round((source.v0 + delta) * 1e6) / 1e6 }),
+                        ...(source.v1 === undefined ? {} : { v1: Math.round((source.v1 + delta) * 1e6) / 1e6 }),
+                    };
+                });
+            if (Object.keys(patch).length)
+                write({ ...current, ...patch });
+            for (const id of wall.children ?? []) {
+                const opening = before[id], current = after[id];
+                if ((opening?.type !== 'door' && opening?.type !== 'window') ||
+                    (current?.type !== 'door' && current?.type !== 'window') ||
+                    !opening.position ||
+                    !current.position)
+                    continue;
+                const legacyOpening = {
+                    ...current,
+                    ...opening,
+                    position: opening.position ?? current.position,
+                    height: opening.height ?? current.height,
+                };
+                const floorAnchored = isFloorAnchoredOpening(legacyOpening);
+                const datum = getOpeningFloorDatum(datumWall, legacyOpening, nodes);
+                let y = legacyOpening.position[1] + old.elevation - datum;
+                let anchor = floorAnchored ? 'floor' : 'wall';
+                const movedOpening = {
+                    ...legacyOpening,
+                    verticalAnchor: 'floor',
+                    position: [legacyOpening.position[0], y, legacyOpening.position[2]],
+                };
+                if (floorAnchored &&
+                    (Math.abs(getOpeningFloorTarget(datumWall, legacyOpening, nodes) - datum) > 1e-6 ||
+                        Math.abs(getOpeningFloorDatum(datumWall, movedOpening, nodes) - datum) > 1e-6)) {
+                    anchor = 'wall';
+                    y = legacyOpening.position[1] + old.elevation - next.elevation;
+                }
+                if (Math.abs(y - current.position[1]) > 1e-6 || (anchor === 'wall' && floorAnchored))
+                    write({
+                        ...current,
+                        verticalAnchor: anchor,
+                        position: [current.position[0], Math.round(y * 1e6) / 1e6, current.position[2]],
+                    });
+            }
+        }
+    }
+    return nodes;
+}

package/dist/utils/load-migration.d.ts

@@ -0,0 +1,28 @@
+type Nodes = Record<string, unknown>;
+type Filled = Map<string, readonly {
+    key: string;
+    json: string;
+    value: unknown;
+}[]>;
+/**
+ * The stored nodes as the load migrations read them: container schema
+ * defaults (`children`, `holes`, `position`, `metadata`, …) supplied where a
+ * raw legacy node leaves them out. Scalar defaults stay absent: migrations read
+ * their absence (see `materializeNodeDefaults`).
+ */
+export declare function loadNodeView(source: Nodes): {
+    view: Nodes;
+    filled: Filled;
+};
+/**
+ * Wraps a load migration so a raw legacy scene can never stop a project
+ * opening: the migration reads {@link loadNodeView}, and if it still throws the
+ * scene loads without it — as main loaded it before the migration existed.
+ */
+export declare function loadMigration<A extends unknown[], R extends {
+    nodes: Nodes;
+}>(name: string, migrate: (nodes: Nodes, ...args: A) => R, unchanged: (nodes: Nodes) => R): (nodes: Nodes, ...args: A) => R;
+/** {@link loadMigration} for a migration that returns the node map itself. */
+export declare function loadMapMigration<A extends unknown[], R extends Nodes>(name: string, migrate: (nodes: Nodes, ...args: A) => R): (nodes: Nodes, ...args: A) => R;
+export {};
+//# sourceMappingURL=load-migration.d.ts.map

package/dist/utils/load-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-migration.d.ts","sourceRoot":"","sources":["../../src/utils/load-migration.ts"],"names":[],"mappings":"AAEA,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AACpC,KAAK,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,CAAC,CAAA;AAEnF;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,GAAG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAqB3E;AAiCD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,EAC3E,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,EACxC,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,CAAC,GAC7B,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAajC;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS,KAAK,EACnE,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GACvC,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAOjC"}

package/dist/utils/load-migration.js

@@ -0,0 +1,89 @@
+import { containerDefaultFields } from './node-defaults.js';
+/**
+ * The stored nodes as the load migrations read them: container schema
+ * defaults (`children`, `holes`, `position`, `metadata`, …) supplied where a
+ * raw legacy node leaves them out. Scalar defaults stay absent: migrations read
+ * their absence (see `materializeNodeDefaults`).
+ */
+export function loadNodeView(source) {
+    let view = null;
+    const filled = new Map();
+    for (const [id, value] of Object.entries(source)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            continue;
+        const node = value;
+        if (typeof node.type !== 'string')
+            continue;
+        let next = null;
+        const keys = [];
+        for (const { key, json, value } of containerDefaultFields(node.type)) {
+            if (node[key] !== undefined)
+                continue;
+            next ??= { ...node };
+            next[key] = structuredClone(value);
+            keys.push({ key, json, value: next[key] });
+        }
+        if (!next)
+            continue;
+        view ??= { ...source };
+        view[id] = next;
+        filled.set(id, keys);
+    }
+    return { view: view ?? source, filled };
+}
+/**
+ * Drops the view's fills a migration carried through untouched (the same
+ * instance, same content), so no stored node is rewritten by them. A value the
+ * migration wrote itself, even an equal one, is its output and stays.
+ */
+function restoreStoredShape(source, view, filled, migrated) {
+    const out = { ...migrated };
+    let same = Object.keys(out).length === Object.keys(source).length;
+    for (const [id, node] of Object.entries(out)) {
+        const fields = filled.get(id);
+        if (fields && node && typeof node === 'object') {
+            const record = node;
+            const untouched = fields.filter(({ key, json, value }) => record[key] === value && JSON.stringify(value) === json);
+            if (node === view[id] && untouched.length === fields.length)
+                out[id] = source[id];
+            else if (untouched.length) {
+                const next = { ...record };
+                for (const { key } of untouched)
+                    delete next[key];
+                out[id] = next;
+            }
+        }
+        if (out[id] !== source[id])
+            same = false;
+    }
+    return same ? source : out;
+}
+function reportFailure(name, error) {
+    console.error(`[scene load] ${name} failed; the scene loads without it`, error);
+}
+/**
+ * Wraps a load migration so a raw legacy scene can never stop a project
+ * opening: the migration reads {@link loadNodeView}, and if it still throws the
+ * scene loads without it — as main loaded it before the migration existed.
+ */
+export function loadMigration(name, migrate, unchanged) {
+    return (source, ...args) => {
+        const { view, filled } = loadNodeView(source);
+        let result;
+        try {
+            result = migrate(view, ...args);
+        }
+        catch (error) {
+            reportFailure(name, error);
+            return unchanged(source);
+        }
+        if (!filled.size)
+            return result;
+        return { ...result, nodes: restoreStoredShape(source, view, filled, result.nodes) };
+    };
+}
+/** {@link loadMigration} for a migration that returns the node map itself. */
+export function loadMapMigration(name, migrate) {
+    const wrapped = loadMigration(name, (nodes, ...args) => ({ nodes: migrate(nodes, ...args) }), (nodes) => ({ nodes }));
+    return (source, ...args) => wrapped(source, ...args).nodes;
+}

package/dist/utils/node-defaults.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Kinds whose load migrations all live in the shared server-safe pipeline, so a
+ * caller that runs only that pipeline (the hosted authority) may fill their
+ * defaults. Roofs, dormers, items and the rest still migrate in the client
+ * loader, which reads fields those defaults would supply.
+ */
+export declare const STRUCTURE_NODE_KINDS: ReadonlySet<string>;
+type ContainerDefault = {
+    key: string;
+    value: unknown;
+    json: string;
+};
+/**
+ * The container defaults of a kind: arrays (`children`, `holes`, `position`, …)
+ * and empty objects (`metadata`). Unlike a scalar default (a legacy slab
+ * without `thickness` is solid down to its level), an omitted container means
+ * exactly its default: the reload after {@link materializeNodeDefaults} reads
+ * it filled and must migrate the same.
+ */
+export declare function containerDefaultFields(kind: string): readonly ContainerDefault[];
+/**
+ * Fills the schema defaults a stored built-in node leaves out, as the last
+ * step of every load (client `setScene`, hosted authority). The migrations run
+ * first on the stored nodes because they read what a node omits (a legacy slab
+ * without `thickness` is solid down to its level); after them, renderers and
+ * tools may rely on every defaulted field (`zone.holes`, `slab.holes`, …).
+ * Only missing top-level fields are added: present values are never parsed,
+ * coerced or stripped. `kinds` limits it to the kinds whose absence-reading
+ * migrations the caller has all run ({@link STRUCTURE_NODE_KINDS} for the
+ * hosted authority).
+ */
+export declare function materializeNodeDefaults<T extends Record<string, unknown>>(nodes: T, kinds?: ReadonlySet<string>): {
+    nodes: T;
+    changed: boolean;
+};
+export {};
+//# sourceMappingURL=node-defaults.d.ts.map

package/dist/utils/node-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-defaults.d.ts","sourceRoot":"","sources":["../../src/utils/node-defaults.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAOnD,CAAA;AA4BF,KAAK,gBAAgB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAErE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,gBAAgB,EAAE,CAchF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvE,KAAK,EAAE,CAAC,EACR,KAAK,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAC1B;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAqBhC"}

package/dist/utils/node-defaults.js

@@ -0,0 +1,96 @@
+import { AnyNode, nodeKindOf } from '../schema/types.js';
+let defaultsByKind;
+/**
+ * Kinds whose load migrations all live in the shared server-safe pipeline, so a
+ * caller that runs only that pipeline (the hosted authority) may fill their
+ * defaults. Roofs, dormers, items and the rest still migrate in the client
+ * loader, which reads fields those defaults would supply.
+ */
+export const STRUCTURE_NODE_KINDS = new Set([
+    'slab',
+    'ceiling',
+    'zone',
+    'wall',
+    'separator',
+    'floor-opening',
+]);
+// Only deterministic defaults: a generated id (`objectId`) is not a default a
+// load may invent.
+function fieldsWithDefaults(shape) {
+    const fields = [];
+    for (const [key, schema] of Object.entries(shape)) {
+        const first = schema.safeParse(undefined);
+        if (!first.success || first.data === undefined)
+            continue;
+        const second = schema.safeParse(undefined);
+        if (JSON.stringify(first.data) !== JSON.stringify(second.data))
+            continue;
+        fields.push({ key, schema });
+    }
+    return fields;
+}
+function defaultFields(kind) {
+    defaultsByKind ??= new Map(AnyNode.options.map((option) => [
+        nodeKindOf(option),
+        fieldsWithDefaults(option.shape),
+    ]));
+    return defaultsByKind.get(kind);
+}
+let containerDefaultsByKind;
+/**
+ * The container defaults of a kind: arrays (`children`, `holes`, `position`, …)
+ * and empty objects (`metadata`). Unlike a scalar default (a legacy slab
+ * without `thickness` is solid down to its level), an omitted container means
+ * exactly its default: the reload after {@link materializeNodeDefaults} reads
+ * it filled and must migrate the same.
+ */
+export function containerDefaultFields(kind) {
+    containerDefaultsByKind ??= new Map();
+    let fields = containerDefaultsByKind.get(kind);
+    if (!fields) {
+        fields = (defaultFields(kind) ?? []).flatMap(({ key, schema }) => {
+            const value = schema.parse(undefined);
+            const container = Array.isArray(value) ||
+                (value !== null && typeof value === 'object' && Object.keys(value).length === 0);
+            return container ? [{ key, value, json: JSON.stringify(value) }] : [];
+        });
+        containerDefaultsByKind.set(kind, fields);
+    }
+    return fields;
+}
+/**
+ * Fills the schema defaults a stored built-in node leaves out, as the last
+ * step of every load (client `setScene`, hosted authority). The migrations run
+ * first on the stored nodes because they read what a node omits (a legacy slab
+ * without `thickness` is solid down to its level); after them, renderers and
+ * tools may rely on every defaulted field (`zone.holes`, `slab.holes`, …).
+ * Only missing top-level fields are added: present values are never parsed,
+ * coerced or stripped. `kinds` limits it to the kinds whose absence-reading
+ * migrations the caller has all run ({@link STRUCTURE_NODE_KINDS} for the
+ * hosted authority).
+ */
+export function materializeNodeDefaults(nodes, kinds) {
+    let out = null;
+    for (const [id, value] of Object.entries(nodes)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            continue;
+        const node = value;
+        const fields = typeof node.type === 'string' && (!kinds || kinds.has(node.type))
+            ? defaultFields(node.type)
+            : undefined;
+        if (!fields)
+            continue;
+        let next = null;
+        for (const { key, schema } of fields) {
+            if (node[key] !== undefined)
+                continue;
+            next ??= { ...node };
+            next[key] = schema.parse(undefined);
+        }
+        if (!next)
+            continue;
+        out ??= { ...nodes };
+        out[id] = next;
+    }
+    return out ? { nodes: out, changed: true } : { nodes, changed: false };
+}

package/dist/utils/normalize-legacy-structure.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeLegacyStructure(source: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=normalize-legacy-structure.d.ts.map

package/dist/utils/normalize-legacy-structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-legacy-structure.d.ts","sourceRoot":"","sources":["../../src/utils/normalize-legacy-structure.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgEjG"}

package/dist/utils/normalize-legacy-structure.js

@@ -0,0 +1,61 @@
+export function normalizeLegacyStructure(source) {
+    const nodes = { ...source };
+    let changed = false;
+    for (const [id, node] of Object.entries(nodes)) {
+        if (node?.type !== 'site' || !Array.isArray(node.children))
+            continue;
+        const children = node.children.map((child) => {
+            if (!child || typeof child !== 'object' || typeof child.id !== 'string')
+                return child;
+            if (!nodes[child.id])
+                nodes[child.id] = { ...child, parentId: id };
+            changed = true;
+            return child.id;
+        });
+        if (children.some((child, index) => child !== node.children[index])) {
+            nodes[id] = { ...node, children };
+        }
+    }
+    for (const [id, node] of Object.entries(nodes)) {
+        // Door/window normalization parses defaults before structural migration.
+        // Retain absence here so old openings cannot look like newly created ones.
+        if ((node?.type === 'door' || node?.type === 'window') &&
+            node.floorThresholdVersion === undefined) {
+            nodes[id] = { ...node, floorThresholdVersion: 0 };
+            changed = true;
+            continue;
+        }
+        // Legacy documentation-only zones have no boundary. Preserve their metadata
+        // as an empty generic zone instead of feeding an absent ring to topology.
+        if (node?.type === 'zone' &&
+            node.polygon === undefined &&
+            (node.spaceRole === undefined || node.spaceRole === 'generic') &&
+            node.autoFromWalls !== true) {
+            nodes[id] = {
+                ...node,
+                name: typeof node.name === 'string' ? node.name : 'Zone',
+                polygon: [],
+            };
+            changed = true;
+            continue;
+        }
+        if (node?.type === 'zone' && typeof node.name !== 'string') {
+            nodes[id] = { ...node, name: node.spaceRole === 'room' ? 'Room' : 'Zone' };
+            changed = true;
+            continue;
+        }
+        if (node?.type !== 'wall' || !Object.hasOwn(node, 'assemblyLayers'))
+            continue;
+        const thickness = Array.isArray(node.assemblyLayers)
+            ? node.assemblyLayers.reduce((total, layer) => typeof layer?.thickness === 'number' &&
+                Number.isFinite(layer.thickness) &&
+                layer.thickness > 0
+                ? total + layer.thickness
+                : total, 0)
+            : 0;
+        const { assemblyLayers: _layers, ...wall } = node;
+        nodes[id] = thickness > 0 ? { ...wall, thickness } : wall;
+        changed = true;
+    }
+    return changed ? nodes : source;
+}

package/dist/utils/omit-undefined.d.ts

@@ -0,0 +1,2 @@
+export declare function omitUndefined<T>(value: T): T;
+//# sourceMappingURL=omit-undefined.d.ts.map

package/dist/utils/omit-undefined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit-undefined.d.ts","sourceRoot":"","sources":["../../src/utils/omit-undefined.ts"],"names":[],"mappings":"AACA,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAc5C"}

package/dist/utils/omit-undefined.js

@@ -0,0 +1,17 @@
+// Scene JSON omits undefined object properties, including nested material and intent fields.
+export function omitUndefined(value) {
+    if (Array.isArray(value)) {
+        const entries = value.map((entry) => omitUndefined(entry));
+        return entries.some((entry, index) => entry !== value[index]) ? entries : value;
+    }
+    if (value === null || typeof value !== 'object')
+        return value;
+    const entries = Object.entries(value);
+    const cleaned = entries
+        .filter(([, entry]) => entry !== undefined)
+        .map(([key, entry]) => [key, omitUndefined(entry)]);
+    return cleaned.length !== entries.length ||
+        cleaned.some(([, entry], index) => entry !== entries[index][1])
+        ? Object.fromEntries(cleaned)
+        : value;
+}