@pascal-app/core 0.9.1 → 0.9.2

package/dist/store/actions/ridge-vent-update.test.js

@@ -0,0 +1,264 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { createDefaultRidgeVentsForSegment, RidgeVentNode } from '../../schema/nodes/ridge-vent';
+import { RoofNode } from '../../schema/nodes/roof';
+import { RoofSegmentNode } from '../../schema/nodes/roof-segment';
+import useScene from '../use-scene';
+globalThis.requestAnimationFrame ??= ((cb) => {
+    cb(0);
+    return 0;
+});
+globalThis.cancelAnimationFrame ??=
+    () => { };
+describe('roof segment default ridge vents', () => {
+    beforeEach(() => {
+        useScene.setState({
+            nodes: {},
+            rootNodeIds: [],
+            dirtyNodes: new Set(),
+            collections: {},
+            materials: {},
+            readOnly: false,
+        });
+    });
+    test('regenerates default ridge vents when the host ridge geometry changes', () => {
+        const roof = RoofNode.parse({ id: 'roof_test', children: [] });
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            parentId: roof.id,
+            roofType: 'gable',
+            width: 8,
+            depth: 6,
+        });
+        const defaults = createDefaultRidgeVentsForSegment(segment);
+        const custom = RidgeVentNode.parse({
+            id: 'rvent_custom',
+            parentId: segment.id,
+            roofSegmentId: segment.id,
+            name: 'Custom Ridge Vent',
+            position: [0, 0.2, 0],
+            length: 1.25,
+            materialPreset: 'preset-custom',
+        });
+        useScene.getState().setScene({
+            [roof.id]: { ...roof, children: [segment.id] },
+            [segment.id]: {
+                ...segment,
+                children: [...defaults.map((vent) => vent.id), custom.id],
+            },
+            ...Object.fromEntries(defaults.map((vent) => [
+                vent.id,
+                { ...vent, parentId: segment.id, roofSegmentId: segment.id },
+            ])),
+            [custom.id]: custom,
+        }, [roof.id]);
+        const oldDefaultIds = defaults.map((vent) => vent.id);
+        useScene.getState().updateNode(segment.id, { width: 12 });
+        const nextSegment = useScene.getState().nodes[segment.id];
+        const nextChildren = nextSegment?.children ?? [];
+        const nextDefaultIds = nextChildren.filter((id) => id !== custom.id);
+        expect(nextChildren).toContain(custom.id);
+        expect(useScene.getState().nodes[custom.id]).toMatchObject({
+            length: 1.25,
+            materialPreset: 'preset-custom',
+        });
+        for (const oldId of oldDefaultIds) {
+            expect(useScene.getState().nodes[oldId]).toBeUndefined();
+        }
+        expect(nextDefaultIds).toHaveLength(defaults.length);
+        expect(nextDefaultIds.some((id) => {
+            const node = useScene.getState().nodes[id];
+            return node?.type === 'ridge-vent' && node.length > (defaults[0]?.length ?? 0);
+        })).toBe(true);
+    });
+    test('does not regenerate default ridge vents when only trim changes', () => {
+        const roof = RoofNode.parse({ id: 'roof_test', children: [] });
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            parentId: roof.id,
+            roofType: 'gable',
+            width: 8,
+            depth: 6,
+        });
+        const defaults = createDefaultRidgeVentsForSegment(segment);
+        useScene.getState().setScene({
+            [roof.id]: { ...roof, children: [segment.id] },
+            [segment.id]: {
+                ...segment,
+                children: defaults.map((vent) => vent.id),
+            },
+            ...Object.fromEntries(defaults.map((vent) => [
+                vent.id,
+                { ...vent, parentId: segment.id, roofSegmentId: segment.id },
+            ])),
+        }, [roof.id]);
+        const originalDefaultId = defaults[0]?.id;
+        useScene.getState().updateNode(segment.id, {
+            trim: { ...segment.trim, left: 2, frontLeftX: 2, frontLeftZ: 3 },
+        });
+        const nextSegment = useScene.getState().nodes[segment.id];
+        expect(nextSegment?.children).toEqual(defaults.map((vent) => vent.id));
+        expect(useScene.getState().nodes[originalDefaultId]).toMatchObject({
+            id: originalDefaultId,
+            length: defaults[0]?.length,
+            position: defaults[0]?.position,
+        });
+    });
+    test('creates default ridge vents after a geometry change when auto ridge vent is enabled', () => {
+        const roof = RoofNode.parse({ id: 'roof_test', children: [] });
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            parentId: roof.id,
+            roofType: 'flat',
+            width: 8,
+            depth: 6,
+            metadata: { autoRidgeVent: true },
+        });
+        useScene.getState().setScene({
+            [roof.id]: { ...roof, children: [segment.id] },
+            [segment.id]: segment,
+        }, [roof.id]);
+        useScene.getState().updateNode(segment.id, {
+            roofType: 'gable',
+        });
+        const nextSegment = useScene.getState().nodes[segment.id];
+        expect(nextSegment?.children).toHaveLength(1);
+        expect(useScene.getState().nodes[nextSegment?.children[0]]).toMatchObject({
+            type: 'ridge-vent',
+            roofSegmentId: segment.id,
+        });
+    });
+    test('regenerates default ridge vents when Dutch auto-vent fields change', () => {
+        const roof = RoofNode.parse({ id: 'roof_test', children: [] });
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            parentId: roof.id,
+            roofType: 'dutch',
+            width: 8,
+            depth: 6,
+            metadata: { autoRidgeVent: true },
+        });
+        const defaults = createDefaultRidgeVentsForSegment(segment);
+        useScene.getState().setScene({
+            [roof.id]: { ...roof, children: [segment.id] },
+            [segment.id]: {
+                ...segment,
+                children: defaults.map((vent) => vent.id),
+            },
+            ...Object.fromEntries(defaults.map((vent) => [
+                vent.id,
+                { ...vent, parentId: segment.id, roofSegmentId: segment.id },
+            ])),
+        }, [roof.id]);
+        const originalDefaultIds = defaults.map((vent) => vent.id);
+        useScene.getState().updateNode(segment.id, {
+            pitch: 52,
+            dutchWaistLengthRatio: 0.72,
+            dutchGabletRake: 0.9,
+        });
+        const nextSegment = useScene.getState().nodes[segment.id];
+        const nextChildren = nextSegment?.children ?? [];
+        expect(nextChildren).toHaveLength(defaults.length);
+        expect(nextChildren.some((id) => originalDefaultIds.includes(id))).toBe(false);
+        for (const oldId of originalDefaultIds) {
+            expect(useScene.getState().nodes[oldId]).toBeUndefined();
+        }
+    });
+    test('refresh replaces legacy default vents that still use preset-white', () => {
+        const roof = RoofNode.parse({ id: 'roof_test', children: [] });
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            parentId: roof.id,
+            roofType: 'gable',
+            width: 8,
+            depth: 6,
+            metadata: { autoRidgeVent: true },
+        });
+        const legacyDefault = RidgeVentNode.parse({
+            id: 'rvent_legacy',
+            parentId: segment.id,
+            roofSegmentId: segment.id,
+            name: 'Ridge Vent',
+            style: 'shingled',
+            materialPreset: 'preset-white',
+            position: [0, 0, 0],
+            length: 8,
+        });
+        useScene.getState().setScene({
+            [roof.id]: { ...roof, children: [segment.id] },
+            [segment.id]: {
+                ...segment,
+                children: [legacyDefault.id],
+            },
+            [legacyDefault.id]: legacyDefault,
+        }, [roof.id]);
+        useScene.getState().updateNode(segment.id, {
+            pitch: 52,
+        });
+        const nextSegment = useScene.getState().nodes[segment.id];
+        const nextChildren = nextSegment?.children ?? [];
+        expect(nextChildren).toHaveLength(1);
+        expect(nextChildren[0]).not.toBe(legacyDefault.id);
+        expect(useScene.getState().nodes[legacyDefault.id]).toBeUndefined();
+    });
+    test('refresh preserves user-created default-looking ridge vents without legacy preset metadata', () => {
+        const roof = RoofNode.parse({ id: 'roof_test', children: [] });
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            parentId: roof.id,
+            roofType: 'gable',
+            width: 8,
+            depth: 6,
+            metadata: { autoRidgeVent: true },
+        });
+        const userVent = RidgeVentNode.parse({
+            id: 'rvent_user',
+            parentId: segment.id,
+            roofSegmentId: segment.id,
+            name: 'Ridge Vent',
+            style: 'shingled',
+            position: [0, 0, 0],
+            length: 8,
+        });
+        useScene.getState().setScene({
+            [roof.id]: { ...roof, children: [segment.id] },
+            [segment.id]: {
+                ...segment,
+                children: [userVent.id],
+            },
+            [userVent.id]: userVent,
+        }, [roof.id]);
+        useScene.getState().updateNode(segment.id, {
+            pitch: 52,
+        });
+        const nextSegment = useScene.getState().nodes[segment.id];
+        const nextChildren = nextSegment?.children ?? [];
+        expect(nextChildren).toContain(userVent.id);
+        expect(useScene.getState().nodes[userVent.id]).toMatchObject({
+            id: userVent.id,
+            roofSegmentId: segment.id,
+            name: 'Ridge Vent',
+            style: 'shingled',
+            length: 8,
+        });
+    });
+    test('does not create default ridge vents after a geometry change when auto ridge vent is disabled', () => {
+        const roof = RoofNode.parse({ id: 'roof_test', children: [] });
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            parentId: roof.id,
+            roofType: 'flat',
+            width: 8,
+            depth: 6,
+            metadata: { autoRidgeVent: false },
+        });
+        useScene.getState().setScene({
+            [roof.id]: { ...roof, children: [segment.id] },
+            [segment.id]: segment,
+        }, [roof.id]);
+        useScene.getState().updateNode(segment.id, {
+            roofType: 'gable',
+        });
+        const nextSegment = useScene.getState().nodes[segment.id];
+        expect(nextSegment?.children ?? []).toHaveLength(0);
+    });
+});

package/dist/store/history-control.d.ts

@@ -6,9 +6,20 @@ type TemporalStoreLike = {
         };
     };
 };
+type TemporalHistoryStoreLike<TPastState> = {
+    temporal: {
+        getState(): {
+            pastStates: TPastState[];
+        };
+        setState(state: {
+            pastStates: TPastState[];
+        }): void;
+    };
+};
 export declare function pauseSceneHistory(sceneStore: TemporalStoreLike): void;
 export declare function resumeSceneHistory(sceneStore: TemporalStoreLike): void;
 export declare function getSceneHistoryPauseDepth(): number;
 export declare function resetSceneHistoryPauseDepth(): void;
+export declare function runAsSingleSceneHistoryStep<TPastState, TResult>(sceneStore: TemporalHistoryStoreLike<TPastState>, run: () => TResult): TResult;
 export {};
 //# sourceMappingURL=history-control.d.ts.map

package/dist/store/history-control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history-control.d.ts","sourceRoot":"","sources":["../../src/store/history-control.ts"],"names":[],"mappings":"AAEA,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,KAAK,IAAI,IAAI,CAAA;YACb,MAAM,IAAI,IAAI,CAAA;SACf,CAAA;KACF,CAAA;CACF,CAAA;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAKrE;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAStE;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAElD"}
+{"version":3,"file":"history-control.d.ts","sourceRoot":"","sources":["../../src/store/history-control.ts"],"names":[],"mappings":"AAEA,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,KAAK,IAAI,IAAI,CAAA;YACb,MAAM,IAAI,IAAI,CAAA;SACf,CAAA;KACF,CAAA;CACF,CAAA;AAED,KAAK,wBAAwB,CAAC,UAAU,IAAI;IAC1C,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,UAAU,EAAE,UAAU,EAAE,CAAA;SACzB,CAAA;QACD,QAAQ,CAAC,KAAK,EAAE;YAAE,UAAU,EAAE,UAAU,EAAE,CAAA;SAAE,GAAG,IAAI,CAAA;KACpD,CAAA;CACF,CAAA;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAKrE;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAStE;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAkBD,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,OAAO,EAC7D,UAAU,EAAE,wBAAwB,CAAC,UAAU,CAAC,EAChD,GAAG,EAAE,MAAM,OAAO,GACjB,OAAO,CAeT"}

package/dist/store/history-control.js

@@ -20,3 +20,36 @@ export function getSceneHistoryPauseDepth() {
 export function resetSceneHistoryPauseDepth() {
     sceneHistoryPauseDepth = 0;
 }
+function retainedPastStateCount(before, after) {
+    for (let start = 0; start < before.length; start += 1) {
+        const retained = before.length - start;
+        if (retained > after.length)
+            continue;
+        let matches = true;
+        for (let index = 0; index < retained; index += 1) {
+            if (before[start + index] !== after[index]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return retained;
+    }
+    return 0;
+}
+export function runAsSingleSceneHistoryStep(sceneStore, run) {
+    const beforePastStates = sceneStore.temporal.getState().pastStates;
+    const result = run();
+    const afterPastStates = sceneStore.temporal.getState().pastStates;
+    const retainedCount = retainedPastStateCount(beforePastStates, afterPastStates);
+    const addedCount = afterPastStates.length - retainedCount;
+    if (addedCount > 1) {
+        const firstAddedState = afterPastStates[retainedCount];
+        if (firstAddedState !== undefined) {
+            sceneStore.temporal.setState({
+                pastStates: [...afterPastStates.slice(0, retainedCount), firstAddedState],
+            });
+        }
+    }
+    return result;
+}

package/dist/store/use-scene-dirty-tracking.test.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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