@pascal-app/core 0.9.2 → 1.0.0-beta.2

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

@@ -1,485 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { BuildingNode, CeilingNode, LevelNode, SlabNode, StairNode, StairSegmentNode, } from '../../schema';
-import { syncAutoStairOpenings } from './stair-opening-sync';
-describe('syncAutoStairOpenings', () => {
-    test('only applies stair holes to destination slabs that overlap the opening', () => {
-        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: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-        });
-        const bedroomSlab = SlabNode.parse({
-            name: 'Bedroom Slab',
-            parentId: upper.id,
-            polygon: [
-                [4, 0],
-                [8, 0],
-                [8, 3],
-                [4, 3],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_main',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_main',
-            name: 'Main Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([
-            building,
-            ground,
-            upper,
-            landingSlab,
-            bedroomSlab,
-            stair,
-            { ...segment, parentId: stair.id },
-        ].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        const bedroomUpdate = updates.find((update) => update.id === bedroomSlab.id);
-        expect(landingUpdate?.data.holes).toHaveLength(1);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-        expect(bedroomUpdate).toBeUndefined();
-    });
-    test('applies stair holes to a later destination slab when the configured offset overhangs the slab edge', () => {
-        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: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_edge',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_edge',
-            name: 'Edge Stair',
-            parentId: ground.id,
-            position: [2, 0, 0],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            openingOffset: 0.08,
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        const hole = landingUpdate?.data.holes?.[0];
-        expect(hole).toBeDefined();
-        expect(Math.min(...hole.map(([, z]) => z))).toBeCloseTo(-0.08);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-    });
-    test('does not apply stair holes to slabs on another building with a matching level number', () => {
-        const buildingA = BuildingNode.parse({ name: 'Building A' });
-        const groundA = LevelNode.parse({ name: 'Ground A', level: 0, parentId: buildingA.id });
-        const upperA = LevelNode.parse({ name: 'Upper A', level: 1, parentId: buildingA.id });
-        const buildingB = BuildingNode.parse({ name: 'Building B' });
-        const upperB = LevelNode.parse({ name: 'Upper B', level: 1, parentId: buildingB.id });
-        const slabA = SlabNode.parse({
-            name: 'Upper A Slab',
-            parentId: upperA.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-        });
-        const slabB = SlabNode.parse({
-            name: 'Upper B Slab',
-            parentId: upperB.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_scoped',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_scoped',
-            name: 'Scoped Stair',
-            parentId: groundA.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: groundA.id,
-            toLevelId: upperA.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([
-            buildingA,
-            groundA,
-            upperA,
-            buildingB,
-            upperB,
-            slabA,
-            slabB,
-            stair,
-            { ...segment, parentId: stair.id },
-        ].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        expect(updates.find((update) => update.id === slabA.id)?.data.holes).toHaveLength(1);
-        expect(updates.find((update) => update.id === slabB.id)).toBeUndefined();
-    });
-    test('uses the parent level when a stair has stale from-level data', () => {
-        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: [
-                [0, 0],
-                [4, 0],
-                [4, 8],
-                [0, 8],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_stale_from',
-            width: 1,
-            length: 6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_stale_from',
-            name: 'Stale From Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: 'default',
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        const hole = landingUpdate?.data.holes?.[0];
-        expect(hole).toBeDefined();
-        expect(Math.min(...hole.map(([, z]) => z))).toBeGreaterThan(0.9);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-    });
-    test('infers the destination level when a destination stair has blank level fields', () => {
-        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: [
-                [0, 0],
-                [4, 0],
-                [4, 8],
-                [0, 8],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_blank_levels',
-            width: 1,
-            length: 6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_blank_levels',
-            name: 'Blank Level Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: '',
-            toLevelId: '',
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        expect(landingUpdate?.data.holes).toHaveLength(1);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-    });
-    test('infers the destination level when a destination stair targets its source level', () => {
-        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: [
-                [0, 0],
-                [4, 0],
-                [4, 8],
-                [0, 8],
-            ],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_self_target',
-            width: 1,
-            length: 6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_self_target',
-            name: 'Self Target Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: ground.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        expect(landingUpdate?.data.holes).toHaveLength(1);
-        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
-    });
-    test('does not add stair holes when a manual surface hole already covers them', () => {
-        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 manualOpening = [
-            [1.0, 0.0],
-            [3.0, 0.0],
-            [3.0, 3.0],
-            [1.0, 3.0],
-        ];
-        const sourceCeiling = CeilingNode.parse({
-            name: 'Source Ceiling',
-            parentId: ground.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [manualOpening],
-            holeMetadata: [{ source: 'manual' }],
-        });
-        const landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [manualOpening],
-            holeMetadata: [{ source: 'manual' }],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_main',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_main',
-            name: 'Main Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([
-            building,
-            ground,
-            upper,
-            sourceCeiling,
-            landingSlab,
-            stair,
-            { ...segment, parentId: stair.id },
-        ].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        expect(updates.find((update) => update.id === landingSlab.id)).toBeUndefined();
-        expect(updates.find((update) => update.id === sourceCeiling.id)).toBeUndefined();
-    });
-    test('adds stair holes when an existing manual hole is too small', () => {
-        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 smallManualOpening = [
-            [1.8, 1.6],
-            [2.2, 1.6],
-            [2.2, 2.1],
-            [1.8, 2.1],
-        ];
-        const landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [smallManualOpening],
-            holeMetadata: [{ source: 'manual' }],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_main',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_main',
-            name: 'Main Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        expect(landingUpdate?.data.holes).toHaveLength(2);
-        expect(landingUpdate?.data.holes?.[0]).toEqual(smallManualOpening);
-        expect(landingUpdate?.data.holeMetadata).toEqual([
-            { source: 'manual' },
-            { source: 'stair', stairId: stair.id },
-        ]);
-    });
-    test('removes stale auto stair holes when a manual hole overlaps the stair opening', () => {
-        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 manualOpening = [
-            [1.0, 0.0],
-            [3.0, 0.0],
-            [3.0, 3.0],
-            [1.0, 3.0],
-        ];
-        const staleAutoOpening = [
-            [1.5, 1],
-            [2.5, 1],
-            [2.5, 2.8],
-            [1.5, 2.8],
-        ];
-        const landingSlab = SlabNode.parse({
-            name: 'Landing Slab',
-            parentId: upper.id,
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            holes: [manualOpening, staleAutoOpening],
-            holeMetadata: [{ source: 'manual' }, { source: 'stair', stairId: 'stair_main' }],
-        });
-        const segment = StairSegmentNode.parse({
-            parentId: 'stair_main',
-            width: 1,
-            length: 2.6,
-            height: 2.5,
-            stepCount: 12,
-        });
-        const stair = StairNode.parse({
-            id: 'stair_main',
-            name: 'Main Stair',
-            parentId: ground.id,
-            position: [2, 0, 0.2],
-            stairType: 'straight',
-            fromLevelId: ground.id,
-            toLevelId: upper.id,
-            slabOpeningMode: 'destination',
-            children: [segment.id],
-        });
-        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
-        const updates = syncAutoStairOpenings(nodes);
-        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
-        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.test.d.ts

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

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

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

@@ -1,63 +0,0 @@
-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.test.d.ts

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

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

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

@@ -1,62 +0,0 @@
-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.test.d.ts

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

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

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