@statelyai/layout 0.4.0 → 0.4.1

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],
@@ -1074,6 +1113,9 @@ export default class ELK {
       },
       settings: {
         ...getLayeredSettings(layoutOptions),
+        ...((arguments_ as ModelArguments)[crossingModel]
+          ? { [CROSSING_MODEL]: (arguments_ as ModelArguments)[crossingModel] }
+          : {}),
         ...(compoundLayout || (hasHierarchy && !separateHierarchy && !topdownLayout)
           ? { separateConnectedComponents: false }
           : {}),
@@ -1430,18 +1472,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;
@@ -2761,12 +2798,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 +2884,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/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,7 +63,8 @@ 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]));
   const layerByPort = new Map<string, number>();
@@ -162,7 +165,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 +183,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 +198,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 +212,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/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

@@ -1894,17 +1894,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(