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

package/dist/store/use-scene-dirty-tracking.test.js

@@ -1,68 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { nodeRegistry } from '../registry/registry';
-import useScene from './use-scene';
-const untrackedDef = {
-    kind: 'test-untracked',
-    schemaVersion: 1,
-    schema: {},
-    category: 'furnishing',
-    defaults: () => ({}),
-    capabilities: {},
-    dirtyTracking: false,
-};
-const trackedDef = {
-    ...untrackedDef,
-    kind: 'test-tracked',
-    dirtyTracking: undefined,
-};
-const UNTRACKED = 'item_untracked';
-const TRACKED = 'item_tracked';
-const UNREGISTERED = 'item_unregistered';
-const makeNode = (id, type) => ({
-    object: 'node',
-    id,
-    type,
-    parentId: null,
-    visible: true,
-    metadata: {},
-    children: [],
-});
-describe('dirty tracking', () => {
-    beforeEach(() => {
-        if (!nodeRegistry.has(untrackedDef.kind))
-            nodeRegistry._register(untrackedDef);
-        if (!nodeRegistry.has(trackedDef.kind))
-            nodeRegistry._register(trackedDef);
-        useScene.setState({
-            nodes: {
-                [UNTRACKED]: makeNode(UNTRACKED, 'test-untracked'),
-                [TRACKED]: makeNode(TRACKED, 'test-tracked'),
-                [UNREGISTERED]: makeNode(UNREGISTERED, 'unregistered-kind'),
-            },
-            rootNodeIds: [UNTRACKED, TRACKED, UNREGISTERED],
-            dirtyNodes: new Set(),
-            collections: {},
-        });
-        useScene.temporal.getState().clear();
-    });
-    // Membership asserts (not set size/equality): the scene store is a module
-    // singleton, and subscribers leaked by other test files can add their own
-    // dirty marks when `setState` fires.
-    test('markDirty skips kinds whose definition opts out', () => {
-        useScene.getState().markDirty(UNTRACKED);
-        expect(useScene.getState().dirtyNodes.has(UNTRACKED)).toBe(false);
-    });
-    test('markDirty tracks kinds without the opt-out, registered or not', () => {
-        useScene.getState().markDirty(TRACKED);
-        useScene.getState().markDirty(UNREGISTERED);
-        expect(useScene.getState().dirtyNodes.has(TRACKED)).toBe(true);
-        expect(useScene.getState().dirtyNodes.has(UNREGISTERED)).toBe(true);
-    });
-    test('deleteNodes removes deleted ids from the dirty set', () => {
-        useScene.getState().markDirty(TRACKED);
-        expect(useScene.getState().dirtyNodes.has(TRACKED)).toBe(true);
-        useScene.getState().deleteNodes([TRACKED]);
-        expect(useScene.getState().nodes[TRACKED]).toBeUndefined();
-        expect(useScene.getState().dirtyNodes.has(TRACKED)).toBe(false);
-    });
-});

package/dist/store/use-scene-elevator-migration.test.d.ts

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

package/dist/store/use-scene-elevator-migration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-scene-elevator-migration.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-elevator-migration.test.ts"],"names":[],"mappings":""}

package/dist/store/use-scene-elevator-migration.test.js

@@ -1,109 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import useScene from './use-scene';
-describe('scene elevator migrations', () => {
-    beforeEach(() => {
-        useScene.setState({
-            nodes: {},
-            rootNodeIds: [],
-            dirtyNodes: new Set(),
-            collections: {},
-        });
-        useScene.temporal.getState().clear();
-    });
-    test('normalizes legacy level-parented elevators into building-scoped nodes', () => {
-        useScene.getState().setScene({
-            site_test: {
-                object: 'node',
-                id: 'site_test',
-                type: 'site',
-                parentId: null,
-                visible: true,
-                metadata: {},
-                children: ['building_test'],
-            },
-            building_test: {
-                object: 'node',
-                id: 'building_test',
-                type: 'building',
-                parentId: 'site_test',
-                visible: true,
-                metadata: {},
-                children: ['level_test'],
-            },
-            level_test: {
-                object: 'node',
-                id: 'level_test',
-                type: 'level',
-                parentId: 'building_test',
-                visible: true,
-                metadata: {},
-                children: ['elevator_test'],
-                level: 0,
-            },
-            elevator_test: {
-                object: 'node',
-                id: 'elevator_test',
-                type: 'elevator',
-                parentId: 'level_test',
-                visible: true,
-                metadata: {},
-            },
-        }, ['site_test']);
-        const nodes = useScene.getState().nodes;
-        const elevator = nodes.elevator_test;
-        const level = nodes.level_test;
-        const building = nodes.building_test;
-        expect(elevator.parentId).toBe('building_test');
-        expect(elevator.position).toEqual([0, 0, 0]);
-        expect(elevator.rotation).toBe(0);
-        expect(level.children).not.toContain('elevator_test');
-        expect(building.children).toContain('elevator_test');
-    });
-    test('migrates level-parented elevators when the level parentId is missing', () => {
-        useScene.getState().setScene({
-            site_test: {
-                object: 'node',
-                id: 'site_test',
-                type: 'site',
-                parentId: null,
-                visible: true,
-                metadata: {},
-                children: ['building_test'],
-            },
-            building_test: {
-                object: 'node',
-                id: 'building_test',
-                type: 'building',
-                parentId: 'site_test',
-                visible: true,
-                metadata: {},
-                children: ['level_test'],
-            },
-            level_test: {
-                object: 'node',
-                id: 'level_test',
-                type: 'level',
-                parentId: null,
-                visible: true,
-                metadata: {},
-                children: ['elevator_test'],
-                level: 0,
-            },
-            elevator_test: {
-                object: 'node',
-                id: 'elevator_test',
-                type: 'elevator',
-                parentId: 'level_test',
-                visible: true,
-                metadata: {},
-            },
-        }, ['site_test']);
-        const nodes = useScene.getState().nodes;
-        const elevator = nodes.elevator_test;
-        const level = nodes.level_test;
-        const building = nodes.building_test;
-        expect(elevator.parentId).toBe('building_test');
-        expect(level.children).not.toContain('elevator_test');
-        expect(building.children).toContain('elevator_test');
-    });
-});

package/dist/store/use-scene-measurement-roundtrip.test.d.ts

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

package/dist/store/use-scene-measurement-roundtrip.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-scene-measurement-roundtrip.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-measurement-roundtrip.test.ts"],"names":[],"mappings":""}

package/dist/store/use-scene-measurement-roundtrip.test.js

@@ -1,97 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { AnyNode, BuildingNode, LevelNode, MeasurementNode, SiteNode, } from '../schema';
-import useScene from './use-scene';
-describe('scene measurement round-trip', () => {
-    beforeEach(() => {
-        useScene.setState({
-            nodes: {},
-            rootNodeIds: [],
-            dirtyNodes: new Set(),
-            collections: {},
-            materials: {},
-            readOnly: false,
-        });
-        useScene.temporal.getState().clear();
-    });
-    test('preserves a complete measurement graph across JSON and setScene', () => {
-        const distance = MeasurementNode.parse({
-            id: 'measurement_distance',
-            parentId: 'level_ground',
-            visible: false,
-            measurement: {
-                kind: 'distance',
-                points: [
-                    [0.25, 0.5, 0.75],
-                    [4.5, 2.25, 1.5],
-                ],
-            },
-        });
-        const area = MeasurementNode.parse({
-            id: 'measurement_area',
-            parentId: 'level_ground',
-            visible: true,
-            measurement: {
-                kind: 'area',
-                base: [
-                    [0, 0, 0],
-                    [3, 0, 0],
-                    [3, 0, 2],
-                    [0, 0, 2],
-                ],
-            },
-        });
-        const volume = MeasurementNode.parse({
-            id: 'measurement_volume',
-            parentId: 'level_ground',
-            visible: false,
-            measurement: {
-                kind: 'volume',
-                base: [
-                    [1, 0, 1],
-                    [3, 0, 1],
-                    [3, 0, 4],
-                    [1, 0, 4],
-                ],
-                extrusion: [0.5, 2.5, 0],
-            },
-        });
-        const level = LevelNode.parse({
-            id: 'level_ground',
-            parentId: 'building_main',
-            level: 0,
-            children: [distance.id, area.id, volume.id],
-        });
-        const building = BuildingNode.parse({
-            id: 'building_main',
-            parentId: 'site_measurements',
-            children: [level.id],
-        });
-        const site = SiteNode.parse({
-            id: 'site_measurements',
-            children: [building.id],
-        });
-        const nodes = Object.fromEntries([site, building, level, distance, area, volume].map((node) => [node.id, node]));
-        const serialized = JSON.stringify({ nodes, rootNodeIds: [site.id] });
-        const decoded = JSON.parse(serialized);
-        const parsedNodes = Object.fromEntries(Object.entries(decoded.nodes).map(([id, node]) => [id, AnyNode.parse(node)]));
-        useScene.getState().setScene(parsedNodes, decoded.rootNodeIds);
-        const reloaded = useScene.getState();
-        const reloadedSite = SiteNode.parse(reloaded.nodes[site.id]);
-        const reloadedBuilding = BuildingNode.parse(reloaded.nodes[building.id]);
-        const reloadedLevel = LevelNode.parse(reloaded.nodes[level.id]);
-        const reloadedMeasurements = [distance.id, area.id, volume.id].map((id) => MeasurementNode.parse(AnyNode.parse(reloaded.nodes[id])));
-        expect(reloaded.rootNodeIds).toEqual([site.id]);
-        expect(reloadedSite.children).toEqual([building.id]);
-        expect(reloadedBuilding.children).toEqual([level.id]);
-        expect(reloadedLevel.children).toEqual([distance.id, area.id, volume.id]);
-        expect(reloadedMeasurements.map((node) => ({
-            id: node.id,
-            visible: node.visible,
-            measurement: node.measurement,
-        }))).toEqual([
-            { id: distance.id, visible: false, measurement: distance.measurement },
-            { id: area.id, visible: true, measurement: area.measurement },
-            { id: volume.id, visible: false, measurement: volume.measurement },
-        ]);
-    });
-});

package/dist/store/use-scene-plugins.test.d.ts

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

package/dist/store/use-scene-plugins.test.d.ts.map

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

package/dist/store/use-scene-plugins.test.js

@@ -1,51 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { loadPlugin, nodeRegistry } from '../registry';
-import useScene from './use-scene';
-describe('scene plugin installation state', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-        useScene.getState().setReadOnly(false);
-        useScene.getState().unloadScene();
-    });
-    test('loads an explicit installed plugin list with the scene', () => {
-        useScene.getState().setScene({}, [], {
-            installedPlugins: ['pascal:trees'],
-            hasExplicitPluginInstallState: true,
-        });
-        expect(useScene.getState().installedPlugins).toEqual(['pascal:trees']);
-        expect(useScene.getState().hasExplicitPluginInstallState).toBe(true);
-    });
-    test('install changes are de-duplicated and become explicit', () => {
-        useScene.getState().setInstalledPlugins(['pascal:trees', 'pascal:trees'], { explicit: true });
-        expect(useScene.getState().installedPlugins).toEqual(['pascal:trees']);
-        expect(useScene.getState().hasExplicitPluginInstallState).toBe(true);
-    });
-    test('clearing geometry preserves project plugin installs', () => {
-        useScene.getState().setInstalledPlugins(['pascal:trees'], { explicit: true });
-        useScene.getState().clearScene();
-        expect(useScene.getState().installedPlugins).toEqual(['pascal:trees']);
-        expect(useScene.getState().hasExplicitPluginInstallState).toBe(true);
-    });
-    test('uninstall clears plugin build work and reinstall schedules it again', async () => {
-        const kind = 'test:plugin-node';
-        const definition = {
-            kind,
-            schemaVersion: 1,
-            schema: z.object({ id: z.string(), type: z.literal(kind) }),
-            category: 'utility',
-            defaults: () => ({}),
-            capabilities: {},
-        };
-        await loadPlugin({ id: 'test:plugin', apiVersion: 1, nodes: [definition] });
-        const nodeId = 'plugin_node';
-        useScene.getState().setScene({
-            [nodeId]: { id: nodeId, type: kind },
-        }, [nodeId], { installedPlugins: ['test:plugin'], hasExplicitPluginInstallState: true });
-        expect(useScene.getState().dirtyNodes.has(nodeId)).toBe(true);
-        useScene.getState().setInstalledPlugins([], { explicit: true });
-        expect(useScene.getState().dirtyNodes.has(nodeId)).toBe(false);
-        useScene.getState().setInstalledPlugins(['test:plugin'], { explicit: true });
-        expect(useScene.getState().dirtyNodes.has(nodeId)).toBe(true);
-    });
-});

package/dist/store/use-scene-wall-slot-migration.test.d.ts

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

package/dist/store/use-scene-wall-slot-migration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-scene-wall-slot-migration.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-wall-slot-migration.test.ts"],"names":[],"mappings":""}

package/dist/store/use-scene-wall-slot-migration.test.js

@@ -1,210 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import useScene from './use-scene';
-function sceneWithWall(wall) {
-    return {
-        site_test: {
-            object: 'node',
-            id: 'site_test',
-            type: 'site',
-            parentId: null,
-            visible: true,
-            metadata: {},
-            children: ['level_test'],
-        },
-        level_test: {
-            object: 'node',
-            id: 'level_test',
-            type: 'level',
-            parentId: 'site_test',
-            visible: true,
-            metadata: {},
-            children: ['wall_test'],
-            level: 0,
-        },
-        wall_test: {
-            object: 'node',
-            id: 'wall_test',
-            type: 'wall',
-            parentId: 'level_test',
-            visible: true,
-            metadata: {},
-            children: [],
-            start: [0, 0],
-            end: [4, 0],
-            ...wall,
-        },
-    };
-}
-function sceneWithNode(node) {
-    return {
-        site_test: {
-            object: 'node',
-            id: 'site_test',
-            type: 'site',
-            parentId: null,
-            visible: true,
-            metadata: {},
-            children: ['level_test'],
-        },
-        level_test: {
-            object: 'node',
-            id: 'level_test',
-            type: 'level',
-            parentId: 'site_test',
-            visible: true,
-            metadata: {},
-            children: ['node_test'],
-            level: 0,
-        },
-        node_test: {
-            object: 'node',
-            id: 'node_test',
-            visible: true,
-            metadata: {},
-            parentId: 'level_test',
-            ...node,
-        },
-    };
-}
-function resetScene() {
-    useScene.setState({
-        nodes: {},
-        rootNodeIds: [],
-        dirtyNodes: new Set(),
-        collections: {},
-        materials: {},
-    });
-    useScene.temporal.getState().clear();
-}
-describe('wall surface-material → slots migration', () => {
-    beforeEach(() => {
-        resetScene();
-    });
-    test('moves legacy library presets into slots and clears the inline fields', () => {
-        useScene.getState().setScene(sceneWithWall({
-            interiorMaterialPreset: 'library:concrete-plate',
-            exteriorMaterialPreset: 'library:wood-woodplank48',
-        }), ['site_test']);
-        const wall = useScene.getState().nodes.wall_test;
-        expect(wall.slots).toEqual({
-            interior: 'library:concrete-plate',
-            exterior: 'library:wood-woodplank48',
-        });
-        expect(wall.interiorMaterialPreset).toBeUndefined();
-        expect(wall.exteriorMaterialPreset).toBeUndefined();
-    });
-    test('mints a scene material for an inline legacy material and references it', () => {
-        useScene.getState().setScene(sceneWithWall({
-            interiorMaterial: { properties: { color: '#abcdef' } },
-        }), ['site_test']);
-        const wall = useScene.getState().nodes.wall_test;
-        const interiorRef = wall.slots?.interior;
-        expect(interiorRef?.startsWith('scene:')).toBe(true);
-        expect(wall.interiorMaterial).toBeUndefined();
-        const materials = useScene.getState().materials;
-        const id = interiorRef.slice('scene:'.length);
-        expect(materials[id]?.material).toEqual({
-            properties: { color: '#abcdef' },
-        });
-    });
-    test('legacy catch-all material applies to both faces; identical inline customs share one scene material', () => {
-        useScene.getState().setScene(sceneWithWall({
-            material: { properties: { color: '#112233' } },
-        }), ['site_test']);
-        const wall = useScene.getState().nodes.wall_test;
-        expect(wall.slots?.interior).toBeDefined();
-        expect(wall.slots?.interior).toBe(wall.slots?.exterior);
-        expect(wall.material).toBeUndefined();
-        // One minted datablock shared across both faces.
-        expect(Object.keys(useScene.getState().materials)).toHaveLength(1);
-    });
-    test('leaves an already slot-modelled wall untouched and mints nothing for unpainted walls', () => {
-        useScene
-            .getState()
-            .setScene(sceneWithWall({ slots: { interior: 'library:concrete-drywall' } }), [
-            'site_test',
-        ]);
-        const migratedWall = useScene.getState().nodes.wall_test;
-        expect(migratedWall.slots).toEqual({ interior: 'library:concrete-drywall' });
-        expect(Object.keys(useScene.getState().materials)).toHaveLength(0);
-        useScene.getState().setScene(sceneWithWall({}), ['site_test']);
-        const plainWall = useScene.getState().nodes.wall_test;
-        expect(plainWall.slots).toBeUndefined();
-        expect(Object.keys(useScene.getState().materials)).toHaveLength(0);
-    });
-});
-describe('procedural kind surface-material → slots migration', () => {
-    beforeEach(resetScene);
-    test('slab: legacy preset → slots.surface, legacy cleared', () => {
-        useScene.getState().setScene(sceneWithNode({
-            type: 'slab',
-            polygon: [
-                [0, 0],
-                [2, 0],
-                [2, 2],
-                [0, 2],
-            ],
-            materialPreset: 'library:flooring-tiles3',
-        }), ['site_test']);
-        const slab = useScene.getState().nodes.node_test;
-        expect(slab.slots).toEqual({ surface: 'library:flooring-tiles3' });
-        expect(slab.materialPreset).toBeUndefined();
-    });
-    test('ceiling: inline custom material mints a scene material on slots.surface', () => {
-        useScene.getState().setScene(sceneWithNode({
-            type: 'ceiling',
-            polygon: [
-                [0, 0],
-                [2, 0],
-                [2, 2],
-            ],
-            material: { properties: { color: '#ddeeff' } },
-        }), ['site_test']);
-        const ceiling = useScene.getState().nodes.node_test;
-        const ref = ceiling.slots?.surface;
-        expect(ref?.startsWith('scene:')).toBe(true);
-        expect(ceiling.material).toBeUndefined();
-        expect(Object.keys(useScene.getState().materials)).toHaveLength(1);
-    });
-    test('fence: legacy preset fans out to every slot id (one shared ref)', () => {
-        useScene.getState().setScene(sceneWithNode({
-            type: 'fence',
-            start: [0, 0],
-            end: [4, 0],
-            materialPreset: 'library:wood-woodplank48',
-        }), ['site_test']);
-        const fence = useScene.getState().nodes.node_test;
-        expect(fence.slots).toEqual({
-            posts: 'library:wood-woodplank48',
-            infill: 'library:wood-woodplank48',
-            base: 'library:wood-woodplank48',
-            rail: 'library:wood-woodplank48',
-        });
-    });
-    test('stair: per-role legacy fields map tread→treads, side→body, railing→railing', () => {
-        useScene.getState().setScene(sceneWithNode({
-            type: 'stair',
-            treadMaterialPreset: 'library:wood-woodplank48',
-            sideMaterialPreset: 'library:concrete-plate',
-            railingMaterialPreset: 'library:metal-chrome',
-        }), ['site_test']);
-        const stair = useScene.getState().nodes.node_test;
-        expect(stair.slots?.treads).toBe('library:wood-woodplank48');
-        expect(stair.slots?.body).toBe('library:concrete-plate');
-        expect(stair.slots?.railing).toBe('library:metal-chrome');
-        expect(stair.treadMaterialPreset).toBeUndefined();
-    });
-    test('unpainted procedural node mints nothing and stays slot-less', () => {
-        useScene.getState().setScene(sceneWithNode({
-            type: 'slab',
-            polygon: [
-                [0, 0],
-                [2, 0],
-                [2, 2],
-            ],
-        }), ['site_test']);
-        const slab = useScene.getState().nodes.node_test;
-        expect(slab.slots).toBeUndefined();
-        expect(Object.keys(useScene.getState().materials)).toHaveLength(0);
-    });
-});

package/dist/store/use-scene-window-migration.test.d.ts

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

package/dist/store/use-scene-window-migration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-scene-window-migration.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-window-migration.test.ts"],"names":[],"mappings":""}

package/dist/store/use-scene-window-migration.test.js

@@ -1,85 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import useScene from './use-scene';
-describe('scene window migrations', () => {
-    beforeEach(() => {
-        useScene.setState({
-            nodes: {},
-            rootNodeIds: [],
-            dirtyNodes: new Set(),
-            collections: {},
-        });
-        useScene.temporal.getState().clear();
-    });
-    test('fills schema defaults on windows saved before a field existed', () => {
-        // Mirrors real legacy scenes (e.g. windows persisted without
-        // columnRatios/rowRatios/frameThickness): the mesh builder reads those
-        // unconditionally, so a missing array crashed the viewer every frame.
-        useScene.getState().setScene({
-            site_test: {
-                object: 'node',
-                id: 'site_test',
-                type: 'site',
-                parentId: null,
-                visible: true,
-                metadata: {},
-                children: ['building_test'],
-            },
-            building_test: {
-                object: 'node',
-                id: 'building_test',
-                type: 'building',
-                parentId: 'site_test',
-                visible: true,
-                metadata: {},
-                children: ['level_test'],
-            },
-            level_test: {
-                object: 'node',
-                id: 'level_test',
-                type: 'level',
-                parentId: 'building_test',
-                visible: true,
-                metadata: {},
-                children: ['wall_test'],
-                level: 0,
-            },
-            wall_test: {
-                object: 'node',
-                id: 'wall_test',
-                type: 'wall',
-                parentId: 'level_test',
-                visible: true,
-                metadata: {},
-                children: ['window_test'],
-                start: [0, 0],
-                end: [4, 0],
-                height: 2.5,
-                thickness: 0.2,
-            },
-            window_test: {
-                object: 'node',
-                id: 'window_test',
-                type: 'window',
-                parentId: 'wall_test',
-                visible: true,
-                metadata: {},
-                wallId: 'wall_test',
-                position: [1, 1, 0],
-                width: 1.2,
-                height: 1.5,
-                windowType: 'fixed',
-            },
-        }, ['site_test']);
-        const window = useScene.getState().nodes.window_test;
-        expect(window).toBeDefined();
-        // Schema defaults land on load…
-        expect(window.columnRatios).toEqual([1]);
-        expect(window.rowRatios).toEqual([1]);
-        expect(window.frameThickness).toBe(0.05);
-        expect(window.sill).toBe(true);
-        // …and authored fields survive.
-        expect(window.width).toBe(1.2);
-        expect(window.height).toBe(1.5);
-        expect(window.wallId).toBe('wall_test');
-    });
-});

package/dist/systems/elevator/elevator-opening-sync.test.d.ts

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

package/dist/systems/elevator/elevator-opening-sync.test.d.ts.map

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