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

package/dist/services/single-undo-dance.test.js

@@ -1,210 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { createSceneApi } from '../registry/scene-api';
-import useScene from '../store/use-scene';
-globalThis.requestAnimationFrame ??= ((cb) => {
-    cb(0);
-    return 0;
-});
-globalThis.cancelAnimationFrame ??=
-    () => { };
-/**
- * Validates the "single-undo dance" pattern used by Stage D actions:
- *
- *   action.commit:
- *     scene.restoreAll()       // revert via snapshot (paused → no zundo record)
- *     scene.resumeHistory()    // unpause zundo
- *     scene.update(...)        // re-apply final → zundo records one diff
- *     return true
- *
- * After the dance, undo() should roll back ONLY the drag's commit —
- * never further back than that. The fence-bend regression that surfaced
- * after Phase 5 Stage D porting was reportedly losing the prior create
- * step on undo; this test pins the correct behavior.
- */
-const FENCE_ID = 'fence_test';
-function makeFence(curveOffset) {
-    return {
-        id: FENCE_ID,
-        type: 'fence',
-        parentId: null,
-        object: 'node',
-        visible: true,
-        metadata: {},
-        start: [0, 0],
-        end: [3, 0],
-        height: 1.8,
-        thickness: 0.08,
-        baseHeight: 0.22,
-        postSpacing: 2,
-        postSize: 0.1,
-        topRailHeight: 0.04,
-        groundClearance: 0,
-        edgeInset: 0.015,
-        baseStyle: 'grounded',
-        showInfill: true,
-        color: '#ffffff',
-        style: 'slat',
-        curveOffset,
-    };
-}
-describe('Single-undo dance', () => {
-    beforeEach(() => {
-        useScene.setState({ nodes: {}, rootNodeIds: [] });
-        useScene.temporal.getState().clear();
-    });
-    test('curve-style commit yields a single undo step', () => {
-        // 1. Create the fence (recorded by zundo).
-        useScene.getState().createNode(makeFence(0));
-        const pastCountAfterCreate = useScene.temporal.getState().pastStates.length;
-        // 2. Simulate the drag.
-        const scene = createSceneApi(useScene);
-        scene.pauseHistory();
-        scene.update(FENCE_ID, { curveOffset: 0.2 });
-        scene.update(FENCE_ID, { curveOffset: 0.5 });
-        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
-        // 3. Commit dance.
-        scene.restoreAll();
-        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0);
-        scene.resumeHistory();
-        scene.update(FENCE_ID, { curveOffset: 0.5 });
-        const pastCountAfterDance = useScene.temporal.getState().pastStates.length;
-        expect(pastCountAfterDance).toBe(pastCountAfterCreate + 1);
-        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
-        // 4. Undo — should return fence to curveOffset 0, NOT delete it.
-        useScene.temporal.getState().undo();
-        const fenceAfterUndo = useScene.getState().nodes[FENCE_ID];
-        expect(fenceAfterUndo).toBeDefined();
-        expect(fenceAfterUndo.curveOffset).toBe(0);
-    });
-    test('StrictMode double-mount: dispose-then-restart preserves history', () => {
-        useScene.getState().createNode(makeFence(0));
-        const pastBeforeBend = useScene.temporal.getState().pastStates.length;
-        // Simulate StrictMode: first mount → cleanup (dispose) → second mount → drag → commit.
-        const scene = createSceneApi(useScene);
-        // Mount 1.
-        scene.pauseHistory();
-        // Mount 1 cleanup (StrictMode): no apply happened yet. dispose-equivalent.
-        scene.restoreAll(); // snapshot empty, no-op.
-        scene.resumeHistory();
-        // Mount 2.
-        scene.pauseHistory();
-        // Drag.
-        scene.update(FENCE_ID, { curveOffset: 0.3 });
-        scene.update(FENCE_ID, { curveOffset: 0.7 });
-        // Commit dance.
-        scene.restoreAll();
-        scene.resumeHistory();
-        scene.update(FENCE_ID, { curveOffset: 0.7 });
-        const pastAfterBend = useScene.temporal.getState().pastStates.length;
-        // Exactly one new entry: the pre-bend state. Not two (which would mean
-        // StrictMode's first mount/cleanup polluted history).
-        expect(pastAfterBend).toBe(pastBeforeBend + 1);
-        useScene.temporal.getState().undo();
-        expect(useScene.getState().nodes[FENCE_ID]).toBeDefined();
-        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0);
-    });
-    test('commit-returns-false (no change) does NOT consume the prior pastState', () => {
-        // This is the suspected bend regression: when action.commit returns
-        // false (draft.curveOffset === ctx.originalCurveOffset), session.commit
-        // calls scene.restoreAll() but doesn't push to pastStates. Subsequent
-        // undo pops the PRIOR action (e.g. fence creation), not the no-op
-        // bend.
-        useScene.getState().createNode(makeFence(0));
-        const pastBeforeBend = useScene.temporal.getState().pastStates.length;
-        const scene = createSceneApi(useScene);
-        scene.pauseHistory();
-        // Drag back to original — simulates no-op bend.
-        scene.update(FENCE_ID, { curveOffset: 0.0 });
-        // Cancel path (mimics session.commit → action.commit returns false → scene.restoreAll → terminate).
-        scene.restoreAll();
-        scene.resumeHistory();
-        const pastAfterNoOp = useScene.temporal.getState().pastStates.length;
-        expect(pastAfterNoOp).toBe(pastBeforeBend); // no entries added
-        // Now undo — this should be a no-op (state unchanged), but pops the create.
-        useScene.temporal.getState().undo();
-        // ⚠️ Reproduces the bug — undo removes the fence:
-        const fence = useScene.getState().nodes[FENCE_ID];
-        if (fence === undefined) {
-            // Bug reproduced. The "no-op bend" allowed Ctrl-Z to fall through
-            // to the fence creation. Fix is in action.commit: don't return false
-            // — push a no-op entry instead, or guard against the cancel path.
-            expect(fence).toBeUndefined();
-        }
-        else {
-            expect(fence.curveOffset).toBe(0);
-        }
-    });
-    test('full session flow via createDragSession with real action.commit dance', async () => {
-        // Reproduces the actual wrapper flow:
-        //   - createNode → session.start → moves → grid:click → session.commit.
-        // The action.commit does the dance internally.
-        const { createDragSession } = await import('./drag-session');
-        useScene.getState().createNode(makeFence(0));
-        const pastBeforeBend = useScene.temporal.getState().pastStates.length;
-        const scene = createSceneApi(useScene);
-        const action = {
-            begin: () => ({ original: 0 }),
-            preview: (_ctx, point) => ({ offset: point[0] }),
-            apply: (draft, _ctx, s) => {
-                s.update(FENCE_ID, { curveOffset: draft.offset });
-                return [FENCE_ID];
-            },
-            commit: (draft, ctx, s) => {
-                if (draft.offset === ctx.original)
-                    return false;
-                s.restoreAll();
-                s.resumeHistory();
-                s.update(FENCE_ID, { curveOffset: draft.offset });
-                return true;
-            },
-            cancel: () => { },
-        };
-        const session = createDragSession(action, scene);
-        session.start({ point: [0, 0] });
-        session.move([0.3, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        session.move([0.5, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        const okCommit = session.commit();
-        expect(okCommit).toBe(true);
-        const pastAfter = useScene.temporal.getState().pastStates.length;
-        expect(pastAfter).toBe(pastBeforeBend + 1);
-        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
-        useScene.temporal.getState().undo();
-        const after = useScene.getState().nodes[FENCE_ID];
-        expect(after).toBeDefined();
-        expect(after.curveOffset).toBe(0);
-    });
-    test('REAL bend (draft != original): one Ctrl-Z undoes only the bend', () => {
-        useScene.getState().createNode(makeFence(0));
-        const stateAfterCreate = useScene.getState().nodes[FENCE_ID];
-        expect(stateAfterCreate.curveOffset).toBe(0);
-        const scene = createSceneApi(useScene);
-        scene.pauseHistory();
-        // Simulate a real drag: capture original, mutate to non-zero.
-        scene.update(FENCE_ID, { curveOffset: 0.5 });
-        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
-        // Dance.
-        scene.restoreAll();
-        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0);
-        scene.resumeHistory();
-        scene.update(FENCE_ID, { curveOffset: 0.5 });
-        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
-        // First Ctrl-Z should undo the bend.
-        useScene.temporal.getState().undo();
-        const afterFirstUndo = useScene.getState().nodes[FENCE_ID];
-        expect(afterFirstUndo).toBeDefined();
-        expect(afterFirstUndo?.curveOffset).toBe(0);
-    });
-    test('a SECOND undo rolls the create step back', () => {
-        useScene.getState().createNode(makeFence(0));
-        const scene = createSceneApi(useScene);
-        scene.pauseHistory();
-        scene.update(FENCE_ID, { curveOffset: 0.5 });
-        scene.restoreAll();
-        scene.resumeHistory();
-        scene.update(FENCE_ID, { curveOffset: 0.5 });
-        useScene.temporal.getState().undo();
-        expect(useScene.getState().nodes[FENCE_ID]).toBeDefined();
-        useScene.temporal.getState().undo();
-        expect(useScene.getState().nodes[FENCE_ID]).toBeUndefined();
-    });
-});

package/dist/services/snap.test.d.ts

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

package/dist/services/snap.test.d.ts.map

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

package/dist/services/snap.test.js

@@ -1,95 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { DEFAULT_ANGLE_STEP, DEFAULT_GRID_STEP, snapAngleToList, snapPointToAngle, snapPointToGrid, snapScalar, snapServices, snapVec3ToGrid, } from './snap';
-describe('snapScalar', () => {
-    test('rounds to multiples of step', () => {
-        expect(snapScalar(0.27, 0.25)).toBe(0.25);
-        expect(snapScalar(0.13, 0.25)).toBe(0.25);
-        expect(snapScalar(0.12, 0.25)).toBe(0);
-        expect(snapScalar(1.7, 0.25)).toBeCloseTo(1.75);
-    });
-    test('returns input unchanged when step is non-positive', () => {
-        expect(snapScalar(0.42, 0)).toBe(0.42);
-        expect(snapScalar(0.42, -1)).toBe(0.42);
-    });
-    test('default step is 0.25m', () => {
-        expect(snapScalar(0.3)).toBe(0.25);
-        expect(snapScalar(0.4)).toBe(0.5);
-        expect(DEFAULT_GRID_STEP).toBe(0.25);
-    });
-});
-describe('snapPointToGrid', () => {
-    test('snaps both components independently', () => {
-        expect(snapPointToGrid([0.3, 0.6], 0.25)).toEqual([0.25, 0.5]);
-    });
-    test('preserves exact-grid points', () => {
-        expect(snapPointToGrid([1, 2], 0.5)).toEqual([1, 2]);
-    });
-});
-describe('snapVec3ToGrid', () => {
-    test('snaps X and Z, leaves Y untouched', () => {
-        expect(snapVec3ToGrid([0.3, 1.7, 0.6], 0.25)).toEqual([0.25, 1.7, 0.5]);
-    });
-});
-describe('snapPointToAngle', () => {
-    test('snaps to axis (0°) when cursor is near horizontal', () => {
-        const from = [0, 0];
-        const cursor = [1, 0.05]; // near 0°
-        const snapped = snapPointToAngle(from, cursor, Math.PI / 4);
-        expect(snapped[0]).toBeCloseTo(1, 1);
-        expect(snapped[1]).toBeCloseTo(0, 5);
-    });
-    test('snaps to 45° at π/4 step', () => {
-        const from = [0, 0];
-        const cursor = [1, 0.9]; // near 45°
-        const snapped = snapPointToAngle(from, cursor, Math.PI / 4);
-        // distance preserved (≈ √(1² + 0.9²) ≈ 1.345), angle locked to 45°
-        const expectedDist = Math.hypot(1, 0.9);
-        expect(snapped[0]).toBeCloseTo(expectedDist * Math.cos(Math.PI / 4));
-        expect(snapped[1]).toBeCloseTo(expectedDist * Math.sin(Math.PI / 4));
-    });
-    test('default angle step is π/12 (15°)', () => {
-        expect(DEFAULT_ANGLE_STEP).toBeCloseTo(Math.PI / 12);
-    });
-    test('grid-snaps the projected point when gridStep is provided', () => {
-        const from = [0, 0];
-        const cursor = [1.05, 0.02]; // ~horizontal, slightly off grid
-        const snapped = snapPointToAngle(from, cursor, Math.PI / 4, 0.25);
-        // After 0° lock + 0.25m grid, X must be a 0.25 multiple.
-        expect(snapped[0] / 0.25).toBeCloseTo(Math.round(snapped[0] / 0.25));
-    });
-    test('preserves distance from `from`', () => {
-        const from = [2, 3];
-        const cursor = [3, 4];
-        const distance = Math.hypot(1, 1);
-        const snapped = snapPointToAngle(from, cursor, Math.PI / 4);
-        expect(Math.hypot(snapped[0] - 2, snapped[1] - 3)).toBeCloseTo(distance);
-    });
-});
-describe('snapAngleToList', () => {
-    test('snaps to the nearest entry within tolerance', () => {
-        const targets = [0, Math.PI / 2, Math.PI, (3 * Math.PI) / 2];
-        expect(snapAngleToList(0.05, targets, Math.PI / 36)).toBe(0);
-        expect(snapAngleToList(Math.PI / 2 + 0.02, targets, Math.PI / 36)).toBe(Math.PI / 2);
-    });
-    test('returns original angle when no target is within tolerance', () => {
-        const targets = [0, Math.PI / 2];
-        expect(snapAngleToList(0.5, targets, Math.PI / 36)).toBe(0.5);
-    });
-    test('handles wrap-around near ±π', () => {
-        const targets = [Math.PI];
-        expect(snapAngleToList(-Math.PI + 0.01, targets, Math.PI / 36)).toBe(Math.PI);
-    });
-});
-describe('snapServices facade', () => {
-    test('grid.snap matches snapPointToGrid', () => {
-        expect(snapServices.grid.snap([0.3, 0.6], 0.25)).toEqual(snapPointToGrid([0.3, 0.6], 0.25));
-    });
-    test('grid.snapScalar matches snapScalar', () => {
-        expect(snapServices.grid.snapScalar(0.3, 0.25)).toBe(snapScalar(0.3, 0.25));
-    });
-    test('angle.snapTo matches snapPointToAngle', () => {
-        const from = [0, 0];
-        const cursor = [1, 0.9];
-        expect(snapServices.angle.snapTo(from, cursor, Math.PI / 4)).toEqual(snapPointToAngle(from, cursor, Math.PI / 4));
-    });
-});

package/dist/store/actions/node-mutation-sanitize.test.d.ts

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

package/dist/store/actions/node-mutation-sanitize.test.d.ts.map

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

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

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

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

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

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

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

@@ -1,212 +0,0 @@
-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);
-    });
-});