@pascal-app/core 1.0.1 → 1.0.4

package/dist/utils/heal-plan-coordinates.d.ts

@@ -0,0 +1,2 @@
+export declare function healScenePlanCoordinates(input: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=heal-plan-coordinates.d.ts.map

package/dist/utils/heal-plan-coordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heal-plan-coordinates.d.ts","sourceRoot":"","sources":["../../src/utils/heal-plan-coordinates.ts"],"names":[],"mappings":"AAqDA,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUhG"}

package/dist/utils/heal-plan-coordinates.js

@@ -0,0 +1,69 @@
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function planPoint(value, allowXY) {
+    if (Array.isArray(value)) {
+        if (!value.every(finite))
+            return;
+        if (value.length === 2)
+            return value;
+        if (value.length === 3)
+            return [value[0], value[2]];
+        return;
+    }
+    if (!(record(value) && finite(value.x)))
+        return;
+    if (finite(value.z))
+        return [value.x, value.z];
+    if (allowXY && !('z' in value) && finite(value.y))
+        return [value.x, value.y];
+}
+function planRing(value, allowXY) {
+    let points = record(value) ? value.points : value;
+    if (Array.isArray(points) && points.length === 1)
+        points = points[0];
+    if (!Array.isArray(points) || points.length < 3)
+        return;
+    const ring = points.map((point) => planPoint(point, allowXY));
+    if (!ring.every((point) => point !== undefined))
+        return;
+    return ring.every((point, i) => point === points[i]) ? points : ring;
+}
+function healNode(node) {
+    // A separately authored vertical dimension identifies legacy XY plan data;
+    // otherwise a missing Z is ambiguous and must not be guessed.
+    const allowXY = [node.height, node.thickness, node.elevation].some(finite);
+    if (node.type === 'wall') {
+        const points = node.start === undefined && node.end === undefined && Array.isArray(node.points)
+            ? node.points
+            : undefined;
+        const start = planPoint(points?.length === 2 ? points[0] : node.start, allowXY);
+        const end = planPoint(points?.length === 2 ? points[1] : node.end, allowXY);
+        if (start && end && (start !== node.start || end !== node.end))
+            return { ...node, start, end };
+    }
+    if (node.type === 'slab') {
+        const source = node.polygon === undefined ? (node.points ?? node.vertices) : node.polygon;
+        const polygon = planRing(source, allowXY);
+        if (polygon && polygon !== node.polygon)
+            return { ...node, polygon };
+    }
+    return node;
+}
+export function healScenePlanCoordinates(input) {
+    let nodes = input;
+    for (const [id, node] of Object.entries(input)) {
+        if (!record(node))
+            continue;
+        const healed = healNode(node);
+        if (healed === node)
+            continue;
+        if (nodes === input)
+            nodes = { ...input };
+        nodes[id] = healed;
+    }
+    return nodes;
+}

package/dist/utils/heal-scene-graph.d.ts

@@ -1,7 +1,14 @@
 export interface HealSceneResult {
-    nodes: Record<string, unknown>;
     /** Ids of zero-length walls that were dropped. */
     droppedWallIds: string[];
+    nodes: Record<string, unknown>;
+    repairedCoordinates: number;
+    /**
+     * Ids of nodes whose null `parentId` was repaired to the one parent that
+     * still claims them via `children`.
+     */
+    repairedParentLinkNodeIds: string[];
+    repairedChildLinkNodeIds: string[];
     /** Count of invalid non-string (e.g. null) entries removed from `children` arrays. */
     strippedChildRefs: number;
     /**
@@ -9,15 +16,22 @@ export interface HealSceneResult {
      * a different node (stale reparent leftovers), plus same-array duplicates.
      */
     strippedStaleChildRefs: number;
-    /**
-     * Ids of nodes whose null `parentId` was repaired to the one parent that
-     * still claims them via `children`.
-     */
-    repairedParentLinkNodeIds: string[];
 }
 /**
  * Returns a healed copy of a `nodes` map. Pure — does not mutate `input`.
  * Nodes that need no repair are passed through by reference.
  */
 export declare function healSceneNodes(input: Record<string, unknown>): HealSceneResult;
+/**
+ * Pass 3 of `healSceneNodes`, on its own for loaders that must not run the
+ * other repairs: a node with a null `parentId` that exactly one parent claims
+ * via `children` gets that `parentId`. Legacy writers (the hosted MCP's
+ * default scene until 2026-10) linked `children` without writing `parentId`.
+ * Embedded legacy site children claim by their `id`, so the flattened node is
+ * repaired too. Pure: nodes that need no repair are passed through by reference.
+ */
+export declare function repairClaimedParentLinks(input: Record<string, unknown>): {
+    nodes: Record<string, unknown>;
+    repairedParentLinkNodeIds: string[];
+};
 //# sourceMappingURL=heal-scene-graph.d.ts.map

package/dist/utils/heal-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heal-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/heal-scene-graph.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,kDAAkD;IAClD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,sFAAsF;IACtF,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAA;IAC9B;;;OAGG;IACH,yBAAyB,EAAE,MAAM,EAAE,CAAA;CACpC;AAgBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CAiH9E"}
+{"version":3,"file":"heal-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/heal-scene-graph.ts"],"names":[],"mappings":"AAgCA,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,mBAAmB,EAAE,MAAM,CAAA;IAC3B;;;OAGG;IACH,yBAAyB,EAAE,MAAM,EAAE,CAAA;IACnC,wBAAwB,EAAE,MAAM,EAAE,CAAA;IAClC,sFAAsF;IACtF,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAA;CAC/B;AAgBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CAqH9E;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACxE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,yBAAyB,EAAE,MAAM,EAAE,CAAA;CACpC,CA8BA"}

package/dist/utils/heal-scene-graph.js

@@ -21,7 +21,10 @@
 //
 // All are also prevented at the source now; this is the load-time safety net
 // for already-saved scenes.
+import { AnyNode, nodeKindOf } from '../schema/types.js';
+import { healScenePlanCoordinates } from './heal-plan-coordinates.js';
 const ZERO_LENGTH_EPS = 1e-6;
+const hostKinds = new Set(AnyNode.options.filter((schema) => 'children' in schema.shape).map(nodeKindOf));
 function isWallLike(node) {
     if (!node || typeof node !== 'object')
         return false;
@@ -40,10 +43,14 @@ function isWallLike(node) {
  */
 export function healSceneNodes(input) {
     const droppedWallIds = [];
+    const repairedChildLinkNodeIds = [];
+    let repairedCoordinates = 0;
     // Pass 1: drop childless zero-length walls. (Only childless ones — a wall
     // carrying a door/window must keep its hosts, degenerate or not.)
     const kept = {};
-    for (const [id, node] of Object.entries(input)) {
+    for (const [id, node] of Object.entries(healScenePlanCoordinates(input))) {
+        if (node !== input[id])
+            repairedCoordinates += 1;
         if (isWallLike(node)) {
             const children = node.children;
             const childless = !Array.isArray(children) || children.length === 0;
@@ -64,9 +71,19 @@ export function healSceneNodes(input) {
     // and stale references whose child's `parentId` names a different parent.
     // Legacy sites embedded full child objects; keep those for migrateNodes to
     // flatten after healing instead of disconnecting the entire building.
-    const nodes = {};
+    const cleanedNodes = {};
     for (const [id, node] of Object.entries(kept)) {
         const children = node?.children;
+        if (node?.type === 'level' && !Array.isArray(children)) {
+            cleanedNodes[id] = {
+                ...node,
+                children: Object.entries(kept)
+                    .filter(([, child]) => child?.parentId === id)
+                    .map(([childId]) => childId),
+            };
+            repairedChildLinkNodeIds.push(id);
+            continue;
+        }
         if (Array.isArray(children)) {
             const seen = new Set();
             const cleaned = children.filter((child) => {
@@ -101,16 +118,50 @@ export function healSceneNodes(input) {
                 return true;
             });
             if (cleaned.length !== children.length) {
-                nodes[id] = { ...node, children: cleaned };
+                cleanedNodes[id] = { ...node, children: cleaned };
                 continue;
             }
         }
-        nodes[id] = node;
+        cleanedNodes[id] = node;
+    }
+    // Pass 3: repair null parent links (`repairClaimedParentLinks`).
+    const { nodes, repairedParentLinkNodeIds } = repairClaimedParentLinks(cleanedNodes);
+    // Reachability follows children, so retaining a node via parentId also
+    // requires repairing its host's reverse link before authority validation.
+    for (const [id, node] of Object.entries(nodes).sort(([a], [b]) => a.localeCompare(b))) {
+        const parentId = node?.parentId;
+        if (typeof parentId !== 'string' || parentId === id)
+            continue;
+        const parent = nodes[parentId];
+        if (!parent || !(hostKinds.has(parent.type ?? '') || Array.isArray(parent.children)))
+            continue;
+        const children = Array.isArray(parent.children) ? parent.children : [];
+        if (children.some((child) => child === id || (child && typeof child === 'object' && child.id === id)))
+            continue;
+        nodes[parentId] = { ...parent, children: [...children, id] };
+        if (!repairedChildLinkNodeIds.includes(parentId))
+            repairedChildLinkNodeIds.push(parentId);
     }
-    // Pass 3: repair null parent links. A node claimed as a child by exactly one
-    // parent must point back at it; legacy writers linked `children` without
-    // writing `parentId`. Embedded legacy site children claim by their `id` so
-    // the flattened flat-map node is repaired too.
+    return {
+        nodes,
+        repairedCoordinates,
+        droppedWallIds,
+        strippedChildRefs,
+        strippedStaleChildRefs,
+        repairedParentLinkNodeIds,
+        repairedChildLinkNodeIds,
+    };
+}
+/**
+ * Pass 3 of `healSceneNodes`, on its own for loaders that must not run the
+ * other repairs: a node with a null `parentId` that exactly one parent claims
+ * via `children` gets that `parentId`. Legacy writers (the hosted MCP's
+ * default scene until 2026-10) linked `children` without writing `parentId`.
+ * Embedded legacy site children claim by their `id`, so the flattened node is
+ * repaired too. Pure: nodes that need no repair are passed through by reference.
+ */
+export function repairClaimedParentLinks(input) {
+    const nodes = { ...input };
     const claimantsByChildId = new Map();
     for (const [id, node] of Object.entries(nodes)) {
         const children = node?.children;
@@ -122,7 +173,7 @@ export function healSceneNodes(input) {
                 : child && typeof child === 'object' && typeof child.id === 'string'
                     ? child.id
                     : null;
-            if (!childId || !(childId in nodes))
+            if (!(childId && childId in nodes))
                 continue;
             const claimants = claimantsByChildId.get(childId) ?? [];
             claimants.push(id);
@@ -141,11 +192,5 @@ export function healSceneNodes(input) {
         nodes[id] = { ...node, parentId: claimants[0] };
         repairedParentLinkNodeIds.push(id);
     }
-    return {
-        nodes,
-        droppedWallIds,
-        strippedChildRefs,
-        strippedStaleChildRefs,
-        repairedParentLinkNodeIds,
-    };
+    return { nodes, repairedParentLinkNodeIds };
 }

package/dist/utils/legacy-material-slots.d.ts

@@ -0,0 +1,23 @@
+import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material.js';
+export type MintedMaterials = Record<SceneMaterialId, SceneMaterial>;
+/**
+ * A legacy surface spec as a `MaterialRef`: a preset that is already a
+ * `library:`/`scene:` ref is used as-is; an inline material mints (or reuses)
+ * a scene material in `minted`. Undefined when the spec carries no material.
+ */
+export declare function legacySpecToMaterialRef(spec: {
+    material?: unknown;
+    materialPreset?: unknown;
+}, minted: MintedMaterials): string | undefined;
+export declare function migrateWallSurfaceMaterials(node: Record<string, any>, minted: MintedMaterials): Record<string, any>;
+export declare function migrateSingleMaterialSlots(node: Record<string, any>, slotIds: readonly string[], minted: MintedMaterials): Record<string, any>;
+export declare const migrateStructuralMaterialSlots: (nodes: {
+    [x: string]: unknown;
+}) => {
+    nodes: {
+        [x: string]: unknown;
+    };
+    materials: {};
+    changed: boolean;
+};
+//# sourceMappingURL=legacy-material-slots.d.ts.map

package/dist/utils/legacy-material-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-material-slots.d.ts","sourceRoot":"","sources":["../../src/utils/legacy-material-slots.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAS9E,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAsBpE;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,EACtD,MAAM,EAAE,eAAe,GACtB,MAAM,GAAG,SAAS,CAcpB;AAKD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,eAAe,uBAqC7F;AAQD,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,MAAM,EAAE,eAAe,uBAkBxB;AA0BD,eAAO,MAAM,8BAA8B;;;;;;;;CAI1C,CAAA"}

package/dist/utils/legacy-material-slots.js

@@ -0,0 +1,120 @@
+import { parseMaterialRef, toSceneMaterialRef } from '../material-library.js';
+import { getEffectiveWallSurfaceMaterial } from '../schema/nodes/wall.js';
+import { loadMigration } from './load-migration.js';
+function hash53(text, seed) {
+    let h1 = 0xdeadbeef ^ seed;
+    let h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        h1 = Math.imul(h1 ^ code, 2654435761);
+        h2 = Math.imul(h2 ^ code, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+// Content-derived, so every load of the same legacy scene — the authority
+// normalises the stored graph on each read — mints the same id.
+function legacySceneMaterialId(materialJson) {
+    const digest = hash53(materialJson, 0).toString(36).padStart(11, '0');
+    return `mat_${(digest + hash53(materialJson, 1).toString(36).padStart(11, '0')).slice(0, 16)}`;
+}
+/**
+ * A legacy surface spec as a `MaterialRef`: a preset that is already a
+ * `library:`/`scene:` ref is used as-is; an inline material mints (or reuses)
+ * a scene material in `minted`. Undefined when the spec carries no material.
+ */
+export function legacySpecToMaterialRef(spec, minted) {
+    if (typeof spec.materialPreset === 'string' && parseMaterialRef(spec.materialPreset)) {
+        return spec.materialPreset;
+    }
+    if (spec.material === undefined)
+        return;
+    const json = JSON.stringify(spec.material);
+    const id = legacySceneMaterialId(json);
+    // One shared datablock per custom colour (mirrors `commitSlotPaint`'s dedupe-on-match).
+    minted[id] ??= {
+        id,
+        name: `Material ${Object.keys(minted).length + 1}`,
+        material: spec.material,
+    };
+    return toSceneMaterialRef(id);
+}
+// Move the retired inline `material*` / `interiorMaterial*` / `exteriorMaterial*`
+// fields onto `node.slots` (interior / exterior → a ref). Already slot-modelled
+// walls and walls with no legacy material are left untouched.
+export function migrateWallSurfaceMaterials(node, minted) {
+    if (node.slots && (node.slots.interior !== undefined || node.slots.exterior !== undefined)) {
+        return node;
+    }
+    // Already on geometric faces (M1 ran on an earlier load): its legacy fallback
+    // is per face now, and re-keying it by side would undo that.
+    if (node.legacyFaceMaterials ||
+        (node.slots && (node.slots.a !== undefined || node.slots.b !== undefined))) {
+        return node;
+    }
+    const slots = { ...(node.slots ?? {}) };
+    for (const side of ['interior', 'exterior']) {
+        const spec = getEffectiveWallSurfaceMaterial(node, side);
+        const ref = legacySpecToMaterialRef(spec, minted);
+        if (ref)
+            slots[side] = ref;
+    }
+    if (Object.keys(slots).length === 0) {
+        return node;
+    }
+    return {
+        ...node,
+        slots,
+        material: undefined,
+        materialPreset: undefined,
+        interiorMaterial: undefined,
+        interiorMaterialPreset: undefined,
+        exteriorMaterial: undefined,
+        exteriorMaterialPreset: undefined,
+    };
+}
+// Move a kind's single legacy `material` / `materialPreset` onto its declared
+// slots. A pre-slot-model node painted one material rendered that material on
+// every part (each slot resolves `node.slots[slot]` → legacy → default), so the
+// migration writes the same ref to every slot id the kind can expose — unused
+// conditional slots are harmless. Already slot-modelled or unpainted nodes are
+// left untouched.
+export function migrateSingleMaterialSlots(node, slotIds, minted) {
+    if (node.slots && Object.keys(node.slots).length > 0) {
+        return node;
+    }
+    const ref = legacySpecToMaterialRef({ material: node.material, materialPreset: node.materialPreset }, minted);
+    if (!ref) {
+        return node;
+    }
+    const slots = {};
+    for (const slotId of slotIds)
+        slots[slotId] = ref;
+    return { ...node, slots, material: undefined, materialPreset: undefined };
+}
+/**
+ * The legacy-finish migrations of the kinds the structural load migrations
+ * read (walls, slabs, ceilings), for the hosted authority: the client loader
+ * runs the same per-node functions in `migrateNodes`.
+ */
+function migrateStructuralMaterialSlotsOnView(sourceNodes) {
+    const materials = {};
+    let nodes = null;
+    for (const [id, value] of Object.entries(sourceNodes)) {
+        const node = value;
+        if (!node || typeof node !== 'object')
+            continue;
+        const next = node.type === 'wall'
+            ? migrateWallSurfaceMaterials(node, materials)
+            : node.type === 'slab' || node.type === 'ceiling'
+                ? migrateSingleMaterialSlots(node, ['surface'], materials)
+                : node;
+        if (next === node)
+            continue;
+        nodes ??= { ...sourceNodes };
+        nodes[id] = next;
+    }
+    return { nodes: nodes ?? sourceNodes, materials, changed: nodes !== null };
+}
+export const migrateStructuralMaterialSlots = loadMigration('legacy material slots', migrateStructuralMaterialSlotsOnView, (nodes) => ({ nodes, materials: {}, changed: false }));

package/dist/utils/legacy-opening-datums.d.ts

@@ -0,0 +1,11 @@
+import type { AnyNode, DoorNode, WallNode, WindowNode } from '../schema/index.js';
+/** A legacy wall election changing is not evidence of an authored floor step. */
+export declare function legacyOpeningFloorChange(wall: WallNode, opening: DoorNode | WindowNode, nodes: Readonly<Record<string, AnyNode>>, oldSupport: number, tolerance?: number, legacyFloor?: number): {
+    datum: number;
+    delta: number;
+    difference: number;
+    reason: string | undefined;
+    fits: boolean;
+    zoneIds: string[];
+};
+//# sourceMappingURL=legacy-opening-datums.d.ts.map

package/dist/utils/legacy-opening-datums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-opening-datums.d.ts","sourceRoot":"","sources":["../../src/utils/legacy-opening-datums.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAY,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AA8ClF,iFAAiF;AACjF,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,EAAE,MAAM,EAClB,SAAS,SAAO,EAChB,WAAW,SAAa;;;;;;;EAuDzB"}

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

@@ -0,0 +1,92 @@
+import { roomFace } from '../commands/structure/shared.js';
+import { floorRoomFaces } from '../lib/floor-room-faces.js';
+import { openingDatumFromSupport, openingFitsAtDatum, supportSegmentAt, wallSupportForNodes, } from '../lib/opening-floor-datum.js';
+import { roomFloorPlate } from '../lib/room-floor-plate.js';
+import { getWallCurveFrameAt, getWallCurveLength } from '../systems/wall/wall-curve.js';
+const contexts = new WeakMap();
+function roomSpans(nodes, levelId) {
+    let levels = contexts.get(nodes);
+    if (!levels) {
+        levels = new Map();
+        contexts.set(nodes, levels);
+    }
+    const cached = levels.get(levelId);
+    if (cached)
+        return cached;
+    const children = Object.values(nodes).filter((node) => node.parentId === levelId);
+    const faces = floorRoomFaces(children.filter((node) => node.type === 'wall' || node.type === 'separator'));
+    const slabs = children.filter((node) => node.type === 'slab');
+    const result = new Map();
+    for (const zone of children) {
+        if (zone.type !== 'zone' ||
+            zone.spaceRole !== 'room' ||
+            zone.hasFloor === false ||
+            zone.floor?.support === 'open')
+            continue;
+        const room = roomFace(nodes, zone, faces);
+        const plate = roomFloorPlate(slabs, zone.id);
+        for (const span of room?.spans ?? []) {
+            const spans = result.get(span.boundaryId) ?? [];
+            spans.push({
+                face: span.face,
+                from: span.t0,
+                to: span.t1,
+                zoneId: zone.id,
+                raised: plate?.plateRole === 'platform',
+            });
+            result.set(span.boundaryId, spans);
+        }
+    }
+    levels.set(levelId, result);
+    return result;
+}
+/** A legacy wall election changing is not evidence of an authored floor step. */
+export function legacyOpeningFloorChange(wall, opening, nodes, oldSupport, tolerance = 1e-6, legacyFloor = oldSupport) {
+    const support = wallSupportForNodes(wall, nodes);
+    const datum = openingDatumFromSupport(wall, opening, support);
+    const fits = openingFitsAtDatum(wall, opening, datum, nodes, support);
+    const delta = datum - oldSupport;
+    const length = getWallCurveLength(wall);
+    const from = Math.max(0, (opening.position[0] - opening.width / 2) / length);
+    const to = Math.min(1, (opening.position[0] + opening.width / 2) / length);
+    const heights = [...support.faceDatum.a, ...support.faceDatum.b].flatMap((segment) => {
+        const a = Math.max(from, segment.start), b = Math.min(to, segment.end);
+        return b > a ? [supportSegmentAt(segment, a), supportSegmentAt(segment, b)] : [];
+    });
+    const difference = heights.length ? Math.max(...heights) - Math.min(...heights) : 0;
+    const chord = (t) => {
+        const { point } = getWallCurveFrameAt(wall, t);
+        const dx = wall.end[0] - wall.start[0], dz = wall.end[1] - wall.start[1];
+        return ((point.x - wall.start[0]) * dx + (point.y - wall.start[1]) * dz) / (dx * dx + dz * dz);
+    };
+    const start = chord(from), end = chord(to);
+    const spans = (roomSpans(nodes, wall.parentId).get(wall.id) ?? []).filter((span) => span.to > start && span.from < end);
+    const covered = (face) => {
+        let cursor = start;
+        for (const span of spans.filter((span) => span.face === face).sort((a, b) => a.from - b.from)) {
+            if (span.from > cursor + 1e-6)
+                return false;
+            cursor = Math.max(cursor, span.to);
+        }
+        return end > start && cursor >= end - 1e-6;
+    };
+    const a = covered('a'), b = covered('b');
+    const step = difference >= 0.001 - 1e-6 && Math.abs(delta) <= difference + tolerance;
+    const reason = step && a && b
+        ? 'between-heights'
+        : step && spans.some((span) => span.raised && covered(span.face))
+            ? 'raised-room'
+            : delta >= -tolerance &&
+                delta <= Math.min(0.05, legacyFloor - oldSupport) + tolerance &&
+                (a || b)
+                ? 'finished-floor'
+                : undefined;
+    return {
+        datum,
+        delta,
+        difference,
+        reason: fits ? reason : undefined,
+        fits,
+        zoneIds: [...new Set(spans.map((span) => span.zoneId))],
+    };
+}

package/dist/utils/legacy-wall-datums.d.ts

@@ -0,0 +1,6 @@
+import type { AnyNode, SlabNode, WallNode } from '../schema/index.js';
+import { type WallSlabSupport } from '../systems/slab/slab-support.js';
+export declare function legacyWallElevations(walls: WallNode[], slabs: SlabNode[], nodes: Readonly<Record<string, AnyNode>>, levelId: string): Map<string, WallSlabSupport>;
+/** Preserve production datums once, before a level first acquires derived plates. */
+export declare function preserveLegacyWallDatums(before: Readonly<Record<string, AnyNode>>, after: Record<string, AnyNode>): Record<string, AnyNode>;
+//# sourceMappingURL=legacy-wall-datums.d.ts.map

package/dist/utils/legacy-wall-datums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-wall-datums.d.ts","sourceRoot":"","sources":["../../src/utils/legacy-wall-datums.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAE5D,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAK3F,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,EAAE,EACjB,KAAK,EAAE,QAAQ,EAAE,EACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,gCAkDhB;AAED,qFAAqF;AACrF,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2LzB"}