@pascal-app/core 0.9.1 → 0.9.2

package/dist/services/riser-diagram.js

@@ -0,0 +1,110 @@
+/**
+ * Riser diagram (plumbing isometric) — the conventional way DWV systems
+ * are drawn for permit: the drain/vent tree projected to a 30° iso so
+ * vertical stacks read as vertical and horizontal runs lean off at 30°,
+ * annotated with size + slope and vent terminations.
+ *
+ * This is a pure projector: it turns the scene's DWV nodes into 2D
+ * drawables (level-independent, no rendering). The editor draws the
+ * result as SVG. Air/refrigerant nodes are ignored — riser diagrams are
+ * a plumbing convention.
+ */
+const COS30 = Math.cos(Math.PI / 6);
+const SIN30 = Math.sin(Math.PI / 6);
+/** A 3D level-local point (meters) projected to 2D iso screen space.
+ *  Screen Y grows DOWNWARD (SVG convention), so higher elevation → lower
+ *  screen Y. */
+export function projectIso(x, y, z) {
+    const sx = (x - z) * COS30;
+    const sy = (x + z) * SIN30 - y;
+    return [sx, sy];
+}
+/** Elevation gain per horizontal meter under which a leg is "vertical". */
+const VERTICAL_EPS = 4; // dy/dxz ratio: steeper than this reads as a stack
+function legIsVertical(a, b) {
+    const horizontal = Math.hypot(b[0] - a[0], b[2] - a[2]);
+    const vertical = Math.abs(b[1] - a[1]);
+    if (horizontal < 1e-4)
+        return true;
+    return vertical / horizontal > VERTICAL_EPS;
+}
+/**
+ * Build the riser diagram for the whole scene. Returns null when there's
+ * no DWV geometry to draw.
+ */
+export function buildRiserDiagram(nodes) {
+    const lines = [];
+    const markers = [];
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const grow = (p) => {
+        if (p[0] < minX)
+            minX = p[0];
+        if (p[1] < minY)
+            minY = p[1];
+        if (p[0] > maxX)
+            maxX = p[0];
+        if (p[1] > maxY)
+            maxY = p[1];
+    };
+    for (const node of Object.values(nodes)) {
+        if (!node)
+            continue;
+        if (node.type === 'pipe-segment') {
+            const path = node.path;
+            for (let i = 0; i < path.length - 1; i++) {
+                const a = path[i];
+                const b = path[i + 1];
+                const from = projectIso(a[0], a[1], a[2]);
+                const to = projectIso(b[0], b[1], b[2]);
+                grow(from);
+                grow(to);
+                lines.push({
+                    from,
+                    to,
+                    system: node.system,
+                    diameter: node.diameter,
+                    vertical: legIsVertical(a, b),
+                    nodeId: node.id,
+                });
+            }
+            // Vent runs that end above everything are vent terminations
+            // (through-roof). Tag the highest endpoint of a vent run.
+            if (node.system === 'vent') {
+                const top = path.reduce((hi, p) => (p[1] > hi[1] ? p : hi), path[0]);
+                const pt = projectIso(top[0], top[1], top[2]);
+                markers.push({
+                    point: pt,
+                    kind: 'vent-termination',
+                    label: `${node.diameter}" VTR`,
+                    nodeId: node.id,
+                });
+            }
+        }
+        else if (node.type === 'pipe-trap') {
+            const pt = projectIso(node.position[0], node.position[1], node.position[2]);
+            grow(pt);
+            markers.push({
+                point: pt,
+                kind: 'trap',
+                label: `${node.diameter}" P-trap`,
+                nodeId: node.id,
+            });
+        }
+        else if (node.type === 'pipe-fitting') {
+            const pt = projectIso(node.position[0], node.position[1], node.position[2]);
+            grow(pt);
+            markers.push({
+                point: pt,
+                kind: 'fitting',
+                label: node.fittingType,
+                nodeId: node.id,
+            });
+        }
+    }
+    if (lines.length === 0 && markers.length === 0)
+        return null;
+    return { lines, markers, bounds: { minX, minY, maxX, maxY } };
+}

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

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

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

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

@@ -0,0 +1,66 @@
+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/snap.d.ts

@@ -12,7 +12,7 @@ export type Vec2 = readonly [number, number];
 export type Vec3 = readonly [number, number, number];
 /** Default planar grid spacing in meters. Matches the editor's wall tool. */
 export declare const DEFAULT_GRID_STEP = 0.25;
-/** Default angle-snap step — π/12 = 15°. Wall tools also use π/4 (45°). */
+/** Default angle-snap step — π/12 = 15°. */
 export declare const DEFAULT_ANGLE_STEP: number;
 /** Snaps a single scalar to the nearest multiple of `step`. */
 export declare function snapScalar(value: number, step?: number): number;
@@ -45,6 +45,14 @@ export declare function snapWorldXZToBuildingLocal(worldX: number, worldZ: numbe
  * — keeps endpoints landing on grid intersections.
  */
 export declare function snapPointToAngle(from: Vec2, cursor: Vec2, angleStep?: number, gridStep?: number): Vec2;
+/**
+ * Snaps a cursor point onto the nearest angle ray from `from` (multiples of
+ * `angleStep`), projecting the cursor onto that ray, then snaps the distance
+ * ALONG the ray to `distanceStep`. Unlike `snapPointToAngle` with a
+ * `gridStep`, the result stays exactly on the snapped ray — grid-snapping
+ * after the angle projection pulls points off non-axis rays.
+ */
+export declare function snapPointAlongAngleRay(from: Vec2, cursor: Vec2, angleStep?: number, distanceStep?: number): Vec2;
 /**
  * Snaps an angle (in radians) to the nearest entry in `snapAngles` (also in
  * radians). Returns the original angle if no entry is within `toleranceRad`.

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

@@ -1 +1 @@
-{"version":3,"file":"snap.d.ts","sourceRoot":"","sources":["../../src/services/snap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC5C,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpD,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,QAAe,CAAA;AAI9C,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAA0B,GAAG,MAAM,CAGlF;AAED,iDAAiD;AACjD,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAEnF;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAElF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,IAAI,EACtB,iBAAiB,EAAE,MAAM,EACzB,IAAI,GAAE,MAA0B,GAC/B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA2BtD;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,IAAI,EACZ,SAAS,GAAE,MAA2B,EACtC,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAWN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,YAAY,GAAE,MAAqB,GAClC,MAAM,CAcR;AAID;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE;QACJ,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC9C,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACrD,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QACjF,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACtF,CAAA;CACF,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,YAU1B,CAAA"}
+{"version":3,"file":"snap.d.ts","sourceRoot":"","sources":["../../src/services/snap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC5C,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpD,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC,4CAA4C;AAC5C,eAAO,MAAM,kBAAkB,QAAe,CAAA;AAI9C,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAA0B,GAAG,MAAM,CAGlF;AAED,iDAAiD;AACjD,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAEnF;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAElF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,IAAI,EACtB,iBAAiB,EAAE,MAAM,EACzB,IAAI,GAAE,MAA0B,GAC/B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA2BtD;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,IAAI,EACZ,SAAS,GAAE,MAA2B,EACtC,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAWN;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,IAAI,EACZ,SAAS,GAAE,MAA2B,EACtC,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI,CAYN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,YAAY,GAAE,MAAqB,GAClC,MAAM,CAcR;AAID;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE;QACJ,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC9C,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACrD,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QACjF,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACtF,CAAA;CACF,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,YAU1B,CAAA"}

package/dist/services/snap.js

@@ -10,7 +10,7 @@
  */
 /** Default planar grid spacing in meters. Matches the editor's wall tool. */
 export const DEFAULT_GRID_STEP = 0.25;
-/** Default angle-snap step — π/12 = 15°. Wall tools also use π/4 (45°). */
+/** Default angle-snap step — π/12 = 15°. */
 export const DEFAULT_ANGLE_STEP = Math.PI / 12;
 // ─── Grid snap ────────────────────────────────────────────────────────
 /** Snaps a single scalar to the nearest multiple of `step`. */
@@ -88,6 +88,26 @@ export function snapPointToAngle(from, cursor, angleStep = DEFAULT_ANGLE_STEP, g
     ];
     return gridStep == null ? projected : snapPointToGrid(projected, gridStep);
 }
+/**
+ * Snaps a cursor point onto the nearest angle ray from `from` (multiples of
+ * `angleStep`), projecting the cursor onto that ray, then snaps the distance
+ * ALONG the ray to `distanceStep`. Unlike `snapPointToAngle` with a
+ * `gridStep`, the result stays exactly on the snapped ray — grid-snapping
+ * after the angle projection pulls points off non-axis rays.
+ */
+export function snapPointAlongAngleRay(from, cursor, angleStep = DEFAULT_ANGLE_STEP, distanceStep) {
+    const dx = cursor[0] - from[0];
+    const dz = cursor[1] - from[1];
+    if (dx === 0 && dz === 0)
+        return [from[0], from[1]];
+    const angle = Math.atan2(dz, dx);
+    const snappedAngle = angleStep > 0 ? Math.round(angle / angleStep) * angleStep : angle;
+    const dirX = Math.cos(snappedAngle);
+    const dirZ = Math.sin(snappedAngle);
+    const projected = dx * dirX + dz * dirZ;
+    const distance = distanceStep != null && distanceStep > 0 ? snapScalar(projected, distanceStep) : projected;
+    return [from[0] + dirX * distance, from[1] + dirZ * distance];
+}
 /**
  * Snaps an angle (in radians) to the nearest entry in `snapAngles` (also in
  * radians). Returns the original angle if no entry is within `toleranceRad`.

package/dist/services/snap.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { DEFAULT_ANGLE_STEP, DEFAULT_GRID_STEP, snapAngleToList, snapPointToAngle, snapPointToGrid, snapScalar, snapServices, snapVec3ToGrid, } from './snap';
+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);
@@ -65,6 +65,48 @@ describe('snapPointToAngle', () => {
         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];

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

@@ -0,0 +1,30 @@
+import type { AnyNode, AnyNodeId } from '../schema';
+export type SystemSummary = {
+    /** Every node in this connected component. */
+    nodeIds: AnyNodeId[];
+    /** Distribution loops present, e.g. ['supply'], ['supply','return']. */
+    systems: string[];
+    /** Duct / lineset run statistics. */
+    runCount: number;
+    runLengthM: number;
+    fittingCount: number;
+    terminalCount: number;
+    equipmentCount: number;
+    /** False = orphaned subtree: air goes nowhere (no furnace / air
+     *  handler / condenser anywhere in the component). */
+    connectedToEquipment: boolean;
+};
+/**
+ * Group every port-bearing node into connected components via coinciding
+ * ports. Nodes with ports but no joints form singleton components; nodes
+ * without `def.ports` don't participate at all.
+ */
+export declare function buildPortComponents(nodes: Readonly<Record<AnyNodeId, AnyNode>>): AnyNodeId[][];
+/**
+ * Summary of the system the given node belongs to, or null when the node
+ * has no ports (not a distribution kind). A node with ports but no
+ * joints yet still gets a (singleton) summary — `connectedToEquipment:
+ * false` is the interesting signal there.
+ */
+export declare function summarizeSystemFor(nodeId: AnyNodeId, nodes: Readonly<Record<AnyNodeId, AnyNode>>): SystemSummary | null;
+//# sourceMappingURL=system-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"system-graph.d.ts","sourceRoot":"","sources":["../../src/services/system-graph.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAoBnD,MAAM,MAAM,aAAa,GAAG;IAC1B,8CAA8C;IAC9C,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,wEAAwE;IACxE,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB;0DACsD;IACtD,oBAAoB,EAAE,OAAO,CAAA;CAC9B,CAAA;AA2DD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,EAAE,CA4B9F;AAkDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,aAAa,GAAG,IAAI,CAStB"}

package/dist/services/system-graph.js

@@ -0,0 +1,164 @@
+import { nodeRegistry } from '../registry';
+/**
+ * The "System" primitive: connected components over the port graph.
+ *
+ * Two nodes are joined when a port of one coincides in space with a port
+ * of the other — the same mated-joint relationship `port-connectivity`
+ * uses for drag propagation, read here at whole-scene scope. A component
+ * is one distribution system: a furnace, its trunk, the tees, branches,
+ * and registers hanging off it.
+ *
+ * Pure logic (def.ports + arithmetic), no rendering — lives in core so
+ * the editor (badges, schedules) and analyses (sizing, code checks) can
+ * share it.
+ */
+/** Distance (meters) under which two ports count as the same joint —
+ *  matches port-connectivity's tolerance for hand-placed joints. */
+const COINCIDENT_EPS_M = 0.05;
+function collectPorts(nodes) {
+    const result = [];
+    for (const node of Object.values(nodes)) {
+        if (!node)
+            continue;
+        const ports = nodeRegistry.get(node.type)?.ports?.(node);
+        if (!ports)
+            continue;
+        for (const port of ports) {
+            result.push({
+                nodeId: node.id,
+                x: port.position[0],
+                y: port.position[1],
+                z: port.position[2],
+                system: port.system,
+            });
+        }
+    }
+    return result;
+}
+/** Union-find over node ids. */
+class Components {
+    parent = new Map();
+    find(id) {
+        let root = this.parent.get(id) ?? id;
+        if (root !== id) {
+            root = this.find(root);
+            this.parent.set(id, root);
+        }
+        return root;
+    }
+    union(a, b) {
+        const ra = this.find(a);
+        const rb = this.find(b);
+        if (ra !== rb)
+            this.parent.set(rb, ra);
+    }
+}
+function pathLength(path) {
+    let total = 0;
+    for (let i = 0; i < path.length - 1; i++) {
+        const a = path[i];
+        const b = path[i + 1];
+        total += Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    }
+    return total;
+}
+/**
+ * Group every port-bearing node into connected components via coinciding
+ * ports. Nodes with ports but no joints form singleton components; nodes
+ * without `def.ports` don't participate at all.
+ */
+export function buildPortComponents(nodes) {
+    const ports = collectPorts(nodes);
+    const components = new Components();
+    const epsSq = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    for (let i = 0; i < ports.length; i++) {
+        const a = ports[i];
+        for (let j = i + 1; j < ports.length; j++) {
+            const b = ports[j];
+            if (a.nodeId === b.nodeId)
+                continue;
+            const dx = a.x - b.x;
+            const dy = a.y - b.y;
+            const dz = a.z - b.z;
+            if (dx * dx + dy * dy + dz * dz <= epsSq)
+                components.union(a.nodeId, b.nodeId);
+        }
+    }
+    const grouped = new Map();
+    const seen = new Set();
+    for (const port of ports) {
+        if (seen.has(port.nodeId))
+            continue;
+        seen.add(port.nodeId);
+        const root = components.find(port.nodeId);
+        const group = grouped.get(root);
+        if (group)
+            group.push(port.nodeId);
+        else
+            grouped.set(root, [port.nodeId]);
+    }
+    return [...grouped.values()];
+}
+function summarize(nodeIds, nodes) {
+    const systems = new Set();
+    let runCount = 0;
+    let runLengthM = 0;
+    let fittingCount = 0;
+    let terminalCount = 0;
+    let equipmentCount = 0;
+    for (const id of nodeIds) {
+        const node = nodes[id];
+        if (!node)
+            continue;
+        const role = nodeRegistry.get(node.type)?.distributionRole;
+        const fields = node;
+        if (role === 'run') {
+            runCount += 1;
+            if (fields.path)
+                runLengthM += pathLength(fields.path);
+            // Linesets carry refrigerant; duct / pipe runs name their own loop.
+            systems.add(fields.system ?? 'refrigerant');
+        }
+        else if (role === 'fitting') {
+            fittingCount += 1;
+            if (fields.system)
+                systems.add(fields.system);
+        }
+        else if (role === 'terminal') {
+            terminalCount += 1;
+            systems.add(fields.terminalType === 'return-grille' ? 'return' : 'supply');
+        }
+        else if (role === 'equipment') {
+            equipmentCount += 1;
+        }
+    }
+    return {
+        nodeIds,
+        systems: [...systems].sort(),
+        runCount,
+        runLengthM,
+        fittingCount,
+        terminalCount,
+        equipmentCount,
+        connectedToEquipment: equipmentCount > 0,
+    };
+}
+/**
+ * Summary of the system the given node belongs to, or null when the node
+ * has no ports (not a distribution kind). A node with ports but no
+ * joints yet still gets a (singleton) summary — `connectedToEquipment:
+ * false` is the interesting signal there.
+ */
+export function summarizeSystemFor(nodeId, nodes) {
+    const node = nodes[nodeId];
+    if (!node)
+        return null;
+    const ports = nodeRegistry.get(node.type)?.ports?.(node);
+    if (!ports || ports.length === 0)
+        return null;
+    for (const component of buildPortComponents(nodes)) {
+        if (component.includes(nodeId))
+            return summarize(component, nodes);
+    }
+    return summarize([nodeId], nodes);
+}

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

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

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

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

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