@pascal-app/core 0.8.0 → 0.9.2

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/systems/wall/wall-move.d.ts

@@ -0,0 +1,48 @@
+import type { WallNode } from '../../schema';
+export type WallPlanPoint = [number, number];
+export type WallMoveAxis = [number, number];
+export type WallMoveEndpoint = 'start' | 'end';
+export type WallMoveBridgePlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+    wall: TWall;
+    originalPoint: WallPlanPoint;
+    movedEndpoint: WallMoveEndpoint;
+};
+export type WallMoveLinkedWallTargetPlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+    wall: TWall;
+    originalPoint: WallPlanPoint;
+    targetPoint: WallPlanPoint;
+};
+export type WallMoveJunctionPlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+    linkedWallsToMove: TWall[];
+    linkedWallTargetPlans: Array<WallMoveLinkedWallTargetPlan<TWall>>;
+    bridgePlans: Array<WallMoveBridgePlan<TWall>>;
+    wallsToDelete: TWall[];
+};
+export declare function getPerpendicularWallMoveAxis(start: WallPlanPoint, end: WallPlanPoint): WallMoveAxis | null;
+export declare function constrainWallMoveDeltaToAxis(deltaX: number, deltaZ: number, axis: WallMoveAxis | null): WallPlanPoint;
+/**
+ * Apply a junction plan to a list of linked walls, producing the per-wall
+ * endpoint updates. Mirrors the 3D `MoveWallTool`'s drag-preview behavior
+ * so the 2D move handler can drive the same scene topology.
+ *
+ * `linkedWallTargetPlans` take precedence over `linkedWallsToMove` — when
+ * the planner emits a target plan for a same-direction-consumed wall the
+ * matchPoint/targetPoint pair encodes the pivot, not the original ↔ next
+ * endpoint mapping.
+ */
+export declare function getLinkedWallUpdates<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(linkedWalls: Array<{
+    wall: TWall;
+    matchPoint?: WallPlanPoint;
+    targetPoint?: WallPlanPoint;
+}>, originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): Array<{
+    id: TWall['id'];
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+}>;
+export declare function getPlannedLinkedWallUpdates<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(plan: WallMoveJunctionPlan<TWall>, originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): Array<{
+    id: TWall['id'];
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+}>;
+export declare function planWallMoveJunctions<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(linkedWalls: TWall[], originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): WallMoveJunctionPlan<TWall>;
+//# sourceMappingURL=wall-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-move.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-move.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,193 @@
+const AXIS_EPSILON = 1e-6;
+export function getPerpendicularWallMoveAxis(start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < AXIS_EPSILON)
+        return null;
+    // Perpendicular (normal) direction for moving the wall "sideways".
+    // This matches the arrow handles shown in the editor.
+    return [-dz / length, dx / length];
+}
+export function constrainWallMoveDeltaToAxis(deltaX, deltaZ, axis) {
+    if (axis) {
+        const projected = deltaX * axis[0] + deltaZ * axis[1];
+        return [axis[0] * projected, axis[1] * projected];
+    }
+    return [deltaX, deltaZ];
+}
+function pointsEqual(a, b) {
+    return Math.abs(a[0] - b[0]) <= AXIS_EPSILON && Math.abs(a[1] - b[1]) <= AXIS_EPSILON;
+}
+function wallTouchesPoint(wall, point) {
+    return pointsEqual(wall.start, point) || pointsEqual(wall.end, point);
+}
+function otherWallEndpoint(wall, point) {
+    return pointsEqual(wall.start, point) ? wall.end : wall.start;
+}
+function wallLengthFromPoint(wall, point) {
+    const freeEndpoint = otherWallEndpoint(wall, point);
+    return Math.hypot(freeEndpoint[0] - point[0], freeEndpoint[1] - point[1]);
+}
+function getMoveWallRelation(wall, sharedPoint, nextPoint) {
+    const moveX = nextPoint[0] - sharedPoint[0];
+    const moveZ = nextPoint[1] - sharedPoint[1];
+    const moveLength = Math.hypot(moveX, moveZ);
+    if (moveLength < AXIS_EPSILON)
+        return 'stationary';
+    const freeEndpoint = otherWallEndpoint(wall, sharedPoint);
+    const wallX = freeEndpoint[0] - sharedPoint[0];
+    const wallZ = freeEndpoint[1] - sharedPoint[1];
+    const wallLength = Math.hypot(wallX, wallZ);
+    if (wallLength < AXIS_EPSILON)
+        return 'stationary';
+    const normalizedCross = Math.abs(moveX * wallZ - moveZ * wallX) / (moveLength * wallLength);
+    if (normalizedCross > 1e-4)
+        return 'off-axis';
+    const normalizedDot = (moveX * wallX + moveZ * wallZ) / (moveLength * wallLength);
+    return normalizedDot >= 0 ? 'same-direction' : 'opposite-direction';
+}
+/**
+ * Apply a junction plan to a list of linked walls, producing the per-wall
+ * endpoint updates. Mirrors the 3D `MoveWallTool`'s drag-preview behavior
+ * so the 2D move handler can drive the same scene topology.
+ *
+ * `linkedWallTargetPlans` take precedence over `linkedWallsToMove` — when
+ * the planner emits a target plan for a same-direction-consumed wall the
+ * matchPoint/targetPoint pair encodes the pivot, not the original ↔ next
+ * endpoint mapping.
+ */
+export function getLinkedWallUpdates(linkedWalls, originalStart, originalEnd, nextStart, nextEnd) {
+    return linkedWalls.map(({ wall, matchPoint, targetPoint }) => {
+        if (matchPoint && targetPoint) {
+            return {
+                id: wall.id,
+                start: pointsEqual(wall.start, matchPoint) ? targetPoint : wall.start,
+                end: pointsEqual(wall.end, matchPoint) ? targetPoint : wall.end,
+            };
+        }
+        const targetStart = targetPoint ?? nextStart;
+        const targetEnd = targetPoint ?? nextEnd;
+        return {
+            id: wall.id,
+            start: pointsEqual(wall.start, originalStart)
+                ? targetStart
+                : pointsEqual(wall.start, originalEnd)
+                    ? targetEnd
+                    : wall.start,
+            end: pointsEqual(wall.end, originalStart)
+                ? targetStart
+                : pointsEqual(wall.end, originalEnd)
+                    ? targetEnd
+                    : wall.end,
+        };
+    });
+}
+export function getPlannedLinkedWallUpdates(plan, originalStart, originalEnd, nextStart, nextEnd) {
+    const movePlans = new Map();
+    for (const wall of plan.linkedWallsToMove) {
+        movePlans.set(wall.id, { wall });
+    }
+    for (const targetPlan of plan.linkedWallTargetPlans) {
+        movePlans.set(targetPlan.wall.id, {
+            wall: targetPlan.wall,
+            matchPoint: targetPlan.originalPoint,
+            targetPoint: targetPlan.targetPoint,
+        });
+    }
+    return getLinkedWallUpdates(Array.from(movePlans.values()), originalStart, originalEnd, nextStart, nextEnd);
+}
+export function planWallMoveJunctions(linkedWalls, originalStart, originalEnd, nextStart, nextEnd) {
+    const linkedWallsToMove = new Map();
+    const linkedWallTargetPlans = new Map();
+    const bridgePlans = new Map();
+    const wallsToDelete = new Map();
+    const addStandardEndpointPlan = (endpoint, point, nextPoint, relatedWalls, keySuffix = '', useTargetPlans = false) => {
+        const hasSideBranch = relatedWalls.some((entry) => entry.relation === 'off-axis');
+        const hasOppositeBridge = relatedWalls.some((entry) => entry.relation === 'opposite-direction' && hasSideBranch);
+        for (const { wall, relation } of relatedWalls) {
+            if (relation === 'stationary' ||
+                relation === 'same-direction' ||
+                (relation === 'opposite-direction' && !hasSideBranch)) {
+                if (useTargetPlans) {
+                    linkedWallTargetPlans.set(wall.id, {
+                        wall,
+                        originalPoint: point,
+                        targetPoint: nextPoint,
+                    });
+                }
+                else {
+                    linkedWallsToMove.set(wall.id, wall);
+                }
+                continue;
+            }
+            if (relation === 'off-axis' && hasOppositeBridge) {
+                continue;
+            }
+            bridgePlans.set(`${wall.id}:${endpoint}${keySuffix}`, {
+                wall,
+                originalPoint: point,
+                movedEndpoint: endpoint,
+            });
+        }
+    };
+    const addEndpointPlan = (endpoint, point, nextPoint) => {
+        const moveLength = Math.hypot(nextPoint[0] - point[0], nextPoint[1] - point[1]);
+        const linkedAtEndpoint = linkedWalls
+            .filter((wall) => wallTouchesPoint(wall, point))
+            .map((wall) => ({
+            wall,
+            relation: getMoveWallRelation(wall, point, nextPoint),
+        }));
+        const consumedSameDirectionWall = linkedAtEndpoint
+            .filter((entry) => entry.relation === 'same-direction')
+            .map((entry) => ({
+            ...entry,
+            distance: wallLengthFromPoint(entry.wall, point),
+        }))
+            .filter((entry) => moveLength + AXIS_EPSILON >= entry.distance)
+            .sort((a, b) => a.distance - b.distance)[0];
+        if (consumedSameDirectionWall) {
+            const pivotPoint = [
+                ...otherWallEndpoint(consumedSameDirectionWall.wall, point),
+            ];
+            const bridgeSource = linkedAtEndpoint.find((entry) => entry.relation === 'opposite-direction');
+            wallsToDelete.set(consumedSameDirectionWall.wall.id, consumedSameDirectionWall.wall);
+            linkedWallTargetPlans.set(consumedSameDirectionWall.wall.id, {
+                wall: consumedSameDirectionWall.wall,
+                originalPoint: point,
+                targetPoint: pivotPoint,
+            });
+            if (bridgeSource) {
+                linkedWallTargetPlans.set(bridgeSource.wall.id, {
+                    wall: bridgeSource.wall,
+                    originalPoint: point,
+                    targetPoint: pivotPoint,
+                });
+                bridgePlans.set(`${bridgeSource.wall.id}:${endpoint}:through`, {
+                    wall: bridgeSource.wall,
+                    originalPoint: pivotPoint,
+                    movedEndpoint: endpoint,
+                });
+                return;
+            }
+            const linkedAtPivot = linkedWalls
+                .filter((wall) => wall.id !== consumedSameDirectionWall.wall.id && wallTouchesPoint(wall, pivotPoint))
+                .map((wall) => ({
+                wall,
+                relation: getMoveWallRelation(wall, pivotPoint, nextPoint),
+            }));
+            addStandardEndpointPlan(endpoint, pivotPoint, nextPoint, linkedAtPivot, ':through-pivot', true);
+            return;
+        }
+        addStandardEndpointPlan(endpoint, point, nextPoint, linkedAtEndpoint);
+    };
+    addEndpointPlan('start', originalStart, nextStart);
+    addEndpointPlan('end', originalEnd, nextEnd);
+    return {
+        linkedWallsToMove: Array.from(linkedWallsToMove.values()),
+        linkedWallTargetPlans: Array.from(linkedWallTargetPlans.values()),
+        bridgePlans: Array.from(bridgePlans.values()),
+        wallsToDelete: Array.from(wallsToDelete.values()),
+    };
+}

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
@@ -33,10 +34,12 @@ export declare function cloneLevelSubtree(nodes: Record<AnyNodeId, AnyNode>, lev
     newLevelId: AnyNodeId;
     idMap: Map<string, string>;
 };
+export type ForkSceneGraphOptions = {
+    preserveScans?: boolean;
+};
 /**
- * Forks a scene graph for use as a new project: clones with new IDs and strips
- * scan and guide nodes (and their references) since those contain user-uploaded
- * imagery that shouldn't carry over to a forked project.
+ * Forks a scene graph for use as a new project: clones with new IDs and, by
+ * default, strips scan and guide nodes since they contain user-uploaded imagery.
  */
-export declare function forkSceneGraph(sceneGraph: SceneGraph): SceneGraph;
+export declare function forkSceneGraph(sceneGraph: SceneGraph, options?: ForkSceneGraphOptions): SceneGraph;
 //# sourceMappingURL=clone-scene-graph.d.ts.map

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;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAgEjE"}
+{"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,17 +195,28 @@ 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 };
 }
 /**
- * Forks a scene graph for use as a new project: clones with new IDs and strips
- * scan and guide nodes (and their references) since those contain user-uploaded
- * imagery that shouldn't carry over to a forked project.
+ * Forks a scene graph for use as a new project: clones with new IDs and, by
+ * default, strips scan and guide nodes since they contain user-uploaded imagery.
  */
-export function forkSceneGraph(sceneGraph) {
-    const { nodes, rootNodeIds, collections } = sceneGraph;
+export function forkSceneGraph(sceneGraph, options = {}) {
+    if (options.preserveScans) {
+        return cloneSceneGraph(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)) {
@@ -247,5 +268,6 @@ export function forkSceneGraph(sceneGraph) {
         nodes: filteredNodes,
         rootNodeIds: filteredRootNodeIds,
         ...(filteredCollections && { collections: filteredCollections }),
+        ...(installedPlugins && { installedPlugins }),
     });
 }

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

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

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

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

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

@@ -0,0 +1,62 @@
+import { describe, expect, test } from 'bun:test';
+import { forkSceneGraph } from './clone-scene-graph';
+function makeNode(id, type, extra = {}) {
+    return {
+        object: 'node',
+        id,
+        type,
+        parentId: null,
+        visible: true,
+        metadata: {},
+        ...extra,
+    };
+}
+function makeSceneGraph() {
+    const site = makeNode('site_1', 'site', { children: ['level_1'] });
+    const level = makeNode('level_1', 'level', {
+        parentId: 'site_1',
+        children: ['wall_1', 'scan_1', 'guide_1'],
+    });
+    const wall = makeNode('wall_1', 'wall', { parentId: 'level_1' });
+    const scan = makeNode('scan_1', 'scan', { parentId: 'level_1', url: 'scan.glb' });
+    const guide = makeNode('guide_1', 'guide', { parentId: 'level_1', url: 'guide.png' });
+    return {
+        nodes: {
+            ['site_1']: site,
+            ['level_1']: level,
+            ['wall_1']: wall,
+            ['scan_1']: scan,
+            ['guide_1']: guide,
+        },
+        rootNodeIds: ['site_1'],
+        collections: {
+            ['collection_1']: {
+                id: 'collection_1',
+                name: 'References',
+                nodeIds: ['scan_1', 'guide_1'],
+            },
+        },
+        installedPlugins: ['pascal:trees'],
+    };
+}
+describe('forkSceneGraph', () => {
+    test('strips scan and guide nodes by default', () => {
+        const forked = forkSceneGraph(makeSceneGraph());
+        const nodes = Object.values(forked.nodes);
+        expect(nodes.some((node) => node.type === 'scan')).toBe(false);
+        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 });
+        const nodes = Object.values(forked.nodes);
+        expect(nodes.some((node) => node.type === 'scan')).toBe(true);
+        expect(nodes.some((node) => node.type === 'guide')).toBe(true);
+        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":""}