@pascal-app/core 0.8.0 → 0.9.2

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

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

@@ -0,0 +1,115 @@
+import type { AnyNode, AnyNodeId } from '../schema';
+/**
+ * Connectivity-aware editing for port-bearing distribution kinds
+ * (HVAC ductwork AND DWV plumbing).
+ *
+ * Two nodes are "connected" when a port of one coincides in space with a
+ * port of the other — exactly how the placement tools mate a fitting onto
+ * a duct end (they snap the fitting's collar onto the run's open port).
+ * This service reads that relationship back out so an edit to one node can
+ * carry its neighbours along.
+ *
+ * Pure logic: it asks each node for its ports via `def.ports` (level-local
+ * meters) and does arithmetic. No Three.js, no rendering — it lives in
+ * core and is consumed by the editor's move tool and the duct/pipe
+ * selection affordances alike.
+ *
+ * ## Propagation model
+ *
+ * The joint graph is snapshotted once at drag start (`analyzePortConnectivity`)
+ * and walked every frame (`resolveConnectivityUpdates`) given the moved node's
+ * live transform. Deltas flow outward from the moved node through coincident
+ * ports:
+ *
+ * - **Fitting** (rigid): a collar pushed by delta `d` translates the whole
+ *   fitting by `d`; every other collar carries that same `d` onward.
+ * - **Run** (stretch + slide, never skew): an endpoint pushed by delta `d` is
+ *   split against the run's own axis. The *parallel* part slides only that
+ *   endpoint (the run lengthens / shortens); the *perpendicular* part
+ *   translates the entire run (so its direction is preserved). The far
+ *   endpoint therefore moves by just the perpendicular part, and that part
+ *   propagates onward to whatever is mated to the far endpoint.
+ *
+ * Propagation walks the whole connected component so a joint stays welded all
+ * the way down the chain, with a visited guard so cycles (looped runs) and
+ * shared joints terminate. First-reached (shortest path) wins on a node
+ * reachable two ways.
+ */
+type Point = readonly [number, number, number];
+/** A node carried by the edit, plus the snapshot needed to revert it. Kept
+ *  deliberately small: the move tools read only `kind` + `nodeId` and the
+ *  matching start snapshot to revert before the single tracked commit. */
+export type PortConnection = {
+    /** A fitting mated collar-to-collar: it translates rigidly. */
+    kind: 'rigid-node';
+    nodeId: AnyNodeId;
+    /** Node's `position` at edit-start. */
+    startPosition: Point;
+} | {
+    /** A run whose endpoint(s) ride the edit: it stretches and/or
+     *  translates, never skews. */
+    kind: 'run';
+    nodeId: AnyNodeId;
+    /** The run's full `path` at edit-start. */
+    startPath: Point[];
+};
+/** One node in the snapshotted joint graph (everything reachable from the
+ *  moved node, excluding the moved node itself). */
+type GraphNode = {
+    id: AnyNodeId;
+    role: 'run' | 'fitting';
+    ports: ReadonlyArray<{
+        id: string;
+        position: Point;
+        system?: string;
+    }>;
+    startPath?: Point[];
+    startPosition?: Point;
+};
+/** Who else sits on a given node's port, keyed `nodeId` → `portId` → mates. */
+type Adjacency = Record<string, Record<string, Array<{
+    nodeId: AnyNodeId;
+    portId: string;
+}>>>;
+export type PortConnectivity = {
+    movedNodeId: AnyNodeId;
+    /** The moved node's port world positions at edit-start, keyed by port id —
+     *  the reference each frame's delta is measured from. */
+    startMovedPorts: Record<string, Point>;
+    /** Reachable run/fitting nodes (excludes the moved node), keyed by id. */
+    graph: Record<string, GraphNode>;
+    /** Port coincidence edges across the moved node + every graph node. */
+    adjacency: Adjacency;
+    /** Flat list of carried nodes for the move tools' revert + "anything to
+     *  follow?" check. Derived from `graph`. */
+    connections: PortConnection[];
+};
+/**
+ * Snapshot the joint graph reachable from `movedNode`'s ports, taken at the
+ * start of a move/resize. Call once before the drag; feed the result to
+ * `resolveConnectivityUpdates` on every frame.
+ *
+ * Only `run`-role partners (segments) and `fitting`-role partners are walked —
+ * terminals and equipment usually mount to a surface and shouldn't be yanked
+ * off it when an adjacent fitting nudges. Fittings that declare
+ * `portConnectivityFollow: false` are anchored fixtures (e.g. pipe-trap) and
+ * are skipped, so a connected run stretches against them instead.
+ */
+export declare function analyzePortConnectivity(movedNode: AnyNode, nodes: Record<string, AnyNode>): PortConnectivity;
+/**
+ * Given the moved node in its live (in-drag) transform, produce the patches
+ * that keep every connected node attached. `previewNode` is the moved node
+ * with its current drag position/rotation applied so its ports recompute.
+ *
+ * Walks the snapshotted graph, propagating each port delta outward: fittings
+ * translate rigidly, runs stretch along their axis and translate across it
+ * (never skew when driven from one end), and effective port movement carries on
+ * to neighbouring joints. Port-level output guards bound cycles while still
+ * allowing a looped/shared run to accept constraints at both endpoints.
+ */
+export declare function resolveConnectivityUpdates(connectivity: PortConnectivity, previewNode: AnyNode): {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+}[];
+export {};
+//# sourceMappingURL=port-connectivity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"port-connectivity.d.ts","sourceRoot":"","sources":["../../src/services/port-connectivity.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAY9C;;0EAE0E;AAC1E,MAAM,MAAM,cAAc,GACtB;IACE,+DAA+D;IAC/D,IAAI,EAAE,YAAY,CAAA;IAClB,MAAM,EAAE,SAAS,CAAA;IACjB,uCAAuC;IACvC,aAAa,EAAE,KAAK,CAAA;CACrB,GACD;IACE;mCAC+B;IAC/B,IAAI,EAAE,KAAK,CAAA;IACX,MAAM,EAAE,SAAS,CAAA;IACjB,2CAA2C;IAC3C,SAAS,EAAE,KAAK,EAAE,CAAA;CACnB,CAAA;AAEL;oDACoD;AACpD,KAAK,SAAS,GAAG;IACf,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,KAAK,GAAG,SAAS,CAAA;IACvB,KAAK,EAAE,aAAa,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,KAAK,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACtE,SAAS,CAAC,EAAE,KAAK,EAAE,CAAA;IACnB,aAAa,CAAC,EAAE,KAAK,CAAA;CACtB,CAAA;AAED,+EAA+E;AAC/E,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC,CAAA;AAE7F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,SAAS,CAAA;IACtB;6DACyD;IACzD,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IACtC,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAChC,uEAAuE;IACvE,SAAS,EAAE,SAAS,CAAA;IACpB;gDAC4C;IAC5C,WAAW,EAAE,cAAc,EAAE,CAAA;CAC9B,CAAA;AAkCD;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,OAAO,EAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,gBAAgB,CAuFlB;AA4GD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,gBAAgB,EAC9B,WAAW,EAAE,OAAO,GACnB;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,CA0F7C"}

package/dist/services/port-connectivity.js

@@ -0,0 +1,300 @@
+import { nodeRegistry } from '../registry';
+/** Distance (meters) under which two ports count as the same joint. Joints
+ *  formed by placement snapping coincide to sub-millimeter; 5 cm leaves
+ *  generous slack for grid-snapped hand placement without false matches. */
+const COINCIDENT_EPS_M = 0.05;
+/** Below this (meters) a propagated delta is treated as zero — stops the
+ *  walk from chasing sub-millimeter perpendicular residue. */
+const DELTA_EPS_M = 1e-4;
+const PROPAGATION_EPS_M = 1e-9;
+function portsOf(node) {
+    return nodeRegistry.get(node.type)?.ports?.(node);
+}
+/** A node's distribution role from the registry (run / fitting / …). */
+function roleOf(node) {
+    return nodeRegistry.get(node.type)?.distributionRole;
+}
+function distSq(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+}
+/** Two ports mate when they coincide AND don't cross incompatible systems
+ *  (a supply duct and a waste pipe that merely touch must not fuse). */
+function portsMate(a, b, epsSq) {
+    if (distSq(a.position, b.position) > epsSq)
+        return false;
+    if (a.system && b.system && a.system !== b.system)
+        return false;
+    return true;
+}
+/**
+ * Snapshot the joint graph reachable from `movedNode`'s ports, taken at the
+ * start of a move/resize. Call once before the drag; feed the result to
+ * `resolveConnectivityUpdates` on every frame.
+ *
+ * Only `run`-role partners (segments) and `fitting`-role partners are walked —
+ * terminals and equipment usually mount to a surface and shouldn't be yanked
+ * off it when an adjacent fitting nudges. Fittings that declare
+ * `portConnectivityFollow: false` are anchored fixtures (e.g. pipe-trap) and
+ * are skipped, so a connected run stretches against them instead.
+ */
+export function analyzePortConnectivity(movedNode, nodes) {
+    const epsSq = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    const movedPorts = portsOf(movedNode) ?? [];
+    const startMovedPorts = {};
+    for (const p of movedPorts)
+        startMovedPorts[p.id] = p.position;
+    // Candidate partners: every run + every following fitting in the scene.
+    const candidates = [];
+    for (const other of Object.values(nodes)) {
+        if (!other || other.id === movedNode.id)
+            continue;
+        const role = roleOf(other);
+        if (role !== 'run' && role !== 'fitting')
+            continue;
+        if (role === 'fitting' && nodeRegistry.get(other.type)?.portConnectivityFollow === false) {
+            continue;
+        }
+        const ports = portsOf(other);
+        if (!ports)
+            continue;
+        const startPath = role === 'run'
+            ? other.path?.map((p) => [...p])
+            : undefined;
+        if (role === 'run' && (!startPath || startPath.length < 2))
+            continue;
+        const startPosition = role === 'fitting'
+            ? (() => {
+                const pos = other.position;
+                return pos ? [pos[0], pos[1], pos[2]] : undefined;
+            })()
+            : undefined;
+        if (role === 'fitting' && !startPosition)
+            continue;
+        candidates.push({ id: other.id, role, ports, startPath, startPosition });
+    }
+    // Walk outward from the moved node, collecting every node reachable through
+    // coincident ports. The adjacency records each port's mates so the resolver
+    // can replay the same edges with live deltas.
+    const adjacency = {};
+    const addEdge = (nodeId, portId, mate) => {
+        const byPort = adjacency[nodeId] ?? {};
+        adjacency[nodeId] = byPort;
+        const mates = byPort[portId] ?? [];
+        byPort[portId] = mates;
+        mates.push(mate);
+    };
+    const graph = {};
+    const visited = new Set([movedNode.id]);
+    // Seed: the moved node's own ports.
+    const queue = [{ id: movedNode.id, ports: movedPorts }];
+    while (queue.length > 0) {
+        const { id, ports } = queue.shift();
+        for (const port of ports) {
+            for (const cand of candidates) {
+                if (cand.id === id)
+                    continue;
+                for (const cp of cand.ports) {
+                    if (!portsMate(port, cp, epsSq))
+                        continue;
+                    addEdge(id, port.id, { nodeId: cand.id, portId: cp.id });
+                    addEdge(cand.id, cp.id, { nodeId: id, portId: port.id });
+                    if (!visited.has(cand.id)) {
+                        visited.add(cand.id);
+                        graph[cand.id] = cand;
+                        queue.push({ id: cand.id, ports: cand.ports });
+                    }
+                }
+            }
+        }
+    }
+    const connections = Object.values(graph).map((g) => g.role === 'fitting'
+        ? { kind: 'rigid-node', nodeId: g.id, startPosition: g.startPosition }
+        : { kind: 'run', nodeId: g.id, startPath: g.startPath });
+    return {
+        movedNodeId: movedNode.id,
+        startMovedPorts,
+        graph,
+        adjacency,
+        connections,
+    };
+}
+function add(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function sub(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function lenSq(v) {
+    return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+}
+/** Split `delta` into the component along unit `axis` and the remainder. */
+function decompose(delta, axis) {
+    const dot = delta[0] * axis[0] + delta[1] * axis[1] + delta[2] * axis[2];
+    const parallel = [axis[0] * dot, axis[1] * dot, axis[2] * dot];
+    return { parallel, perp: sub(delta, parallel) };
+}
+function scale(v, scalar) {
+    return [v[0] * scalar, v[1] * scalar, v[2] * scalar];
+}
+function average(deltas) {
+    const sum = deltas.reduce((acc, delta) => add(acc, delta), [0, 0, 0]);
+    return scale(sum, 1 / deltas.length);
+}
+function nearlyEqual(a, b) {
+    return lenSq(sub(a, b)) <= DELTA_EPS_M * DELTA_EPS_M;
+}
+function propagationEqual(a, b) {
+    return lenSq(sub(a, b)) <= PROPAGATION_EPS_M * PROPAGATION_EPS_M;
+}
+function effectivePortDeltas(constraints) {
+    return Object.fromEntries(Object.entries(constraints).map(([portId, bySource]) => [
+        portId,
+        average(Object.values(bySource)),
+    ]));
+}
+/** Unit direction of the run's segment adjacent to its `start` / `end` tip. */
+function endpointAxis(path, portId) {
+    const n = path.length;
+    const [a, b] = portId === 'start' ? [path[1], path[0]] : [path[n - 2], path[n - 1]];
+    const dir = sub(b, a);
+    const l2 = lenSq(dir);
+    if (l2 < 1e-12)
+        return [0, 0, 0];
+    const l = Math.sqrt(l2);
+    return [dir[0] / l, dir[1] / l, dir[2] / l];
+}
+function runPathFromSinglePortDelta(startPath, portId, delta) {
+    const nearIdx = portId === 'start' ? 0 : startPath.length - 1;
+    const axis = endpointAxis(startPath, portId);
+    const { parallel, perp } = decompose(delta, axis);
+    const path = startPath.map((p) => add(p, perp));
+    path[nearIdx] = add(path[nearIdx], parallel);
+    return path;
+}
+function runEndpointDeltas(startPath, path) {
+    return {
+        start: sub(path[0], startPath[0]),
+        end: sub(path[path.length - 1], startPath[startPath.length - 1]),
+    };
+}
+function runPathFromPortDeltas(startPath, portDeltas) {
+    const startDelta = portDeltas.start;
+    const endDelta = portDeltas.end;
+    if (startDelta && endDelta) {
+        if (startPath.length === 2) {
+            return [add(startPath[0], startDelta), add(startPath[1], endDelta)];
+        }
+        if (nearlyEqual(startDelta, endDelta)) {
+            return startPath.map((p) => add(p, startDelta));
+        }
+        const startParts = decompose(startDelta, endpointAxis(startPath, 'start'));
+        const endParts = decompose(endDelta, endpointAxis(startPath, 'end'));
+        const commonPerp = average([startParts.perp, endParts.perp]);
+        const path = startPath.map((p) => add(p, commonPerp));
+        path[0] = add(path[0], startParts.parallel);
+        path[path.length - 1] = add(path[path.length - 1], endParts.parallel);
+        return path;
+    }
+    return runPathFromSinglePortDelta(startPath, startDelta ? 'start' : 'end', (startDelta ?? endDelta));
+}
+/**
+ * Given the moved node in its live (in-drag) transform, produce the patches
+ * that keep every connected node attached. `previewNode` is the moved node
+ * with its current drag position/rotation applied so its ports recompute.
+ *
+ * Walks the snapshotted graph, propagating each port delta outward: fittings
+ * translate rigidly, runs stretch along their axis and translate across it
+ * (never skew when driven from one end), and effective port movement carries on
+ * to neighbouring joints. Port-level output guards bound cycles while still
+ * allowing a looped/shared run to accept constraints at both endpoints.
+ */
+export function resolveConnectivityUpdates(connectivity, previewNode) {
+    const { graph, adjacency, startMovedPorts, movedNodeId } = connectivity;
+    if (Object.keys(graph).length === 0)
+        return [];
+    const newPorts = portsOf(previewNode) ?? [];
+    const newMovedPos = {};
+    for (const p of newPorts)
+        newMovedPos[p.id] = p.position;
+    // Each queue item drives a node's port by a delta ("this collar / endpoint
+    // must move by this much").
+    const queue = [];
+    const results = {};
+    const constrainedPorts = {};
+    const propagatedPorts = {};
+    const enqueueMates = (nodeId, portId, delta) => {
+        const byPort = propagatedPorts[nodeId] ?? {};
+        propagatedPorts[nodeId] = byPort;
+        const previous = byPort[portId];
+        if (previous && propagationEqual(previous, delta))
+            return;
+        byPort[portId] = delta;
+        for (const mate of adjacency[nodeId]?.[portId] ?? []) {
+            if (mate.nodeId === movedNodeId)
+                continue;
+            queue.push({
+                nodeId: mate.nodeId,
+                portId: mate.portId,
+                delta,
+                sourceKey: `${nodeId}:${portId}`,
+            });
+        }
+    };
+    const acceptPortDelta = (nodeId, portId, sourceKey, delta) => {
+        const byPort = constrainedPorts[nodeId] ?? {};
+        constrainedPorts[nodeId] = byPort;
+        const bySource = byPort[portId] ?? {};
+        byPort[portId] = bySource;
+        const existing = bySource[sourceKey];
+        if (existing && propagationEqual(existing, delta)) {
+            return false;
+        }
+        bySource[sourceKey] = delta;
+        return true;
+    };
+    // Seed from the moved node's live port deltas.
+    for (const [portId, start] of Object.entries(startMovedPorts)) {
+        const now = newMovedPos[portId];
+        if (!now)
+            continue;
+        const delta = sub(now, start);
+        if (lenSq(delta) <= DELTA_EPS_M * DELTA_EPS_M)
+            continue;
+        enqueueMates(movedNodeId, portId, delta);
+    }
+    while (queue.length > 0) {
+        const { nodeId, portId, delta, sourceKey } = queue.shift();
+        const node = graph[nodeId];
+        if (!node)
+            continue;
+        if (!acceptPortDelta(nodeId, portId, sourceKey, delta))
+            continue;
+        const portDeltas = effectivePortDeltas(constrainedPorts[nodeId]);
+        if (node.role === 'fitting') {
+            const start = node.startPosition;
+            const effectiveDelta = average(Object.values(portDeltas));
+            results[nodeId] = {
+                id: nodeId,
+                data: { position: add(start, effectiveDelta) },
+            };
+            // Rigid: every collar carries the effective body translation onward.
+            for (const p of node.ports) {
+                enqueueMates(nodeId, p.id, effectiveDelta);
+            }
+        }
+        else {
+            const startPath = node.startPath;
+            const path = runPathFromPortDeltas(startPath, portDeltas);
+            results[nodeId] = { id: nodeId, data: { path } };
+            for (const [nextPortId, nextDelta] of Object.entries(runEndpointDeltas(startPath, path))) {
+                if (lenSq(nextDelta) <= DELTA_EPS_M * DELTA_EPS_M)
+                    continue;
+                enqueueMates(nodeId, nextPortId, nextDelta);
+            }
+        }
+    }
+    return Object.values(results);
+}

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

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

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

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