@statelyai/layout 0.4.0 → 0.4.2

package/src/layered/greedy-switch-decider.ts

@@ -15,6 +15,36 @@ function sidePorts(node: CrossingNode, side: Side): CrossingPort[] {
   return side === "WEST" || side === "SOUTH" ? ports.reverse() : ports;
 }
 
+/** Port connectivity and layers; switches within layers leave it unchanged. */
+export interface GreedySwitchTopology {
+  incoming: Map<string, string[]>;
+  outgoing: Map<string, string[]>;
+  layerByPort: Map<string, number>;
+  ownerByPort: Map<string, CrossingNode>;
+}
+
+export function greedySwitchTopology(graph: CrossingGraph): GreedySwitchTopology {
+  const topology: GreedySwitchTopology = {
+    incoming: new Map(),
+    outgoing: new Map(),
+    layerByPort: new Map(),
+    ownerByPort: new Map(),
+  };
+  for (const [layer, nodes] of graph.layers.entries())
+    for (const node of nodes)
+      for (const port of node.ports) {
+        topology.layerByPort.set(port.id, layer);
+        topology.ownerByPort.set(port.id, node);
+        topology.incoming.set(port.id, []);
+        topology.outgoing.set(port.id, []);
+      }
+  for (const edge of graph.edges) {
+    topology.outgoing.get(edge.source)?.push(edge.target);
+    topology.incoming.get(edge.target)?.push(edge.source);
+  }
+  return topology;
+}
+
 interface Adjacency {
   position: number;
   cardinality: number;
@@ -27,10 +57,10 @@ interface Adjacency {
  */
 export class GreedySwitchDecider {
   readonly #free: readonly CrossingNode[];
-  readonly #incoming = new Map<string, string[]>();
-  readonly #outgoing = new Map<string, string[]>();
-  readonly #layerByPort = new Map<string, number>();
-  readonly #ownerByPort = new Map<string, CrossingNode>();
+  readonly #incoming: ReadonlyMap<string, readonly string[]>;
+  readonly #outgoing: ReadonlyMap<string, readonly string[]>;
+  readonly #layerByPort: ReadonlyMap<string, number>;
+  readonly #ownerByPort: ReadonlyMap<string, CrossingNode>;
   readonly #neighbourPositions = new Map<string, number>();
   readonly #adjacencies = new Map<string, { sides: Map<Side, Adjacency[]> }>();
   readonly #matrix = new Map<string, [number, number]>();
@@ -39,21 +69,18 @@ export class GreedySwitchDecider {
   readonly #inLayerSize = new Map<Side, number>();
   readonly #oneSided?: "WEST" | "EAST";
 
-  constructor(graph: CrossingGraph, freeLayerIndex: number, oneSided?: "WEST" | "EAST") {
+  constructor(
+    graph: CrossingGraph,
+    freeLayerIndex: number,
+    oneSided?: "WEST" | "EAST",
+    topology = greedySwitchTopology(graph),
+  ) {
     this.#free = graph.layers[freeLayerIndex] ?? [];
     this.#oneSided = oneSided;
-    for (const [layer, nodes] of graph.layers.entries())
-      for (const node of nodes)
-        for (const port of node.ports) {
-          this.#layerByPort.set(port.id, layer);
-          this.#ownerByPort.set(port.id, node);
-          this.#incoming.set(port.id, []);
-          this.#outgoing.set(port.id, []);
-        }
-    for (const edge of graph.edges) {
-      this.#outgoing.get(edge.source)?.push(edge.target);
-      this.#incoming.get(edge.target)?.push(edge.source);
-    }
+    this.#incoming = topology.incoming;
+    this.#outgoing = topology.outgoing;
+    this.#layerByPort = topology.layerByPort;
+    this.#ownerByPort = topology.ownerByPort;
     for (const [layerIndex, side] of [
       [freeLayerIndex - 1, "EAST"],
       [freeLayerIndex + 1, "WEST"],

package/src/layered/hierarchy-sweepiness.ts

@@ -1,12 +1,16 @@
 /* Native adaptation of ELK 0.11.1 LayerSweepTypeDecider. SPDX-License-Identifier: EPL-2.0 */
 import { externalPortDummyOf } from "./external-port-dummy";
-import { getCrossingUnits } from "./crossing-constraints";
-import type { AcyclicOrientation, LayeredPhaseInput } from "./types";
+import type { CrossingGraph } from "./crossing-counter";
+import type { LayeredPhaseInput } from "./types";
 
+/**
+ * Whether a child graph is swept on its own before its parent. Like ELK, a
+ * node starts a random path when no western port carries an edge and ends one
+ * when no eastern port does, on the canonical crossing graph's port sides.
+ */
 export function useBottomUpHierarchySweep(
   input: LayeredPhaseInput,
-  orientation: AcyclicOrientation,
-  layers: readonly (readonly string[])[],
+  graph: CrossingGraph,
   parent: {
     portOrderFixed: boolean;
     inputPorts: number;
@@ -19,24 +23,27 @@ export function useBottomUpHierarchySweep(
     return true;
   if (parent.deterministic) return false;
   const nodes = new Map(input.graph.nodes.map((node) => [node.id, node]));
+  const owner = new Map<string, string>();
+  for (const node of graph.layers.flat())
+    for (const port of node.ports) owner.set(port.id, node.id);
+  const degree = new Map<string, number>(),
+    targets = new Map<string, string[]>();
+  for (const { source, target } of graph.edges) {
+    degree.set(source, (degree.get(source) ?? 0) + 1);
+    degree.set(target, (degree.get(target) ?? 0) + 1);
+    const from = owner.get(source)!;
+    targets.set(from, [...(targets.get(from) ?? []), owner.get(target)!]);
+  }
   const infos = new Map(
-    input.graph.nodes.map((node) => [node.id, { random: 0, hierarchy: 0, edges: 0 }]),
+    graph.layers.flat().map((node) => [node.id, { random: 0, hierarchy: 0, edges: 0 }]),
   );
-  const outgoing = new Map<string, string[]>(),
-    incoming = new Map<string, string[]>();
-  for (const edge of input.graph.edges) {
-    const reversed = orientation.reversedEdgeIds.has(edge.id);
-    const source = reversed ? edge.targetId : edge.sourceId,
-      target = reversed ? edge.sourceId : edge.targetId;
-    outgoing.set(source, [...(outgoing.get(source) ?? []), target]);
-    incoming.set(target, [...(incoming.get(target) ?? []), source]);
-  }
-  const units = getCrossingUnits(input);
   let randomPaths = 0,
     hierarchyPaths = 0;
   const transfer = (source: string, target: string) => {
     const a = infos.get(source)!,
       b = infos.get(target)!;
+    randomPaths += a.random;
+    hierarchyPaths += a.hierarchy;
     b.random += a.random;
     b.hierarchy += a.hierarchy;
     b.edges += a.edges + 1;
@@ -44,39 +51,28 @@ export function useBottomUpHierarchySweep(
   const outputSide = ({ right: "EAST", left: "WEST", down: "SOUTH", up: "NORTH" } as const)[
     input.direction
   ];
-  const passEdges = (id: string) => {
-    const state = infos.get(id)!;
-    for (const target of outgoing.get(id) ?? []) {
-      randomPaths += state.random;
-      hierarchyPaths += state.hierarchy;
-      transfer(id, target);
-    }
-  };
-  for (const layer of layers) {
+  for (const layer of graph.layers) {
     const northSouth: string[] = [];
-    for (const id of layer) {
-      if (id.startsWith("__layout_dummy:north-south:")) {
-        northSouth.push(id);
+    for (const node of layer) {
+      if (node.type === "NORTH_SOUTH_PORT") {
+        northSouth.push(node.id);
         continue;
       }
-      const node = nodes.get(id)!,
-        state = infos.get(id)!;
-      const external = externalPortDummyOf(node);
+      const state = infos.get(node.id)!;
+      const connected = (side: string) =>
+        node.ports.some((port) => port.side === side && degree.has(port.id));
+      const external = externalPortDummyOf(nodes.get(node.id)!);
       if (external) {
         state.hierarchy = 1;
         if (external.side === outputSide) hierarchyPaths += state.edges;
-      } else {
-        if (!incoming.get(id)?.length) state.random = 1;
-        else if (!outgoing.get(id)?.length) randomPaths += state.edges;
-      }
-      passEdges(id);
-      for (const dummy of units?.associates.get(id) ?? []) {
-        randomPaths += state.random;
-        hierarchyPaths += state.hierarchy;
-        transfer(id, dummy);
-      }
+      } else if (!connected("WEST")) state.random = 1;
+      else if (!connected("EAST")) randomPaths += state.edges;
+      for (const target of targets.get(node.id) ?? []) transfer(node.id, target);
+      for (const port of node.ports)
+        if ((port.side === "NORTH" || port.side === "SOUTH") && port.dummy)
+          transfer(node.id, port.dummy);
     }
-    for (const id of northSouth) passEdges(id);
+    for (const id of northSouth) for (const target of targets.get(id) ?? []) transfer(id, target);
   }
   const all = randomPaths + hierarchyPaths;
   return (all === 0 ? Number.POSITIVE_INFINITY : (randomPaths - hierarchyPaths) / all) >= boundary;

package/src/layered/index.ts

@@ -1436,15 +1436,16 @@ export function* createLayeredScopePipeline<N, E, G, P>(
     settings: options.settings ?? {},
     ...(options.nodeSettings === undefined ? {} : { nodeSettings: options.nodeSettings }),
     ...(options.edgeSettings === undefined ? {} : { edgeSettings: options.edgeSettings }),
-    portSettings: (port, node) => ({
-      ...options.portSettings?.(port, node),
-      ...(parallelPortIndexByKey.has(`${node.id}\0${port.name}`)
-        ? { "port.index": parallelPortIndexByKey.get(`${node.id}\0${port.name}`) }
-        : {}),
-      ...(switchedSideByPort.has(`${node.id}\0${port.name}`)
-        ? { "port.side": switchedSideByPort.get(`${node.id}\0${port.name}`) }
-        : {}),
-    }),
+    portSettings: (port, node) => {
+      const key = `${node.id}\0${port.name}`;
+      return {
+        ...options.portSettings?.(port, node),
+        ...(parallelPortIndexByKey.has(key)
+          ? { "port.index": parallelPortIndexByKey.get(key) }
+          : {}),
+        ...(switchedSideByPort.has(key) ? { "port.side": switchedSideByPort.get(key) } : {}),
+      };
+    },
   };
   const measure = <T>(id: string, run: () => T): T => {
     context?.throwIfAborted();
@@ -1697,12 +1698,16 @@ export function* createLayeredScopePipeline<N, E, G, P>(
     southEdges = new Set<string>();
   const upper = direction === "right" || direction === "left" ? "NORTH" : "WEST";
   const lower = direction === "right" || direction === "left" ? "SOUTH" : "EAST";
+  // First node per id, as `find` returns.
+  const endpointNodes = new Map<string, GraphNode>();
+  for (const node of expanded.input.graph.nodes)
+    if (!endpointNodes.has(node.id)) endpointNodes.set(node.id, node);
   for (const edge of expanded.input.graph.edges)
     for (const [id, name] of [
       [edge.sourceId, edge.sourcePort],
       [edge.targetId, edge.targetPort],
     ]) {
-      const node = expanded.input.graph.nodes.find((n) => n.id === id),
+      const node = endpointNodes.get(id!),
         port = node?.ports?.find((p) => p.name === name);
       const side =
         node && port ? expanded.input.portSettings?.(port, node)?.["port.side"] : undefined;
@@ -1894,17 +1899,6 @@ export function* createLayeredScopePipeline<N, E, G, P>(
       switchedSideByPort.set(`${origin.node.id}\0${origin.port.name}`, opposite);
     }
   }
-  // Preserve the existing merged-edge dummy policy without moving FIRST/LAST
-  // nodes after crossing minimization.
-  if (expanded.input.settings.mergeEdges === true) {
-    order = {
-      ...order,
-      layers: order.layers.map((layer) => [
-        ...layer.filter((id) => id.startsWith("__layout_dummy:")),
-        ...layer.filter((id) => !id.startsWith("__layout_dummy:")),
-      ]),
-    };
-  }
   const unzippingFanIn =
     graph.edges.length === graph.nodes.length - 1 &&
     graph.nodes.some(

package/src/layered/loop-envelopes.ts

@@ -7,6 +7,7 @@ import {
   routeFixedSelfLoop,
   selfLoopTracks,
 } from "./fixed-self-loop";
+import { findNode } from "./node-lookup";
 
 export interface LoopEnvelope {
   before: number;
@@ -23,7 +24,7 @@ export function hasMovableLoopPorts(input: LayeredPhaseInput, edge: GraphEdge):
     edge.targetPort !== undefined
   )
     return false;
-  const node = input.graph.nodes.find((candidate) => candidate.id === edge.sourceId);
+  const node = findNode(input.graph.nodes, edge.sourceId);
   const constraints = node && input.nodeSettings?.(node)?.portConstraints;
   return constraints === undefined || constraints === "FREE" || constraints === "UNDEFINED";
 }
@@ -31,10 +32,15 @@ export function hasMovableLoopPorts(input: LayeredPhaseInput, edge: GraphEdge):
 export function loopEnvelopes(input: LayeredPhaseInput): ReadonlyMap<string, LoopEnvelope> {
   const envelopes = new Map<string, LoopEnvelope>();
   if ((input.settings.edgeRouting ?? "ORTHOGONAL") !== "ORTHOGONAL") return envelopes;
+  const loopsByNodeId = new Map<string, GraphEdge[]>();
+  for (const edge of input.graph.edges)
+    if (edge.sourceId === edge.targetId) {
+      const loops = loopsByNodeId.get(edge.sourceId);
+      if (loops) loops.push(edge);
+      else loopsByNodeId.set(edge.sourceId, [edge]);
+    }
   for (const node of input.graph.nodes) {
-    const allLoops = input.graph.edges.filter(
-      (edge) => edge.sourceId === node.id && edge.targetId === node.id,
-    );
+    const allLoops = loopsByNodeId.get(node.id)?.slice() ?? [];
     const constraints = input.nodeSettings?.(node)?.portConstraints;
     if (
       allLoops.length &&

package/src/layered/node-lookup.ts

@@ -0,0 +1,29 @@
+import type { GraphNode } from "@statelyai/graph";
+
+// First position of each id per node list, rebuilt when the list's length
+// changes. Layout code only appends to node lists, never replaces entries in
+// place; positions are still checked on use and a miss scans like `find`.
+const indexByNodes = new WeakMap<
+  readonly GraphNode[],
+  { length: number; positions: Map<string, number> }
+>();
+
+function indexNodes(nodes: readonly GraphNode[]): Map<string, number> {
+  const positions = new Map<string, number>();
+  for (const [index, node] of nodes.entries())
+    if (!positions.has(node.id)) positions.set(node.id, index);
+  indexByNodes.set(nodes, { length: nodes.length, positions });
+  return positions;
+}
+
+/** Same as `nodes.find((node) => node.id === id)`, indexed per list. */
+export function findNode(nodes: readonly GraphNode[], id: string): GraphNode | undefined {
+  const cached = indexByNodes.get(nodes);
+  let position = (
+    cached && cached.length === nodes.length ? cached.positions : indexNodes(nodes)
+  ).get(id);
+  if (position !== undefined && nodes[position]?.id !== id) position = indexNodes(nodes).get(id);
+  return position !== undefined && nodes[position]?.id === id
+    ? nodes[position]
+    : nodes.find((node) => node.id === id);
+}

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;
 }