@statelyai/layout 0.2.0 → 0.4.0

package/src/layered/crossing-graph.ts

@@ -0,0 +1,401 @@
+import type { GraphEdge, GraphNode } from "@statelyai/graph";
+import type { CrossingGraph, CrossingNode, CrossingPort } from "./crossing-counter";
+import { getCrossingUnits } from "./crossing-constraints";
+import type { AcyclicOrientation, LayeredPhaseInput } from "./types";
+
+/** Translate the native candidate's physical ports into canonical clockwise order. */
+export function crossingGraph(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  layers: readonly (readonly string[])[],
+  incoming?: ReadonlyMap<string, readonly string[]>,
+  outgoing?: ReadonlyMap<string, readonly string[]>,
+): CrossingGraph {
+  return createCrossingGraphBuilder(input)(orientation, layers, incoming, outgoing);
+}
+
+/**
+ * Reusable {@link crossingGraph} for repeated counts over one phase input.
+ * Port keys and node/port settings are memoized, so the input's settings must
+ * not change while the builder is in use.
+ */
+export function createCrossingGraphBuilder(input: LayeredPhaseInput) {
+  const keys = new Map<string, Map<string, string>>();
+  const key = (id: string, name: string) => {
+    let byName = keys.get(id);
+    if (!byName) keys.set(id, (byName = new Map()));
+    let value = byName.get(name);
+    if (value === undefined) byName.set(name, (value = JSON.stringify([id, name])));
+    return value;
+  };
+  const nodeInfo = new Map<GraphNode, { constraints: unknown; hypernode: boolean }>();
+  const infoOf = (node: GraphNode) => {
+    let info = nodeInfo.get(node);
+    if (!info) {
+      const settings = input.nodeSettings?.(node);
+      info = { constraints: settings?.portConstraints, hypernode: settings?.hypernode === true };
+      nodeInfo.set(node, info);
+    }
+    return info;
+  };
+  const portInfo = new Map<
+    GraphNode,
+    Map<
+      string,
+      { authored?: NonNullable<GraphNode["ports"]>[number]; index: number; side?: string }
+    >
+  >();
+  const authoredPort = (node: GraphNode, name: string) => {
+    let byName = portInfo.get(node);
+    if (!byName) portInfo.set(node, (byName = new Map()));
+    let info = byName.get(name);
+    if (!info) {
+      const index = node.ports?.findIndex((port) => port.name === name) ?? -1;
+      const authored = index < 0 ? undefined : node.ports![index];
+      info = {
+        authored,
+        index,
+        side: authored && input.portSettings?.(authored, node)?.["port.side"],
+      };
+      byName.set(name, info);
+    }
+    return info;
+  };
+  const degreesByOrientation = new WeakMap<
+    AcyclicOrientation,
+    ReadonlyMap<string, { incoming: number; outgoing: number }>
+  >();
+  const degreesOf = (orientation: AcyclicOrientation) => {
+    let degrees = degreesByOrientation.get(orientation);
+    if (!degrees) {
+      const counted = new Map<string, { incoming: number; outgoing: number }>();
+      for (const edge of input.graph.edges) {
+        if (edge.sourceId === edge.targetId) continue;
+        const reversed = orientation.reversedEdgeIds.has(edge.id);
+        for (const [nodeId, name, source] of [
+          [edge.sourceId, edge.sourcePort, !reversed],
+          [edge.targetId, edge.targetPort, reversed],
+        ] as const) {
+          if (name === undefined) continue;
+          const id = key(nodeId, name),
+            degree = counted.get(id) ?? { incoming: 0, outgoing: 0 };
+          if (source) degree.outgoing++;
+          else degree.incoming++;
+          counted.set(id, degree);
+        }
+      }
+      degreesByOrientation.set(orientation, (degrees = counted));
+    }
+    return degrees;
+  };
+  // Port identities, sides and fallback ranks depend only on the orientation;
+  // each build replays them against the current port orders.
+  const plans = new WeakMap<AcyclicOrientation, CrossingGraphPlan>();
+  return (
+    orientation: AcyclicOrientation,
+    layers: readonly (readonly string[])[],
+    incoming?: ReadonlyMap<string, readonly string[]>,
+    outgoing?: ReadonlyMap<string, readonly string[]>,
+  ): CrossingGraph => {
+    let plan = plans.get(orientation);
+    if (
+      !plan ||
+      plan.units !== getCrossingUnits(input) ||
+      plan.nodes !== input.graph.nodes ||
+      plan.edgeList !== input.graph.edges
+    ) {
+      plan = planCrossingGraph(input, orientation, key, infoOf, authoredPort, degreesOf);
+      plans.set(orientation, plan);
+    }
+    return buildCrossingGraph(plan, layers, incoming, outgoing);
+  };
+}
+
+/** One `add` of the original builder with its build-independent values resolved. */
+interface PortOperation {
+  nodeId: string;
+  id: string;
+  side: CrossingPort["side"];
+  /** Incident edge whose position in the selected port order ranks the port. */
+  edgeId?: string;
+  source: boolean;
+  /** Rank when the edge is absent from the selected port order. */
+  fallback: number;
+  /** FIXED_POS/FIXED_RATIO geometric rank, overriding the order rank. */
+  fixedRank?: number;
+  /** FIXED_POS/FIXED_RATIO shared ports keep their first rank. */
+  keepRank: boolean;
+  /** North/south dummy detached from this port, linked after the add. */
+  northSouthDummy?: string;
+}
+
+interface CrossingGraphPlan {
+  units: ReturnType<typeof getCrossingUnits>;
+  nodes: LayeredPhaseInput["graph"]["nodes"];
+  edgeList: LayeredPhaseInput["graph"]["edges"];
+  operations: PortOperation[];
+  edges: Array<{ source: string; target: string }>;
+  nodeKinds: Map<string, { type: CrossingNode["type"]; unit?: string }>;
+}
+
+function planCrossingGraph(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  key: (id: string, name: string) => string,
+  infoOf: (node: GraphNode) => { constraints: unknown; hypernode: boolean },
+  authoredPort: (
+    node: GraphNode,
+    name: string,
+  ) => { authored?: NonNullable<GraphNode["ports"]>[number]; index: number; side?: string },
+  degreesOf: (
+    orientation: AcyclicOrientation,
+  ) => ReadonlyMap<string, { incoming: number; outgoing: number }>,
+): CrossingGraphPlan {
+  const units = getCrossingUnits(input);
+  const nodes = new Map(input.graph.nodes.map((node) => [node.id, node]));
+  const canonicalSide = (side: string): CrossingPort["side"] => {
+    const sides: Record<string, CrossingPort["side"]> =
+      input.direction === "right"
+        ? { NORTH: "NORTH", EAST: "EAST", SOUTH: "SOUTH", WEST: "WEST" }
+        : input.direction === "left"
+          ? { NORTH: "NORTH", EAST: "WEST", SOUTH: "SOUTH", WEST: "EAST" }
+          : input.direction === "down"
+            ? { NORTH: "WEST", EAST: "SOUTH", SOUTH: "EAST", WEST: "NORTH" }
+            : { NORTH: "EAST", EAST: "SOUTH", SOUTH: "WEST", WEST: "NORTH" };
+    return sides[side]!;
+  };
+  const degrees = degreesOf(orientation);
+  const operations: PortOperation[] = [];
+  // Distinct port ids per node, in first-add order, as the build's members map.
+  const ports = new Map<string, Set<string>>();
+  const add = (node: GraphNode, name: string, source: boolean, edge?: GraphEdge): string => {
+    let members = ports.get(node.id);
+    if (!members) ports.set(node.id, (members = new Set()));
+    const id = key(node.id, name);
+    const { authored, index: authoredIndex, side: configuredSide } = authoredPort(node, name);
+    const { constraints } = infoOf(node);
+    const flexible =
+      constraints === undefined || constraints === "UNDEFINED" || constraints === "FREE";
+    const degree = degrees.get(id);
+    // The initial model-order pass requires ELK PortSideProcessor's free sides.
+    // Existing non-model sweep integration retains its separate side policy.
+    // Resolve these ports from cycle-broken connectivity,
+    // even when an authored side was supplied. Equal degrees choose WEST.
+    const side =
+      flexible &&
+      (input.settings["considerModelOrder.strategy"] ?? "NONE") !== "NONE" &&
+      authored &&
+      degree
+        ? degree.outgoing > degree.incoming
+          ? "EAST"
+          : "WEST"
+        : configuredSide
+          ? canonicalSide(configuredSide)
+          : source
+            ? "EAST"
+            : "WEST";
+    const keepRank = constraints === "FIXED_POS" || constraints === "FIXED_RATIO";
+    let fixedRank: number | undefined;
+    if (authored && keepRank) {
+      const vertical = input.direction === "down" || input.direction === "up";
+      const reverse = input.direction === "left" || input.direction === "up";
+      const size = input.sizes.get(node.id)!;
+      const cross = vertical
+        ? (authored.x ?? 0) + (authored.width ?? 0) / 2
+        : (authored.y ?? 0) + (authored.height ?? 0) / 2;
+      const flow = vertical
+        ? (authored.y ?? 0) + (authored.height ?? 0) / 2
+        : (authored.x ?? 0) + (authored.width ?? 0) / 2;
+      const canonicalFlow = reverse ? (vertical ? size.height : size.width) - flow : flow;
+      fixedRank =
+        side === "NORTH"
+          ? canonicalFlow
+          : side === "SOUTH"
+            ? -canonicalFlow
+            : side === "EAST"
+              ? cross
+              : -cross;
+    }
+    operations.push({
+      nodeId: node.id,
+      id,
+      side,
+      edgeId: edge?.id,
+      source,
+      fallback: authored ? authoredIndex : members.size,
+      fixedRank,
+      keepRank,
+    });
+    members.add(id);
+    return id;
+  };
+  const endpoint = (edge: GraphEdge, source: boolean) => {
+    const authoredSource = source !== orientation.reversedEdgeIds.has(edge.id);
+    const node = nodes.get(authoredSource ? edge.sourceId : edge.targetId)!;
+    const name = authoredSource ? edge.sourcePort : edge.targetPort;
+    const merged = input.settings.mergeEdges === true || infoOf(node).hypernode;
+    return add(
+      node,
+      name ?? (merged ? `__implicit:${source}` : `__implicit:${edge.id}:${source}`),
+      source,
+      edge,
+    );
+  };
+  const edges = input.graph.edges
+    .filter((edge) => edge.sourceId !== edge.targetId)
+    .map((edge) => ({ source: endpoint(edge, true), target: endpoint(edge, false) }));
+  // Real ELK retains ports with no incident edge in this scope.
+  for (const node of input.graph.nodes)
+    for (const port of node.ports ?? []) {
+      if (!ports.get(node.id)?.has(key(node.id, port.name)))
+        add(node, port.name, port.direction === "out");
+    }
+  for (const [dummy, origin] of units?.northSouthOrigins ?? []) {
+    const owner = nodes.get(origin.node.id)!;
+    add(owner, origin.port.name, false);
+    operations.at(-1)!.northSouthDummy = dummy;
+  }
+  const nodeKinds = new Map<string, { type: CrossingNode["type"]; unit?: string }>();
+  for (const node of input.graph.nodes) {
+    const id = node.id;
+    nodeKinds.set(id, {
+      type: id.startsWith("__layout_dummy:north-south:")
+        ? "NORTH_SOUTH_PORT"
+        : units?.longEdgeNodes?.has(id)
+          ? "LONG_EDGE"
+          : id.startsWith("__layout_dummy:label:")
+            ? "LABEL"
+            : "NORMAL",
+      unit: units?.units.get(id),
+    });
+  }
+  return {
+    units,
+    nodes: input.graph.nodes,
+    edgeList: input.graph.edges,
+    operations,
+    edges,
+    nodeKinds,
+  };
+}
+
+function buildCrossingGraph(
+  plan: CrossingGraphPlan,
+  layers: readonly (readonly string[])[],
+  incoming: ReadonlyMap<string, readonly string[]> | undefined,
+  outgoing: ReadonlyMap<string, readonly string[]> | undefined,
+): CrossingGraph {
+  // First index of each edge id, like `indexOf`, per selected port order.
+  const ranks = new Map<readonly string[], Map<string, number>>();
+  const rankIn = (selected: readonly string[]) => {
+    let rank = ranks.get(selected);
+    if (!rank) {
+      rank = new Map();
+      for (let index = 0; index < selected.length; index++)
+        if (!rank.has(selected[index]!)) rank.set(selected[index]!, index);
+      ranks.set(selected, rank);
+    }
+    return rank;
+  };
+  const ports = new Map<string, Map<string, { port: CrossingPort; rank: number }>>();
+  for (const operation of plan.operations) {
+    let members = ports.get(operation.nodeId);
+    if (!members) ports.set(operation.nodeId, (members = new Map()));
+    const selected =
+      operation.edgeId === undefined
+        ? undefined
+        : (operation.source ? outgoing : incoming)?.get(operation.nodeId);
+    let rank = selected ? (rankIn(selected).get(operation.edgeId!) ?? -1) : -1;
+    if (rank < 0) rank = operation.fallback;
+    if (operation.fixedRank !== undefined) rank = operation.fixedRank;
+    const existing = members.get(operation.id);
+    if (existing) {
+      // A shared port occupies its first position in the selected port order;
+      // later incident edges must not move that one physical port.
+      if (!operation.keepRank) existing.rank = Math.min(existing.rank, rank);
+    } else members.set(operation.id, { port: { id: operation.id, side: operation.side }, rank });
+    if (operation.northSouthDummy !== undefined) {
+      members.get(operation.id)!.port.dummy = operation.northSouthDummy;
+      for (const member of ports.get(operation.northSouthDummy)?.values() ?? [])
+        member.port.origin = operation.id;
+    }
+  }
+  const sideRank = { NORTH: 0, EAST: 1, SOUTH: 2, WEST: 3 };
+  return {
+    layers: layers.map((layer) =>
+      layer.map((id) => {
+        const kind = plan.nodeKinds.get(id);
+        return {
+          id,
+          type: kind?.type ?? kindOf(id, plan.units),
+          unit: kind ? kind.unit : plan.units?.units.get(id),
+          ports: [...(ports.get(id)?.values() ?? [])]
+            .sort((a, b) => sideRank[a.port.side] - sideRank[b.port.side] || a.rank - b.rank)
+            .map((member) => member.port),
+        };
+      }),
+    ),
+    edges: plan.edges.map((edge) => ({ source: edge.source, target: edge.target })),
+  };
+}
+
+/**
+ * A port carrying edges of both directions attaches each direction separately
+ * once routed, so a crossing between them is real. Count it: give each
+ * east or west mixed port a twin for its reversed edges, after it on the
+ * east side and before it on the west (so forward edges sit above), and move
+ * those edges to the twin. `reversed` is index-aligned with `graph.edges`.
+ */
+export function splitMixedCrossingPorts(
+  graph: CrossingGraph,
+  reversed: readonly boolean[],
+): CrossingGraph {
+  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);
+  });
+  const mixed = new Set<string>();
+  for (const layer of graph.layers)
+    for (const node of layer)
+      for (const port of node.ports)
+        if (directions.get(port.id) === 3 && (port.side === "EAST" || port.side === "WEST"))
+          mixed.add(port.id);
+  if (!mixed.size) return graph;
+  const twin = (id: string) => `${id}\0reversed`;
+  return {
+    layers: graph.layers.map((layer) =>
+      layer.map((node) =>
+        node.ports.some((port) => mixed.has(port.id))
+          ? {
+              ...node,
+              ports: node.ports.flatMap((port) => {
+                if (!mixed.has(port.id)) return [port];
+                const other = { ...port, id: twin(port.id) };
+                return port.side === "EAST" ? [port, other] : [other, port];
+              }),
+            }
+          : node,
+      ),
+    ),
+    edges: graph.edges.map((edge, index) =>
+      reversed[index] && (mixed.has(edge.source) || mixed.has(edge.target))
+        ? {
+            source: mixed.has(edge.source) ? twin(edge.source) : edge.source,
+            target: mixed.has(edge.target) ? twin(edge.target) : edge.target,
+          }
+        : edge,
+    ),
+  };
+}
+
+function kindOf(id: string, units: ReturnType<typeof getCrossingUnits>): CrossingNode["type"] {
+  return id.startsWith("__layout_dummy:north-south:")
+    ? "NORTH_SOUTH_PORT"
+    : units?.longEdgeNodes?.has(id)
+      ? "LONG_EDGE"
+      : id.startsWith("__layout_dummy:label:")
+        ? "LABEL"
+        : "NORMAL";
+}

package/src/layered/cycle-random.ts

@@ -0,0 +1,22 @@
+import { JavaRandom } from "../java-random";
+import type { LayeredPhaseInput } from "./types";
+
+export const phaseRandomByInput = new WeakMap<LayeredPhaseInput, JavaRandom>();
+
+const afterCycle = new WeakMap<LayeredPhaseInput, JavaRandom>();
+
+export function recordCycleRandom(input: LayeredPhaseInput, random: JavaRandom): void {
+  afterCycle.set(input, random.clone());
+}
+
+export function crossingRandom(input: LayeredPhaseInput): JavaRandom {
+  return afterCycle.get(input)?.clone() ?? new JavaRandom(input.settings.randomSeed ?? 1);
+}
+
+export function inheritCycleRandom<T extends LayeredPhaseInput>(from: LayeredPhaseInput, to: T): T {
+  const phaseRandom = phaseRandomByInput.get(from);
+  if (phaseRandom) phaseRandomByInput.set(to, phaseRandom);
+  const random = afterCycle.get(from);
+  if (random) afterCycle.set(to, random);
+  return to;
+}

package/src/layered/elk-port-lists.ts

@@ -0,0 +1,243 @@
+import type { GraphEdge, GraphNode } from "@statelyai/graph";
+import { orientConstrainedEdges } from "./constraint-orientation";
+import type { AcyclicOrientation, LayeredPhaseInput } from "./types";
+
+/** One ELK port: its authored name (implicit edge ports have none) and edge lists. */
+export interface PortEdgeList {
+  name?: string;
+  outgoing: string[];
+  incoming: string[];
+}
+
+/** ELK imports ports in authored order; side sorting happens after dummy insertion. */
+export function authoredPortIndex(
+  input: LayeredPhaseInput,
+  node: GraphNode | undefined,
+  name: string | undefined,
+): number {
+  const port = name === undefined ? undefined : node?.ports?.find((p) => p.name === name);
+  if (!node || !port) return -1;
+  const settings = input.portSettings?.(port, node) as
+    | { "port.authoredIndex"?: number }
+    | undefined;
+  return settings?.["port.authoredIndex"] ?? node.ports!.indexOf(port);
+}
+
+/**
+ * Replays ELK's per-port edge lists through import, EdgeAndLayerConstraintEdgeReverser
+ * and cycle breaking. ELK appends a reversed edge to the end of its new ports'
+ * lists, so an edge's position records its reversal history.
+ */
+export function simulatePortEdgeLists(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+): Map<string, PortEdgeList[]> {
+  const ports = new Map<string, PortEdgeList[]>();
+  for (const node of input.graph.nodes) {
+    const authored = (node.ports ?? [])
+      .map((port) => ({ name: port.name, index: authoredPortIndex(input, node, port.name) }))
+      .sort((a, b) => a.index - b.index);
+    ports.set(
+      node.id,
+      authored.map(({ name }) => ({ name, outgoing: [], incoming: [] })),
+    );
+  }
+  const ends = new Map<string, { source: PortEdgeList; target: PortEdgeList }>();
+  const portOf = (nodeId: string, name: string | undefined): PortEdgeList | undefined => {
+    const list = ports.get(nodeId);
+    if (!list) return undefined;
+    const named = name === undefined ? undefined : list.find((port) => port.name === name);
+    if (named) return named;
+    // Edges without an authored port receive their own port at import.
+    const port: PortEdgeList = { outgoing: [], incoming: [] };
+    list.push(port);
+    return port;
+  };
+  const edges: GraphEdge[] = [];
+  for (const edge of input.graph.edges) {
+    if (edge.sourceId === edge.targetId) continue;
+    const source = portOf(edge.sourceId, edge.sourcePort);
+    const target = portOf(edge.targetId, edge.targetPort);
+    if (!source || !target) continue;
+    source.outgoing.push(edge.id);
+    target.incoming.push(edge.id);
+    ends.set(edge.id, { source, target });
+    edges.push(edge);
+  }
+  // Local edges keep import order; hierarchy segments follow in creation order.
+  const position = new Map(input.graph.edges.map((edge, index) => [edge.id, index]));
+  const segment = new Map(
+    input.graph.edges.flatMap((edge) => {
+      const rank = (input.edgeSettings?.(edge) as { "edge.hierarchyRank"?: number } | undefined)?.[
+        "edge.hierarchyRank"
+      ];
+      return rank === undefined ? [] : [[edge.id, rank] as const];
+    }),
+  );
+  const importOrder = (a: string, b: string) =>
+    Number(segment.has(a)) - Number(segment.has(b)) ||
+    (segment.get(a) ?? 0) - (segment.get(b) ?? 0) ||
+    position.get(a)! - position.get(b)!;
+  for (const list of ports.values())
+    for (const port of list) {
+      port.outgoing.sort(importOrder);
+      port.incoming.sort(importOrder);
+    }
+  const reverse = (id: string) => {
+    const end = ends.get(id)!;
+    end.source.outgoing.splice(end.source.outgoing.indexOf(id), 1);
+    end.target.incoming.splice(end.target.incoming.indexOf(id), 1);
+    end.target.outgoing.push(id);
+    end.source.incoming.push(id);
+    ends.set(id, { source: end.target, target: end.source });
+  };
+  const replay = (
+    pending: Set<string>,
+    visit: (node: GraphNode) => "outgoing" | "incoming" | "all" | undefined,
+  ) => {
+    for (const node of input.graph.nodes) {
+      const kind = visit(node);
+      if (!kind) continue;
+      // Like ELK, iterate copies: reversal moves edges between these lists.
+      for (const port of (ports.get(node.id) ?? []).slice()) {
+        if (kind !== "incoming")
+          for (const id of port.outgoing.slice()) if (pending.delete(id)) reverse(id);
+        if (kind !== "outgoing")
+          for (const id of port.incoming.slice()) if (pending.delete(id)) reverse(id);
+      }
+    }
+  };
+  const known = new Set(edges.map((edge) => edge.id));
+  const prepared = orientConstrainedEdges(input, new Set());
+  const constrained = new Set([...prepared.reversedEdgeIds].filter((id) => known.has(id)));
+  const wholeNodes = new Set(prepared.reversedNodeIds);
+  const constraint = (node: GraphNode) =>
+    String(input.nodeSettings?.(node)?.["layering.layerConstraint"] ?? "NONE");
+  // Outer FIRST/LAST nodes reverse first; the remaining nodes may reverse whole.
+  const pending = new Set(constrained);
+  replay(pending, (node) =>
+    constraint(node).startsWith("FIRST")
+      ? "incoming"
+      : constraint(node).startsWith("LAST")
+        ? "outgoing"
+        : undefined,
+  );
+  replay(pending, (node) => (wholeNodes.has(node.id) ? "all" : undefined));
+  for (const id of pending) reverse(id);
+  // The cycle breaker reverses the remaining difference while visiting outgoing edges.
+  const cycles = new Set(
+    [...known].filter((id) => orientation.reversedEdgeIds.has(id) !== constrained.has(id)),
+  );
+  replay(cycles, () => "outgoing");
+  for (const id of cycles) reverse(id);
+  return ports;
+}
+
+/**
+ * LabelDummyInserter keeps a labeled edge on its source port and moves the
+ * dummy's outgoing part to the end of the target port's incoming edges.
+ */
+export function insertLabelDummyPorts(
+  lists: ReadonlyMap<string, readonly PortEdgeList[]>,
+  orientation: AcyclicOrientation,
+  segmentIdsByEdgeId: ReadonlyMap<string, readonly string[]>,
+): Map<string, PortEdgeList[]> {
+  const result = new Map(
+    [...lists].map(([id, ports]) => [
+      id,
+      ports.map((port) => ({
+        ...port,
+        outgoing: [...port.outgoing],
+        incoming: [...port.incoming],
+      })),
+    ]),
+  );
+  const dummies: [string, PortEdgeList[]][] = [];
+  for (const ports of result.values()) {
+    for (const port of ports) {
+      for (const id of port.outgoing) {
+        const parts = segmentIdsByEdgeId.get(id);
+        if (parts?.length !== 2) continue;
+        const reversed = orientation.reversedEdgeIds.has(id);
+        const [head, tail] = reversed ? [parts[1]!, parts[0]!] : [parts[0]!, parts[1]!];
+        port.outgoing[port.outgoing.indexOf(id)] = head;
+        for (const target of result.values())
+          for (const candidate of target) {
+            const at = candidate.incoming.indexOf(id);
+            if (at < 0) continue;
+            candidate.incoming.splice(at, 1);
+            candidate.incoming.push(tail);
+          }
+        dummies.push([
+          `__layout_dummy:label:${id}`,
+          [
+            { name: "input", outgoing: [], incoming: [head] },
+            { name: "output", outgoing: [tail], incoming: [] },
+          ],
+        ]);
+      }
+    }
+  }
+  for (const [id, ports] of dummies) result.set(id, ports);
+  return result;
+}
+
+/**
+ * ELK's network-simplex layerer orders nodes by connected-component DFS. Each
+ * visit walks ports in list order, incoming edges before outgoing edges; a
+ * component larger than the current first one moves to the front.
+ */
+export function elkComponentOrder(
+  input: LayeredPhaseInput,
+  lists: ReadonlyMap<string, readonly PortEdgeList[]>,
+): string[] {
+  const endpoints = new Map(input.graph.edges.map((edge) => [edge.id, edge]));
+  const nodeIds = new Set(input.graph.nodes.map((node) => node.id));
+  const visited = new Set<string>();
+  const components: string[][] = [];
+  const neighbors = (id: string) =>
+    (lists.get(id) ?? []).flatMap((port) =>
+      [...port.incoming, ...port.outgoing].flatMap((edgeId) => {
+        const edge = endpoints.get(edgeId);
+        const opposite = edge && (edge.sourceId === id ? edge.targetId : edge.sourceId);
+        return opposite && nodeIds.has(opposite) ? [opposite] : [];
+      }),
+    );
+  const visit = (root: string, component: string[]) => {
+    visited.add(root);
+    component.push(root);
+    const stack = [{ next: neighbors(root), index: 0 }];
+    while (stack.length > 0) {
+      const frame = stack.at(-1)!;
+      const id = frame.next[frame.index++];
+      if (id === undefined) stack.pop();
+      else if (!visited.has(id)) {
+        visited.add(id);
+        component.push(id);
+        stack.push({ next: neighbors(id), index: 0 });
+      }
+    }
+  };
+  for (const node of input.graph.nodes) {
+    if (visited.has(node.id)) continue;
+    const component: string[] = [];
+    visit(node.id, component);
+    if (components.length > 0 && components[0]!.length >= component.length)
+      components.push(component);
+    else components.unshift(component);
+  }
+  return components.flat();
+}
+
+/** Each node's edge positions within ELK's port edge lists, keyed by listed edge id. */
+export function edgeListRanks(
+  lists: ReadonlyMap<string, readonly PortEdgeList[]>,
+  kind: "incoming" | "outgoing",
+): Map<string, Map<string, number>> {
+  return new Map(
+    [...lists].map(([id, ports]) => [
+      id,
+      new Map(ports.flatMap((port) => port[kind]).map((edgeId, index) => [edgeId, index])),
+    ]),
+  );
+}