@statelyai/layout 0.4.0 → 0.4.1

package/src/layered/opposing-tracks.ts

@@ -120,6 +120,14 @@ function crossing(s: Segment, t: Segment): boolean {
     h.a.y < Math.max(v.a.y, v.b.y) - EPS
   );
 }
+const onBorder = (p: TrackPoint, r: TrackRect) => {
+  const inX = p.x >= r.x - EPS && p.x <= r.x + r.width + EPS,
+    inY = p.y >= r.y - EPS && p.y <= r.y + r.height + EPS;
+  return (
+    (inY && (Math.abs(p.x - r.x) <= EPS || Math.abs(p.x - r.x - r.width) <= EPS)) ||
+    (inX && (Math.abs(p.y - r.y) <= EPS || Math.abs(p.y - r.y - r.height) <= EPS))
+  );
+};
 const segmentsOf = (points: readonly TrackPoint[]): Segment[] =>
   points.slice(1).flatMap((b, i) => {
     const s = { a: points[i]!, b };
@@ -159,8 +167,28 @@ export function separateOpposingTracks(scene: TrackScene): Map<string, TrackPoin
     if (!rects) terminalCache.set(key, (rects = terminals(a.route, b.route)));
     return rects;
   };
+  const boxes = new WeakMap<Segment[], [number, number, number, number]>();
+  const boxOf = (segments: Segment[]) => {
+    let box = boxes.get(segments);
+    if (!box) {
+      box = [Infinity, Infinity, -Infinity, -Infinity];
+      for (const { a, b } of segments) {
+        box[0] = Math.min(box[0], a.x, b.x);
+        box[1] = Math.min(box[1], a.y, b.y);
+        box[2] = Math.max(box[2], a.x, b.x);
+        box[3] = Math.max(box[3], a.y, b.y);
+      }
+      boxes.set(segments, box);
+    }
+    return box;
+  };
+  const none = { opposing: 0, overlap: 0, crossings: 0 };
   // The metric's pair measures: opposite-direction and same-direction shared length, crossings.
   const pair = (mine: Segment[], self: State, other: State) => {
+    // Routes with disjoint bounds neither share a track nor cross.
+    const [ax0, ay0, ax1, ay1] = boxOf(mine),
+      [bx0, by0, bx1, by1] = boxOf(other.measured);
+    if (ax1 < bx0 - EPS || bx1 < ax0 - EPS || ay1 < by0 - EPS || by1 < ay0 - EPS) return none;
     const rects = terminalsOf(self, other);
     const as = rects.length ? clip(mine, rects, true) : mine,
       bs = rects.length ? clip(other.measured, rects, true) : other.measured;
@@ -449,6 +477,41 @@ export function separateOpposingTracks(scene: TrackScene): Map<string, TrackPoin
                 0,
               )
             : along;
+          // A portless end may instead slide along its node side; its
+          // perpendicular neighbour stretches.
+          const after = { a: corner, b: beyond };
+          const against = (s: Segment) =>
+            states.reduce(
+              (sum, other) =>
+                other === state
+                  ? sum
+                  : other.measured.reduce((n, t) => n + (opposite(s, t) ? shared(s, t) : 0), sum),
+              0,
+            );
+          if (
+            state.route.ends.length === 2 &&
+            state.route.ports?.[reversed ? 1 : 0] === undefined &&
+            rect &&
+            onBorder(port, rect) &&
+            (h ? vertical(after) : horizontal(after))
+          ) {
+            const lo = h ? rect.y : rect.x,
+              hi = lo + (h ? rect.height : rect.width);
+            for (const delta of offsets) {
+              const moved = shift(port, delta);
+              if ((h ? moved.y : moved.x) < lo - EPS || (h ? moved.y : moved.x) > hi + EPS)
+                continue;
+              const next = [
+                { a: moved, b: shift(corner, delta) },
+                { a: shift(corner, delta), b: beyond },
+              ];
+              // The stretched neighbour may not run against another route more than before.
+              if (!keeps(after, next[1]!) || against(next[1]!) > against(after) + EPS) continue;
+              const replaced = [moved, shift(corner, delta), ...path.slice(2)];
+              const points = reversed ? replaced.reverse() : replaced;
+              consider(points, [segment, after], next, next[0]!, 0, delta);
+            }
+          }
           for (const stub of new Set([along - clearance, spacing]))
             for (const delta of offsets) {
               if (stub < 1 || along - stub < spacing) continue;
@@ -491,17 +554,30 @@ export function separateOpposingTracks(scene: TrackScene): Map<string, TrackPoin
    * half a spacing either side of the port's centre.
    */
   function splitSharedPorts(tolerant: boolean) {
-    const ports = scene.ports;
-    if (!ports?.size) return;
     type End = { state: State; end: 0 | 1 };
     const groups = new Map<string, { port: TrackPort; normal: TrackPoint; ends: End[] }>();
+    // Implicit attachment points per node; points within EPS are one point.
+    const implicit = new Map<string, TrackPoint[]>();
     for (const state of states)
       for (const end of [0, 1] as const) {
-        const id = state.route.ports?.[end];
-        const port = id === undefined ? undefined : ports.get(id);
-        if (!port || state.points.length < 2) continue;
+        if (state.points.length < 2) continue;
         const path = end ? [...state.points].reverse() : state.points;
         const [p, q] = path as [TrackPoint, TrackPoint];
+        let id = state.route.ports?.[end];
+        let port = id === undefined ? undefined : scene.ports?.get(id);
+        // Portless ends meeting at one point of a node border (merged edges)
+        // share an implicit port there.
+        const node = state.route.ends.length === 2 ? state.route.ends[end]! : undefined;
+        const rect = node === undefined ? undefined : nodes.get(node);
+        if (id === undefined && rect && onBorder(p, rect)) {
+          const points = implicit.get(node!) ?? [];
+          implicit.set(node!, points);
+          let at = points.find((o) => Math.abs(o.x - p.x) <= EPS && Math.abs(o.y - p.y) <= EPS);
+          if (!at) points.push((at = { x: p.x, y: p.y }));
+          id = `${node}\0${points.indexOf(at)}`;
+          port = { node: node!, rect: { ...at, width: 0, height: 0 } };
+        }
+        if (!port) continue;
         const s = { a: p, b: q };
         if (size(s) <= EPS || (!horizontal(s) && !vertical(s))) continue;
         const normal = { x: Math.sign(q.x - p.x), y: Math.sign(q.y - p.y) };
@@ -510,7 +586,14 @@ export function separateOpposingTracks(scene: TrackScene): Map<string, TrackPoin
         if (!group) groups.set(key, (group = { port, normal, ends: [] }));
         group.ends.push({ state, end });
       }
-    for (const { port, normal, ends } of groups.values()) {
+    for (const group of groups.values()) {
+      const { port, normal } = group;
+      // An earlier split may have slid a straight route off an implicit port.
+      const ends = group.ends.filter(({ state, end }) => {
+        if (state.route.ports?.[end] !== undefined) return true;
+        const p = end ? state.points.at(-1)! : state.points[0]!;
+        return Math.abs(p.x - port.rect.x) <= EPS && Math.abs(p.y - port.rect.y) <= EPS;
+      });
       const incoming = ends.filter((e) => e.end === 1),
         outgoing = ends.filter((e) => e.end === 0);
       if (!incoming.length || !outgoing.length) continue;
@@ -530,10 +613,27 @@ export function separateOpposingTracks(scene: TrackScene): Map<string, TrackPoin
         sideHi = node[lateral] + (lateral === "x" ? node.width : node.height);
       const wide = extent >= spacing - EPS;
       const half = spacing / 2;
+      // A straight portless two-point route slides sideways whole, both ends
+      // staying on their node sides.
+      const slid = (state: State, points: TrackPoint[], end: 0 | 1, offset: number) => {
+        if (state.route.ports?.some((id) => id !== undefined)) return undefined;
+        if (Math.abs(points[0]![across] - points[1]![across]) <= EPS) return undefined;
+        const far = nodes.get(state.route.ends[1 - end] ?? "");
+        const moved = points.map((p) => ({ ...p, [lateral]: p[lateral] + offset }));
+        const within = (value: number, rect: TrackRect) => {
+          const lo = rect[lateral];
+          return (
+            value >= lo - EPS && value <= lo + (lateral === "x" ? rect.width : rect.height) + EPS
+          );
+        };
+        const value = moved[0]![lateral];
+        return within(value, node) && far && within(value, far) ? moved : undefined;
+      };
       // Move one end of a route sideways by `offset`, keeping it orthogonal.
-      const shifted = (points: TrackPoint[], end: 0 | 1, offset: number) => {
+      const shifted = (state: State, points: TrackPoint[], end: 0 | 1, offset: number) => {
         if (Math.abs(offset) <= EPS) return points;
         const path = end ? [...points].reverse() : [...points];
+        if (path.length === 2) return slid(state, points, end, offset);
         if (path.length < 3) return undefined;
         const [p, q, r] = path as [TrackPoint, TrackPoint, TrackPoint];
         const along = r[lateral] - q[lateral];
@@ -594,7 +694,7 @@ export function separateOpposingTracks(scene: TrackScene): Map<string, TrackPoin
         const next = new Map<State, TrackPoint[]>();
         let feasible = true;
         for (const e of ends) {
-          const points = shifted(next.get(e.state) ?? e.state.points, e.end, offsetOf(e));
+          const points = shifted(e.state, next.get(e.state) ?? e.state.points, e.end, offsetOf(e));
           if (!points) {
             feasible = false;
             break;

package/src/layered/orthogonal-hypersegments.ts

@@ -72,13 +72,34 @@ export function countOrthogonalHypersegmentCrossings(
   ports: readonly OrthogonalPort[],
   connections: readonly OrthogonalConnection[],
 ): number {
-  const { segments } = createOrthogonalHypersegments(ports, connections);
-  const spans = segments.map((s) => ({
-    leftStart: Math.min(...s.incoming),
-    leftEnd: Math.max(...s.incoming),
-    rightStart: Math.min(...s.outgoing),
-    rightEnd: Math.max(...s.outgoing),
-  }));
+  return scoreOrthogonalHypersegments(ports, connections).count;
+}
+
+/**
+ * {@link countOrthogonalHypersegmentCrossings}, optionally separating shared
+ * tracks. ELK routes a hyperedge on one shared track. When it joins two or
+ * more ports on each side, its edges would run opposite ways along that
+ * track, which routing never allows; `separateShared` counts such a
+ * hyperedge's edges one by one instead. `shared` reports whether one exists.
+ */
+export function scoreOrthogonalHypersegments(
+  ports: readonly OrthogonalPort[],
+  connections: readonly OrthogonalConnection[],
+  separateShared = false,
+): { count: number; shared: boolean } {
+  const { segments: merged, segmentByPort } = createOrthogonalHypersegments(ports, connections);
+  const sharedSegments = new Set(
+    merged.flatMap((s, i) => (s.incoming.length > 1 && s.outgoing.length > 1 ? [i] : [])),
+  );
+  const separating = separateShared && sharedSegments.size > 0;
+  const spans = merged
+    .filter((_, i) => !separating || !sharedSegments.has(i))
+    .map((s) => ({
+      leftStart: Math.min(...s.incoming),
+      leftEnd: Math.max(...s.incoming),
+      rightStart: Math.min(...s.outgoing),
+      rightEnd: Math.max(...s.outgoing),
+    }));
   let count = 0;
   for (let i = 0; i < spans.length; i++)
     for (let j = i + 1; j < spans.length; j++) {
@@ -88,5 +109,46 @@ export function countOrthogonalHypersegmentCrossings(
       if (a.leftStart < b.leftEnd && b.leftStart < a.leftEnd) count++;
       if (a.rightStart < b.rightEnd && b.rightStart < a.rightEnd) count++;
     }
+  if (separating) {
+    // A separated edge is a one-point span on each side.
+    const position = new Map(ports.map((p) => [p.id, p.position]));
+    const edges = connections
+      .filter((c) => sharedSegments.has(segmentByPort.get(c.source)!))
+      .map((c) => [position.get(c.source)!, position.get(c.target)!] as const);
+    for (const [left, right] of edges)
+      for (const b of spans) {
+        if ((left - b.leftStart) * (right - b.rightStart) < 0) count++;
+        if (left < b.leftEnd && b.leftStart < left) count++;
+        if (right < b.rightEnd && b.rightStart < right) count++;
+      }
+    count += strictInversions(edges);
+  }
+  return { count, shared: sharedSegments.size > 0 };
+}
+
+/** Pairs whose ends are strictly inverted: two separated edges that cross, in O(n log n). */
+function strictInversions(pairs: ReadonlyArray<readonly [number, number]>): number {
+  const ranks = [...new Set(pairs.map(([, right]) => right))].sort((a, b) => a - b);
+  const rankOf = new Map(ranks.map((value, index) => [value, index + 1]));
+  const tree = new Array<number>(ranks.length + 1).fill(0);
+  const atMost = (rank: number) => {
+    let sum = 0;
+    for (let i = rank; i > 0; i -= i & -i) sum += tree[i]!;
+    return sum;
+  };
+  const sorted = [...pairs].sort((a, b) => a[0] - b[0]);
+  let inserted = 0,
+    count = 0;
+  for (let start = 0; start < sorted.length;) {
+    let end = start;
+    while (end < sorted.length && sorted[end]![0] === sorted[start]![0]) end++;
+    // Edges with an equal left end never cross; compare against earlier ones only.
+    for (let i = start; i < end; i++) count += inserted - atMost(rankOf.get(sorted[i]![1])!);
+    for (let i = start; i < end; i++) {
+      for (let r = rankOf.get(sorted[i]![1])!; r <= ranks.length; r += r & -r) tree[r]!++;
+      inserted++;
+    }
+    start = end;
+  }
   return count;
 }

package/src/layered/strategies.ts

@@ -7,7 +7,7 @@ import {
 } from "./initial-model-order";
 import { insertionSort } from "./gwt-sort";
 import { CanonicalPortDistributor } from "./port-distributor";
-import { countAllCrossings } from "./crossing-counter";
+import { countAllCrossings, type CrossingGraph } from "./crossing-counter";
 import {
   createCrossingGraphBuilder,
   crossingGraph,
@@ -124,6 +124,24 @@ function cycleModelOrder(input: LayeredPhaseInput): Map<string, number> {
   );
 }
 
+/**
+ * Internal setting: how crossing minimization models ports and tracks.
+ * `mixedPorts` (default true) counts a port carrying both directions as two
+ * ports and groups its neighbours by direction. `separateSharedTracks`
+ * (default false) counts a hyperedge joining two or more ports on each side
+ * of its gap edge by edge, since routing never lets edges run opposite ways
+ * along one track. A `probe` records whether either choice can change the
+ * order. Each helps on average but steers the sweeps into worse orders on
+ * some graphs, so the elkjs facade also lays such graphs out with the
+ * alternatives and keeps the best result.
+ */
+export const CROSSING_MODEL = "internal.crossingModel";
+export interface CrossingModel {
+  mixedPorts?: boolean;
+  separateSharedTracks?: boolean;
+  probe?: { mixedPorts: boolean; sharedTracks: boolean };
+}
+
 export const breakCyclesWithDepthFirstSearch: CycleBreaker = (input) => {
   const outgoing = new Map<string, GraphEdge[]>();
   for (const node of input.graph.nodes) outgoing.set(node.id, []);
@@ -818,14 +836,7 @@ export function applyLayerConstraintOrder(input: LayeredPhaseInput, order: Layer
     ...order,
     layers: order.layers.map((layer) => {
       const unconstrained = layer.filter((id) => !constrained.has(id));
-      const mergedOrder =
-        input.settings.mergeEdges === true
-          ? [
-              ...unconstrained.filter((id) => id.startsWith("__layout_dummy:")),
-              ...unconstrained.filter((id) => !id.startsWith("__layout_dummy:")),
-            ]
-          : unconstrained;
-      return [...mergedOrder, ...layer.filter((id) => constrained.has(id))];
+      return [...unconstrained, ...layer.filter((id) => constrained.has(id))];
     }),
   };
 }
@@ -1897,6 +1908,8 @@ export interface LayerSweepSession {
   currentLayers(): readonly (readonly string[])[];
   /** Current canonical port ids of one node, as {@link snapshot} records them. */
   physicalPortOrder(nodeId: string): string[];
+  /** Canonical crossing graph in the current order; callers must not mutate it. */
+  crossingGraph(): CrossingGraph;
   /** Live incident edge orders of one node; callers must not mutate them. */
   edgeOrders(nodeId: string): { incoming: readonly string[]; outgoing: readonly string[] };
   /** Same as restoring a snapshot that differs only in one layer. */
@@ -1984,6 +1997,32 @@ export function createLayerSweepSession(
   }
   const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
   const edgeById = new Map(input.graph.edges.map((edge) => [edge.id, edge]));
+  // ELK lists a compound's boundary ports in creation order: edges on them
+  // take their slots in that order, in model order within a port. Authored
+  // ports already arrive in ELK's sorted order and keep their edge order.
+  const boundaryPortIndex = (nodeId: string, edgeId: string, incoming: boolean) => {
+    const edge = edgeById.get(edgeId)!;
+    const name =
+      incoming !== orientation.reversedEdgeIds.has(edgeId) ? edge.targetPort : edge.sourcePort;
+    if (!name?.startsWith("__native_hierarchy")) return -1;
+    return nodeById.get(nodeId)!.ports?.findIndex((port) => port.name === name) ?? -1;
+  };
+  for (const [orders, incoming] of [
+    [outputPortOrder, false],
+    [inputPortOrder, true],
+  ] as const)
+    for (const [nodeId, edgeIds] of orders) {
+      if (edgeIds.length < 2) continue;
+      const slots = edgeIds.flatMap((id, slot) =>
+        boundaryPortIndex(nodeId, id, incoming) < 0 ? [] : [slot],
+      );
+      const sorted = slots
+        .map((slot) => edgeIds[slot]!)
+        .sort(
+          (a, b) => boundaryPortIndex(nodeId, a, incoming) - boundaryPortIndex(nodeId, b, incoming),
+        );
+      slots.forEach((slot, index) => (edgeIds[slot] = sorted[index]!));
+    }
   const edgeModelOrder = new Map(input.graph.edges.map((edge, index) => [edge.id, index]));
   const hierarchicalNodes = new Set<string>();
   const fixedOrderNodes = new Set(
@@ -2037,6 +2076,10 @@ export function createLayerSweepSession(
     }
   }
   const buildCrossingGraph = createCrossingGraphBuilder(input);
+  const crossingModel: CrossingModel =
+    (input.settings as { [CROSSING_MODEL]?: CrossingModel })[CROSSING_MODEL] ?? {};
+  const mixedPorts = crossingModel.mixedPorts !== false,
+    probe = crossingModel.probe;
   const countCrossings = (candidateLayers: readonly (readonly string[])[]): number => {
     if (exactPortSweep) {
       const graph = buildCrossingGraph(
@@ -2045,7 +2088,26 @@ export function createLayerSweepSession(
         inputPortOrder,
         outputPortOrder,
       );
-      let total = countAllCrossings(splitMixedCrossingPorts(graph, canonicalReversed)).total;
+      // Edge orders rank a side's ports per direction; a fixed-side port with
+      // a reversed edge mixes both, so count the sweep's physical port order.
+      for (const layer of graph.layers)
+        for (const node of layer) {
+          const physical = node.ports.length > 1 ? canonicalNodes.get(node.id)?.ports : undefined;
+          if (physical?.length !== node.ports.length) continue;
+          const slot = new Map(physical.map((port, index) => [port.id, index]));
+          if (node.ports.every((port) => slot.has(port.id)))
+            node.ports.sort((a, b) => slot.get(a.id)! - slot.get(b.id)!);
+        }
+      const split = mixedPorts ? splitMixedCrossingPorts(graph, canonicalReversed) : graph;
+      const score = countAllCrossings(
+        split,
+        crossingModel.separateSharedTracks ? "separated" : "hyperedges",
+      );
+      if (probe) {
+        if (split !== graph) probe.mixedPorts = true;
+        if (score.sharedTracks) probe.sharedTracks = true;
+      }
+      let total = score.total;
       const nodeInfluence = Number(
         input.settings["considerModelOrder.crossingCounterNodeInfluence"] ?? 0,
       );
@@ -2151,12 +2213,13 @@ export function createLayerSweepSession(
           !forward,
           nodeRelativePortRanks,
         );
-        const fixedIds = new Set(fixedLayer);
-        for (let index = 0; index < canonicalEdges.length; index++) {
+        // The fixed layer's edges toward the free layer, in edge order.
+        const byEnd = forward ? canonicalEdgesBySource : canonicalEdgesByTarget;
+        const indices = fixedLayer.flatMap((id) => byEnd.get(id) ?? []).sort((a, b) => a - b);
+        for (const index of indices) {
           const edge = canonicalEdges[index]!;
           const [source, target] = canonicalOrientedEndpoints[index]!;
-          if (!fixedIds.has(forward ? source : target) || !freeIds.has(forward ? target : source))
-            continue;
+          if (!freeIds.has(forward ? target : source)) continue;
           const endpoint = canonicalEndpoints.get(edge.id)!;
           const rank =
             canonicalDistributor.state.ranks[forward ? endpoint.source : endpoint.target]!;
@@ -2288,6 +2351,18 @@ export function createLayerSweepSession(
   const canonicalOrientedEndpoints = canonicalEdges.map((edge) =>
     getOrientedEndpoints(edge, orientation),
   );
+  const canonicalEdgesBySource = new Map<string, number[]>(),
+    canonicalEdgesByTarget = new Map<string, number[]>();
+  canonicalOrientedEndpoints.forEach(([source, target], index) => {
+    for (const [byEnd, id] of [
+      [canonicalEdgesBySource, source],
+      [canonicalEdgesByTarget, target],
+    ] as const) {
+      const list = byEnd.get(id);
+      if (list) list.push(index);
+      else byEnd.set(id, [index]);
+    }
+  });
   const canonicalEndpoints = new Map(
     canonicalEdges.map((edge, index) => [edge.id, canonicalGraph.edges[index]!]),
   );
@@ -2386,6 +2461,7 @@ export function createLayerSweepSession(
     fixed: readonly string[],
     beyond: readonly string[] = [],
   ) => {
+    if (!mixedPorts) return;
     const fixedIds = new Set(fixed);
     const groups = new Map<string, Array<{ id: string; reversed: boolean }>>();
     for (const id of free) {
@@ -2408,6 +2484,7 @@ export function createLayerSweepSession(
     }
     if (![...groups.values()].some((g) => g.some((m) => m.reversed) && g.some((m) => !m.reversed)))
       return;
+    if (probe) probe.mixedPorts = true;
     const index = new Map(free.map((id, i) => [id, i]));
     // The direction whose nodes lead further toward the start of the layer
     // beyond (from the previous sweep) goes first; forward edges by default.
@@ -2649,6 +2726,10 @@ export function createLayerSweepSession(
     restore,
     finish,
     currentLayers: () => working,
+    crossingGraph: () => ({
+      layers: working.map((layer) => layer.map((id) => canonicalNodes.get(id)!)),
+      edges: canonicalGraph.edges,
+    }),
     physicalPortOrder: (id) => canonicalNodes.get(id)?.ports.map((port) => port.id) ?? [],
     edgeOrders: (id) => ({
       incoming: inputPortOrder.get(id) ?? [],
@@ -3783,6 +3864,18 @@ function implicitEdgeEndpoints(
 
   const result = new Map<string, { source: Point; target: Point }>();
   const edgeModelOrder = new Map(input.graph.edges.map((edge, index) => [edge.id, index]));
+  // First positions in swept port orders, as `indexOf` finds them.
+  const orderIndexes = new Map<readonly string[], Map<string, number>>();
+  const orderIndex = (list: readonly string[], id: string) => {
+    let positions = orderIndexes.get(list);
+    if (!positions) {
+      positions = new Map();
+      for (const [index, item] of list.entries())
+        if (!positions.has(item)) positions.set(item, index);
+      orderIndexes.set(list, positions);
+    }
+    return positions.get(id) ?? -1;
+  };
   const placedPorts = new Map<GraphNode, { rect: EntityRect; ports: GraphPort[] | undefined }>();
   const portSideCounts = new Map<GraphNode, Map<unknown, number>>();
   const portSideCount = (node: GraphNode, side: unknown): number => {
@@ -3860,8 +3953,8 @@ function implicitEdgeEndpoints(
         const selected = (
           leftIncoming ? sweptOrder?.inputPortOrderByNodeId : sweptOrder?.outputPortOrderByNodeId
         )?.get(nodeId);
-        const a = selected?.indexOf(left.edge.id) ?? -1,
-          b = selected?.indexOf(right.edge.id) ?? -1;
+        const a = selected ? orderIndex(selected, left.edge.id) : -1,
+          b = selected ? orderIndex(selected, right.edge.id) : -1;
         if (a >= 0 && b >= 0 && a !== b) return (leftIncoming ? -1 : 1) * (a - b);
       }
       if (interactiveLeftSourceOrder) {
@@ -4931,9 +5024,13 @@ function routeEdges(style: "ORTHOGONAL" | "POLYLINE" | "SPLINES"): EdgeRouter {
           candidate.straight = Math.abs(segment.start - segment.end) < 1e-3;
           candidate.slot = increasing ? segment.slot : maximumSlot - segment.slot;
           if (segment.partner !== undefined) {
+            // The route leaves the graph source on the half holding that end.
             const partner = result.segments[segment.partner]!;
-            candidate.secondSlot = increasing ? partner.slot : maximumSlot - segment.slot;
-            if (!increasing) candidate.slot = maximumSlot - partner.slot;
+            const [first, second] = physicalPort(candidate, "source").graphSource
+              ? [segment, partner]
+              : [partner, segment];
+            candidate.slot = increasing ? first.slot : maximumSlot - first.slot;
+            candidate.secondSlot = increasing ? second.slot : maximumSlot - second.slot;
             const sourcePort = portByCandidate.get(candidate)!.source;
             const offset =
               (increasing ? candidate.sourceCross : candidate.targetCross) -