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

package/dist/services/opening-guides.test.js

@@ -1,208 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { computeEdgeGaps, computeOpeningGuides, detectAlongWallAlignment, detectEqualSpacing, detectVerticalAlignment, } from './opening-guides';
-function span(id, centerS, width, centerY = 1, height = 1) {
-    return { id, centerS, width, centerY, height };
-}
-const WALL = { length: 10, height: 2.5 };
-describe('detectEqualSpacing', () => {
-    test('returns null for fewer than three openings', () => {
-        const a = span('a', 0.5, 1);
-        const b = span('b', 2.5, 1);
-        expect(detectEqualSpacing([a, b], 'b', 0.03, 0.02)).toBeNull();
-    });
-    test('detects a run of equal gaps across three openings', () => {
-        // width 1 each: a[0,1] b[2,3] c[4,5] → two gaps of 1m.
-        const a = span('a', 0.5, 1);
-        const b = span('b', 2.5, 1);
-        const c = span('c', 4.5, 1);
-        const run = detectEqualSpacing([a, b, c], 'b', 0.03, 0.02);
-        expect(run).not.toBeNull();
-        expect(run?.gap).toBeCloseTo(1);
-        expect(run?.segments).toHaveLength(2);
-        expect(run?.openingIds).toEqual(['a', 'b', 'c']);
-        expect(run?.segments[0]).toEqual({ fromS: 1, toS: 2 });
-        expect(run?.segments[1]).toEqual({ fromS: 3, toS: 4 });
-    });
-    test('extends a run across four openings (three gaps)', () => {
-        const openings = [span('a', 0.5, 1), span('b', 2.5, 1), span('c', 4.5, 1), span('d', 6.5, 1)];
-        const run = detectEqualSpacing(openings, 'c', 0.03, 0.02);
-        expect(run?.segments).toHaveLength(3);
-        expect(run?.openingIds).toEqual(['a', 'b', 'c', 'd']);
-    });
-    test('returns null when gaps differ beyond tolerance', () => {
-        const a = span('a', 0.5, 1); // [0,1]
-        const b = span('b', 2.5, 1); // [2,3] → gap 1
-        const c = span('c', 5, 1); //   [4.5,5.5] → gap 1.5
-        expect(detectEqualSpacing([a, b, c], 'b', 0.03, 0.02)).toBeNull();
-    });
-    test('returns null when the moving opening is not part of the equal run', () => {
-        const a = span('a', 0.5, 1);
-        const b = span('b', 2.5, 1);
-        const c = span('c', 4.5, 1); // a,b,c form equal gaps of 1
-        const d = span('d', 10, 1); // far right, breaks the run
-        expect(detectEqualSpacing([a, b, c, d], 'd', 0.03, 0.02)).toBeNull();
-    });
-    test('a near-zero (touching) gap breaks a run', () => {
-        const a = span('a', 0.5, 1); // [0,1]
-        const b = span('b', 1.505, 1); // [1.005,2.005] → gap 0.005 < minGap
-        const c = span('c', 3.005, 1); // [2.505,3.505] → gap 0.5
-        expect(detectEqualSpacing([a, b, c], 'b', 0.03, 0.02)).toBeNull();
-    });
-    test('honours the equal-spacing tolerance', () => {
-        const a = span('a', 0.5, 1); // [0,1]
-        const b = span('b', 2.5, 1); // [2,3] → gap 1.0
-        const c = span('c', 4.52, 1); // [4.02,5.02] → gap 1.02
-        expect(detectEqualSpacing([a, b, c], 'b', 0.03, 0.02)?.segments).toHaveLength(2);
-        expect(detectEqualSpacing([a, b, c], 'b', 0.01, 0.02)).toBeNull();
-    });
-});
-describe('computeEdgeGaps', () => {
-    test('measures clearance to the nearest neighbour on each side', () => {
-        const moving = span('m', 5, 1); // [4.5,5.5]
-        const left = span('l', 2, 1); // [1.5,2.5]
-        const right = span('r', 8, 1); // [7.5,8.5]
-        const gaps = computeEdgeGaps(moving, [left, right], WALL, 0.02);
-        const byside = Object.fromEntries(gaps.map((g) => [g.side, g]));
-        expect(byside.left?.distance).toBeCloseTo(2);
-        expect(byside.left?.target).toBe('opening');
-        expect(byside.left?.targetId).toBe('l');
-        expect(byside.right?.distance).toBeCloseTo(2);
-        expect(byside.right?.targetId).toBe('r');
-    });
-    test('falls back to wall ends with no neighbour', () => {
-        const moving = span('m', 5, 1); // [4.5,5.5]
-        const gaps = computeEdgeGaps(moving, [], WALL, 0.02);
-        const byside = Object.fromEntries(gaps.map((g) => [g.side, g]));
-        expect(byside.left?.target).toBe('wall-start');
-        expect(byside.left?.distance).toBeCloseTo(4.5);
-        expect(byside.right?.target).toBe('wall-end');
-        expect(byside.right?.distance).toBeCloseTo(4.5);
-    });
-    test('omits a side that is flush / overlapping (below minGap)', () => {
-        const moving = span('m', 5, 1); // [4.5,5.5]
-        const flush = span('l', 4, 1); // [3.5,4.5] right edge touches moving left
-        const gaps = computeEdgeGaps(moving, [flush], WALL, 0.02);
-        expect(gaps.find((g) => g.side === 'left')).toBeUndefined();
-        expect(gaps.find((g) => g.side === 'right')?.target).toBe('wall-end');
-    });
-});
-describe('detectAlongWallAlignment', () => {
-    test('detects edge-to-edge alignment within tolerance', () => {
-        const moving = span('m', 5, 2); // [4,6]
-        const sib = span('s', 7.05, 2); // left edge 6.05
-        const a = detectAlongWallAlignment(moving, [sib], 0.08);
-        expect(a?.movingFeature).toBe('right');
-        expect(a?.targetFeature).toBe('left');
-        expect(a?.snap).toBeCloseTo(0.05);
-        expect(a?.s).toBeCloseTo(6.05);
-    });
-    test('detects centre alignment', () => {
-        const moving = span('m', 5, 2);
-        const sib = span('s', 5.03, 0.5); // centre 5.03, edges far from moving edges
-        const a = detectAlongWallAlignment(moving, [sib], 0.08);
-        expect(a?.movingFeature).toBe('center');
-        expect(a?.targetFeature).toBe('center');
-        expect(a?.snap).toBeCloseTo(0.03);
-    });
-    test('returns null when nothing is within tolerance', () => {
-        const moving = span('m', 5, 2);
-        const sib = span('s', 9, 2);
-        expect(detectAlongWallAlignment(moving, [sib], 0.08)).toBeNull();
-    });
-});
-describe('detectVerticalAlignment', () => {
-    test('detects a shared sill within tolerance', () => {
-        const moving = span('m', 5, 1, 1.5, 1); // sill 1.0
-        const sib = span('s', 8, 1, 2.04, 2); // sill 1.04
-        const a = detectVerticalAlignment(moving, [sib], 0.08);
-        expect(a?.movingFeature).toBe('sill');
-        expect(a?.targetFeature).toBe('sill');
-        expect(a?.snap).toBeCloseTo(0.04);
-        expect(a?.y).toBeCloseTo(1.04);
-    });
-    test('returns null when sills/tops differ beyond tolerance', () => {
-        const moving = span('m', 5, 1, 1.5, 1); // sill 1, top 2, centre 1.5
-        const sib = span('s', 8, 1, 0.4, 0.4); // sill 0.2, top 0.6, centre 0.4
-        expect(detectVerticalAlignment(moving, [sib], 0.08)).toBeNull();
-    });
-});
-describe('computeOpeningGuides', () => {
-    test('includes sill/head for windows', () => {
-        const moving = span('m', 5, 1, 1.5, 1); // bottom 1, top 2
-        const guides = computeOpeningGuides({
-            moving,
-            siblings: [],
-            wall: WALL,
-            includeVertical: true,
-        });
-        expect(guides.sillHead?.sill).toBeCloseTo(1);
-        expect(guides.sillHead?.head).toBeCloseTo(0.5); // 2.5 - 2
-        expect(guides.sillHead?.bottomY).toBeCloseTo(1);
-        expect(guides.sillHead?.topY).toBeCloseTo(2);
-    });
-    test('omits vertical guides for doors (sit on the floor)', () => {
-        const moving = span('m', 5, 1, 1, 2);
-        const sib = span('s', 8, 1, 1, 2);
-        const guides = computeOpeningGuides({
-            moving,
-            siblings: [sib],
-            wall: WALL,
-            includeVertical: false,
-        });
-        expect(guides.sillHead).toBeNull();
-        expect(guides.vertical).toBeNull();
-        // along-wall + proximity still computed for doors
-        expect(guides.gaps.length).toBeGreaterThan(0);
-    });
-    test('combines proximity and equal-spacing in one pass', () => {
-        const moving = span('b', 2.5, 1);
-        const guides = computeOpeningGuides({
-            moving,
-            siblings: [span('a', 0.5, 1), span('c', 4.5, 1)],
-            wall: WALL,
-            includeVertical: true,
-        });
-        expect(guides.gaps).toHaveLength(2);
-        expect(guides.equalSpacing?.gap).toBeCloseTo(1);
-        expect(guides.equalSpacing?.openingIds).toEqual(['a', 'b', 'c']);
-    });
-});
-describe('opening-guides — review regressions', () => {
-    test('detectEqualSpacing finds a run that starts partway through a drifting sequence', () => {
-        // gaps 1.00, 1.02, 1.04 — only [b,c,d] is equal within 0.03 and includes the
-        // moving opening; a first-gap-anchored greedy scan used to drop it.
-        const openings = [span('a', 0.5, 1), span('b', 2.5, 1), span('c', 4.52, 1), span('d', 6.56, 1)];
-        const run = detectEqualSpacing(openings, 'd', 0.03, 0.02);
-        expect(run?.openingIds).toEqual(['b', 'c', 'd']);
-        expect(run?.gap).toBeCloseTo(1.03);
-        expect(run?.segments).toHaveLength(2);
-    });
-    test('detectEqualSpacing prefers the leftmost run on a length tie', () => {
-        // gaps 1,1,2,2 with the moving opening in the middle — two equal-length runs.
-        const openings = [
-            span('a', 0.5, 1),
-            span('b', 2.5, 1),
-            span('c', 4.5, 1),
-            span('d', 7.5, 1),
-            span('e', 10.5, 1),
-        ];
-        expect(detectEqualSpacing(openings, 'c', 0.03, 0.02)?.openingIds).toEqual(['a', 'b', 'c']);
-    });
-    test('computeEdgeGaps suppresses both sides when a sibling overlaps', () => {
-        const moving = span('m', 5, 1); // [4.5,5.5]
-        const containing = span('s', 5, 2); // [4,6] straddles both edges
-        expect(computeEdgeGaps(moving, [containing], WALL, 0.02)).toEqual([]);
-    });
-    test('alignment detectors ignore the moving opening if present in siblings', () => {
-        const moving = span('m', 5, 2, 1.5, 1);
-        expect(detectAlongWallAlignment(moving, [moving], 0.08)).toBeNull();
-        expect(detectVerticalAlignment(moving, [moving], 0.08)).toBeNull();
-    });
-    test('detectAlongWallAlignment reports a negative snap when the feature is past the target', () => {
-        const moving = span('m', 5, 2); // centre 5
-        const sib = span('s', 4.96, 0.5); // centre 4.96
-        const a = detectAlongWallAlignment(moving, [sib], 0.08);
-        expect(a?.movingFeature).toBe('center');
-        expect(a?.snap).toBeCloseTo(-0.04);
-    });
-});

package/dist/services/port-connectivity.test.d.ts

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

package/dist/services/port-connectivity.test.d.ts.map

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

package/dist/services/port-connectivity.test.js

@@ -1,297 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { registerNode } from '../registry';
-import { analyzePortConnectivity, resolveConnectivityUpdates } from './port-connectivity';
-// Stub registrations mirroring the real kinds' port + role conventions
-// without importing the nodes package (which pulls in CSG and can't load
-// under the test runner). A run exposes start/end at its path tips; the
-// fitting here is a simple two-collar elbow at ±X around its position.
-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('duct-fitting', 'fitting', (node) => {
-    const position = node.position;
-    const system = node.system;
-    return [
-        {
-            id: 'inlet',
-            position: [position[0] - 0.2, position[1], position[2]],
-            direction: [-1, 0, 0],
-            diameter: 6,
-            system,
-        },
-        {
-            id: 'outlet',
-            position: [position[0] + 0.2, position[1], position[2]],
-            direction: [1, 0, 0],
-            diameter: 6,
-            system,
-        },
-    ];
-});
-stubDef('duct-tee', 'fitting', (node) => {
-    const position = node.position;
-    const system = node.system;
-    return [
-        {
-            id: 'inlet',
-            position: [position[0] - 0.2, position[1], position[2]],
-            direction: [-1, 0, 0],
-            diameter: 6,
-            system,
-        },
-        {
-            id: 'outlet',
-            position: [position[0] + 0.2, position[1], position[2]],
-            direction: [1, 0, 0],
-            diameter: 6,
-            system,
-        },
-        {
-            id: 'branch',
-            position: [position[0], position[1], position[2] + 0.2],
-            direction: [0, 0, 1],
-            diameter: 6,
-            system,
-        },
-    ];
-});
-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 expectPointClose(actual, expected) {
-    expect(actual[0]).toBeCloseTo(expected[0], 6);
-    expect(actual[1]).toBeCloseTo(expected[1], 6);
-    expect(actual[2]).toBeCloseTo(expected[2], 6);
-}
-describe('port connectivity — joint follow (stretch vs translate)', () => {
-    // Layout: duct A ends at the fitting's inlet (−0.2,0,0); duct B starts at the
-    // fitting's outlet (+0.2,0,0). Both runs lie on the X axis. Dragging A's
-    // mated endpoint carries the fitting and duct B; how B reacts depends on
-    // whether the drag is along its axis (stretch) or across it (translate).
-    function joint() {
-        const fitting = makeNode('duct-fitting', { position: [0, 0, 0], system: 'supply' });
-        const ductA = makeNode('duct-segment', {
-            path: [
-                [-3, 0, 0],
-                [-0.2, 0, 0],
-            ],
-            system: 'supply',
-        });
-        const ductB = makeNode('duct-segment', {
-            path: [
-                [0.2, 0, 0],
-                [3, 0, 0],
-            ],
-            system: 'supply',
-        });
-        return { fitting, ductA, ductB };
-    }
-    function movedA(end) {
-        const { ductA } = joint();
-        return { ...ductA, path: [[-3, 0, 0], end] };
-    }
-    test('the fitting and sibling run are picked up as carried connections', () => {
-        const { fitting, ductA, ductB } = joint();
-        const connectivity = analyzePortConnectivity(ductA, sceneOf(fitting, ductA, ductB));
-        expect(connectivity.connections.find((c) => c.kind === 'rigid-node' && c.nodeId === fitting.id)).toBeDefined();
-        expect(connectivity.connections.find((c) => c.kind === 'run' && c.nodeId === ductB.id)).toBeDefined();
-    });
-    test('perpendicular drag translates the WHOLE sibling run (no skew)', () => {
-        const { fitting, ductA, ductB } = joint();
-        const nodes = sceneOf(fitting, ductA, ductB);
-        const connectivity = analyzePortConnectivity(ductA, nodes);
-        // Move A's mated end +1 in Z — perpendicular to B's X axis.
-        const updates = resolveConnectivityUpdates(connectivity, movedA([-0.2, 0, 1]));
-        expect(updates.find((u) => u.id === fitting.id).data.position).toEqual([0, 0, 1]);
-        const bPath = updates.find((u) => u.id === ductB.id).data.path;
-        // Both ends ride +1 in Z: the run keeps its length and direction.
-        expect(bPath[0]).toEqual([0.2, 0, 1]);
-        expect(bPath[1]).toEqual([3, 0, 1]);
-    });
-    test('parallel drag stretches the sibling run (only the near end slides)', () => {
-        const { fitting, ductA, ductB } = joint();
-        const nodes = sceneOf(fitting, ductA, ductB);
-        const connectivity = analyzePortConnectivity(ductA, nodes);
-        // Move A's mated end +0.5 in X — along B's axis (the fitting slides toward B).
-        const updates = resolveConnectivityUpdates(connectivity, movedA([0.3, 0, 0]));
-        const bPath = updates.find((u) => u.id === ductB.id).data.path;
-        // Near end slid +0.5 in X; far end stayed put → the run shortened.
-        expect(bPath[0]).toEqual([0.7, 0, 0]);
-        expect(bPath[1]).toEqual([3, 0, 0]);
-    });
-    test('perpendicular slide propagates through the sibling run to its far joint', () => {
-        // Extend the chain: duct B's far end (3,0,0) meets a second elbow, and duct
-        // C hangs off that elbow. A perpendicular drag should carry the whole chain.
-        const { fitting, ductA, ductB } = joint();
-        const elbow2 = makeNode('duct-fitting', { position: [3.2, 0, 0], system: 'supply' });
-        // elbow ports are ±0.2 on X around its position → inlet at (3,0,0) meets B.
-        const ductC = makeNode('duct-segment', {
-            path: [
-                [3.4, 0, 0],
-                [6, 0, 0],
-            ],
-            system: 'supply',
-        });
-        const nodes = sceneOf(fitting, ductA, ductB, elbow2, ductC);
-        const connectivity = analyzePortConnectivity(ductA, nodes);
-        const updates = resolveConnectivityUpdates(connectivity, movedA([-0.2, 0, 1]));
-        // Whole chain rode +1 in Z.
-        const bPath = updates.find((u) => u.id === ductB.id).data.path;
-        expect(bPath[1]).toEqual([3, 0, 1]);
-        expect(updates.find((u) => u.id === elbow2.id).data.position).toEqual([3.2, 0, 1]);
-        const cPath = updates.find((u) => u.id === ductC.id).data.path;
-        expect(cPath[0]).toEqual([3.4, 0, 1]);
-        expect(cPath[1]).toEqual([6, 0, 1]);
-    });
-    test('a run reached from both ends applies both endpoint deltas', () => {
-        const moved = makeNode('duct-segment', {
-            path: [
-                [0, 0, 0],
-                [3, 0, 0],
-            ],
-            system: 'supply',
-        });
-        const follower = makeNode('duct-segment', {
-            path: [
-                [0, 0, 0],
-                [3, 0, 0],
-            ],
-            system: 'supply',
-        });
-        const nodes = sceneOf(moved, follower);
-        const connectivity = analyzePortConnectivity(moved, nodes);
-        const preview = {
-            ...moved,
-            path: [
-                [0, 0, 1],
-                [3, 0, 2],
-            ],
-        };
-        const updates = resolveConnectivityUpdates(connectivity, preview);
-        const path = updates.find((u) => u.id === follower.id).data.path;
-        expect(path[0]).toEqual([0, 0, 1]);
-        expect(path[1]).toEqual([3, 0, 2]);
-    });
-    test('a polyline run reached from both ends preserves interior bend shape', () => {
-        const moved = makeNode('duct-segment', {
-            path: [
-                [0, 0, 0],
-                [3, 0, 3],
-            ],
-            system: 'supply',
-        });
-        const follower = makeNode('duct-segment', {
-            path: [
-                [0, 0, 0],
-                [1, 0, 0],
-                [1, 0, 3],
-                [3, 0, 3],
-            ],
-            system: 'supply',
-        });
-        const nodes = sceneOf(moved, follower);
-        const connectivity = analyzePortConnectivity(moved, nodes);
-        const preview = {
-            ...moved,
-            path: [
-                [-0.5, 0, 0],
-                [3.5, 0, 3],
-            ],
-        };
-        const updates = resolveConnectivityUpdates(connectivity, preview);
-        const path = updates.find((u) => u.id === follower.id).data.path;
-        expect(path).toEqual([
-            [-0.5, 0, 0],
-            [1, 0, 0],
-            [1, 0, 3],
-            [3.5, 0, 3],
-        ]);
-    });
-    test('a fitting reached from both collars rebroadcasts its final compatible rigid delta', () => {
-        const moved = makeNode('duct-segment', {
-            path: [
-                [-0.2, 0, 0],
-                [0.2, 0, 0],
-            ],
-            system: 'supply',
-        });
-        const fitting = makeNode('duct-tee', { position: [0, 0, 0], system: 'supply' });
-        const downstream = makeNode('duct-segment', {
-            path: [
-                [0, 0, 0.2],
-                [3, 0, 0.2],
-            ],
-            system: 'supply',
-        });
-        const nodes = sceneOf(moved, fitting, downstream);
-        const connectivity = analyzePortConnectivity(moved, nodes);
-        const preview = {
-            ...moved,
-            path: [
-                [-0.2, 0, 1],
-                [0.2, 0, 1.00005],
-            ],
-        };
-        const updates = resolveConnectivityUpdates(connectivity, preview);
-        expectPointClose(updates.find((u) => u.id === fitting.id).data.position, [0, 0, 1.000025]);
-        const path = updates.find((u) => u.id === downstream.id).data.path;
-        expectPointClose(path[0], [0, 0, 1.200025]);
-        expectPointClose(path[1], [3, 0, 1.200025]);
-    });
-    test('a fitting reached from incompatible collars merges constraints deterministically', () => {
-        const moved = makeNode('duct-segment', {
-            path: [
-                [-0.2, 0, 0],
-                [0.2, 0, 0],
-            ],
-            system: 'supply',
-        });
-        const fitting = makeNode('duct-fitting', { position: [0, 0, 0], system: 'supply' });
-        const nodes = sceneOf(moved, fitting);
-        const connectivity = analyzePortConnectivity(moved, nodes);
-        const preview = {
-            ...moved,
-            path: [
-                [-0.2, 0, 1],
-                [0.2, 0, -1],
-            ],
-        };
-        const updates = resolveConnectivityUpdates(connectivity, preview);
-        expectPointClose(updates.find((u) => u.id === fitting.id).data.position, [0, 0, 0]);
-    });
-    test('an unrelated run not on the fitting is left alone', () => {
-        const { fitting, ductA, ductB } = joint();
-        const distant = makeNode('duct-segment', {
-            path: [
-                [10, 0, 0],
-                [13, 0, 0],
-            ],
-            system: 'supply',
-        });
-        const nodes = sceneOf(fitting, ductA, ductB, distant);
-        const connectivity = analyzePortConnectivity(ductA, nodes);
-        expect(connectivity.connections.find((c) => c.nodeId === distant.id)).toBeUndefined();
-    });
-});

package/dist/services/riser-diagram.test.d.ts

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

package/dist/services/riser-diagram.test.d.ts.map

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

package/dist/services/riser-diagram.test.js

@@ -1,66 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { buildRiserDiagram, projectIso } from './riser-diagram';
-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]));
-}
-describe('projectIso', () => {
-    test('higher elevation maps to smaller screen Y', () => {
-        const [, lowY] = projectIso(0, 0, 0);
-        const [, highY] = projectIso(0, 2, 0);
-        expect(highY).toBeLessThan(lowY);
-    });
-});
-describe('buildRiserDiagram', () => {
-    test('null when no DWV nodes', () => {
-        const wall = makeNode('wall', {});
-        expect(buildRiserDiagram(sceneOf(wall))).toBeNull();
-    });
-    test('classifies a vertical stack vs a sloped horizontal drain', () => {
-        const stack = makeNode('pipe-segment', {
-            path: [
-                [0, 0, 0],
-                [0, 3, 0],
-            ],
-            diameter: 3,
-            system: 'vent',
-        });
-        const drain = makeNode('pipe-segment', {
-            path: [
-                [0, 0, 0],
-                [3, -0.06, 0],
-            ],
-            diameter: 2,
-            system: 'waste',
-        });
-        const diagram = buildRiserDiagram(sceneOf(stack, drain));
-        const stackLine = diagram.lines.find((l) => l.nodeId === stack.id);
-        const drainLine = diagram.lines.find((l) => l.nodeId === drain.id);
-        expect(stackLine.vertical).toBe(true);
-        expect(drainLine.vertical).toBe(false);
-    });
-    test('emits a vent-termination marker for a vent run', () => {
-        const vent = makeNode('pipe-segment', {
-            path: [
-                [0, 0, 0],
-                [0, 3, 0],
-            ],
-            diameter: 2,
-            system: 'vent',
-        });
-        const diagram = buildRiserDiagram(sceneOf(vent));
-        expect(diagram.markers.some((m) => m.kind === 'vent-termination')).toBe(true);
-    });
-    test('labels traps', () => {
-        const trap = makeNode('pipe-trap', {
-            position: [1, 0, 0],
-            diameter: 1.5,
-        });
-        const diagram = buildRiserDiagram(sceneOf(trap));
-        expect(diagram.markers.some((m) => m.kind === 'trap')).toBe(true);
-    });
-});

package/dist/services/single-undo-dance.test.d.ts

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

package/dist/services/single-undo-dance.test.d.ts.map

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