@pascal-app/core 0.8.0 → 0.9.2

package/dist/store/actions/node-mutation-sanitize.test.js

@@ -0,0 +1,147 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import useScene from '../use-scene';
+globalThis.requestAnimationFrame ??= ((cb) => {
+    cb(0);
+    return 0;
+});
+globalThis.cancelAnimationFrame ??=
+    () => { };
+const SHELF_ID = 'shelf_sanitize';
+const SOLAR_PANEL_ID = 'sp_x';
+function makeShelf(overrides = {}) {
+    return {
+        id: SHELF_ID,
+        type: 'shelf',
+        parentId: null,
+        object: 'node',
+        visible: true,
+        name: 'Shelf',
+        metadata: {},
+        children: [],
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        width: 1.2,
+        depth: 0.3,
+        thickness: 0.04,
+        height: 0.9,
+        style: 'wall-shelf',
+        rows: 1,
+        columns: 1,
+        withBack: false,
+        withSides: true,
+        withBottom: false,
+        bracketStyle: 'minimal',
+        ...overrides,
+    };
+}
+function makeSolarPanel() {
+    return {
+        id: SOLAR_PANEL_ID,
+        type: 'solar-panel',
+        parentId: null,
+        object: 'node',
+        visible: true,
+        name: 'Panel',
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+        rows: 2,
+        columns: 3,
+        panelWidth: 1,
+        panelHeight: 1.65,
+        gapX: 0.02,
+        gapY: 0.02,
+        mountingType: 'flush',
+        tiltAngle: 15,
+        standoffHeight: 0.05,
+        frameThickness: 0.04,
+        frameDepth: 0.04,
+    };
+}
+function shelf() {
+    return useScene.getState().nodes[SHELF_ID];
+}
+describe('node mutation numeric sanitization', () => {
+    beforeEach(() => {
+        useScene.setState({
+            nodes: {
+                [SHELF_ID]: makeShelf(),
+                [SOLAR_PANEL_ID]: makeSolarPanel(),
+            },
+            rootNodeIds: [SHELF_ID, SOLAR_PANEL_ID],
+            dirtyNodes: new Set(),
+            collections: {},
+            readOnly: false,
+        });
+        useScene.temporal.getState().clear();
+    });
+    test('drops NaN numeric updates while preserving other fields in the patch', () => {
+        useScene.getState().updateNode(SHELF_ID, {
+            thickness: Number.NaN,
+            name: 'Renamed after NaN',
+        });
+        expect(shelf().thickness).toBe(0.04);
+        expect(Number.isFinite(shelf().thickness)).toBe(true);
+        expect(shelf().name).toBe('Renamed after NaN');
+    });
+    test('drops Infinity numeric updates while preserving later normal updates', () => {
+        useScene.getState().updateNode(SHELF_ID, {
+            width: Infinity,
+            name: 'Renamed after Infinity',
+        });
+        expect(shelf().width).toBe(1.2);
+        expect(Number.isFinite(shelf().width)).toBe(true);
+        expect(shelf().name).toBe('Renamed after Infinity');
+        useScene.getState().updateNode(SHELF_ID, {
+            name: 'Clean rename',
+        });
+        expect(shelf().name).toBe('Clean rename');
+    });
+    test('clamps out-of-range numeric updates to the node schema bounds', () => {
+        useScene.getState().updateNode(SHELF_ID, {
+            width: 99,
+            thickness: -1,
+        });
+        expect(shelf().width).toBe(3);
+        expect(shelf().thickness).toBe(0.01);
+    });
+    test('preserves extra fields while sanitizing numeric updates', () => {
+        useScene.setState({
+            nodes: {
+                [SHELF_ID]: {
+                    ...makeShelf(),
+                    legacyField: 'current',
+                },
+            },
+            rootNodeIds: [SHELF_ID],
+        });
+        useScene.getState().updateNode(SHELF_ID, {
+            width: Infinity,
+            legacyPatch: 'patch',
+        });
+        const node = useScene.getState().nodes[SHELF_ID];
+        expect(node.width).toBe(1.2);
+        expect(node.legacyField).toBe('current');
+        expect(node.legacyPatch).toBe('patch');
+    });
+    test('allows non-canonical ids to receive updates', () => {
+        useScene.getState().updateNode(SOLAR_PANEL_ID, {
+            name: 'Updated panel',
+        });
+        const panel = useScene.getState().nodes[SOLAR_PANEL_ID];
+        expect(panel.name).toBe('Updated panel');
+    });
+    test('sanitizes non-finite numeric values during create', () => {
+        const createdId = 'shelf_created';
+        useScene.getState().createNode(makeShelf({
+            id: createdId,
+            width: Infinity,
+            thickness: Number.NaN,
+        }));
+        const created = useScene.getState().nodes[createdId];
+        expect(created.width).toBe(1.2);
+        expect(created.thickness).toBe(0.04);
+        expect(Number.isFinite(created.width)).toBe(true);
+        expect(Number.isFinite(created.thickness)).toBe(true);
+    });
+});

package/dist/store/actions/reparent.test.d.ts

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

package/dist/store/actions/reparent.test.d.ts.map

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

package/dist/store/actions/reparent.test.js

@@ -0,0 +1,212 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import useScene from '../use-scene';
+globalThis.requestAnimationFrame ??= ((cb) => {
+    cb(0);
+    return 0;
+});
+globalThis.cancelAnimationFrame ??=
+    () => { };
+const ROOF_ID = 'roof_test';
+const SEG_A_ID = 'rseg_a';
+const SEG_B_ID = 'rseg_b';
+const VENT_ID = 'bvent_v1';
+function makeRoof() {
+    return {
+        id: ROOF_ID,
+        type: 'roof',
+        parentId: null,
+        object: 'node',
+        visible: true,
+        name: '',
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+        children: [SEG_A_ID, SEG_B_ID],
+    };
+}
+function makeSegment(id, children = []) {
+    return {
+        id,
+        type: 'roof-segment',
+        parentId: ROOF_ID,
+        object: 'node',
+        visible: true,
+        name: '',
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+        roofType: 'gable',
+        width: 8,
+        depth: 6,
+        wallHeight: 0.5,
+        pitch: 40,
+        wallThickness: 0.1,
+        deckThickness: 0.1,
+        overhang: 0.3,
+        shingleThickness: 0.05,
+        children,
+    };
+}
+function makeVent(parentId) {
+    return {
+        id: VENT_ID,
+        type: 'box-vent',
+        parentId,
+        roofSegmentId: parentId,
+        object: 'node',
+        visible: true,
+        name: '',
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+        width: 0.4,
+        depth: 0.4,
+        height: 0.15,
+        hoodOverhang: 0.04,
+        topTaper: 0.4,
+        capHeight: 0.07,
+        capGap: 0,
+        domeCurvature: 0.65,
+        baseInset: 0.06,
+        baseHeight: 0.04,
+        cornerBevel: 0.012,
+        style: 'cap',
+        materialPreset: 'preset-white',
+    };
+}
+function childrenOf(id) {
+    const seg = useScene.getState().nodes[id];
+    return (seg?.children ?? []);
+}
+function vent() {
+    return useScene.getState().nodes[VENT_ID];
+}
+describe('node-actions reparent — repeated segment-hopping', () => {
+    beforeEach(() => {
+        useScene.setState({
+            nodes: {
+                [ROOF_ID]: makeRoof(),
+                [SEG_A_ID]: makeSegment(SEG_A_ID, [VENT_ID]),
+                [SEG_B_ID]: makeSegment(SEG_B_ID, []),
+                [VENT_ID]: makeVent(SEG_A_ID),
+            },
+            rootNodeIds: [ROOF_ID],
+        });
+        useScene.temporal.getState().clear();
+    });
+    test('initial state: vent listed once in A.children, absent from B.children', () => {
+        expect(childrenOf(SEG_A_ID)).toEqual([VENT_ID]);
+        expect(childrenOf(SEG_B_ID)).toEqual([]);
+        expect(vent().parentId).toBe(SEG_A_ID);
+    });
+    test('A→B: auto-reparent moves vent without leaving duplicates', () => {
+        useScene
+            .getState()
+            .updateNode(VENT_ID, { parentId: SEG_B_ID, roofSegmentId: SEG_B_ID });
+        expect(childrenOf(SEG_A_ID)).toEqual([]);
+        expect(childrenOf(SEG_B_ID)).toEqual([VENT_ID]);
+        expect(vent().parentId).toBe(SEG_B_ID);
+    });
+    test('A→B→A→B: three hops leave children lists clean (regression: vent crash)', () => {
+        // Move 1: A → B
+        useScene
+            .getState()
+            .updateNode(VENT_ID, { parentId: SEG_B_ID, roofSegmentId: SEG_B_ID });
+        expect(childrenOf(SEG_A_ID)).toEqual([]);
+        expect(childrenOf(SEG_B_ID)).toEqual([VENT_ID]);
+        // Move 2: B → A
+        useScene
+            .getState()
+            .updateNode(VENT_ID, { parentId: SEG_A_ID, roofSegmentId: SEG_A_ID });
+        expect(childrenOf(SEG_A_ID)).toEqual([VENT_ID]);
+        expect(childrenOf(SEG_B_ID)).toEqual([]);
+        // Move 3: A → B (the move the user reports crashes)
+        useScene
+            .getState()
+            .updateNode(VENT_ID, { parentId: SEG_B_ID, roofSegmentId: SEG_B_ID });
+        expect(childrenOf(SEG_A_ID)).toEqual([]);
+        expect(childrenOf(SEG_B_ID)).toEqual([VENT_ID]);
+        expect(vent().parentId).toBe(SEG_B_ID);
+        // Crucially: the vent must appear in EXACTLY ONE segment's children.
+        // Duplicate listing is what makes the roof renderer mount two
+        // <NodeRenderer key={ventId}> instances and crash the scene-registry
+        // on unmount.
+        const totalListings = childrenOf(SEG_A_ID).filter((id) => id === VENT_ID).length +
+            childrenOf(SEG_B_ID).filter((id) => id === VENT_ID).length;
+        expect(totalListings).toBe(1);
+    });
+    test.each([
+        ['chimney', 'chmn_x'],
+        ['skylight', 'sky_x'],
+        ['dormer', 'dorm_x'],
+        ['solar-panel', 'sp_x'],
+        ['ridge-vent', 'rvent_x'],
+    ])('A→B→A→B for %s: chimney-style auto-reparent leaves children clean', (type, idStr) => {
+        const id = idStr;
+        useScene.setState({
+            nodes: {
+                [ROOF_ID]: makeRoof(),
+                [SEG_A_ID]: makeSegment(SEG_A_ID, [id]),
+                [SEG_B_ID]: makeSegment(SEG_B_ID, []),
+                [id]: {
+                    id,
+                    type,
+                    parentId: SEG_A_ID,
+                    roofSegmentId: SEG_A_ID,
+                    object: 'node',
+                    visible: true,
+                    name: '',
+                    metadata: {},
+                    position: [0, 0, 0],
+                    rotation: 0,
+                },
+            },
+            rootNodeIds: [ROOF_ID],
+        });
+        const hop = (to) => useScene.getState().updateNode(id, { parentId: to, roofSegmentId: to });
+        hop(SEG_B_ID);
+        hop(SEG_A_ID);
+        hop(SEG_B_ID);
+        expect(childrenOf(SEG_A_ID)).toEqual([]);
+        expect(childrenOf(SEG_B_ID)).toEqual([id]);
+        const node = useScene.getState().nodes[id];
+        expect(node.parentId).toBe(SEG_B_ID);
+    });
+    test('A→B→A→B with redundant manual children edits (vent move-tool pattern, pre-fix)', () => {
+        // Reproduces the box-vent / ridge-vent move-tool order: manual
+        // children edits FIRST, then updateNode({parentId}) which triggers
+        // auto-reparent. The dual handling must not leave the vent listed
+        // in both segments after three hops.
+        const hop = (from, to) => {
+            const st = useScene.getState();
+            // 1. Manual: filter old children, push to new children — using
+            //    the snapshot (st.nodes) captured before any updates.
+            const oldSeg = st.nodes[from];
+            if (oldSeg) {
+                st.updateNode(from, {
+                    children: (oldSeg.children ?? []).filter((id) => id !== VENT_ID),
+                });
+            }
+            const newSeg = st.nodes[to];
+            if (newSeg && !(newSeg.children ?? []).includes(VENT_ID)) {
+                st.updateNode(to, {
+                    children: [...(newSeg.children ?? []), VENT_ID],
+                });
+            }
+            // 2. Then the auto-reparent path via parentId.
+            st.updateNode(VENT_ID, {
+                parentId: to,
+                roofSegmentId: to,
+            });
+        };
+        hop(SEG_A_ID, SEG_B_ID);
+        hop(SEG_B_ID, SEG_A_ID);
+        hop(SEG_A_ID, SEG_B_ID);
+        expect(childrenOf(SEG_A_ID)).toEqual([]);
+        expect(childrenOf(SEG_B_ID)).toEqual([VENT_ID]);
+        expect(vent().parentId).toBe(SEG_B_ID);
+        const totalListings = childrenOf(SEG_A_ID).filter((id) => id === VENT_ID).length +
+            childrenOf(SEG_B_ID).filter((id) => id === VENT_ID).length;
+        expect(totalListings).toBe(1);
+    });
+});

package/dist/store/actions/ridge-vent-update.test.d.ts

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

package/dist/store/actions/ridge-vent-update.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ridge-vent-update.test.d.ts","sourceRoot":"","sources":["../../../src/store/actions/ridge-vent-update.test.ts"],"names":[],"mappings":""}

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"}