@pascal-app/core 1.0.1 → 1.0.4

package/dist/utils/structure-id.d.ts

@@ -0,0 +1,4 @@
+import { type SceneStructureInput, type SceneStructureResult, type StructureIdFactory } from '../lib/structure-reconcile.js';
+export declare function createStructureIdFactory(nodes: Record<string, unknown>): (kind: Parameters<StructureIdFactory>[0], boundaryIds: readonly string[]) => string;
+export declare function reconcileStructureWithStableIds(input: Omit<SceneStructureInput, 'mintId'>): SceneStructureResult;
+//# sourceMappingURL=structure-id.d.ts.map

package/dist/utils/structure-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure-id.d.ts","sourceRoot":"","sources":["../../src/utils/structure-id.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACxB,MAAM,4BAA4B,CAAA;AAInC,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAE7D,MAAM,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,EAAE,aAAa,SAAS,MAAM,EAAE,YAahF;AAwCD,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,GACzC,oBAAoB,CA4EtB"}

package/dist/utils/structure-id.js

@@ -0,0 +1,115 @@
+import { comparePlateComponents, floorPlateId } from '../lib/floor-plate-id.js';
+import { reconcileSceneStructure, } from '../lib/structure-reconcile.js';
+import { zoneColorForSeed } from '../lib/zone-colors.js';
+export function createStructureIdFactory(nodes) {
+    const minted = new Set();
+    return (kind, boundaryIds) => {
+        const seed = JSON.stringify([...new Set(boundaryIds)].sort());
+        for (let attempt = 0;; attempt++) {
+            let hash = 0xcbf29ce484222325n;
+            for (const byte of new TextEncoder().encode(`${seed}|${kind}|${attempt}`)) {
+                hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+            }
+            const id = `${kind}_${hash.toString(36).padStart(16, '0')}`;
+            if (minted.has(id) || Object.hasOwn(nodes, id))
+                continue;
+            minted.add(id);
+            return id;
+        }
+    };
+}
+function boundaries(node, nodes) {
+    if (node.type === 'zone')
+        return [...node.boundaryWallIds, ...node.boundarySeparatorIds];
+    const zoneIds = node.type === 'slab'
+        ? (node.zoneIds ?? [])
+        : node.type === 'ceiling' && node.zoneId
+            ? [node.zoneId]
+            : [];
+    return [
+        ...new Set(zoneIds.flatMap((id) => (nodes[id]?.type === 'zone' ? boundaries(nodes[id], nodes) : []))),
+    ].sort();
+}
+function remapReferences(value, ids) {
+    const fields = value;
+    const changes = {};
+    for (const key of ['id', 'parentId', 'zoneId', 'supportSlabId', 'deckSlabId', 'survivorId']) {
+        const id = fields[key];
+        if (typeof id === 'string' && ids.has(id))
+            changes[key] = ids.get(id);
+    }
+    // Only newly minted rooms are remapped; pick their colour from the final id before persistence.
+    if (fields.type === 'zone' && typeof fields.id === 'string' && ids.has(fields.id))
+        changes.color = zoneColorForSeed(ids.get(fields.id));
+    for (const key of ['children', 'zoneIds', 'members']) {
+        const references = fields[key];
+        if (Array.isArray(references) && references.some((id) => ids.has(id))) {
+            const mapped = references.map((id) => ids.get(id) ?? id);
+            changes[key] =
+                key === 'zoneIds' || (key === 'children' && fields.type === 'ceiling')
+                    ? mapped.sort()
+                    : mapped;
+        }
+    }
+    return Object.keys(changes).length ? { ...value, ...changes } : value;
+}
+export function reconcileStructureWithStableIds(input) {
+    const provisional = createStructureIdFactory(input.nodes);
+    const result = reconcileSceneStructure({ ...input, mintId: (kind) => provisional(kind, []) });
+    const created = result.patches.flatMap((patch) => (patch.op === 'create' ? [patch.node] : []));
+    if (!created.length)
+        return result;
+    // The kernel's mint callback receives only a kind. Resolve the owning room
+    // boundaries from its completed plan, without deriving construction a second time.
+    const mint = createStructureIdFactory(input.nodes);
+    const ids = new Map();
+    for (const node of created.sort((a, b) => {
+        const key = (n) => JSON.stringify([n.type, boundaries(n, result.nodes), 'polygon' in n ? n.polygon : []]);
+        const left = key(a), right = key(b);
+        return left < right ? -1 : left > right ? 1 : 0;
+    })) {
+        if (node.type === 'zone' ||
+            (node.type === 'slab' && !node.plateRole) ||
+            node.type === 'ceiling')
+            ids.set(node.id, mint(node.type, boundaries(node, result.nodes)));
+    }
+    const components = new Map();
+    const occupied = new Set([...Object.keys(input.nodes), ...ids.values()]);
+    const plates = created
+        .filter((node) => node.type === 'slab' &&
+        !!node.plateRole &&
+        !(node.plateRole === 'base' &&
+            node.zoneIds?.some((id) => {
+                const zone = result.nodes[id];
+                return zone?.type === 'zone' && !!zone.floor?.footprint;
+            })))
+        .sort((a, b) => comparePlateComponents({ outer: a.polygon, holes: a.holes }, { outer: b.polygon, holes: b.holes }));
+    for (const plate of plates) {
+        const zoneIds = (plate.zoneIds ?? []).map((id) => ids.get(id) ?? id).sort();
+        const key = JSON.stringify([
+            plate.parentId,
+            plate.plateRole === 'base' ? 'base' : 'room',
+            zoneIds,
+        ]);
+        let component = components.get(key) ?? 0;
+        let id;
+        do {
+            id = floorPlateId(plate.parentId, plate.plateRole, zoneIds, component++);
+        } while (occupied.has(id));
+        occupied.add(id);
+        components.set(key, component);
+        ids.set(plate.id, id);
+    }
+    return {
+        nodes: Object.fromEntries(Object.entries(result.nodes).map(([id, node]) => [
+            ids.get(id) ?? id,
+            remapReferences(node, ids),
+        ])),
+        patches: result.patches.map((patch) => patch.op === 'create'
+            ? { ...patch, node: remapReferences(patch.node, ids) }
+            : patch.op === 'update'
+                ? { ...patch, data: remapReferences(patch.data, ids) }
+                : patch),
+        events: result.events.map((event) => remapReferences(event, ids)),
+    };
+}

package/dist/utils/vertical-scene-migration.d.ts

@@ -2,12 +2,12 @@ export type VerticalSceneMigration = {
     changed: boolean;
     nodes: Record<string, unknown>;
 };
-/**
- * Applies the vertical-model load migration to serialized scene nodes.
- *
- * This must remain pure, idempotent, and server-safe: the editor loader and
- * hosted scene authority both call it so they compare and persist the same
- * canonical fields during collaboration.
- */
-export declare function migrateVerticalSceneNodes(sourceNodes: Record<string, unknown>): VerticalSceneMigration;
+export declare const migrateVerticalSceneNodes: (nodes: {
+    [x: string]: unknown;
+}) => {
+    nodes: {
+        [x: string]: unknown;
+    };
+    changed: boolean;
+};
 //# sourceMappingURL=vertical-scene-migration.d.ts.map

package/dist/utils/vertical-scene-migration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertical-scene-migration.d.ts","sourceRoot":"","sources":["../../src/utils/vertical-scene-migration.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,CAAA;AAuBD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,sBAAsB,CA+KxB"}
+{"version":3,"file":"vertical-scene-migration.d.ts","sourceRoot":"","sources":["../../src/utils/vertical-scene-migration.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,CAAA;AAgOD,eAAO,MAAM,yBAAyB;;;;;;;CAIrC,CAAA"}

package/dist/utils/vertical-scene-migration.js

@@ -3,6 +3,7 @@ import { deriveLegacyLevelHeight } from '../services/level-height.js';
 import { getCeilingClampBound } from '../services/storey.js';
 import { computeWallSlabSupport } from '../systems/slab/slab-support.js';
 import { DEFAULT_WALL_HEIGHT } from '../systems/wall/wall-footprint.js';
+import { loadMigration } from './load-migration.js';
 function getFiniteNumber(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
@@ -27,7 +28,7 @@ const BURIED_PIN_EPSILON = 1e-3;
  * hosted scene authority both call it so they compare and persist the same
  * canonical fields during collaboration.
  */
-export function migrateVerticalSceneNodes(sourceNodes) {
+function migrateVerticalSceneNodesOnView(sourceNodes) {
     const nodes = { ...sourceNodes };
     let changed = false;
     const replaceNode = (id, node) => {
@@ -85,7 +86,7 @@ export function migrateVerticalSceneNodes(sourceNodes) {
                 end: wall.end,
                 curveOffset: wall.curveOffset,
                 thickness: wall.thickness,
-            }, slabs, walls).elevation;
+            }, slabs, walls, undefined, undefined, 0, nodes).elevation;
             const effectiveHeight = wall.height ?? DEFAULT_WALL_HEIGHT;
             const top = Math.max(0, electedBase) + effectiveHeight;
             if (Math.abs(plane - top) < PLANE_BOUND_EPSILON) {
@@ -107,14 +108,22 @@ export function migrateVerticalSceneNodes(sourceNodes) {
             replaceNode(id, derivedRise);
         }
     }
-    // Preserve the exact occupied interval of legacy slabs.
+    // Preserve the exact occupied interval of legacy slabs. The elevation every
+    // renderer assumes for a slab without one is written too: later migrations do
+    // arithmetic on it, and the loader's schema defaults would otherwise supply it
+    // only after them, so a saved and reloaded scene would migrate differently.
     for (const [id, node] of Object.entries(nodes)) {
-        if (node?.type !== 'slab' || 'thickness' in node)
+        if (node?.type !== 'slab')
             continue;
         const elevation = getFiniteNumber(node.elevation, 0.05);
+        if ('thickness' in node) {
+            if (node.elevation !== elevation)
+                replaceNode(id, { ...node, elevation });
+            continue;
+        }
         replaceNode(id, elevation < 0
-            ? { ...node, thickness: 0.05, recessed: true }
-            : { ...node, thickness: elevation });
+            ? { ...node, elevation, thickness: 0.05, recessed: true }
+            : { ...node, elevation, thickness: elevation });
     }
     if (isLegacyScene) {
         for (const [id, node] of Object.entries(nodes)) {
@@ -160,9 +169,9 @@ export function migrateVerticalSceneNodes(sourceNodes) {
                 end: node.end,
                 curveOffset: node.curveOffset,
                 thickness: node.thickness,
-            }, siblings.filter((sibling) => sibling.type === 'slab'), siblings.filter((sibling) => sibling.type === 'wall'));
+            }, siblings.filter((sibling) => sibling.type === 'slab'), siblings.filter((sibling) => sibling.type === 'wall'), undefined, undefined, 0, nodes);
             const elected = support.electedSlabId ? nodes[support.electedSlabId] : null;
-            if (!elected)
+            if (!elected || elected.plateRole)
                 continue;
             const pinnedBase = getFiniteNumber(node.supportOffset, 0);
             const electedTop = getFiniteNumber(elected.elevation, 0.05);
@@ -177,3 +186,4 @@ export function migrateVerticalSceneNodes(sourceNodes) {
     }
     return changed ? { changed, nodes } : { changed, nodes: sourceNodes };
 }
+export const migrateVerticalSceneNodes = loadMigration('vertical migration', migrateVerticalSceneNodesOnView, (nodes) => ({ nodes, changed: false }));

package/dist/utils/wall-assembly-migration.d.ts

@@ -0,0 +1,14 @@
+export type WallAssemblyMigration = {
+    changed: boolean;
+    nodes: Record<string, unknown>;
+};
+/**
+ * Converts every wall that still stores the WS5 `WallAssembly` (#937) to F2
+ * layers (`wallAssemblyFromLegacy`). The layer sum is the WS5 total, so
+ * `thickness` and the drawing stay the same.
+ *
+ * Pure, idempotent and server-safe: the editor loader and the hosted scene
+ * authority both run it, so both compare and persist the same canonical field.
+ */
+export declare function migrateLegacyWallAssemblies(nodes: Record<string, unknown>): WallAssemblyMigration;
+//# sourceMappingURL=wall-assembly-migration.d.ts.map

package/dist/utils/wall-assembly-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-assembly-migration.d.ts","sourceRoot":"","sources":["../../src/utils/wall-assembly-migration.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,qBAAqB,CAWjG"}

package/dist/utils/wall-assembly-migration.js

@@ -0,0 +1,23 @@
+import { isLegacyWallAssembly, wallAssemblyFromLegacy } from '../systems/wall/wall-assembly.js';
+/**
+ * Converts every wall that still stores the WS5 `WallAssembly` (#937) to F2
+ * layers (`wallAssemblyFromLegacy`). The layer sum is the WS5 total, so
+ * `thickness` and the drawing stay the same.
+ *
+ * Pure, idempotent and server-safe: the editor loader and the hosted scene
+ * authority both run it, so both compare and persist the same canonical field.
+ */
+export function migrateLegacyWallAssemblies(nodes) {
+    let changed = false;
+    const next = { ...nodes };
+    for (const [id, node] of Object.entries(nodes)) {
+        if (node === null || typeof node !== 'object')
+            continue;
+        const record = node;
+        if (record.type !== 'wall' || !isLegacyWallAssembly(record.assembly))
+            continue;
+        next[id] = { ...record, assembly: wallAssemblyFromLegacy(record.assembly) };
+        changed = true;
+    }
+    return { changed, nodes: changed ? next : nodes };
+}

package/dist/utils/wall-face-migration.d.ts

@@ -0,0 +1,23 @@
+import type { WallFace } from '../schema/nodes/wall.js';
+declare const BANDS: readonly ["lower", "middle", "upper", "top"];
+type Band = (typeof BANDS)[number];
+/** Band slot keys M1 emits for M2 to consume (`aLower` … `bTop`). */
+export declare function wallBandSlotKey(face: WallFace, band: Band): string;
+export declare const migrateWallFaceKeys: (nodes: {
+    [x: string]: unknown;
+}) => {
+    nodes: {
+        [x: string]: unknown;
+    };
+    changed: boolean;
+};
+export declare const migrateWallFaceBands: (nodes: {
+    [x: string]: unknown;
+}) => {
+    nodes: {
+        [x: string]: unknown;
+    };
+    changed: boolean;
+};
+export {};
+//# sourceMappingURL=wall-face-migration.d.ts.map

package/dist/utils/wall-face-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-face-migration.d.ts","sourceRoot":"","sources":["../../src/utils/wall-face-migration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,sBAAsB,CAAA;AAqBpE,QAAA,MAAM,KAAK,8CAA+C,CAAA;AAC1D,KAAK,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAA;AA4BlC,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAElE;AAsOD,eAAO,MAAM,mBAAmB;;;;;;;CAI/B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;CAIhC,CAAA"}

package/dist/utils/wall-face-migration.js

@@ -0,0 +1,246 @@
+import { loadMigration } from './load-migration.js';
+const LEGACY_SUFFIX = {
+    interior: 'Interior',
+    exterior: 'Exterior',
+};
+const BANDS = ['lower', 'middle', 'upper', 'top'];
+const BAND_SUFFIX = {
+    lower: 'Lower',
+    middle: 'Middle',
+    upper: 'Upper',
+    top: 'Top',
+};
+const TRIMS = [
+    ['skirting', 'Skirting'],
+    ['crown', 'Crown'],
+    ['chairRail', 'ChairRail'],
+];
+const LEGACY_MATERIAL_KEYS = [
+    'interiorMaterial',
+    'interiorMaterialPreset',
+    'exteriorMaterial',
+    'exteriorMaterialPreset',
+];
+const SEMANTIC_SLOT_KEYS = new Set([
+    'interior',
+    'exterior',
+    'front',
+    'back',
+    ...BANDS.flatMap((band) => [`${band}Interior`, `${band}Exterior`]),
+    ...TRIMS.flatMap(([kind]) => [`${kind}Interior`, `${kind}Exterior`]),
+]);
+/** Band slot keys M1 emits for M2 to consume (`aLower` … `bTop`). */
+export function wallBandSlotKey(face, band) {
+    return `${face}${BAND_SUFFIX[band]}`;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function slotRecord(node) {
+    return isRecord(node.slots) ? node.slots : {};
+}
+function hasRef(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+/** The side a face showed: the stored classification, else front → interior, back → exterior. */
+function legacyFaceSide(node, face) {
+    const stored = face === 'a' ? node.frontSide : node.backSide;
+    if (stored === 'interior' || stored === 'exterior')
+        return stored;
+    return face === 'a' ? 'interior' : 'exterior';
+}
+/** The face a legacy trim side drew on (the treatment renderer's side sign). */
+function legacyTrimFace(node, side) {
+    if (node.frontSide === side)
+        return 'a';
+    if (node.backSide === side)
+        return 'b';
+    return side === 'interior' ? 'a' : 'b';
+}
+function trimSides(config) {
+    return isRecord(config) ? config.sides : undefined;
+}
+function needsFaceKeyMigration(node) {
+    if (Object.keys(slotRecord(node)).some((key) => SEMANTIC_SLOT_KEYS.has(key)))
+        return true;
+    if (LEGACY_MATERIAL_KEYS.some((key) => node[key] !== undefined))
+        return true;
+    return TRIMS.some(([kind]) => {
+        const sides = trimSides(node[kind]);
+        return sides === 'interior' || sides === 'exterior';
+    });
+}
+function hasLegacyMaterial(spec) {
+    return spec.material !== undefined || typeof spec.materialPreset === 'string';
+}
+function migrateWallNode(node) {
+    const source = slotRecord(node);
+    const slots = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (!SEMANTIC_SLOT_KEYS.has(key))
+            slots[key] = value;
+    }
+    const put = (key, value) => {
+        if (!hasRef(slots[key]) && hasRef(value))
+            slots[key] = value;
+    };
+    const faceSide = { a: legacyFaceSide(node, 'a'), b: legacyFaceSide(node, 'b') };
+    for (const face of ['a', 'b']) {
+        const suffix = LEGACY_SUFFIX[faceSide[face]];
+        put(face, source[faceSide[face]]);
+        for (const band of BANDS)
+            put(wallBandSlotKey(face, band), source[`${band}${suffix}`]);
+    }
+    const next = { ...node };
+    for (const [kind, suffix] of TRIMS) {
+        const sides = trimSides(node[kind]);
+        const interiorFace = legacyTrimFace(node, 'interior');
+        const exteriorFace = legacyTrimFace(node, 'exterior');
+        // Drawn sides claim their face first. When both legacy sides drew on one
+        // face (a degenerate side pair), that face keeps the interior trim and the
+        // other face — which `both` now also draws — takes the exterior one.
+        const order = sides === 'exterior' ? ['exterior', 'interior'] : ['interior', 'exterior'];
+        for (const side of order) {
+            put(`${side === 'interior' ? interiorFace : exteriorFace}${suffix}`, source[`${kind}${LEGACY_SUFFIX[side]}`]);
+        }
+        if (interiorFace === exteriorFace)
+            put(`${interiorFace === 'a' ? 'b' : 'a'}${suffix}`, source[`${kind}Exterior`]);
+        if (sides === 'interior' || sides === 'exterior') {
+            next[kind] = {
+                ...node[kind],
+                sides: sides === 'interior' ? interiorFace : exteriorFace,
+            };
+        }
+    }
+    // Stray geometric aliases written by older tools: only fill a face M1 left empty.
+    put('a', source.front);
+    put('b', source.back);
+    const legacyFaceMaterials = isRecord(node.legacyFaceMaterials)
+        ? { ...node.legacyFaceMaterials }
+        : {};
+    for (const face of ['a', 'b']) {
+        if (hasRef(slots[face]) || legacyFaceMaterials[face] !== undefined)
+            continue;
+        const side = faceSide[face];
+        const spec = {
+            material: node[`${side}Material`],
+            materialPreset: node[`${side}MaterialPreset`],
+        };
+        if (!hasLegacyMaterial(spec))
+            continue;
+        legacyFaceMaterials[face] = Object.fromEntries(Object.entries(spec).filter(([, value]) => value !== undefined));
+    }
+    for (const key of LEGACY_MATERIAL_KEYS)
+        delete next[key];
+    if (Object.keys(slots).length > 0 || node.slots !== undefined)
+        next.slots = slots;
+    if (Object.keys(legacyFaceMaterials).length > 0)
+        next.legacyFaceMaterials = legacyFaceMaterials;
+    return next;
+}
+/**
+ * M1: wall slot keys `interior` / `exterior` (and their band and trim variants,
+ * plus stray `front` / `back`) become geometric `a` / `b` keys; legacy inline
+ * side finishes move to `legacyFaceMaterials`; single-sided trims name a face.
+ * The resolved finish of every face is unchanged.
+ */
+function migrateWallFaceKeysOnView(sourceNodes) {
+    let nodes = null;
+    for (const [id, node] of Object.entries(sourceNodes)) {
+        if (!isRecord(node) || node.type !== 'wall' || !needsFaceKeyMigration(node))
+            continue;
+        nodes ??= { ...sourceNodes };
+        nodes[id] = migrateWallNode(node);
+    }
+    return { nodes: nodes ?? sourceNodes, changed: nodes !== null };
+}
+const BAND_DEFAULTS = { lowerHeight: 0.84, middleHeight: 0.61, upperHeight: 0.61 };
+function finiteHeight(value, fallback) {
+    return Math.max(0, typeof value === 'number' && Number.isFinite(value) ? value : fallback);
+}
+/** Band count the renderer drew for a stored config (1 = no bands). */
+function drawnBandCount(raw) {
+    if (raw.enabled !== true)
+        return 1;
+    const count = raw.count === undefined ? 1 : raw.count;
+    if (typeof count !== 'number' || !Number.isFinite(count))
+        return 1;
+    return Math.max(1, Math.min(4, Math.round(count)));
+}
+function bandRegions(node, slots) {
+    const raw = (isRecord(node.faceBands) ? node.faceBands : {});
+    const count = drawnBandCount(raw);
+    if (count < 2)
+        return [];
+    const lower = finiteHeight(raw.lowerHeight, BAND_DEFAULTS.lowerHeight);
+    const middle = count >= 3 ? finiteHeight(raw.middleHeight, BAND_DEFAULTS.middleHeight) : 0;
+    const upper = count >= 4 ? finiteHeight(raw.upperHeight, BAND_DEFAULTS.upperHeight) : 0;
+    const bounds = count === 2
+        ? [
+            ['lower', undefined, lower],
+            ['upper', lower, undefined],
+        ]
+        : count === 3
+            ? [
+                ['lower', undefined, lower],
+                ['middle', lower, lower + middle],
+                ['upper', lower + middle, undefined],
+            ]
+            : [
+                ['lower', undefined, lower],
+                ['middle', lower, lower + middle],
+                ['upper', lower + middle, lower + middle + upper],
+                ['top', lower + middle + upper, undefined],
+            ];
+    const regions = [];
+    for (const face of ['a', 'b']) {
+        for (const [band, v0, v1] of bounds) {
+            const finish = slots[wallBandSlotKey(face, band)];
+            // An unpainted band showed the face finish, which is what shows without a region.
+            if (!hasRef(finish))
+                continue;
+            if (v0 !== undefined && v1 !== undefined && v1 <= v0)
+                continue;
+            regions.push({
+                id: `band-${face}-${band}`,
+                face,
+                ...(v0 === undefined ? {} : { v0 }),
+                ...(v1 === undefined ? {} : { v1 }),
+                finish,
+            });
+        }
+    }
+    return regions;
+}
+const BAND_SLOT_KEYS = new Set(['a', 'b'].flatMap((face) => BANDS.map((band) => wallBandSlotKey(face, band))));
+/**
+ * M2: enabled face bands (2–4) become full-width horizontal `faceRegions` with
+ * the same heights and finishes; `faceBands` and the band slot keys are dropped.
+ * Runs after M1 (it reads the geometric band keys M1 writes).
+ */
+function migrateWallFaceBandsOnView(sourceNodes) {
+    let nodes = null;
+    for (const [id, node] of Object.entries(sourceNodes)) {
+        if (!isRecord(node) || node.type !== 'wall')
+            continue;
+        const slots = slotRecord(node);
+        const bandKeys = Object.keys(slots).filter((key) => BAND_SLOT_KEYS.has(key));
+        if (node.faceBands === undefined && !('faceBands' in node) && bandKeys.length === 0)
+            continue;
+        const regions = bandRegions(node, slots);
+        const next = { ...node };
+        delete next.faceBands;
+        if (bandKeys.length > 0) {
+            next.slots = Object.fromEntries(Object.entries(slots).filter(([key]) => !BAND_SLOT_KEYS.has(key)));
+        }
+        if (regions.length > 0) {
+            const existing = Array.isArray(node.faceRegions) ? node.faceRegions : [];
+            next.faceRegions = [...regions, ...existing];
+        }
+        nodes ??= { ...sourceNodes };
+        nodes[id] = next;
+    }
+    return { nodes: nodes ?? sourceNodes, changed: nodes !== null };
+}
+export const migrateWallFaceKeys = loadMigration('wall face keys', migrateWallFaceKeysOnView, (nodes) => ({ nodes, changed: false }));
+export const migrateWallFaceBands = loadMigration('wall face bands', migrateWallFaceBandsOnView, (nodes) => ({ nodes, changed: false }));

package/dist/validation/opening-bounds.d.ts

@@ -0,0 +1,36 @@
+import type { AnyNode } from '../schema/types.js';
+type OpeningNode = Extract<AnyNode, {
+    type: 'door' | 'window';
+}>;
+type WallNode = Extract<AnyNode, {
+    type: 'wall';
+}>;
+/** Slack in meters before an opening counts as leaving its host wall. */
+export declare const OPENING_BOUNDS_TOLERANCE = 0.01;
+export type OpeningBoundsIssue = {
+    openingId: string;
+    openingType: OpeningNode['type'];
+    wallId: string;
+} & ({
+    kind: 'along_wall';
+    from: number;
+    to: number;
+    wallLength: number;
+} | {
+    kind: 'vertical';
+    bottom: number;
+    top: number;
+    wallHeight: number;
+});
+/**
+ * Geometric containment of a wall-hosted opening. `position` is wall-local:
+ * x runs along the wall from `start`, y is the opening's center height from
+ * the wall base. Callers resolve `wallHeight` (plane-bound walls take it
+ * from the storey, explicit walls from `height`) so this stays pure over
+ * the node data and both the build-JSON validator and the MCP verify tool
+ * report the same thing.
+ */
+export declare function checkOpeningWithinWall(opening: Pick<OpeningNode, 'id' | 'type' | 'position' | 'width' | 'height'>, wall: Pick<WallNode, 'id' | 'start' | 'end'>, wallHeight: number): OpeningBoundsIssue[];
+export declare function formatOpeningBoundsIssue(issue: OpeningBoundsIssue): string;
+export {};
+//# sourceMappingURL=opening-bounds.d.ts.map

package/dist/validation/opening-bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-bounds.d.ts","sourceRoot":"","sources":["../../src/validation/opening-bounds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAE9C,KAAK,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAC,CAAA;AAChE,KAAK,QAAQ,GAAG,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAElD,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,OAAO,CAAA;AAE5C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAChC,MAAM,EAAE,MAAM,CAAA;CACf,GAAG,CACA;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACpE;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CACxE,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,EAC3E,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,OAAO,GAAG,KAAK,CAAC,EAC5C,UAAU,EAAE,MAAM,GACjB,kBAAkB,EAAE,CAgBtB;AAID,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAM1E"}

package/dist/validation/opening-bounds.js

@@ -0,0 +1,34 @@
+/** Slack in meters before an opening counts as leaving its host wall. */
+export const OPENING_BOUNDS_TOLERANCE = 0.01;
+/**
+ * Geometric containment of a wall-hosted opening. `position` is wall-local:
+ * x runs along the wall from `start`, y is the opening's center height from
+ * the wall base. Callers resolve `wallHeight` (plane-bound walls take it
+ * from the storey, explicit walls from `height`) so this stays pure over
+ * the node data and both the build-JSON validator and the MCP verify tool
+ * report the same thing.
+ */
+export function checkOpeningWithinWall(opening, wall, wallHeight) {
+    const wallLength = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    const from = opening.position[0] - opening.width / 2;
+    const to = opening.position[0] + opening.width / 2;
+    const bottom = opening.position[1] - opening.height / 2;
+    const top = opening.position[1] + opening.height / 2;
+    const base = { openingId: opening.id, openingType: opening.type, wallId: wall.id };
+    const issues = [];
+    if (from < -OPENING_BOUNDS_TOLERANCE || to > wallLength + OPENING_BOUNDS_TOLERANCE) {
+        issues.push({ ...base, kind: 'along_wall', from, to, wallLength });
+    }
+    if (bottom < -OPENING_BOUNDS_TOLERANCE || top > wallHeight + OPENING_BOUNDS_TOLERANCE) {
+        issues.push({ ...base, kind: 'vertical', bottom, top, wallHeight });
+    }
+    return issues;
+}
+const m = (value) => value.toFixed(2);
+export function formatOpeningBoundsIssue(issue) {
+    const subject = `${issue.openingType} ${issue.openingId}`;
+    if (issue.kind === 'along_wall') {
+        return `${subject} extends outside wall ${issue.wallId}: spans ${m(issue.from)}–${m(issue.to)} m along a ${m(issue.wallLength)} m wall`;
+    }
+    return `${subject} vertical bounds [${m(issue.bottom)}, ${m(issue.top)}] exceed wall ${issue.wallId} height ${m(issue.wallHeight)}m`;
+}

package/dist/validation/validate-build-json.d.ts

@@ -24,6 +24,8 @@ export type ParsedBuildJson = {
     materials?: Record<string, SceneMaterial>;
     /** Item collections; member nodes carry the matching `collectionIds`. */
     collections?: Record<string, Collection>;
+    /** The project the file was saved from, where its scripted nodes' artifacts live. */
+    projectId?: string;
 };
 export type SchemaIssue = {
     nodeId: string;

package/dist/validation/validate-build-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAW,KAAK,WAAW,EAAc,MAAM,iBAAiB,CAAA;AAGvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACzC,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACzC,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAwCD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CA2XzE"}
+{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAW,KAAK,WAAW,EAAc,MAAM,iBAAiB,CAAA;AAOvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACzC,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACxC,qFAAqF;IACrF,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAwCD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAoazE"}