@pascal-app/core 0.9.1 → 0.9.2

package/dist/systems/stair/stair-opening-preview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}
+{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}

package/dist/systems/stair/stair-opening-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,QAAQ,EAIT,MAAM,cAAc,CAAA;AA8rBrB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAqG5E"}
+{"version":3,"file":"stair-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,QAAQ,EAIT,MAAM,cAAc,CAAA;AA0qBrB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAqG5E"}

package/dist/systems/stair/stair-opening-sync.js

@@ -329,19 +329,6 @@ function getSpiralOpeningPolygon(stair, offset = 0) {
         return toWorldPlanPoint(stair, Math.cos(angle) * radius, Math.sin(angle) * radius);
     });
 }
-function getSpiralLandingPolygon(stair, offset = 0) {
-    const width = Math.max(stair.width ?? 1, 0.4);
-    const outerRadius = Math.max(0.05, (stair.innerRadius ?? 0.9) + width);
-    const depth = Math.max(stair.topLandingDepth ?? 0.9, 0.1);
-    const halfWidth = width / 2;
-    const localPoints = [
-        [outerRadius - offset, -halfWidth - offset],
-        [outerRadius + depth + offset, -halfWidth - offset],
-        [outerRadius + depth + offset, halfWidth + offset],
-        [outerRadius - offset, halfWidth + offset],
-    ];
-    return localPoints.map(([x, z]) => toWorldPlanPoint(stair, x, z));
-}
 function getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, openingOffsetOverride) {
     const layouts = getStraightStairLayouts(stair, nodes);
     if (layouts.length === 0)
@@ -413,11 +400,7 @@ function getStairOpeningPolygons(stair, nodes, targetElevation, openingOffsetOve
     }
     if (stair.stairType === 'spiral') {
         const offset = Math.max(openingOffset - STAIR_SLAB_OPENING_TIGHTENING, 0);
-        const polygons = [getSpiralOpeningPolygon(stair, offset)];
-        if (stair.topLandingMode === 'integrated') {
-            polygons.push(getSpiralLandingPolygon(stair, offset));
-        }
-        return polygons;
+        return [getSpiralOpeningPolygon(stair, offset)];
     }
     if (typeof targetElevation === 'number') {
         return getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, openingOffset);

package/dist/systems/stair/stair-opening-sync.test.js

@@ -443,4 +443,43 @@ describe('syncAutoStairOpenings', () => {
         expect(landingUpdate?.data.holes).toEqual([manualOpening]);
         expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'manual' }]);
     });
+    test('does not add a separate rectangular hole for an integrated spiral top landing', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [-4, -4],
+                [4, -4],
+                [4, 4],
+                [-4, 4],
+            ],
+        });
+        const stair = StairNode.parse({
+            id: 'stair_spiral_landing',
+            name: 'Spiral Landing Stair',
+            parentId: ground.id,
+            position: [0, 0, 0],
+            rotation: Math.PI / 2,
+            stairType: 'spiral',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            innerRadius: 0.35,
+            width: 1.2,
+            sweepAngle: Math.PI * 1.6,
+            topLandingMode: 'integrated',
+            topLandingDepth: 1.1,
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        const holes = landingUpdate?.data.holes ?? [];
+        const rectangularHoles = holes.filter((hole) => hole.length === 4);
+        expect(holes).toHaveLength(1);
+        expect(rectangularHoles).toHaveLength(0);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
 });

package/dist/systems/wall/wall-mitering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAQlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAoND,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAmBlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAkPD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/systems/wall/wall-mitering.js

@@ -3,6 +3,16 @@ import { getWallCurveFrameAt, isCurvedWall } from './wall-curve';
 // UTILITY FUNCTIONS
 // ============================================================================
 const TOLERANCE = 0.001;
+// Miter joints are line-line intersections, so the joint point sits a distance
+// ≈ halfThickness / sin(θ) from the junction, where θ is the angle between the
+// two walls. As θ → 0 (two walls nearly collinear — e.g. a room-preset preview
+// dragged on top of an existing wall, or a freshly-drawn wall almost parallel
+// to its neighbour) that distance runs away to infinity and the wall renders as
+// an infinite spike. Cap the joint at this multiple of the wall half-thickness;
+// beyond it we fall back to a square (butt) joint, exactly like the existing
+// parallel-walls guard. 10× preserves every realistic corner (a 0.1 m wall keeps
+// mitering down to ~11°) while bounding the pathological near-collinear case.
+const MITER_LIMIT = 10;
 function pointToKey(p, tolerance = TOLERANCE) {
     const snap = 1 / tolerance;
     return `${Math.round(p.x * snap)},${Math.round(p.y * snap)}`;
@@ -144,7 +154,14 @@ function calculateJunctionIntersections(junction, getThickness) {
                 const edgeA = createLineFromPointAndVector(pA, v);
                 const edgeB = createLineFromPointAndVector(pB, v);
                 const angle = Math.atan2(v.y, v.x);
-                processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB, isPassthrough: true });
+                processedWalls.push({
+                    wallId: wall.id,
+                    angle,
+                    edgeA,
+                    edgeB,
+                    isPassthrough: true,
+                    halfThickness: halfT,
+                });
             }
         }
         else {
@@ -159,7 +176,14 @@ function calculateJunctionIntersections(junction, getThickness) {
             const edgeA = createLineFromPointAndVector(pA, v);
             const edgeB = createLineFromPointAndVector(pB, v);
             const angle = Math.atan2(v.y, v.x);
-            processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB, isPassthrough: false });
+            processedWalls.push({
+                wallId: wall.id,
+                angle,
+                edgeA,
+                edgeB,
+                isPassthrough: false,
+                halfThickness: halfT,
+            });
         }
     }
     // Sort by outgoing angle
@@ -182,6 +206,18 @@ function calculateJunctionIntersections(junction, getThickness) {
             x: (wall1.edgeA.b * wall2.edgeB.c - wall2.edgeB.b * wall1.edgeA.c) / det,
             y: (wall2.edgeB.a * wall1.edgeA.c - wall1.edgeA.a * wall2.edgeB.c) / det,
         };
+        // Miter limit: `det` only catches walls that are *exactly* parallel. Two
+        // walls meeting at a shallow angle have a small-but-nonzero `det`, so `p`
+        // lands far from the junction (∝ 1/sin θ) and the wall renders as an
+        // infinite spike. Reject any joint farther than MITER_LIMIT half-thicknesses
+        // from the meeting point — those walls fall back to a square joint.
+        const maxMiter = MITER_LIMIT * Math.max(wall1.halfThickness, wall2.halfThickness);
+        const dx = p.x - meetingPoint.x;
+        const dy = p.y - meetingPoint.y;
+        if (!(Number.isFinite(p.x) && Number.isFinite(p.y)) ||
+            dx * dx + dy * dy > maxMiter * maxMiter) {
+            continue;
+        }
         // Only assign intersection to non-passthrough walls
         // Passthrough walls don't receive junction data (their geometry doesn't change)
         if (!wall1.isPassthrough) {

package/dist/systems/wall/wall-mitering.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wall-mitering.test.d.ts.map

package/dist/systems/wall/wall-mitering.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-mitering.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.test.ts"],"names":[],"mappings":""}

package/dist/systems/wall/wall-mitering.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'bun:test';
+import { calculateLevelMiters, getWallMiterBoundaryPoints } from './wall-mitering';
+function wall(id, start, end) {
+    return {
+        id,
+        type: 'wall',
+        object: 'node',
+        visible: true,
+        parentId: 'level_test',
+        children: [],
+        start,
+        end,
+        thickness: 0.1,
+        height: 2.5,
+        frontSide: 'interior',
+        backSide: 'exterior',
+        metadata: {},
+    };
+}
+function maxBoundaryCoord(walls) {
+    const miter = calculateLevelMiters(walls);
+    let max = 0;
+    for (const w of walls) {
+        const bp = getWallMiterBoundaryPoints(w, miter);
+        expect(bp).not.toBeNull();
+        if (!bp)
+            continue;
+        for (const p of [bp.startLeft, bp.startRight, bp.endLeft, bp.endRight]) {
+            expect(Number.isFinite(p.x)).toBe(true);
+            expect(Number.isFinite(p.y)).toBe(true);
+            max = Math.max(max, Math.abs(p.x), Math.abs(p.y));
+        }
+    }
+    return max;
+}
+describe('wall mitering miter limit', () => {
+    // Two 3 m walls sharing the origin, meeting at decreasing angles. Without a
+    // miter limit the joint point runs to infinity as the angle → 0 (∝ 1/sin θ),
+    // which is the "infinite wall" seen when a room-preset preview lands on top of
+    // an existing wall. The boundary must stay bounded near the wall length.
+    test.each([90, 30, 10, 5, 1, 0.1, 0.01])('stays bounded at a %s° junction', (deg) => {
+        const rad = (deg * Math.PI) / 180;
+        const walls = [
+            wall('A', [0, 0], [3, 0]),
+            wall('B', [0, 0], [3 * Math.cos(rad), 3 * Math.sin(rad)]),
+        ];
+        // 3 m walls + a few cm of joint: anything past ~4 m is a runaway spike.
+        expect(maxBoundaryCoord(walls)).toBeLessThan(4);
+    });
+    test('still miters a normal 90° corner', () => {
+        const walls = [wall('A', [0, 0], [3, 0]), wall('B', [0, 0], [0, 3])];
+        const miter = calculateLevelMiters(walls);
+        const bpA = getWallMiterBoundaryPoints(walls[0], miter);
+        expect(bpA).not.toBeNull();
+        if (!bpA)
+            throw new Error('expected miter boundary points');
+        // The shared corner is pulled to the mitred intersection, offset from the
+        // raw butt position (halfThickness 0.05) by the diagonal of the joint.
+        const startSideX = Math.min(bpA.startLeft.x, bpA.startRight.x);
+        expect(startSideX).toBeLessThan(-0.001);
+        expect(startSideX).toBeGreaterThan(-0.5);
+    });
+});

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

@@ -4,6 +4,7 @@ export type SceneGraph = {
     nodes: Record<AnyNodeId, AnyNode>;
     rootNodeIds: AnyNodeId[];
     collections?: Record<CollectionId, Collection>;
+    installedPlugins?: string[];
 };
 /**
  * Deep clones a scene graph with all node IDs regenerated while preserving

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

@@ -1 +1 @@
-{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;CAC/C,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAuGlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA8E/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CAoEZ"}
+{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAmHlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAwF/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CAqEZ"}

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

@@ -1,3 +1,4 @@
+import { remapMeasurementReferences } from '../lib/measurement-geometry';
 import { generateId } from '../schema/base';
 /**
  * Extracts the type prefix from a node ID (e.g., "wall_abc123" -> "wall")
@@ -16,7 +17,7 @@ function extractIdPrefix(id) {
  * - Multi-scene in-memory scenarios
  */
 export function cloneSceneGraph(sceneGraph) {
-    const { nodes, rootNodeIds, collections } = sceneGraph;
+    const { nodes, rootNodeIds, collections, installedPlugins } = sceneGraph;
     // Build ID mapping: old ID -> new ID
     const idMap = new Map();
     // Pass 1: Generate new IDs for all nodes
@@ -57,6 +58,14 @@ export function cloneSceneGraph(sceneGraph) {
             ;
             clonedNode.wallId = idMap.get(clonedNode.wallId);
         }
+        // Remap roofSegmentId (doors/windows/items hosted on roof wall faces)
+        if ('roofSegmentId' in clonedNode && typeof clonedNode.roofSegmentId === 'string') {
+            ;
+            clonedNode.roofSegmentId = idMap.get(clonedNode.roofSegmentId);
+        }
+        if (clonedNode.type === 'measurement') {
+            clonedNode.measurement = remapMeasurementReferences(clonedNode.measurement, idMap);
+        }
         clonedNodes[newId] = clonedNode;
     }
     // Remap root node IDs
@@ -102,6 +111,7 @@ export function cloneSceneGraph(sceneGraph) {
         nodes: clonedNodes,
         rootNodeIds: clonedRootNodeIds,
         ...(clonedCollections && { collections: clonedCollections }),
+        ...(installedPlugins && { installedPlugins: [...installedPlugins] }),
     };
 }
 /**
@@ -119,7 +129,7 @@ export function cloneSceneGraph(sceneGraph) {
  */
 export function cloneLevelSubtree(nodes, levelId) {
     const levelNode = nodes[levelId];
-    if (!levelNode || levelNode.type !== 'level') {
+    if (levelNode?.type !== 'level') {
         throw new Error(`Node "${levelId}" is not a level`);
     }
     // Recursively collect the level node + all descendants via children arrays
@@ -185,6 +195,15 @@ export function cloneLevelSubtree(nodes, levelId) {
             ;
             cloned.wallId = idMap.get(cloned.wallId) ?? cloned.wallId;
         }
+        // Remap roofSegmentId (doors/windows/items hosted on roof wall faces)
+        if ('roofSegmentId' in cloned && typeof cloned.roofSegmentId === 'string') {
+            ;
+            cloned.roofSegmentId =
+                idMap.get(cloned.roofSegmentId) ?? cloned.roofSegmentId;
+        }
+        if (cloned.type === 'measurement') {
+            cloned.measurement = remapMeasurementReferences(cloned.measurement, idMap);
+        }
         clonedNodes.push(cloned);
     }
     return { clonedNodes, newLevelId, idMap };
@@ -197,7 +216,7 @@ export function forkSceneGraph(sceneGraph, options = {}) {
     if (options.preserveScans) {
         return cloneSceneGraph(sceneGraph);
     }
-    const { nodes, rootNodeIds, collections } = sceneGraph;
+    const { nodes, rootNodeIds, collections, installedPlugins } = sceneGraph;
     // First, identify scan and guide node IDs to exclude (user-uploaded imagery)
     const excludedNodeIds = new Set();
     for (const [nodeId, node] of Object.entries(nodes)) {
@@ -249,5 +268,6 @@ export function forkSceneGraph(sceneGraph, options = {}) {
         nodes: filteredNodes,
         rootNodeIds: filteredRootNodeIds,
         ...(filteredCollections && { collections: filteredCollections }),
+        ...(installedPlugins && { installedPlugins }),
     });
 }

package/dist/utils/clone-scene-graph.test.js

@@ -36,6 +36,7 @@ function makeSceneGraph() {
                 nodeIds: ['scan_1', 'guide_1'],
             },
         },
+        installedPlugins: ['pascal:trees'],
     };
 }
 describe('forkSceneGraph', () => {
@@ -46,6 +47,7 @@ describe('forkSceneGraph', () => {
         expect(nodes.some((node) => node.type === 'guide')).toBe(false);
         expect(nodes.some((node) => node.type === 'wall')).toBe(true);
         expect(forked.collections).toEqual({});
+        expect(forked.installedPlugins).toEqual(['pascal:trees']);
     });
     test('preserves scan and guide nodes when requested', () => {
         const forked = forkSceneGraph(makeSceneGraph(), { preserveScans: true });
@@ -55,5 +57,6 @@ describe('forkSceneGraph', () => {
         expect(nodes.map((node) => node.id)).not.toContain('scan_1');
         expect(nodes.map((node) => node.id)).not.toContain('guide_1');
         expect(Object.values(forked.collections ?? {}).flatMap((collection) => collection.nodeIds)).toHaveLength(2);
+        expect(forked.installedPlugins).toEqual(['pascal:trees']);
     });
 });

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

@@ -0,0 +1,18 @@
+export interface HealSceneResult {
+    nodes: Record<string, unknown>;
+    /** Ids of zero-length walls that were dropped. */
+    droppedWallIds: string[];
+    /** Count of non-string (e.g. null) entries removed from `children` arrays. */
+    strippedChildRefs: number;
+    /**
+     * Count of child references removed because the child's `parentId` points at
+     * a different node (stale reparent leftovers), plus same-array duplicates.
+     */
+    strippedStaleChildRefs: number;
+}
+/**
+ * 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;
+//# sourceMappingURL=heal-scene-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heal-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/heal-scene-graph.ts"],"names":[],"mappings":"AAqBA,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,kDAAkD;IAClD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,8EAA8E;IAC9E,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,CA0D9E"}

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

@@ -0,0 +1,90 @@
+// Repairs scene-graph corruption that pre-dates the source fixes, so existing
+// saved scenes still load. Known kinds of damage:
+//
+//  1. A `children` array containing a non-string entry. The capture wall-merge
+//     re-attached a wall-hosted item without minting an id, so `undefined` was
+//     pushed into the wall's children — which serializes to `[null]`. The wall
+//     schema rejects `null` children, so the whole scene fails to load.
+//  2. A zero-length wall (start === end). It renders nothing, but lingers as a
+//     junk node and is a foot-gun for snapping/mitering.
+//  3. A child referenced by a parent it no longer belongs to: the child's
+//     `parentId` points at node B while node A's `children` still lists it
+//     (stale leftover from a reparent that didn't clean the old parent). The
+//     duplicate reference renders the child twice (duplicate React keys in the
+//     2D plan, doubled hosted geometry in 3D). Same-array duplicates are
+//     collapsed too.
+//
+// All are also prevented at the source now; this is the load-time safety net
+// for already-saved scenes.
+const ZERO_LENGTH_EPS = 1e-6;
+function isWallLike(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    const n = node;
+    return (n.type === 'wall' &&
+        Array.isArray(n.start) &&
+        Array.isArray(n.end) &&
+        typeof n.start[0] === 'number' &&
+        typeof n.start[1] === 'number' &&
+        typeof n.end[0] === 'number' &&
+        typeof n.end[1] === 'number');
+}
+/**
+ * Returns a healed copy of a `nodes` map. Pure — does not mutate `input`.
+ * Nodes that need no repair are passed through by reference.
+ */
+export function healSceneNodes(input) {
+    const droppedWallIds = [];
+    // 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)) {
+        if (isWallLike(node)) {
+            const children = node.children;
+            const childless = !Array.isArray(children) || children.length === 0;
+            const dx = node.end[0] - node.start[0];
+            const dz = node.end[1] - node.start[1];
+            if (childless && Math.hypot(dx, dz) <= ZERO_LENGTH_EPS) {
+                droppedWallIds.push(id);
+                continue;
+            }
+        }
+        kept[id] = node;
+    }
+    const dropped = new Set(droppedWallIds);
+    let strippedChildRefs = 0;
+    let strippedStaleChildRefs = 0;
+    // Pass 2: clean `children` arrays — drop non-string entries (the `[null]`
+    // bug), references to walls we just removed, same-array duplicates, and
+    // stale references whose child's `parentId` names a different parent.
+    const nodes = {};
+    for (const [id, node] of Object.entries(kept)) {
+        const children = node?.children;
+        if (Array.isArray(children)) {
+            const seen = new Set();
+            const cleaned = children.filter((c) => {
+                if (typeof c !== 'string' || dropped.has(c)) {
+                    strippedChildRefs++;
+                    return false;
+                }
+                if (seen.has(c)) {
+                    strippedStaleChildRefs++;
+                    return false;
+                }
+                seen.add(c);
+                const child = kept[c];
+                if (child && typeof child.parentId === 'string' && child.parentId !== id) {
+                    strippedStaleChildRefs++;
+                    return false;
+                }
+                return true;
+            });
+            if (cleaned.length !== children.length) {
+                nodes[id] = { ...node, children: cleaned };
+                continue;
+            }
+        }
+        nodes[id] = node;
+    }
+    return { nodes, droppedWallIds, strippedChildRefs, strippedStaleChildRefs };
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=heal-scene-graph.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heal-scene-graph.test.d.ts","sourceRoot":"","sources":["../../src/utils/heal-scene-graph.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'bun:test';
+import { healSceneNodes } from './heal-scene-graph';
+describe('healSceneNodes', () => {
+    test('strips non-string (null) children entries', () => {
+        const { nodes, strippedChildRefs } = healSceneNodes({
+            wall_a: {
+                id: 'wall_a',
+                type: 'wall',
+                start: [0, 0],
+                end: [1, 0],
+                children: [null, 'item_x'],
+            },
+            item_x: { id: 'item_x', type: 'item' },
+        });
+        expect(strippedChildRefs).toBe(1);
+        expect(nodes.wall_a.children).toEqual(['item_x']);
+    });
+    test('drops childless zero-length walls and removes their parent reference', () => {
+        const { nodes, droppedWallIds } = healSceneNodes({
+            level_0: { id: 'level_0', type: 'level', children: ['wall_zero', 'wall_real'] },
+            wall_zero: { id: 'wall_zero', type: 'wall', start: [5, 5], end: [5, 5], children: [] },
+            wall_real: { id: 'wall_real', type: 'wall', start: [0, 0], end: [3, 0], children: [] },
+        });
+        expect(droppedWallIds).toEqual(['wall_zero']);
+        expect('wall_zero' in nodes).toBe(false);
+        expect(nodes.level_0.children).toEqual(['wall_real']);
+    });
+    test('keeps a zero-length wall that still hosts a door/window', () => {
+        const { nodes, droppedWallIds } = healSceneNodes({
+            wall_z: { id: 'wall_z', type: 'wall', start: [1, 1], end: [1, 1], children: ['door_1'] },
+            door_1: { id: 'door_1', type: 'door' },
+        });
+        expect(droppedWallIds).toEqual([]);
+        expect('wall_z' in nodes).toBe(true);
+    });
+    test('passes a clean scene through untouched', () => {
+        const input = {
+            wall_a: { id: 'wall_a', type: 'wall', start: [0, 0], end: [2, 0], children: ['door_1'] },
+            door_1: { id: 'door_1', type: 'door' },
+        };
+        const { nodes, droppedWallIds, strippedChildRefs } = healSceneNodes(input);
+        expect(droppedWallIds).toEqual([]);
+        expect(strippedChildRefs).toBe(0);
+        expect(nodes.wall_a).toBe(input.wall_a);
+    });
+    test('drops a stale child reference left behind by a reparent', () => {
+        // window's parentId says wall_b, but wall_a still lists it — the exact
+        // corruption that rendered a window twice (duplicate React keys in 2D).
+        const { nodes, strippedStaleChildRefs } = healSceneNodes({
+            wall_a: { id: 'wall_a', type: 'wall', start: [0, 0], end: [2, 0], children: ['window_1'] },
+            wall_b: { id: 'wall_b', type: 'wall', start: [2, 0], end: [4, 0], children: ['window_1'] },
+            window_1: { id: 'window_1', type: 'window', parentId: 'wall_b' },
+        });
+        expect(strippedStaleChildRefs).toBe(1);
+        expect(nodes.wall_a.children).toEqual([]);
+        expect(nodes.wall_b.children).toEqual(['window_1']);
+    });
+    test('collapses same-array duplicate child references', () => {
+        const { nodes, strippedStaleChildRefs } = healSceneNodes({
+            wall_a: {
+                id: 'wall_a',
+                type: 'wall',
+                start: [0, 0],
+                end: [2, 0],
+                children: ['door_1', 'door_1'],
+            },
+            door_1: { id: 'door_1', type: 'door', parentId: 'wall_a' },
+        });
+        expect(strippedStaleChildRefs).toBe(1);
+        expect(nodes.wall_a.children).toEqual(['door_1']);
+    });
+    test('keeps children whose parentId matches or is absent', () => {
+        const input = {
+            wall_a: {
+                id: 'wall_a',
+                type: 'wall',
+                start: [0, 0],
+                end: [2, 0],
+                children: ['door_1', 'item_legacy'],
+            },
+            door_1: { id: 'door_1', type: 'door', parentId: 'wall_a' },
+            item_legacy: { id: 'item_legacy', type: 'item' },
+        };
+        const { nodes, strippedStaleChildRefs } = healSceneNodes(input);
+        expect(strippedStaleChildRefs).toBe(0);
+        expect(nodes.wall_a).toBe(input.wall_a);
+    });
+});

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

@@ -15,6 +15,7 @@ export type BuildStats = {
 export type ParsedBuildJson = {
     nodes: Record<string, unknown>;
     rootNodeIds: string[];
+    installedPlugins?: 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":"AAAA,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE3D,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,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;CACtB,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;AA8BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAuNzE"}
+{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAG3D,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,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;CAC5B,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;AA8BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAwPzE"}

package/dist/validation/validate-build-json.js

@@ -1,4 +1,5 @@
 import { AnyNode } from '../schema/types';
+import { healSceneNodes } from '../utils/heal-scene-graph';
 const KNOWN_TYPES = new Set(AnyNode.options.map((o) => o.shape.type.parse(undefined)));
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -52,6 +53,7 @@ export function validateBuildJson(input) {
     }
     const nodesRaw = input.nodes;
     const rootNodeIdsRaw = input.rootNodeIds;
+    const installedPluginsRaw = input.installedPlugins;
     if (!isPlainObject(nodesRaw)) {
         errors.push({
             severity: 'error',
@@ -77,8 +79,29 @@ export function validateBuildJson(input) {
             schemaIssueCount: 0,
         };
     }
-    const nodes = nodesRaw;
+    // Heal known pre-existing corruption (null children, zero-length walls) up
+    // front, so a scene saved before the source fixes still imports instead of
+    // hard-failing schema validation. `parsed` below carries the repaired nodes.
+    const { nodes, droppedWallIds, strippedChildRefs } = healSceneNodes(nodesRaw);
     const rootNodeIds = rootNodeIdsRaw;
+    const installedPlugins = Array.isArray(installedPluginsRaw) &&
+        installedPluginsRaw.every((pluginId) => typeof pluginId === 'string')
+        ? Array.from(new Set(installedPluginsRaw))
+        : undefined;
+    if (installedPluginsRaw !== undefined && installedPlugins === undefined) {
+        warnings.push({
+            severity: 'warning',
+            code: 'invalid_installed_plugins',
+            message: 'Ignored invalid "installedPlugins" — expected an array of plugin IDs.',
+        });
+    }
+    if (strippedChildRefs > 0 || droppedWallIds.length > 0) {
+        warnings.push({
+            severity: 'warning',
+            code: 'auto_repaired',
+            message: `Repaired on import: removed ${strippedChildRefs} invalid child reference${strippedChildRefs === 1 ? '' : 's'} and ${droppedWallIds.length} zero-length wall${droppedWallIds.length === 1 ? '' : 's'}.`,
+        });
+    }
     if (rootNodeIds.length === 0) {
         errors.push({
             severity: 'error',
@@ -217,7 +240,13 @@ export function validateBuildJson(input) {
     const ok = errors.length === 0;
     return {
         ok,
-        parsed: ok ? { nodes, rootNodeIds } : null,
+        parsed: ok
+            ? {
+                nodes,
+                rootNodeIds,
+                ...(installedPlugins ? { installedPlugins } : {}),
+            }
+            : null,
         stats,
         errors,
         warnings,