@statelyai/layout 0.4.0 → 0.4.2

package/dist/{layout-engine-DAw06RhN.cjs → layout-engine-BFP1TZbF.cjs}

@@ -1,4 +1,4 @@
-const require_layered = require('./layered-CBPg6_6_.cjs');
+const require_layered = require('./layered-BJu8A21s.cjs');
 let _statelyai_graph_layout = require("@statelyai/graph/layout");
 
 //#region src/fixed.ts

package/dist/{layout-engine-DC3IYkIy.mjs → layout-engine-DnlmGxHL.mjs}

@@ -1,4 +1,4 @@
-import { G as placePorts, R as getPolylineMidpoint, Y as JavaRandom, i as layeredAlgorithm, n as elkjs0111LayeredAlgorithm, x as setElkjs0111ResultPolicy } from "./layered-C7ERzZjR.mjs";
+import { K as placePorts, X as JavaRandom, i as layeredAlgorithm, n as elkjs0111LayeredAlgorithm, x as setElkjs0111ResultPolicy, z as getPolylineMidpoint } from "./layered-BsAdm_u8.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
 //#region src/fixed.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/layout",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Extensible, graph-native layout algorithms for @statelyai/graph",
   "license": "EPL-2.0 OR GPL-3.0-or-later",
   "repository": {

package/src/elkjs/index.ts

@@ -7,7 +7,7 @@ import {
   type LayeredLayoutOptions,
   type LayerOrder,
 } from "../layered";
-import { createLayerSweepSession } from "../layered/strategies";
+import { createLayerSweepSession, CROSSING_MODEL, type CrossingModel } from "../layered/strategies";
 import {
   minimizeHierarchyCrossings,
   type HierarchyCrossingScope,
@@ -83,6 +83,10 @@ export type {
 } from "./public-types";
 export type { ElkId, ElkLogging } from "./types";
 
+/** The crossing-model setting a layout passes to crossing minimization. */
+const crossingModel = Symbol("crossingModel");
+type ModelArguments = ElkLayoutArguments & { [crossingModel]?: CrossingModel };
+
 interface PreparedElkScope {
   graph: ElkNode;
   native: Graph;
@@ -168,21 +172,45 @@ export default class ELK {
     arguments_: ElkLayoutArguments = {},
   ): Promise<LaidOutElkNode<T>> {
     const options = { ...this.#options.defaultLayoutOptions, ...arguments_.layoutOptions };
-    const variants = crossingVariants(options, graph);
-    const pristine = variants.length ? structuredClone(graph) : undefined;
-    let best = separated(await this.#layoutWithoutDefectiveCompaction(graph, arguments_), options);
+    const seeds = crossingVariants(options, graph);
+    const probe = mayShareTracks(graph, options)
+      ? { mixedPorts: false, sharedTracks: false }
+      : undefined;
+    const pristine = seeds.length || probe ? structuredClone(graph) : undefined;
+    let best = separated(
+      await this.#layoutWithoutDefectiveCompaction(
+        graph,
+        probe ? { ...arguments_, [crossingModel]: { probe } } : arguments_,
+      ),
+      options,
+    );
     if (!pristine) return best;
-    // A compound layout with defects tries other random seeds and keeps the
-    // best measured result. Above ELK's default thoroughness, every compound
-    // layout does, trading time for fewer crossings and bends.
+    // Crossing minimization models a port carrying both directions as two
+    // ports with grouped neighbours, and counts hyperedges as ELK routes
+    // them. Each choice steers the sweeps into worse orders on some graphs,
+    // so a graph where the mixed-port model applied is also laid out without
+    // it, and one with a hyperedge that routing must split is also laid out
+    // counting that hyperedge edge by edge. The best result wins.
+    // A compound layout with defects tries other random seeds too. Above
+    // ELK's default thoroughness, every compound layout does, trading time
+    // for fewer crossings and bends.
+    const reseed =
+      seeds.length > 0 && (thorough(options, graph) || measureLayout(best, true).defects > 0);
+    const variants: ModelArguments[] = [
+      ...(probe?.mixedPorts ? [{ ...arguments_, [crossingModel]: { mixedPorts: false } }] : []),
+      ...(probe?.sharedTracks
+        ? [{ ...arguments_, [crossingModel]: { mixedPorts: false, separateSharedTracks: true } }]
+        : []),
+      ...(reseed ? seeds : []).map((variant) => ({
+        ...arguments_,
+        layoutOptions: { ...arguments_.layoutOptions, ...variant },
+      })),
+    ];
+    if (!variants.length) return best;
     let quality = measureLayout(best);
-    if (quality.defects === 0 && !thorough(options, graph)) return best;
     for (const variant of variants) {
       const candidate = separated(
-        await this.#layoutWithoutDefectiveCompaction(structuredClone(pristine), {
-          ...arguments_,
-          layoutOptions: { ...arguments_.layoutOptions, ...variant },
-        }),
+        await this.#layoutWithoutDefectiveCompaction(structuredClone(pristine), variant),
         options,
       );
       const candidateQuality = measureLayout(candidate);
@@ -196,7 +224,7 @@ export default class ELK {
 
   async #layoutWithoutDefectiveCompaction<T extends ElkNode>(
     graph: T,
-    arguments_: ElkLayoutArguments,
+    arguments_: ModelArguments,
   ): Promise<LaidOutElkNode<T>> {
     const compacting = usesPostCompaction(
       { ...this.#options.defaultLayoutOptions, ...arguments_.layoutOptions },
@@ -204,7 +232,7 @@ export default class ELK {
     );
     const pristine = compacting ? structuredClone(graph) : undefined;
     const result = await this.#layout(graph, arguments_);
-    const defects = pristine ? measureLayout(result).defects : 0;
+    const defects = pristine ? measureLayout(result, true).defects : 0;
     if (!pristine || defects === 0) return result;
     // Post-compaction is an optimization; it must not route edges through nodes
     // or fold a route back onto itself.
@@ -213,7 +241,7 @@ export default class ELK {
       ...arguments_,
       layoutOptions: { ...arguments_.layoutOptions, ...strategy },
     });
-    return measureLayout(uncompacted).defects < defects ? uncompacted : result;
+    return measureLayout(uncompacted, true).defects < defects ? uncompacted : result;
   }
 
   async #layout<T extends ElkNode>(
@@ -592,8 +620,19 @@ export default class ELK {
             const { sourceId, targetId } = originalHierarchyEndpoints.get(edge)!;
             const sourceInside = descendantOwnerByEndpointId.has(sourceId);
             const proxy = proxyFor(sourceInside ? "output" : "input", edge);
+            // ELK keeps center labels on the shallowest segment: the parent's,
+            // unless the edge enters through the child's own port.
+            const labels =
+              (graph.edges ?? []).includes(edge) && !ownPortFor(edge)
+                ? edge.labels?.filter(
+                    (label) =>
+                      (getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER") !==
+                      "CENTER",
+                  )
+                : edge.labels;
             const segment: ElkEdge = {
               ...edge,
+              labels,
               id: `__native_hierarchy_edge_${String(child.id)}_${String(edge.id)}`,
               sources: [sourceInside ? sourceId : proxy.ports![0]!.id!],
               targets: [sourceInside ? proxy.ports![0]!.id! : targetId],
@@ -1057,6 +1096,14 @@ export default class ELK {
       getOption(layoutOptions, "padding"),
       algorithm === "layered" ? 12 : 0,
     );
+    // Element options are replaced, never mutated, while a scope lays out; parse each once.
+    const parsedSettings = new WeakMap<object, ElkLayeredOptionValueByName>();
+    const elementSettings = (elementOptions: Readonly<Record<string, unknown>> | undefined) => {
+      const key = elementOptions ?? noElementOptions;
+      let settings = parsedSettings.get(key);
+      if (!settings) parsedSettings.set(key, (settings = getElementLayeredSettings(key)));
+      return settings;
+    };
     const options: LayeredLayoutOptions = {
       direction: getDirection(layoutOptions),
       spacing: {
@@ -1074,6 +1121,9 @@ export default class ELK {
       },
       settings: {
         ...getLayeredSettings(layoutOptions),
+        ...((arguments_ as ModelArguments)[crossingModel]
+          ? { [CROSSING_MODEL]: (arguments_ as ModelArguments)[crossingModel] }
+          : {}),
         ...(compoundLayout || (hasHierarchy && !separateHierarchy && !topdownLayout)
           ? { separateConnectedComponents: false }
           : {}),
@@ -1090,13 +1140,13 @@ export default class ELK {
       },
       nodeSettings: (node) => {
         const child = findById(graph.children, node.id)?.item;
-        return getElementLayeredSettings(child?.layoutOptions ?? {});
+        return elementSettings(child?.layoutOptions);
       },
       edgeSettings: (edge) => {
         const elkEdge = findById(graph.edges, edge.id)?.item;
         return {
-          ...getElementLayeredSettings(elkEdge?.layoutOptions ?? {}),
-          ...getElementLayeredSettings(elkEdge?.labels?.[0]?.layoutOptions ?? {}),
+          ...elementSettings(elkEdge?.layoutOptions),
+          ...elementSettings(elkEdge?.labels?.[0]?.layoutOptions),
           // ELK appends hierarchy segments to port edge lists in creation order.
           "edge.hierarchyRank": elkEdge && hierarchySegmentRank.get(elkEdge),
         };
@@ -1106,7 +1156,7 @@ export default class ELK {
         const found = findById(child?.ports, port.name);
         const elkPort = found?.item;
         return {
-          ...getElementLayeredSettings(elkPort?.layoutOptions ?? {}),
+          ...elementSettings(elkPort?.layoutOptions),
           // ELK imports ports in authored order and sorts sides after dummy insertion.
           "port.authoredIndex": found?.position,
           "port.labelWidth": Math.max(
@@ -1430,18 +1480,13 @@ function coordinatePreparedScopes(
       ).length;
       const childScope: HierarchyCrossingScope = {
         ...scopes.get(child)!,
-        useBottomUp: useBottomUpHierarchySweep(
-          childPhase.input,
-          childPhase.orientation,
-          childSession.snapshot().layers,
-          {
-            portOrderFixed: parentPortOrderFixed,
-            inputPorts,
-            outputPorts,
-            deterministic:
-              child.options?.settings?.["crossingMinimization.strategy"] === "MEDIAN_LAYER_SWEEP",
-          },
-        ),
+        useBottomUp: useBottomUpHierarchySweep(childPhase.input, childSession.crossingGraph(), {
+          portOrderFixed: parentPortOrderFixed,
+          inputPorts,
+          outputPorts,
+          deterministic:
+            child.options?.settings?.["crossingMinimization.strategy"] === "MEDIAN_LAYER_SWEEP",
+        }),
         alignBoundary: (forward) => {
           const childLayers = childSession.currentLayers();
           const layerIndex = forward ? 0 : childLayers.length - 1;
@@ -1709,8 +1754,16 @@ function applyNodeMicroLayout(
   }
 }
 
+// Accepted spellings per option suffix, built once.
+const exactKeysBySuffix = new Map<string, readonly string[]>();
+
 function getOption(options: Readonly<Record<string, unknown>>, suffix: string): unknown {
-  const exactKeys = [suffix, `elk.${suffix}`, `org.eclipse.elk.${suffix}`];
+  let exactKeys = exactKeysBySuffix.get(suffix);
+  if (!exactKeys)
+    exactKeysBySuffix.set(
+      suffix,
+      (exactKeys = [suffix, `elk.${suffix}`, `org.eclipse.elk.${suffix}`]),
+    );
   for (const key of exactKeys) {
     if (options[key] !== undefined) return options[key];
   }
@@ -1795,6 +1848,8 @@ function findById<T extends { id?: ElkId }>(items: readonly T[] | undefined, id:
   return position === undefined ? undefined : { item: items[position]!, position };
 }
 
+const noElementOptions: Readonly<Record<string, unknown>> = {};
+
 function getElementLayeredSettings(
   options: Readonly<Record<string, unknown>>,
 ): ElkLayeredOptionValueByName {
@@ -2761,12 +2816,18 @@ function elkBoundaryEdgeOrder(
       if (child.children?.length)
         for (const edge of order(child)) if (leaves(edge)) result.add(edge);
     for (const child of node.children ?? []) {
-      for (const port of [...(child.ports ?? []).map((p) => String(p.id)), String(child.id)]) {
+      for (const port of (child.ports ?? []).map((p) => String(p.id))) {
         for (const edge of edges)
           if (endpoints(edge).sourceId === port && leaves(edge)) result.add(edge);
         for (const edge of edges)
           if (endpoints(edge).targetId === port && leaves(edge)) result.add(edge);
       }
+      // Each edge on the node itself gets its own implicit port, in import order.
+      const id = String(child.id);
+      for (const edge of edges) {
+        const { sourceId, targetId } = endpoints(edge);
+        if ((sourceId === id || targetId === id) && leaves(edge)) result.add(edge);
+      }
     }
     return [...result];
   };
@@ -2841,6 +2902,47 @@ function crossingVariants(
   return [{ "elk.randomSeed": "2" }, { "elk.randomSeed": "3" }];
 }
 
+/**
+ * Whether two edges between different ends can share a port: an explicit port
+ * carrying two or more of them, or implicit ports that merge because some
+ * scope merges edges or a node is a hypernode.
+ */
+function mayShareTracks(graph: ElkNode, options: Readonly<Record<string, unknown>>): boolean {
+  const merging = (node: ElkNode, inherited: Readonly<Record<string, unknown>> = {}) => {
+    const settings = getElementLayeredSettings({
+      ...inherited,
+      ...node.properties,
+      ...node.layoutOptions,
+    });
+    return settings.mergeEdges === true || settings.hypernode === true;
+  };
+  const anyMerging = (node: ElkNode): boolean =>
+    merging(node) || (node.children ?? []).some(anyMerging);
+  if (merging(graph, options) || (graph.children ?? []).some(anyMerging)) return true;
+  const ports = new Set<string>();
+  const collectPorts = (node: ElkNode) => {
+    for (const port of node.ports ?? []) ports.add(String(port.id));
+    for (const child of node.children ?? []) collectPorts(child);
+  };
+  collectPorts(graph);
+  if (!ports.size) return false;
+  const seen = new Set<string>();
+  const visit = (node: ElkNode): boolean => {
+    for (const edge of node.edges ?? []) {
+      const source = String(edge.sources?.[0] ?? edge.source),
+        target = String(edge.targets?.[0] ?? edge.target);
+      if (source === target) continue;
+      for (const end of [source, target]) {
+        if (!ports.has(end)) continue;
+        if (seen.has(end)) return true;
+        seen.add(end);
+      }
+    }
+    return (node.children ?? []).some(visit);
+  };
+  return visit(graph);
+}
+
 /** Whether the graph asks for more than ELK's default layered thoroughness (7). */
 function thorough(options: Readonly<Record<string, unknown>>, graph: ElkNode): boolean {
   const own = { ...options, ...graph.properties, ...graph.layoutOptions };

package/src/elkjs/layout-quality.ts

@@ -35,14 +35,18 @@ const strictlyInside = (value: number, low: number, high: number) =>
   value > low + EPS && value < high - EPS;
 const overlapLength = (a: readonly [number, number], b: readonly [number, number]) =>
   Math.max(0, Math.min(a[1], b[1]) - Math.max(a[0], b[0]));
+/** Within `margin` of the rectangle, its border included. */
 const inRect = (point: Point, rect: Rect, margin: number) =>
-  point.x > rect.x - margin &&
-  point.x < rect.x + rect.width + margin &&
-  point.y > rect.y - margin &&
-  point.y < rect.y + rect.height + margin;
+  point.x >= rect.x - margin - EPS &&
+  point.x <= rect.x + rect.width + margin + EPS &&
+  point.y >= rect.y - margin - EPS &&
+  point.y <= rect.y + rect.height + margin + EPS;
 
-/** Measure an ELK JSON result in absolute coordinates. */
-export function measureLayout(root: ElkNode): LayoutQuality {
+/**
+ * Measure an ELK JSON result in absolute coordinates. `defectsOnly` skips the
+ * pairwise route measures (crossings and overlap stay 0).
+ */
+export function measureLayout(root: ElkNode, defectsOnly = false): LayoutQuality {
   const frames = new Map<string, Point>([[String(root.id), { x: 0, y: 0 }]]);
   const rects = new Map<string, Rect>();
   const owner = new Map<string, string>();
@@ -64,7 +68,8 @@ export function measureLayout(root: ElkNode): LayoutQuality {
   };
   place(root, { x: 0, y: 0 });
 
-  const routes: Array<{ ends: string[]; segments: Segment[]; labels: Rect[] }> = [];
+  const routes: Array<{ ends: string[]; segments: Segment[]; visible: Segment[]; labels: Rect[] }> =
+    [];
   let defects = 0,
     bends = 0,
     length = 0;
@@ -127,7 +132,13 @@ export function measureLayout(root: ElkNode): LayoutQuality {
       for (const [index, first] of segments.entries())
         for (const second of segments.slice(index + 1))
           if (sharedLength(first, second) > EPS) defects++;
-      routes.push({ ends, segments, labels });
+      routes.push({
+        ends,
+        segments,
+        visible:
+          labels.length && !defectsOnly ? segments.flatMap((s) => outsideAll(s, labels)) : segments,
+        labels,
+      });
     }
     for (const child of parent.children ?? []) collect(child);
   };
@@ -164,33 +175,42 @@ export function measureLayout(root: ElkNode): LayoutQuality {
 
   let crossings = 0,
     overlap = 0;
-  for (const [index, first] of routes.entries())
-    for (const second of routes.slice(index + 1)) {
-      const shared = first.ends
-        .filter((id) => second.ends.includes(id))
-        .flatMap((id) => {
-          const rect = rects.get(id);
-          return rect ? [rect] : [];
-        });
-      const clear = (point: Point) => shared.every((rect) => !inRect(point, rect, TERMINAL_MARGIN));
-      for (const s of first.segments)
-        for (const t of second.segments) {
+  if (!defectsOnly)
+    for (const [index, first] of routes.entries())
+      for (const second of routes.slice(index + 1)) {
+        const shared = first.ends
+          .filter((id) => second.ends.includes(id))
+          .flatMap((id) => {
+            const rect = rects.get(id);
+            return rect ? [rect] : [];
+          });
+        const clear = (point: Point) =>
+          shared.every((rect) => !inRect(point, rect, TERMINAL_MARGIN));
+        // A crossing under an edge's own label is not seen; two routes crossing
+        // at one point cross once.
+        let points: Set<string> | undefined;
+        const cross = (s: Segment, t: Segment) => {
           const h = horizontal(s) && vertical(t) ? s : horizontal(t) && vertical(s) ? t : undefined;
-          if (h) {
-            const v = h === s ? t : s;
-            const point = { x: v.a.x, y: h.a.y };
-            if (
-              strictlyInside(point.x, ...span(h, "x")) &&
-              strictlyInside(point.y, ...span(v, "y")) &&
-              clear(point)
-            )
-              crossings++;
-            continue;
+          if (!h) return;
+          const v = h === s ? t : s;
+          const point = { x: v.a.x, y: h.a.y };
+          if (
+            strictlyInside(point.x, ...span(h, "x")) &&
+            strictlyInside(point.y, ...span(v, "y")) &&
+            clear(point)
+          )
+            (points ??= new Set()).add(`${Math.round(point.x / EPS)}:${Math.round(point.y / EPS)}`);
+        };
+        const unlabeled = first.visible === first.segments && second.visible === second.segments;
+        for (const s of first.segments)
+          for (const t of second.segments) {
+            if (unlabeled) cross(s, t);
+            const shared = sharedLength(s, t);
+            if (shared > EPS && clear(s.a) && clear(s.b)) overlap += shared;
           }
-          const shared = sharedLength(s, t);
-          if (shared > EPS && clear(s.a) && clear(s.b)) overlap += shared;
-        }
-    }
+        if (!unlabeled) for (const s of first.visible) for (const t of second.visible) cross(s, t);
+        crossings += points?.size ?? 0;
+      }
   const xs = bounds.map((point) => point.x).filter(Number.isFinite),
     ys = bounds.map((point) => point.y).filter(Number.isFinite);
   const area = xs.length
@@ -199,6 +219,34 @@ export function measureLayout(root: ElkNode): LayoutQuality {
   return { defects, crossings, overlap, bends, length, area };
 }
 
+/** The parts of an axis-parallel segment outside the open interiors of `rects`. */
+function outsideAll(segment: Segment, rects: readonly Rect[]): Segment[] {
+  let parts = [segment];
+  for (const rect of rects)
+    parts = parts.flatMap((part) => {
+      const axis = horizontal(part) ? "x" : vertical(part) ? "y" : undefined;
+      if (!axis) return [part];
+      const cross = axis === "x" ? "y" : "x";
+      const [low, high] =
+        axis === "x" ? [rect.x, rect.x + rect.width] : [rect.y, rect.y + rect.height];
+      const [crossLow, crossHigh] =
+        cross === "x" ? [rect.x, rect.x + rect.width] : [rect.y, rect.y + rect.height];
+      if (!strictlyInside(part.a[cross], crossLow, crossHigh)) return [part];
+      const [from, to] = span(part, axis);
+      if (overlapLength([from, to], [low, high]) <= EPS) return [part];
+      const at = (value: number) => ({ ...part.a, [axis]: value }) as Point;
+      return (
+        [
+          [from, Math.max(from, low)],
+          [Math.min(to, high), to],
+        ] as const
+      )
+        .filter(([a, b]) => b - a > EPS)
+        .map(([a, b]) => ({ a: at(a), b: at(b) }));
+    });
+  return parts;
+}
+
 function sharedLength(s: Segment, t: Segment): number {
   if (horizontal(s) && horizontal(t) && Math.abs(s.a.y - t.a.y) < EPS)
     return overlapLength(span(s, "x"), span(t, "x"));

package/src/layered/bk-node-placement.ts

@@ -328,11 +328,17 @@ function buildNeighbors(input: LayeredPhaseInput, order: LayerOrder) {
   };
   // Routing gives fixed-side self-loop terminals on shared-slot ports a slot
   // among the side's other edges (after them here), so anchors reserve it.
+  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]);
+    }
   const loopTerminals = (id: string, side: string): number => {
     const node = nodeById.get(id);
     if (!node) return 0;
-    return input.graph.edges
-      .filter((edge) => edge.sourceId === id && edge.targetId === id)
+    return (loopsByNodeId.get(id) ?? [])
       .flatMap((edge) => [edge.sourcePort, edge.targetPort])
       .filter((name) => {
         const port = node.ports?.find((candidate) => candidate.name === name);
@@ -515,11 +521,8 @@ function alignBlocks(
       const adjacent = (bal.hdir === "LEFT" ? neighbors.right : neighbors.left).get(id) ?? [];
       const low = Math.floor((adjacent.length + 1) / 2) - 1;
       const high = Math.ceil((adjacent.length + 1) / 2) - 1;
-      const indices =
-        bal.vdir === "UP"
-          ? Array.from({ length: Math.max(0, high - low + 1) }, (_, i) => high - i)
-          : Array.from({ length: Math.max(0, high - low + 1) }, (_, i) => low + i);
-      for (const median of indices) {
+      for (let i = 0; i < high - low + 1; i++) {
+        const median = bal.vdir === "UP" ? high - i : low + i;
         if (bal.align.get(id) !== id) break;
         const neighbor = adjacent[median];
         if (neighbor === undefined) continue;

package/src/layered/crossing-counter.ts

@@ -3,7 +3,7 @@
  * Native adaptation of ELK AllCrossingsCounter and CrossingsCounter.
  * SPDX-License-Identifier: EPL-2.0
  */
-import { countOrthogonalHypersegmentCrossings } from "./orthogonal-hypersegments";
+import { scoreOrthogonalHypersegments } from "./orthogonal-hypersegments";
 
 export interface CrossingPort {
   id: string;
@@ -29,6 +29,8 @@ export interface CrossingScore {
   inLayer: number;
   northSouth: number;
   total: number;
+  /** Some hyperedge joins two or more ports on each side of its gap. */
+  sharedTracks: boolean;
 }
 
 class IndexTree {
@@ -61,9 +63,11 @@ class IndexTree {
 /** Score a canonical candidate without changing its node or port orders. */
 export function countAllCrossings(
   graph: CrossingGraph,
-  boundaryMode: "hyperedges" | "edges" = "hyperedges",
+  /** "separated" counts hyperedges like ELK unless they would share a track (see scoreOrthogonalHypersegments). */
+  boundaryMode: "hyperedges" | "separated" | "edges" = "hyperedges",
 ): CrossingScore {
-  const nodes = new Map(graph.layers.flat().map((node) => [node.id, node]));
+  // Only north/south counting resolves nodes by id.
+  let nodes: Map<string, CrossingNode> | undefined;
   const layerByPort = new Map<string, number>();
   const incoming = new Map<string, string[]>(),
     outgoing = new Map<string, string[]>();
@@ -78,7 +82,6 @@ export function countAllCrossings(
     outgoing.get(edge.source)!.push(edge.target);
     incoming.get(edge.target)!.push(edge.source);
   }
-  const connected = (id: string) => [...incoming.get(id)!, ...outgoing.get(id)!];
   const degree = (id: string) => incoming.get(id)!.length + outgoing.get(id)!.length;
   const face = (layer: readonly CrossingNode[], side: "EAST" | "WEST", topDown = true) =>
     (topDown ? layer : [...layer].reverse()).flatMap((node) => {
@@ -92,7 +95,11 @@ export function countAllCrossings(
     for (const [position, port] of ports.entries()) {
       tree.remove(position);
       const pending: number[] = [];
-      for (const peer of connected(port.id)) {
+      // Incoming then outgoing peers, without concatenating them.
+      const before = incoming.get(port.id)!,
+        after = outgoing.get(port.id)!;
+      for (let index = 0; index < before.length + after.length; index++) {
+        const peer = index < before.length ? before[index]! : after[index - before.length]!;
         if (inLayerOnly && layerByPort.get(peer) !== layerByPort.get(port.id)) {
           crossings += tree.size;
           continue;
@@ -141,7 +148,9 @@ export function countAllCrossings(
       const node = ownerByPort.get(port.id)!;
       const targets =
         node.type === "NORMAL"
-          ? nodes.get(port.dummy!)!.ports.map((peer) => ({ id: peer.id, degree: degree(peer.id) }))
+          ? (nodes ??= new Map(graph.layers.flat().map((node) => [node.id, node])))
+              .get(port.dummy!)!
+              .ports.map((peer) => ({ id: peer.id, degree: degree(peer.id) }))
           : node.type === "LONG_EDGE"
             ? node.ports
                 .filter((peer) => peer.id !== port.id)
@@ -162,7 +171,13 @@ export function countAllCrossings(
     }
     return crossings;
   };
-  const score: CrossingScore = { betweenLayers: 0, inLayer: 0, northSouth: 0, total: 0 };
+  const score: CrossingScore = {
+    betweenLayers: 0,
+    inLayer: 0,
+    northSouth: 0,
+    total: 0,
+    sharedTracks: false,
+  };
   if (!graph.layers.length) return score;
   score.inLayer += countPorts(face(graph.layers[0]!, "WEST"), true);
   score.inLayer += countPorts(face(graph.layers.at(-1)!, "EAST"), true);
@@ -174,7 +189,7 @@ export function countAllCrossings(
           node.ports.some((port) => port.side === "EAST" && degree(port.id) > 1),
         ) ||
         next.some((node) => node.ports.some((port) => port.side === "WEST" && degree(port.id) > 1));
-      if (hyper && boundaryMode === "hyperedges") {
+      if (hyper && boundaryMode !== "edges") {
         const sourcePorts = layer
           .flatMap((node) => node.ports)
           .filter((port) => outgoing.get(port.id)!.some((peer) => layerByPort.get(peer) !== index));
@@ -189,7 +204,7 @@ export function countAllCrossings(
         });
         const sources = new Set(sourcePorts.map((port) => port.id)),
           targets = new Set(targetPorts.map((port) => port.id));
-        score.betweenLayers += countOrthogonalHypersegmentCrossings(
+        const hyperedges = scoreOrthogonalHypersegments(
           [
             ...sourcePorts.map((port, position) => ({
               id: port.id,
@@ -203,7 +218,10 @@ export function countAllCrossings(
             })),
           ],
           graph.edges.filter((edge) => sources.has(edge.source) && targets.has(edge.target)),
+          boundaryMode === "separated",
         );
+        score.betweenLayers += hyperedges.count;
+        score.sharedTracks ||= hyperedges.shared;
         score.inLayer +=
           countPorts(face(layer, "EAST"), true) + countPorts(face(next, "WEST"), true);
       } else {

package/src/layered/crossing-graph.ts

@@ -353,8 +353,8 @@ export function splitMixedCrossingPorts(
   const directions = new Map<string, number>();
   graph.edges.forEach((edge, index) => {
     const bit = reversed[index] ? 2 : 1;
-    for (const port of [edge.source, edge.target])
-      directions.set(port, (directions.get(port) ?? 0) | bit);
+    directions.set(edge.source, (directions.get(edge.source) ?? 0) | bit);
+    directions.set(edge.target, (directions.get(edge.target) ?? 0) | bit);
   });
   const mixed = new Set<string>();
   for (const layer of graph.layers)