@pascal-app/core 1.0.0-beta.3 → 1.0.0-beta.5

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

@@ -13,6 +13,11 @@
 //     duplicate reference renders the child twice (duplicate React keys in the
 //     2D plan, doubled hosted geometry in 3D). Same-array duplicates are
 //     collapsed too.
+//  4. A node with a null `parentId` that exactly one parent still claims via
+//     `children` (the legacy site-child flatten and the old default-scene
+//     assembler both linked children without writing `parentId`). The editor
+//     renders the chain through `children`, but the hosted scene authority
+//     validates parent/child symmetry and rejects the whole scene.
 //
 // All are also prevented at the source now; this is the load-time safety net
 // for already-saved scenes.
@@ -102,5 +107,45 @@ export function healSceneNodes(input) {
         }
         nodes[id] = node;
     }
-    return { nodes, droppedWallIds, strippedChildRefs, strippedStaleChildRefs };
+    // 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.
+    const claimantsByChildId = new Map();
+    for (const [id, node] of Object.entries(nodes)) {
+        const children = node?.children;
+        if (!Array.isArray(children))
+            continue;
+        for (const child of children) {
+            const childId = typeof child === 'string'
+                ? child
+                : child && typeof child === 'object' && typeof child.id === 'string'
+                    ? child.id
+                    : null;
+            if (!childId || !(childId in nodes))
+                continue;
+            const claimants = claimantsByChildId.get(childId) ?? [];
+            claimants.push(id);
+            claimantsByChildId.set(childId, claimants);
+        }
+    }
+    const repairedParentLinkNodeIds = [];
+    for (const [id, node] of Object.entries(nodes)) {
+        if (!node || typeof node !== 'object')
+            continue;
+        if (node.parentId != null)
+            continue;
+        const claimants = claimantsByChildId.get(id);
+        if (claimants?.length !== 1 || claimants[0] === id)
+            continue;
+        nodes[id] = { ...node, parentId: claimants[0] };
+        repairedParentLinkNodeIds.push(id);
+    }
+    return {
+        nodes,
+        droppedWallIds,
+        strippedChildRefs,
+        strippedStaleChildRefs,
+        repairedParentLinkNodeIds,
+    };
 }

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

@@ -0,0 +1,4 @@
+export { type HealSceneResult, healSceneNodes } from './heal-scene-graph';
+export { type RetiredSceneNodeMigration, removeRetiredDrawingSheetNodes, } from './retired-scene-nodes';
+export { migrateVerticalSceneNodes, type VerticalSceneMigration, } from './vertical-scene-migration';
+//# sourceMappingURL=scene-migrations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scene-migrations.d.ts","sourceRoot":"","sources":["../../src/utils/scene-migrations.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,EACL,KAAK,yBAAyB,EAC9B,8BAA8B,GAC/B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,yBAAyB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,4BAA4B,CAAA"}

package/dist/utils/scene-migrations.js

@@ -0,0 +1,7 @@
+// Server-safe scene migrations shared by the client loader and the hosted
+// scene authority. Everything exported here must stay pure data logic with no
+// store, React, or Three.js imports so it can run in Server Components and
+// API routes.
+export { healSceneNodes } from './heal-scene-graph';
+export { removeRetiredDrawingSheetNodes, } from './retired-scene-nodes';
+export { migrateVerticalSceneNodes, } from './vertical-scene-migration';

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

@@ -0,0 +1,13 @@
+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;
+//# sourceMappingURL=vertical-scene-migration.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,179 @@
+import { GROUND_SUPPORT_ID } from '../hooks/spatial-grid/support-host-id';
+import { deriveLegacyLevelHeight } from '../services/level-height';
+import { getCeilingClampBound } from '../services/storey';
+import { computeWallSlabSupport } from '../systems/slab/slab-support';
+import { DEFAULT_WALL_HEIGHT } from '../systems/wall/wall-footprint';
+function getFiniteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function getStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === 'string')
+        : [];
+}
+// Walls whose top lands within this of the storey plane become plane-bound;
+// ceilings whose stored height lands within this of their clamp bound become
+// follows-mode. The strict comparison preserves intentional 0.20-short walls.
+const PLANE_BOUND_EPSILON = 0.2;
+// A ground-pinned wall counts as buried only when the elected slab's occupied
+// interval strictly straddles the pinned base. The tolerance absorbs float
+// drift in stamped offsets without capturing a slab that merely touches the
+// base from above.
+const BURIED_PIN_EPSILON = 1e-3;
+/**
+ * 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 function migrateVerticalSceneNodes(sourceNodes) {
+    const nodes = { ...sourceNodes };
+    let changed = false;
+    const replaceNode = (id, node) => {
+        nodes[id] = node;
+        changed = true;
+    };
+    // A level without `height` marks a scene saved before the vertical model
+    // landed. Compute the gate before mutating anything so stair and ceiling
+    // intent on already-migrated scenes is never reclassified.
+    const isLegacyScene = Object.values(nodes).some((node) => node?.type === 'level' && !('height' in node));
+    // Ordinals are semantic and compact independently within each building.
+    const buildingNodes = Object.values(nodes).filter((node) => node?.type === 'building');
+    const levelsByBuilding = new Map();
+    for (const [id, node] of Object.entries(nodes)) {
+        if (node?.type !== 'level')
+            continue;
+        const buildingId = buildingNodes.find((building) => building.id === node.parentId)?.id ??
+            buildingNodes.find((building) => getStringArray(building.children).includes(id))?.id ??
+            null;
+        const bucket = levelsByBuilding.get(buildingId) ?? [];
+        bucket.push({ id, ordinal: getFiniteNumber(node.level, 0) });
+        levelsByBuilding.set(buildingId, bucket);
+    }
+    for (const bucket of levelsByBuilding.values()) {
+        const sorted = [...bucket].sort((a, b) => a.ordinal - b.ordinal);
+        const negativeCount = sorted.filter((entry) => entry.ordinal < 0).length;
+        sorted.forEach((entry, index) => {
+            const nextOrdinal = index - negativeCount;
+            const current = nodes[entry.id];
+            if (current.level !== nextOrdinal) {
+                replaceNode(entry.id, { ...current, level: nextOrdinal });
+            }
+        });
+    }
+    // Materialize exact legacy storey planes before classifying wall tops.
+    const legacyLevelIds = Object.entries(nodes)
+        .filter(([, node]) => node?.type === 'level' && !('height' in node))
+        .map(([id]) => id);
+    const derivedHeights = new Map();
+    for (const levelId of legacyLevelIds) {
+        derivedHeights.set(levelId, deriveLegacyLevelHeight(levelId, nodes));
+    }
+    for (const levelId of legacyLevelIds) {
+        const plane = derivedHeights.get(levelId);
+        const level = nodes[levelId];
+        replaceNode(levelId, { ...level, height: plane });
+        const children = getStringArray(level.children)
+            .map((childId) => nodes[childId])
+            .filter((child) => child !== undefined);
+        const slabs = children.filter((child) => child.type === 'slab');
+        const walls = children.filter((child) => child.type === 'wall');
+        for (const wall of walls) {
+            const electedBase = computeWallSlabSupport({
+                start: wall.start,
+                end: wall.end,
+                curveOffset: wall.curveOffset,
+                thickness: wall.thickness,
+            }, slabs, walls).elevation;
+            const effectiveHeight = wall.height ?? DEFAULT_WALL_HEIGHT;
+            const top = Math.max(0, electedBase) + effectiveHeight;
+            if (Math.abs(plane - top) < PLANE_BOUND_EPSILON) {
+                if ('height' in wall) {
+                    const { height: _height, ...planeBound } = wall;
+                    replaceNode(wall.id, planeBound);
+                }
+            }
+            else if (wall.height !== effectiveHeight) {
+                replaceNode(wall.id, { ...wall, height: effectiveHeight });
+            }
+        }
+    }
+    if (isLegacyScene) {
+        for (const [id, node] of Object.entries(nodes)) {
+            if (node?.type !== 'stair' || node.totalRise !== 2.5)
+                continue;
+            const { totalRise: _totalRise, ...derivedRise } = node;
+            replaceNode(id, derivedRise);
+        }
+    }
+    // Preserve the exact occupied interval of legacy slabs.
+    for (const [id, node] of Object.entries(nodes)) {
+        if (node?.type !== 'slab' || 'thickness' in node)
+            continue;
+        const elevation = getFiniteNumber(node.elevation, 0.05);
+        replaceNode(id, elevation < 0
+            ? { ...node, thickness: 0.05, recessed: true }
+            : { ...node, thickness: elevation });
+    }
+    if (isLegacyScene) {
+        for (const [id, node] of Object.entries(nodes)) {
+            if (node?.type !== 'ceiling' || !('height' in node))
+                continue;
+            const dropHeight = () => {
+                const { height: _height, ...follows } = node;
+                replaceNode(id, follows);
+            };
+            if (node.autoFromWalls === true) {
+                dropHeight();
+                continue;
+            }
+            if (typeof node.parentId !== 'string')
+                continue;
+            const bound = getCeilingClampBound(node.parentId, nodes, Array.isArray(node.polygon) ? node.polygon : []);
+            const stored = getFiniteNumber(node.height, Number.NaN);
+            if (Number.isFinite(bound) && Math.abs(stored - bound) < PLANE_BOUND_EPSILON) {
+                dropHeight();
+            }
+        }
+    }
+    // Terrain-sculpt-era drafting stamped `supportSlabId: 'ground'` onto walls
+    // drawn in 3D on flat scenes. The pin short-circuits slab election, so a
+    // wall whose feet sit inside a floor slab keeps its base at the level floor
+    // — buried in the slab, z-fighting its side faces — while the panel shows
+    // the base as automatic. Heal the pin only in that buried state: a deck
+    // hovering above an intentionally grounded wall must keep its pin (dropping
+    // it would lift the wall onto the deck). Scenes with sculpted terrain are
+    // skipped wholesale — a ground host is load-bearing there, and the live
+    // terrain field isn't visible to this pure pass.
+    const hasSculptedTerrain = Object.values(nodes).some((node) => node?.type === 'site' && node.terrain != null);
+    if (!hasSculptedTerrain) {
+        for (const [id, node] of Object.entries(nodes)) {
+            if (node?.type !== 'wall' || node.supportSlabId !== GROUND_SUPPORT_ID)
+                continue;
+            const levelId = typeof node.parentId === 'string' ? node.parentId : null;
+            if (!levelId || nodes[levelId]?.type !== 'level')
+                continue;
+            const siblings = Object.values(nodes).filter((sibling) => sibling != null && sibling.parentId === levelId);
+            const support = computeWallSlabSupport({
+                start: node.start,
+                end: node.end,
+                curveOffset: node.curveOffset,
+                thickness: node.thickness,
+            }, siblings.filter((sibling) => sibling.type === 'slab'), siblings.filter((sibling) => sibling.type === 'wall'));
+            const elected = support.electedSlabId ? nodes[support.electedSlabId] : null;
+            if (!elected)
+                continue;
+            const pinnedBase = getFiniteNumber(node.supportOffset, 0);
+            const electedTop = getFiniteNumber(elected.elevation, 0.05);
+            const electedBottom = electedTop - getFiniteNumber(elected.thickness, 0.05);
+            const buried = electedBottom <= pinnedBase + BURIED_PIN_EPSILON &&
+                electedTop > pinnedBase + BURIED_PIN_EPSILON;
+            if (!buried)
+                continue;
+            const { supportSlabId: _host, supportOffset: _offset, ...healed } = node;
+            replaceNode(id, healed);
+        }
+    }
+    return changed ? { changed, nodes } : { changed, nodes: sourceNodes };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,9 +17,9 @@
       "default": "./dist/utils/clone-scene-graph.js"
     },
     "./scene-migrations": {
-      "types": "./dist/utils/retired-scene-nodes.d.ts",
-      "import": "./dist/utils/retired-scene-nodes.js",
-      "default": "./dist/utils/retired-scene-nodes.js"
+      "types": "./dist/utils/scene-migrations.d.ts",
+      "import": "./dist/utils/scene-migrations.js",
+      "default": "./dist/utils/scene-migrations.js"
     },
     "./registry": {
       "types": "./dist/registry/index.d.ts",