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

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,137 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { DEFAULT_ANGLE_STEP, DEFAULT_GRID_STEP, snapAngleToList, snapPointAlongAngleRay, 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('snapPointAlongAngleRay', () => {
-    test('stays exactly on the 15° ray while distance-snapping to the grid step', () => {
-        const from = [0, 0];
-        const cursor = [2, 0.5]; // ≈14° — snaps to 15°
-        const snapped = snapPointAlongAngleRay(from, cursor, Math.PI / 12, 0.25);
-        expect(Math.atan2(snapped[1], snapped[0])).toBeCloseTo(Math.PI / 12, 10);
-        const distance = Math.hypot(snapped[0], snapped[1]);
-        expect(distance / 0.25).toBeCloseTo(Math.round(distance / 0.25), 10);
-    });
-    test('grid-snapping after the angle projection would pull the point off the ray', () => {
-        const from = [0, 0];
-        const cursor = [2, 0.5];
-        const offRay = snapPointToAngle(from, cursor, Math.PI / 12, 0.25);
-        expect(Math.atan2(offRay[1], offRay[0])).not.toBeCloseTo(Math.PI / 12, 4);
-    });
-    test('45° back-compat: locks to the diagonal with grid-multiple distance', () => {
-        const from = [1, 1];
-        const cursor = [2.1, 1.9]; // near 45° from `from`
-        const snapped = snapPointAlongAngleRay(from, cursor, Math.PI / 4, 0.25);
-        expect(Math.atan2(snapped[1] - 1, snapped[0] - 1)).toBeCloseTo(Math.PI / 4, 10);
-        const distance = Math.hypot(snapped[0] - 1, snapped[1] - 1);
-        expect(distance / 0.25).toBeCloseTo(Math.round(distance / 0.25), 10);
-    });
-    test('preserves the projected distance when no distanceStep is given', () => {
-        const from = [0, 0];
-        const cursor = [1, 0.05]; // near 0°
-        const snapped = snapPointAlongAngleRay(from, cursor, Math.PI / 12);
-        expect(snapped[0]).toBeCloseTo(1, 10); // projection of (1, 0.05) onto 0° ray
-        expect(snapped[1]).toBeCloseTo(0, 10);
-    });
-    test('returns `from` for a zero-length segment', () => {
-        expect(snapPointAlongAngleRay([2, 3], [2, 3], Math.PI / 12, 0.25)).toEqual([2, 3]);
-    });
-    test('is idempotent on its own output', () => {
-        const from = [0.5, -1];
-        const cursor = [3.2, 0.4];
-        const once = snapPointAlongAngleRay(from, cursor, Math.PI / 12, 0.5);
-        const twice = snapPointAlongAngleRay(from, once, Math.PI / 12, 0.5);
-        expect(twice[0]).toBeCloseTo(once[0], 10);
-        expect(twice[1]).toBeCloseTo(once[1], 10);
-    });
-});
-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/services/system-graph.test.d.ts

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

package/dist/services/system-graph.test.d.ts.map

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

package/dist/services/system-graph.test.js

@@ -1,138 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { registerNode } from '../registry';
-import { buildPortComponents, summarizeSystemFor } from './system-graph';
-// Stub registrations: the graph consults `def.ports` for the connectivity
-// graph and `def.distributionRole` to classify each node. Mirrors the real
-// kinds' port + role conventions (duct runs expose start/end, equipment a
-// supply collar, terminals one collar) without importing the nodes package.
-function stubDef(kind, distributionRole, ports) {
-    registerNode({
-        kind,
-        schemaVersion: 1,
-        schema: {},
-        category: 'utility',
-        distributionRole,
-        defaults: () => ({}),
-        capabilities: {},
-        ports,
-    });
-}
-stubDef('duct-segment', 'run', (node) => {
-    const path = node.path;
-    const system = node.system;
-    return [
-        { id: 'start', position: path[0], direction: [-1, 0, 0], diameter: 6, system },
-        {
-            id: 'end',
-            position: path[path.length - 1],
-            direction: [1, 0, 0],
-            diameter: 6,
-            system,
-        },
-    ];
-});
-stubDef('hvac-equipment', 'equipment', (node) => {
-    const position = node.position;
-    return [{ id: 'supply', position, direction: [0, 1, 0], diameter: 12, system: 'supply' }];
-});
-stubDef('duct-terminal', 'terminal', (node) => {
-    const position = node.position;
-    return [{ id: 'collar', position, direction: [0, -1, 0], diameter: 6, system: 'supply' }];
-});
-let nextId = 0;
-function makeNode(type, fields) {
-    nextId += 1;
-    return { id: `${type}_${nextId}`, type, object: 'node', parentId: null, ...fields };
-}
-function sceneOf(...nodes) {
-    return Object.fromEntries(nodes.map((n) => [n.id, n]));
-}
-function run(path, system = 'supply') {
-    return makeNode('duct-segment', { path, system, diameter: 6 });
-}
-describe('buildPortComponents', () => {
-    test('chained runs land in one component; a distant run is separate', () => {
-        const a = run([
-            [0, 0, 0],
-            [3, 0, 0],
-        ]);
-        const b = run([
-            [3, 0, 0],
-            [3, 0, 4],
-        ]); // shares a's end
-        const c = run([
-            [20, 0, 0],
-            [24, 0, 0],
-        ]); // far away
-        const components = buildPortComponents(sceneOf(a, b, c));
-        expect(components.length).toBe(2);
-        const joined = components.find((g) => g.length === 2);
-        expect(new Set(joined)).toEqual(new Set([a.id, b.id]));
-    });
-    test('joints within tolerance still join; outside do not', () => {
-        const a = run([
-            [0, 0, 0],
-            [3, 0, 0],
-        ]);
-        const near = run([
-            [3.03, 0, 0],
-            [6, 0, 0],
-        ]); // 3 cm — joined
-        const far = run([
-            [3.2, 0, 4],
-            [6, 0, 4],
-        ]); // 20 cm in another row — separate
-        const components = buildPortComponents(sceneOf(a, near, far));
-        expect(components.length).toBe(2);
-    });
-    test('nodes without ports do not participate', () => {
-        const wall = makeNode('wall', {});
-        const a = run([
-            [0, 0, 0],
-            [3, 0, 0],
-        ]);
-        const components = buildPortComponents(sceneOf(wall, a));
-        expect(components.length).toBe(1);
-        expect(components[0]).toEqual([a.id]);
-    });
-});
-describe('summarizeSystemFor', () => {
-    test('full tree: equipment → run → terminal, stats add up', () => {
-        const furnace = makeNode('hvac-equipment', { position: [0, 0, 0] });
-        const trunk = run([
-            [0, 0, 0],
-            [4, 0, 0],
-        ]);
-        const branch = run([
-            [4, 0, 0],
-            [4, 0, 3],
-        ]);
-        const register = makeNode('duct-terminal', {
-            position: [4, 0, 3],
-            terminalType: 'supply-register',
-        });
-        const scene = sceneOf(furnace, trunk, branch, register);
-        const summary = summarizeSystemFor(register.id, scene);
-        expect(summary.nodeIds.length).toBe(4);
-        expect(summary.connectedToEquipment).toBe(true);
-        expect(summary.runCount).toBe(2);
-        expect(summary.runLengthM).toBeCloseTo(7, 6);
-        expect(summary.terminalCount).toBe(1);
-        expect(summary.equipmentCount).toBe(1);
-        expect(summary.systems).toEqual(['supply']);
-    });
-    test('orphaned run reports no equipment', () => {
-        const lonely = run([
-            [10, 0, 10],
-            [14, 0, 10],
-        ]);
-        const summary = summarizeSystemFor(lonely.id, sceneOf(lonely));
-        expect(summary.connectedToEquipment).toBe(false);
-        expect(summary.runCount).toBe(1);
-        expect(summary.runLengthM).toBeCloseTo(4, 6);
-    });
-    test('port-less node → null', () => {
-        const wall = makeNode('wall', {});
-        expect(summarizeSystemFor(wall.id, sceneOf(wall))).toBeNull();
-    });
-});

package/dist/services/validate-dwv.test.d.ts

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

package/dist/services/validate-dwv.test.d.ts.map

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

package/dist/services/validate-dwv.test.js

@@ -1,109 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { registerNode } from '../registry';
-import { validateDwv } from './validate-dwv';
-// The validator reads node fields directly + buildPortComponents (which
-// consults def.ports), so register stub port-providers for the DWV kinds
-// it groups by. Mirrors the system-graph test's approach.
-function stubDef(kind, ports) {
-    registerNode({
-        kind,
-        schemaVersion: 1,
-        schema: {},
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities: {},
-        ports,
-    });
-}
-stubDef('pipe-segment', (node) => {
-    const path = node.path;
-    const diameter = node.diameter;
-    const system = node.system;
-    return [
-        { id: 'start', position: path[0], direction: [-1, 0, 0], diameter, system },
-        {
-            id: 'end',
-            position: path[path.length - 1],
-            direction: [1, 0, 0],
-            diameter,
-            system,
-        },
-    ];
-});
-stubDef('pipe-trap', (node) => {
-    const position = node.position;
-    return [{ id: 'inlet', position, direction: [0, 1, 0], diameter: 1.5, system: 'waste' }];
-});
-let nextId = 0;
-function makeNode(type, fields) {
-    nextId += 1;
-    return { id: `${type}_${nextId}`, type, object: 'node', parentId: null, ...fields };
-}
-function sceneOf(...nodes) {
-    return Object.fromEntries(nodes.map((n) => [n.id, n]));
-}
-/** A waste run from a→b. Drop the end Y to slope it. */
-function waste(path, diameter = 2) {
-    return makeNode('pipe-segment', { path, diameter, system: 'waste' });
-}
-const QUARTER_PER_FOOT = 1 / 48;
-describe('validateDwv — slope', () => {
-    test('flags a flat waste run', () => {
-        const run = waste([
-            [0, 0, 0],
-            [3, 0, 0], // dead level
-        ]);
-        const findings = validateDwv(sceneOf(run));
-        expect(findings.some((f) => f.code === 'slope-too-flat')).toBe(true);
-    });
-    test('passes a run sloped at quarter-inch per foot', () => {
-        const drop = 3 * QUARTER_PER_FOOT;
-        const run = waste([
-            [0, 0, 0],
-            [3, -drop, 0],
-        ]);
-        const findings = validateDwv(sceneOf(run));
-        expect(findings.some((f) => f.code === 'slope-too-flat')).toBe(false);
-    });
-    test('flags an over-steep run (siphoning risk)', () => {
-        // 2" pipe, max slope = 2/12 ≈ 0.167; drop 2m over 1m horizontal.
-        const run = waste([
-            [0, 0, 0],
-            [1, -2, 0],
-        ]);
-        const findings = validateDwv(sceneOf(run));
-        expect(findings.some((f) => f.code === 'slope-too-steep')).toBe(true);
-    });
-    test('ignores vents (level is fine)', () => {
-        const vent = makeNode('pipe-segment', {
-            path: [
-                [0, 0, 0],
-                [0, 3, 0],
-            ],
-            diameter: 2,
-            system: 'vent',
-        });
-        const findings = validateDwv(sceneOf(vent));
-        expect(findings.length).toBe(0);
-    });
-});
-describe('validateDwv — trap arm', () => {
-    test('flags an over-long trap arm', () => {
-        const trap = makeNode('pipe-trap', {
-            position: [0, 0, 0],
-            diameter: 1.5, // max arm 42in = 1.067m
-            armLengthM: 2, // way over
-        });
-        const findings = validateDwv(sceneOf(trap));
-        expect(findings.some((f) => f.code === 'trap-arm-too-long')).toBe(true);
-    });
-    test('passes a trap arm within the limit', () => {
-        const trap = makeNode('pipe-trap', {
-            position: [0, 0, 0],
-            diameter: 2, // max arm 60in = 1.524m
-            armLengthM: 1,
-        });
-        const findings = validateDwv(sceneOf(trap));
-        expect(findings.some((f) => f.code === 'trap-arm-too-long')).toBe(false);
-    });
-});

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