@statelyai/layout 0.4.0 → 0.4.2

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,
@@ -60,7 +60,13 @@ import type { ElkLayeredOptionValueByName } from "./elk-options";
 import { conservativeSpline } from "./spline-bezier";
 import { getFlexiblePortPosition } from "./flexible-ports";
 import { traceLayeredPhase } from "../internal/layered-trace";
-import { assertNorthSouthPortSides, GreedySwitchDecider } from "./greedy-switch-decider";
+import {
+  assertNorthSouthPortSides,
+  GreedySwitchDecider,
+  greedySwitchTopology,
+  type GreedySwitchTopology,
+} from "./greedy-switch-decider";
+import { findNode } from "./node-lookup";
 
 const modelSweepInputs = new WeakSet<LayeredPhaseInput>();
 
@@ -124,6 +130,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 +842,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))];
     }),
   };
 }
@@ -1022,6 +1039,8 @@ export function applyGreedySwitch(
       (layerIndex + 1 < layers.length ? countBoundary(layerIndex) : 0)
     );
   };
+  // Switches stay within layers, so port connectivity and layers are fixed.
+  let greedyTopology: GreedySwitchTopology | undefined;
   const sweep = (forward: boolean): boolean => {
     let changed = false;
     const indices = forward
@@ -1038,6 +1057,7 @@ export function applyGreedySwitch(
           greedyGraph,
           layerIndex,
           type === "ONE_SIDED" ? (forward ? "WEST" : "EAST") : undefined,
+          (greedyTopology ??= greedySwitchTopology(greedyGraph)),
         );
         do {
           improved = false;
@@ -1897,6 +1917,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. */
@@ -1911,7 +1933,9 @@ export interface LayerSweepSession {
 }
 
 function clonePortOrders(orders?: ReadonlyMap<string, readonly string[]>): Map<string, string[]> {
-  return new Map([...(orders ?? [])].map(([id, edges]) => [id, [...edges]]));
+  const clone = new Map<string, string[]>();
+  if (orders) for (const [id, edges] of orders) clone.set(id, edges.slice());
+  return clone;
 }
 
 function minimizeCrossingsWithLayerSweep(
@@ -1984,6 +2008,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 +2087,12 @@ 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;
+  // Reused per count: physical port positions of one node.
+  const physicalSlot = new Map<string, number>();
   const countCrossings = (candidateLayers: readonly (readonly string[])[]): number => {
     if (exactPortSweep) {
       const graph = buildCrossingGraph(
@@ -2045,7 +2101,27 @@ 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;
+          physicalSlot.clear();
+          for (const [index, port] of physical.entries()) physicalSlot.set(port.id, index);
+          if (node.ports.every((port) => physicalSlot.has(port.id)))
+            node.ports.sort((a, b) => physicalSlot.get(a.id)! - physicalSlot.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 +2227,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]!;
@@ -2223,6 +2300,20 @@ export function createLayerSweepSession(
     // and same-layer recursion must not be separated into independent sums.
     for (const id of freeLayer) {
       const order = (forward ? inputPortOrder : outputPortOrder).get(id) ?? [];
+      const visit = (edgeId: string) => {
+        const edge = edgeById.get(edgeId)!;
+        const [source, target] = getOrientedEndpoints(edge, orientation);
+        const neighbor = forward ? source : target;
+        const rank = edgeRanks.get(edgeId);
+        if (assignment.layerByNodeId.get(neighbor) === assignment.layerByNodeId.get(id))
+          visits.get(id)!.push(neighbor);
+        else if (rank !== undefined) visits.get(id)!.push(rank);
+      };
+      // One edge forms one group; nothing to sort.
+      if (order.length < 2) {
+        for (const edgeId of order) visit(edgeId);
+        continue;
+      }
       const groups = new Map<string, string[]>();
       for (const edgeId of order) {
         const edge = edgeById.get(edgeId)!;
@@ -2233,25 +2324,18 @@ export function createLayerSweepSession(
         if (group) group.push(edgeId);
         else groups.set(key, [edgeId]);
       }
+      // Port sorting reorders ports, not the edges on one port; those keep
+      // ELK's edge list order. Expanded segments keep their listed edge id.
+      const listed = units?.edgeListRanks?.[forward ? "incoming" : "outgoing"].get(id);
+      const rank = (edgeId: string) => listed?.get(listedEdgeId(edgeId));
       for (const group of groups.values()) {
-        // Port sorting reorders ports, not the edges on one port; those keep
-        // ELK's edge list order. Expanded segments keep their listed edge id.
-        const listed = units?.edgeListRanks?.[forward ? "incoming" : "outgoing"].get(id);
-        const rank = (edgeId: string) => listed?.get(listedEdgeId(edgeId));
-        group.sort(
-          (a, b) =>
-            (rank(a) !== undefined && rank(b) !== undefined ? rank(a)! - rank(b)! : 0) ||
-            edgeModelOrder.get(a)! - edgeModelOrder.get(b)!,
-        );
-        for (const edgeId of group) {
-          const edge = edgeById.get(edgeId)!;
-          const [source, target] = getOrientedEndpoints(edge, orientation);
-          const neighbor = forward ? source : target;
-          const rank = edgeRanks.get(edgeId);
-          if (assignment.layerByNodeId.get(neighbor) === assignment.layerByNodeId.get(id))
-            visits.get(id)!.push(neighbor);
-          else if (rank !== undefined) visits.get(id)!.push(rank);
-        }
+        if (group.length > 1)
+          group.sort(
+            (a, b) =>
+              (rank(a) !== undefined && rank(b) !== undefined ? rank(a)! - rank(b)! : 0) ||
+              edgeModelOrder.get(a)! - edgeModelOrder.get(b)!,
+          );
+        for (const edgeId of group) visit(edgeId);
       }
     }
     return { ranks, visits };
@@ -2288,6 +2372,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]!]),
   );
@@ -2316,6 +2412,13 @@ export function createLayerSweepSession(
     });
     for (const index of touched)
       for (const node of canonicalGraph.layers[index]!) {
+        // One port leaves every edge order tied, and one edge has no order.
+        if (
+          node.ports.length < 2 ||
+          ((outputPortOrder.get(node.id)?.length ?? 0) < 2 &&
+            (inputPortOrder.get(node.id)?.length ?? 0) < 2)
+        )
+          continue;
         const ordinal = new Map(node.ports.map((port, index) => [port.id, index]));
         for (const [orders, source] of [
           [outputPortOrder, true],
@@ -2386,6 +2489,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 +2512,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.
@@ -2638,17 +2743,27 @@ export function createLayerSweepSession(
     shuffleFirstLayer,
     sweep,
     countCrossings: () => countCrossings(working),
-    snapshot: () => ({
-      physicalPortOrderByNodeId: new Map(
-        [...canonicalNodes].map(([id, node]) => [id, node.ports.map((port) => port.id)]),
-      ),
-      layers: working.map((layer) => [...layer]),
-      inputPortOrderByNodeId: clonePortOrders(inputPortOrder),
-      outputPortOrderByNodeId: clonePortOrders(outputPortOrder),
-    }),
+    snapshot: () => {
+      const physicalPortOrderByNodeId = new Map<string, string[]>();
+      for (const [id, node] of canonicalNodes)
+        physicalPortOrderByNodeId.set(
+          id,
+          node.ports.map((port) => port.id),
+        );
+      return {
+        physicalPortOrderByNodeId,
+        layers: working.map((layer) => [...layer]),
+        inputPortOrderByNodeId: clonePortOrders(inputPortOrder),
+        outputPortOrderByNodeId: clonePortOrders(outputPortOrder),
+      };
+    },
     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) ?? [],
@@ -3341,7 +3456,7 @@ function nodeFlowOffset(
   layerByNodeId: ReadonlyMap<string, number>,
   margins?: { leading: number; trailing: number; maxLeading: number; maxTrailing: number },
 ): number {
-  const node = input.graph.nodes.find((candidate) => candidate.id === id);
+  const node = findNode(input.graph.nodes, id);
   const alignment = node
     ? (input.nodeSettings?.(node)?.alignment ?? input.settings.alignment)
     : input.settings.alignment;
@@ -3707,7 +3822,85 @@ function implicitEdgeEndpoints(
 ): ReadonlyMap<string, { source: Point; target: Point }> {
   const horizontal = input.direction === "left" || input.direction === "right";
   const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
-  const groups = new Map<string, Array<{ edge: GraphEdge; endpoint: "source" | "target" }>>();
+  // Settings stay fixed for the call; resolve each node's and port's once.
+  const nodeSettingsByNode = new Map<
+    GraphNode,
+    ReturnType<NonNullable<typeof input.nodeSettings>>
+  >();
+  const nodeSettingsOf = (node: GraphNode) => {
+    if (!nodeSettingsByNode.has(node)) nodeSettingsByNode.set(node, input.nodeSettings?.(node));
+    return nodeSettingsByNode.get(node);
+  };
+  // Port settings depend on the owning node too, so cache them per node.
+  const portSettingsByNode = new Map<
+    GraphNode,
+    Map<GraphPort, ReturnType<NonNullable<typeof input.portSettings>>>
+  >();
+  const portSettingsOf = (port: GraphPort, node: GraphNode) => {
+    let byPort = portSettingsByNode.get(node);
+    if (!byPort) portSettingsByNode.set(node, (byPort = new Map()));
+    if (!byPort.has(port)) byPort.set(port, input.portSettings?.(port, node));
+    return byPort.get(port);
+  };
+  // Endpoint groups by side and node, in first-entry order.
+  type EndpointGroup = {
+    nodeId: string;
+    side: string;
+    entries: Array<{ edge: GraphEdge; endpoint: "source" | "target" }>;
+  };
+  const groups: EndpointGroup[] = [];
+  const groupsBySide = new Map<string, Map<string, EndpointGroup>>();
+  const modelOrderPromotion =
+    input.settings["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT";
+  const directionReversed = input.direction === "left" || input.direction === "up";
+  const endpointSide = (nodeId: string, portName: string | undefined): string | undefined => {
+    const node = nodeById.get(nodeId);
+    const port = node?.ports?.find((candidate) => candidate.name === portName);
+    const constraints = node ? nodeSettingsOf(node)?.portConstraints : undefined;
+    if (
+      !node ||
+      !port ||
+      (constraints !== "FIXED_SIDE" &&
+        constraints !== "FIXED_ORDER" &&
+        constraints !== "FIXED_RATIO" &&
+        constraints !== "FIXED_POS")
+    ) {
+      return undefined;
+    }
+    const configured = portSettingsOf(port, node)?.["port.side"];
+    return configured === "WEST" || configured === "NORTH"
+      ? "before"
+      : configured === "EAST" || configured === "SOUTH"
+        ? "after"
+        : undefined;
+  };
+  const fixedImplicitSide = (nodeId: string, portName: string | undefined, source: boolean) => {
+    const node = nodeById.get(nodeId);
+    const constraints = node && nodeSettingsOf(node)?.portConstraints;
+    if (
+      portName !== undefined ||
+      !["FIXED_SIDE", "FIXED_ORDER", "FIXED_RATIO", "FIXED_POS"].includes(String(constraints))
+    )
+      return undefined;
+    // ELK assigns implicit port sides before cycle breaking. Fixed sides
+    // survive edge reversal; a feedback edge cannot move its endpoint.
+    return source !== directionReversed ? "after" : "before";
+  };
+  const addEntry = (
+    nodeId: string,
+    side: string,
+    entry: { edge: GraphEdge; endpoint: "source" | "target" },
+  ) => {
+    let byNode = groupsBySide.get(side);
+    if (!byNode) groupsBySide.set(side, (byNode = new Map()));
+    const group = byNode.get(nodeId);
+    if (group) group.entries.push(entry);
+    else {
+      const created = { nodeId, side, entries: [entry] };
+      byNode.set(nodeId, created);
+      groups.push(created);
+    }
+  };
   for (const edge of input.graph.edges) {
     if (hasMovableLoopPorts(input, edge)) continue;
     const sourceRect = placement.rectByNodeId.get(edge.sourceId);
@@ -3715,8 +3908,6 @@ function implicitEdgeEndpoints(
     if (!sourceRect || !targetRect) continue;
     const sourceFlow = horizontal ? sourceRect.x : sourceRect.y;
     const targetFlow = horizontal ? targetRect.x : targetRect.y;
-    const modelOrderPromotion =
-      input.settings["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT";
     const sourceBoundary = externalPortDummyOf(nodeById.get(edge.sourceId) ?? {});
     const targetBoundary = externalPortDummyOf(nodeById.get(edge.targetId) ?? {});
     // A zero-gap boundary can coincide with the node's flow origin.
@@ -3729,40 +3920,6 @@ function implicitEdgeEndpoints(
         : sourceFlow <= targetFlow);
     const feedback =
       input.settings.feedbackEdges === true && orientation?.reversedEdgeIds.has(edge.id) === true;
-    const directionReversed = input.direction === "left" || input.direction === "up";
-    const endpointSide = (nodeId: string, portName: string | undefined): string | undefined => {
-      const node = nodeById.get(nodeId);
-      const port = node?.ports?.find((candidate) => candidate.name === portName);
-      const constraints = node ? input.nodeSettings?.(node)?.portConstraints : undefined;
-      if (
-        !node ||
-        !port ||
-        (constraints !== "FIXED_SIDE" &&
-          constraints !== "FIXED_ORDER" &&
-          constraints !== "FIXED_RATIO" &&
-          constraints !== "FIXED_POS")
-      ) {
-        return undefined;
-      }
-      const configured = input.portSettings?.(port, node)?.["port.side"];
-      return configured === "WEST" || configured === "NORTH"
-        ? "before"
-        : configured === "EAST" || configured === "SOUTH"
-          ? "after"
-          : undefined;
-    };
-    const fixedImplicitSide = (nodeId: string, portName: string | undefined, source: boolean) => {
-      const node = nodeById.get(nodeId);
-      const constraints = node && input.nodeSettings?.(node)?.portConstraints;
-      if (
-        portName !== undefined ||
-        !["FIXED_SIDE", "FIXED_ORDER", "FIXED_RATIO", "FIXED_POS"].includes(String(constraints))
-      )
-        return undefined;
-      // ELK assigns implicit port sides before cycle breaking. Fixed sides
-      // survive edge reversal; a feedback edge cannot move its endpoint.
-      return source !== directionReversed ? "after" : "before";
-    };
     const sourceSide =
       endpointSide(edge.sourceId, edge.sourcePort) ??
       fixedImplicitSide(edge.sourceId, edge.sourcePort, true) ??
@@ -3771,18 +3928,24 @@ function implicitEdgeEndpoints(
       endpointSide(edge.targetId, edge.targetPort) ??
       fixedImplicitSide(edge.targetId, edge.targetPort, false) ??
       (feedback ? (directionReversed ? "after" : "before") : forward ? "before" : "after");
-    const sourceKey = `${edge.sourceId}:${sourceSide}`;
-    const targetKey = `${edge.targetId}:${targetSide}`;
-    const sourceGroup = groups.get(sourceKey) ?? [];
-    sourceGroup.push({ edge, endpoint: "source" });
-    groups.set(sourceKey, sourceGroup);
-    const targetGroup = groups.get(targetKey) ?? [];
-    targetGroup.push({ edge, endpoint: "target" });
-    groups.set(targetKey, targetGroup);
+    addEntry(edge.sourceId, sourceSide, { edge, endpoint: "source" });
+    addEntry(edge.targetId, targetSide, { edge, endpoint: "target" });
   }
 
   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 => {
@@ -3790,22 +3953,19 @@ function implicitEdgeEndpoints(
     if (!counts) {
       counts = new Map();
       for (const port of node.ports ?? []) {
-        const portSide = input.portSettings?.(port, node)?.["port.side"];
+        const portSide = portSettingsOf(port, node)?.["port.side"];
         counts.set(portSide, (counts.get(portSide) ?? 0) + 1);
       }
       portSideCounts.set(node, counts);
     }
     return counts.get(side) ?? 0;
   };
-  for (const [key, entries] of groups) {
-    const split = key.lastIndexOf(":");
-    const nodeId = key.slice(0, split);
-    const side = key.slice(split + 1);
+  for (const { nodeId, side, entries } of groups) {
     const rect = placement.rectByNodeId.get(nodeId);
     if (!rect) continue;
     const mergeEdges = input.settings.mergeEdges === true;
     const node = nodeById.get(nodeId);
-    const nodeSettings = node ? input.nodeSettings?.(node) : undefined;
+    const nodeSettings = node ? nodeSettingsOf(node) : undefined;
     const hypernode = nodeSettings?.hypernode;
     const unzipping = (input.settings["layerUnzipping.strategy"] ?? "NONE") === "ALTERNATING";
     const crossingStrategy = input.settings["crossingMinimization.strategy"] ?? "LAYER_SWEEP";
@@ -3860,8 +4020,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) {
@@ -4006,7 +4166,7 @@ function implicitEdgeEndpoints(
       const portName = endpoint === "source" ? edge.sourcePort : edge.targetPort;
       const explicitPort = node?.ports?.find((port) => port.name === portName);
       const physicalSide =
-        node && explicitPort ? input.portSettings?.(explicitPort, node)?.["port.side"] : undefined;
+        node && explicitPort ? portSettingsOf(explicitPort, node)?.["port.side"] : undefined;
       const singleFixedSidePort =
         constraints === "FIXED_SIDE" &&
         physicalSide !== undefined &&
@@ -4015,9 +4175,7 @@ function implicitEdgeEndpoints(
       // Movable port ordering comes from the layer sweep above. Fixed coordinates
       // and authored anchors must replace the synthesized node-origin fallback.
       const authoredAnchor =
-        node && explicitPort
-          ? input.portSettings?.(explicitPort, node)?.["port.anchor"]
-          : undefined;
+        node && explicitPort ? portSettingsOf(explicitPort, node)?.["port.anchor"] : undefined;
       if (
         portName !== undefined &&
         node &&
@@ -4346,6 +4504,16 @@ function routeEdges(style: "ORTHOGONAL" | "POLYLINE" | "SPLINES"): EdgeRouter {
       flowLayerByNodeId.set(interval.id, flowLayers.length - 1);
     }
     const bodyFlowLayers = flowLayers.map((bounds) => ({ ...bounds }));
+    // Placed node ids per flow layer, in placement order. Layer loops only
+    // move these nodes, so a grouping stays valid while its loop runs.
+    const placedIdsByFlowLayer = () => {
+      const ids = flowLayers.map(() => [] as string[]);
+      for (const id of placement.rectByNodeId.keys()) {
+        const layer = flowLayerByNodeId.get(id);
+        if (layer !== undefined) ids[layer]!.push(id);
+      }
+      return ids;
+    };
     const labelFlowLayers = new Set(
       [...flowLayerByNodeId]
         .filter(([id]) => id.startsWith("__layout_dummy:label:"))
@@ -4473,10 +4641,11 @@ function routeEdges(style: "ORTHOGONAL" | "POLYLINE" | "SPLINES"): EdgeRouter {
       labelExtraByGap[gap] = Math.max(labelExtraByGap[gap] ?? 0, extra);
     }
     let labelShift = 0;
+    const labelShiftIds = placedIdsByFlowLayer();
     for (const [layerNo, bounds] of flowLayers.entries()) {
       if (labelShift !== 0) {
-        for (const [id, rect] of placement.rectByNodeId) {
-          if (flowLayerByNodeId.get(id) !== layerNo) continue;
+        for (const id of labelShiftIds[layerNo]!) {
+          const rect = placement.rectByNodeId.get(id)!;
           mutableRects.set(
             id,
             horizontal ? { ...rect, x: rect.x + labelShift } : { ...rect, y: rect.y + labelShift },
@@ -4931,9 +5100,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) -
@@ -4964,11 +5137,13 @@ function routeEdges(style: "ORTHOGONAL" | "POLYLINE" | "SPLINES"): EdgeRouter {
         leadingSlots > 0 ? edgeNodeSpacing + (leadingSlots - 1) * edgeEdgeSpacing : 0;
       let nextStart = (flowLayers[0]?.start ?? 0) + leadingWidth;
       // ELK omits ordinary node spacing beside an external-port-only layer.
+      const flowLayerIds = flowLayers.map(() => [] as string[]);
+      for (const [id, layer] of flowLayerByNodeId) flowLayerIds[layer]!.push(id);
       const externalFlowLayers = new Set(
         flowLayers.flatMap((_, layer) => {
-          const ids = [...flowLayerByNodeId].filter(([, index]) => index === layer);
+          const ids = flowLayerIds[layer]!;
           return ids.length &&
-            ids.every(([id]) => {
+            ids.every((id) => {
               const node = nodeById.get(id);
               const side = node && externalPortDummyOf(node)?.side;
               return horizontal
@@ -4979,10 +5154,11 @@ function routeEdges(style: "ORTHOGONAL" | "POLYLINE" | "SPLINES"): EdgeRouter {
             : [];
         }),
       );
+      const shiftedIds = placedIdsByFlowLayer();
       for (const [layerNo, bounds] of flowLayers.entries()) {
         const shift = nextStart - bounds.start;
-        for (const [id, rect] of placement.rectByNodeId) {
-          if (flowLayerByNodeId.get(id) !== layerNo) continue;
+        for (const id of shiftedIds[layerNo]!) {
+          const rect = placement.rectByNodeId.get(id)!;
           mutableRects.set(
             id,
             horizontal ? { ...rect, x: rect.x + shift } : { ...rect, y: rect.y + shift },
@@ -5340,10 +5516,11 @@ function routeEdges(style: "ORTHOGONAL" | "POLYLINE" | "SPLINES"): EdgeRouter {
         }
       }
       let nextStart = flowLayers[0]?.start ?? 0;
+      const shiftedIds = placedIdsByFlowLayer();
       for (const [layerNo, bounds] of flowLayers.entries()) {
         const shift = nextStart - bounds.start;
-        for (const [id, rect] of placement.rectByNodeId) {
-          if (flowLayerByNodeId.get(id) !== layerNo) continue;
+        for (const id of shiftedIds[layerNo]!) {
+          const rect = placement.rectByNodeId.get(id)!;
           mutableRects.set(
             id,
             horizontal ? { ...rect, x: rect.x + shift } : { ...rect, y: rect.y + shift },
@@ -6677,7 +6854,7 @@ export function normalizePlacementForPortExtents(
       [nextLayer, false],
     ] as const) {
       for (const id of ids) {
-        const node = input.graph.nodes.find((candidate) => candidate.id === id);
+        const node = findNode(input.graph.nodes, id);
         const rect = placement.rectByNodeId.get(id);
         if (!node || !rect) continue;
         const bodyStart = horizontal ? rect.x : rect.y;