@statelyai/layout 0.3.0 → 0.4.0

package/src/layered/orthogonal-cycle-order.ts

@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2020 Kiel University and others.
+ * Adapted from ELK v0.11.0 HyperEdgeCycleDetector.
+ * Source commit: 54123e884b1ae743b453260f713b20c9bf5787f2
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import type { JavaRandom } from "../java-random";
+export interface OrthogonalDependency {
+  source: number;
+  target: number;
+  weight: number;
+  critical: boolean;
+}
+/** ELK's weighted segment ordering; returned dependencies point backwards in that order. */
+export function detectOrthogonalCycles(
+  count: number,
+  dependencies: readonly OrthogonalDependency[],
+  criticalOnly: boolean,
+  random: JavaRandom,
+): { marks: number[]; backwards: OrthogonalDependency[] } {
+  const considered = dependencies.filter((d) => !criticalOnly || d.critical);
+  const incoming = Array.from({ length: count }, () => [] as OrthogonalDependency[]);
+  const outgoing = Array.from({ length: count }, () => [] as OrthogonalDependency[]);
+  for (const dependency of considered) {
+    incoming[dependency.target]!.push(dependency);
+    outgoing[dependency.source]!.push(dependency);
+  }
+  const inWeight = incoming.map((edges) => edges.reduce((sum, e) => sum + e.weight, 0));
+  const outWeight = outgoing.map((edges) => edges.reduce((sum, e) => sum + e.weight, 0));
+  const criticalIn = incoming.map((edges) =>
+    edges.reduce((sum, e) => sum + (e.critical ? e.weight : 0), 0),
+  );
+  const criticalOut = outgoing.map((edges) =>
+    edges.reduce((sum, e) => sum + (e.critical ? e.weight : 0), 0),
+  );
+  const marks = Array.from({ length: count }, (_, i) => -i - 1);
+  const remaining = new Set(marks.map((_, i) => i));
+  const sinks: number[] = [],
+    sources: number[] = [];
+  for (let i = 0; i < count; i++)
+    if (outWeight[i] === 0) sinks.push(i);
+    else if (inWeight[i] === 0) sources.push(i);
+  let nextSink = count - 1,
+    nextSource = count + 1;
+  const update = (node: number) => {
+    for (const edge of outgoing[node]!) {
+      const target = edge.target;
+      if (marks[target]! < 0 && edge.weight > 0) {
+        inWeight[target]! -= edge.weight;
+        if (edge.critical) criticalIn[target]! -= edge.weight;
+        if (inWeight[target]! <= 0 && outWeight[target]! > 0) sources.push(target);
+      }
+    }
+    for (const edge of incoming[node]!) {
+      const source = edge.source;
+      if (marks[source]! < 0 && edge.weight > 0) {
+        outWeight[source]! -= edge.weight;
+        if (edge.critical) criticalOut[source]! -= edge.weight;
+        if (outWeight[source]! <= 0 && inWeight[source]! > 0) sinks.push(source);
+      }
+    }
+  };
+  while (remaining.size) {
+    while (sinks.length) {
+      const node = sinks.shift()!;
+      remaining.delete(node);
+      marks[node] = nextSink--;
+      update(node);
+    }
+    while (sources.length) {
+      const node = sources.shift()!;
+      remaining.delete(node);
+      marks[node] = nextSource++;
+      update(node);
+    }
+    let maximum = -2147483648;
+    let candidates: number[] = [];
+    // TreeSet compares initial negative marks, hence reverse segment creation order.
+    for (const node of [...remaining].sort((a, b) => marks[a]! - marks[b]!)) {
+      if (!criticalOnly && criticalOut[node]! > 0 && criticalIn[node]! <= 0) {
+        candidates = [node];
+        break;
+      }
+      const outflow = outWeight[node]! - inWeight[node]!;
+      if (outflow >= maximum) {
+        if (outflow > maximum) {
+          candidates = [];
+          maximum = outflow;
+        }
+        candidates.push(node);
+      }
+    }
+    if (candidates.length) {
+      const node = candidates[random.nextInt(candidates.length)]!;
+      remaining.delete(node);
+      marks[node] = nextSource++;
+      update(node);
+    }
+  }
+  for (let i = 0; i < count; i++) if (marks[i]! < count) marks[i]! += count + 1;
+  // Upstream iterates each source's outgoing list, not the global edge list.
+  const backwards = outgoing.flatMap((edges) =>
+    edges.filter((e) => marks[e.source]! > marks[e.target]!),
+  );
+  return { marks, backwards };
+}

package/src/layered/orthogonal-hypersegments.ts

@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2016, 2020 Kiel University and others.
+ * Adapted from ELK v0.11.0 OrthogonalRoutingGenerator, HyperEdgeSegment
+ * and HyperedgeCrossingsCounter.
+ * Source commit: 54123e884b1ae743b453260f713b20c9bf5787f2
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+export interface OrthogonalPort {
+  id: string;
+  side: "source" | "target";
+  position: number;
+}
+export interface OrthogonalConnection {
+  source: string;
+  target: string;
+}
+/** ELK visits output ports on each boundary side, then recursively follows all connected edges. */
+export function createOrthogonalHypersegments(
+  ports: readonly OrthogonalPort[],
+  connections: readonly OrthogonalConnection[],
+  /** Position of a connection in its port's incoming or outgoing edge list, when known. */
+  listRank?: (connection: number, list: "incoming" | "outgoing") => number | undefined,
+) {
+  const byId = new Map(ports.map((p) => [p.id, p]));
+  const incoming = new Map(ports.map((p) => [p.id, [] as number[]]));
+  const outgoing = new Map(ports.map((p) => [p.id, [] as number[]]));
+  for (const [index, edge] of connections.entries()) {
+    incoming.get(edge.target)!.push(index);
+    outgoing.get(edge.source)!.push(index);
+  }
+  // ELK follows each port's edges in list order; fall back to connection order.
+  if (listRank)
+    for (const [lists, list] of [
+      [incoming, "incoming"],
+      [outgoing, "outgoing"],
+    ] as const)
+      for (const members of lists.values())
+        members.sort((a, b) => {
+          const ra = listRank(a, list),
+            rb = listRank(b, list);
+          return ra !== undefined && rb !== undefined ? ra - rb || a - b : a - b;
+        });
+  const segmentByPort = new Map<string, number>();
+  const segments: Array<{ ports: string[]; incoming: number[]; outgoing: number[] }> = [];
+  const visit = (id: string, index: number) => {
+    if (segmentByPort.has(id)) return;
+    segmentByPort.set(id, index);
+    const port = byId.get(id)!,
+      segment = segments[index]!;
+    segment.ports.push(id);
+    (port.side === "source" ? segment.incoming : segment.outgoing).push(port.position);
+    for (const connection of incoming.get(id)!) visit(connections[connection]!.source, index);
+    for (const connection of outgoing.get(id)!) visit(connections[connection]!.target, index);
+  };
+  for (const side of ["source", "target"] as const)
+    for (const port of ports) {
+      if (port.side !== side || outgoing.get(port.id)!.length === 0 || segmentByPort.has(port.id))
+        continue;
+      const index = segments.length;
+      segments.push({ ports: [], incoming: [], outgoing: [] });
+      visit(port.id, index);
+    }
+  for (const segment of segments) {
+    segment.incoming = [...new Set(segment.incoming)].sort((a, b) => a - b);
+    segment.outgoing = [...new Set(segment.outgoing)].sort((a, b) => a - b);
+  }
+  return { segments, segmentByPort };
+}
+
+/** ELK's hyperedge crossing estimate; positions are distinct ordinal port ranks on each side. */
+export function countOrthogonalHypersegmentCrossings(
+  ports: readonly OrthogonalPort[],
+  connections: readonly OrthogonalConnection[],
+): number {
+  const { segments } = createOrthogonalHypersegments(ports, connections);
+  const spans = segments.map((s) => ({
+    leftStart: Math.min(...s.incoming),
+    leftEnd: Math.max(...s.incoming),
+    rightStart: Math.min(...s.outgoing),
+    rightEnd: Math.max(...s.outgoing),
+  }));
+  let count = 0;
+  for (let i = 0; i < spans.length; i++)
+    for (let j = i + 1; j < spans.length; j++) {
+      const a = spans[i]!,
+        b = spans[j]!;
+      if ((a.leftStart - b.leftStart) * (a.rightStart - b.rightStart) < 0) count++;
+      if (a.leftStart < b.leftEnd && b.leftStart < a.leftEnd) count++;
+      if (a.rightStart < b.rightEnd && b.rightStart < a.rightEnd) count++;
+    }
+  return count;
+}

package/src/layered/orthogonal-junctions.ts

@@ -0,0 +1,202 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2020 Kiel University and others.
+ * Native adaptation of ELK orthogonal routing junction generation.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import type { GraphEdge, GraphNode, GraphPort, Point } from "@statelyai/graph";
+import type { AcyclicOrientation, LayeredPhaseInput } from "./types";
+import type { OrthogonalSegment } from "./orthogonal-segments";
+import { createOrthogonalHypersegments, type OrthogonalPort } from "./orthogonal-hypersegments";
+import { isMergedHyperedgeDummy } from "./hyperedge-dummy-merger";
+export type OrthogonalJunctionGroup = Array<{
+  edgeId: string;
+  reversed: boolean;
+  segment: OrthogonalSegment;
+  partner?: OrthogonalSegment;
+  sourceValue: number;
+  targetValue: number;
+}>;
+/** Emit branches from routing-port spans, before endpoint restoration and compaction. */
+export function orthogonalJunctionPoints(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  raw: ReadonlyMap<string, { source: Point; target: Point }>,
+  flowLayerByNodeId: ReadonlyMap<string, number>,
+  junctionGroups: OrthogonalJunctionGroup[],
+  pointsByEdgeId: ReadonlyMap<string, readonly Point[]>,
+  orthogonalTrackByEdgeId: ReadonlyMap<string, number>,
+  orthogonalDetourByEdgeId: ReadonlyMap<
+    string,
+    { firstTrack: number; secondTrack: number; crossover: number }
+  >,
+  portDirection: (node: GraphNode, port: GraphPort) => GraphPort["direction"],
+): ReadonlyMap<string, readonly Point[]> {
+  const horizontal = input.direction === "left" || input.direction === "right";
+  const increasing = input.direction === "right" || input.direction === "down";
+  const nodeById = new Map(input.graph.nodes.map((n) => [n.id, n]));
+  const junctionPointsByEdgeId = new Map<string, readonly Point[]>();
+
+  type BoundaryEdge = {
+    edge: GraphEdge;
+    source: string;
+    target: string;
+    sourceValue: number;
+    targetValue: number;
+    inLayer: boolean;
+  };
+  const boundaries = new Map<
+    number,
+    { ports: Map<string, OrthogonalPort>; edges: BoundaryEdge[] }
+  >();
+  const face = (edge: GraphEdge, source: boolean) => {
+    const id = source ? edge.sourceId : edge.targetId;
+    const node = nodeById.get(id)!;
+    const name = source ? edge.sourcePort : edge.targetPort;
+    const port = node.ports?.find((p) => p.name === name);
+    if (node.id.startsWith("__layout_dummy:") && (name === "input" || name === "output"))
+      return horizontal
+        ? (name === "output") === increasing
+          ? "EAST"
+          : "WEST"
+        : (name === "output") === increasing
+          ? "SOUTH"
+          : "NORTH";
+    const side = port && input.portSettings?.(port, node)?.["port.side"];
+    if (side && side !== "UNDEFINED") return side;
+    const physicalSource = source !== orientation.reversedEdgeIds.has(edge.id);
+    const outgoing = port
+      ? (portDirection(node, port) ?? port.direction) === "out"
+      : physicalSource;
+    return horizontal
+      ? outgoing === increasing
+        ? "EAST"
+        : "WEST"
+      : outgoing === increasing
+        ? "SOUTH"
+        : "NORTH";
+  };
+  for (const edge of input.graph.edges) {
+    const from = flowLayerByNodeId.get(edge.sourceId),
+      to = flowLayerByNodeId.get(edge.targetId);
+    const endpoints = raw.get(edge.id);
+    if (from === undefined || to === undefined || !endpoints || edge.sourceId === edge.targetId)
+      continue;
+    const firstFace = face(edge, true),
+      lastFace = face(edge, false);
+    const positiveFace = horizontal ? "EAST" : "SOUTH",
+      negativeFace = horizontal ? "WEST" : "NORTH";
+    if (
+      ![positiveFace, negativeFace].includes(String(firstFace)) ||
+      ![positiveFace, negativeFace].includes(String(lastFace))
+    )
+      continue;
+    const firstBoundary = from - (firstFace === negativeFace ? 1 : 0),
+      lastBoundary = to - (lastFace === negativeFace ? 1 : 0);
+    if (firstBoundary !== lastBoundary) continue;
+    let boundary = boundaries.get(firstBoundary);
+    if (!boundary) boundaries.set(firstBoundary, (boundary = { ports: new Map(), edges: [] }));
+    const key = (source: boolean) => {
+      const id = source ? edge.sourceId : edge.targetId,
+        name = source ? edge.sourcePort : edge.targetPort;
+      if (isMergedHyperedgeDummy(input, id))
+        return JSON.stringify([id, source ? firstFace : lastFace]);
+      return name !== undefined ? JSON.stringify([id, name]) : JSON.stringify([edge.id, source]);
+    };
+    for (const source of [true, false]) {
+      const id = key(source),
+        point = source ? endpoints.source : endpoints.target;
+      if (!boundary.ports.has(id))
+        boundary.ports.set(id, {
+          id,
+          side:
+            ((source ? firstFace : lastFace) === positiveFace) === increasing ? "source" : "target",
+          position: horizontal ? point.y : point.x,
+        });
+    }
+    const reversed = orientation.reversedEdgeIds.has(edge.id);
+    const source = key(!reversed),
+      target = key(reversed);
+    boundary.edges.push({
+      edge,
+      source,
+      target,
+      sourceValue: boundary.ports.get(source)!.position,
+      targetValue: boundary.ports.get(target)!.position,
+      inLayer: from === to,
+    });
+  }
+  const routedEdges = new Set(
+    junctionGroups.flatMap((group) => group.map((record) => record.edgeId)),
+  );
+  const inLayerGroups: typeof junctionGroups = [];
+  for (const [, boundary] of [...boundaries].sort(([a], [b]) => (increasing ? a - b : b - a))) {
+    if (!boundary.edges.some((e) => e.inLayer)) continue;
+    const ports = [...boundary.ports.values()].sort((a, b) => a.position - b.position);
+    const grouped = createOrthogonalHypersegments(ports, boundary.edges);
+    const records: (typeof junctionGroups)[number] = [];
+    for (const group of grouped.segments)
+      for (const port of group.ports) {
+        const members = boundary.edges.filter(
+          (e) => e.source === port && e.inLayer && !routedEdges.has(e.edge.id),
+        );
+        for (const record of members) {
+          const values = [...group.incoming, ...group.outgoing];
+          records.push({
+            edgeId: record.edge.id,
+            reversed: orientation.reversedEdgeIds.has(record.edge.id),
+            sourceValue: record.sourceValue,
+            targetValue: record.targetValue,
+            segment: { ...group, start: Math.min(...values), end: Math.max(...values), slot: 0 },
+          });
+        }
+      }
+    inLayerGroups.push(records);
+  }
+  junctionGroups = [...inLayerGroups, ...junctionGroups];
+  const createdJunctions = new Set<string>();
+  for (const group of junctionGroups) {
+    for (const { edgeId, reversed, segment, partner, sourceValue, targetValue } of group) {
+      const physical = [...(pointsByEdgeId.get(edgeId) ?? [])];
+      if (reversed) physical.reverse();
+      const bends = Math.abs(segment.start - segment.end) < 1e-3 ? [] : physical.slice(1, -1);
+      const junctions: Point[] = [];
+      for (const [index, point] of bends.entries()) {
+        const track = orthogonalTrackByEdgeId.get(edgeId);
+        const detour = orthogonalDetourByEdgeId.get(edgeId);
+        const flow = horizontal ? point.x : point.y;
+        if (track !== undefined && Math.abs(flow - track) > 1e-9) continue;
+        if (
+          detour &&
+          Math.abs(flow - detour.firstTrack) > 1e-9 &&
+          Math.abs(flow - detour.secondTrack) > 1e-9
+        )
+          continue;
+        const current = partner && index >= 2 ? partner : segment;
+        const value =
+          index === 0
+            ? sourceValue
+            : index === bends.length - 1
+              ? targetValue
+              : segment.outgoing[0]!;
+        const boundary =
+          current.incoming.length > 0 &&
+          current.outgoing.length > 0 &&
+          ((Math.abs(value - current.incoming[0]!) < 1e-3 &&
+            Math.abs(value - current.outgoing[0]!) < 1e-3) ||
+            (Math.abs(value - current.incoming.at(-1)!) < 1e-3 &&
+              Math.abs(value - current.outgoing.at(-1)!) < 1e-3));
+        const key = `${point.x}:${point.y}`;
+        if (
+          !createdJunctions.has(key) &&
+          ((value > current.start && value < current.end) || boundary)
+        ) {
+          junctions.push(point);
+          createdJunctions.add(key);
+        }
+      }
+      junctionPointsByEdgeId.set(edgeId, junctions);
+    }
+  }
+
+  return junctionPointsByEdgeId;
+}

package/src/layered/orthogonal-segments.ts

@@ -0,0 +1,243 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2020 Kiel University and others.
+ * Adapted from ELK v0.11.0 orthogonal segment splitting and routing generation.
+ * Source commit: 54123e884b1ae743b453260f713b20c9bf5787f2
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import type { JavaRandom } from "../java-random";
+import { detectOrthogonalCycles, type OrthogonalDependency } from "./orthogonal-cycle-order";
+export interface OrthogonalSegmentInput {
+  incoming: readonly number[];
+  outgoing: readonly number[];
+}
+export interface OrthogonalSegment {
+  incoming: number[];
+  outgoing: number[];
+  start: number;
+  end: number;
+  slot: number;
+  partner?: number;
+  splitBy?: number;
+}
+const extent = (s: OrthogonalSegmentInput) => {
+  const values = [...s.incoming, ...s.outgoing];
+  return {
+    start: values.length ? Math.min(...values) : NaN,
+    end: values.length ? Math.max(...values) : NaN,
+  };
+};
+const crossings = (positions: readonly number[], start: number, end: number) =>
+  positions.filter((p) => p >= start && p <= end).length;
+const orderingCrossings = (a: OrthogonalSegment, b: OrthogonalSegment) =>
+  crossings(a.outgoing, b.start, b.end) + crossings(b.incoming, a.start, a.end);
+/** Full ELK segment dependency, critical split, cycle removal and rank phases. */
+export function routeOrthogonalSegments(
+  input: readonly OrthogonalSegmentInput[],
+  conflictThreshold: number,
+  criticalThreshold: number,
+  random: JavaRandom,
+) {
+  const segments: OrthogonalSegment[] = input.map((s) => ({
+    incoming: [...s.incoming],
+    outgoing: [...s.outgoing],
+    ...extent(s),
+    slot: 0,
+  }));
+  let dependencies: OrthogonalDependency[] = [];
+  const add = (source: number, target: number, critical: boolean, weight: number) =>
+    dependencies.push({ source, target, critical, weight });
+  const conflicts = (a: readonly number[], b: readonly number[]) => {
+    if (!a.length || !b.length) return 0;
+    let i = 0,
+      j = 0,
+      count = 0;
+    while (true) {
+      const x = a[i]!,
+        y = b[j]!;
+      if (x > y - criticalThreshold && x < y + criticalThreshold) return -1;
+      if (x > y - conflictThreshold && x < y + conflictThreshold) count++;
+      if (x <= y && i < a.length - 1) i++;
+      else if (y <= x && j < b.length - 1) j++;
+      else break;
+    }
+    return count;
+  };
+  const create = (a: number, b: number) => {
+    const left = segments[a]!,
+      right = segments[b]!;
+    if (Math.abs(left.start - left.end) < 1e-3 || Math.abs(right.start - right.end) < 1e-3)
+      return 0;
+    const c1 = conflicts(left.outgoing, right.incoming),
+      c2 = conflicts(right.outgoing, left.incoming);
+    if (c1 === -1 || c2 === -1) {
+      if (c1 === -1) add(b, a, true, 1);
+      if (c2 === -1) add(a, b, true, 1);
+      return Number(c1 === -1) + Number(c2 === -1);
+    }
+    const v1 = c1 + 16 * orderingCrossings(left, right),
+      v2 = c2 + 16 * orderingCrossings(right, left);
+    if (v1 < v2) add(a, b, false, v2 - v1);
+    else if (v1 > v2) add(b, a, false, v1 - v2);
+    else if (v1 > 0) {
+      add(a, b, false, 0);
+      add(b, a, false, 0);
+    }
+    return 0;
+  };
+  let criticalCount = 0;
+  for (let a = 0; a < segments.length - 1; a++)
+    for (let b = a + 1; b < segments.length; b++) criticalCount += create(a, b);
+  if (criticalCount >= 2) {
+    const cycle = detectOrthogonalCycles(segments.length, dependencies, true, random);
+    const selected = new Set<number>();
+    for (const dependency of cycle.backwards) {
+      let { source, target } = dependency;
+      if (selected.has(source) || selected.has(target)) continue;
+      const a = segments[source]!,
+        b = segments[target]!;
+      if (a.incoming.length + a.outgoing.length > 2 && b.incoming.length + b.outgoing.length <= 2)
+        [source, target] = [target, source];
+      selected.add(source);
+      segments[source]!.splitBy = target;
+    }
+    const coords = segments.flatMap((s) => [...s.incoming, ...s.outgoing]).sort((a, b) => a - b);
+    const areas: Array<{ start: number; end: number }> = [];
+    for (let i = 1; i < coords.length; i++)
+      if (coords[i]! - coords[i - 1]! >= 2 * criticalThreshold)
+        areas.push({
+          start: coords[i - 1]! + criticalThreshold,
+          end: coords[i]! - criticalThreshold,
+        });
+    const ordered = [...selected].sort(
+      (a, b) => segments[a]!.end - segments[a]!.start - (segments[b]!.end - segments[b]!.start),
+    );
+    for (const index of ordered) {
+      const segment = segments[index]!,
+        causing = segment.splitBy!;
+      let position = (segment.start + segment.end) / 2;
+      const possible = areas.flatMap((area, i) =>
+        area.start <= segment.end && area.end >= segment.start ? [i] : [],
+      );
+      if (possible.length) {
+        const rating = (areaIndex: number) => {
+          const area = areas[areaIndex]!,
+            center = (area.start + area.end) / 2;
+          // ELK rates using the provisional halves' extents before adding the bridge.
+          const left = {
+            ...segment,
+            outgoing: [center],
+            ...extent({ incoming: segment.incoming, outgoing: [] }),
+          };
+          const right = {
+            ...segment,
+            incoming: [center],
+            ...extent({ incoming: [], outgoing: segment.outgoing }),
+          };
+          let depCount = 2,
+            cross = 0;
+          const neighbors = [
+            ...dependencies.filter((d) => d.target === index).map((d) => d.source),
+            ...dependencies.filter((d) => d.source === index).map((d) => d.target),
+          ];
+          for (const other of neighbors)
+            for (const half of [left, right]) {
+              const c1 = orderingCrossings(half, segments[other]!),
+                c2 = orderingCrossings(segments[other]!, half);
+              if (c1 === c2) {
+                if (c1 > 0) {
+                  depCount += 2;
+                  cross += c1;
+                }
+              } else {
+                depCount++;
+                cross += Math.min(c1, c2);
+              }
+            }
+          cross +=
+            orderingCrossings(left, segments[causing]!) +
+            orderingCrossings(segments[causing]!, right);
+          return { cross, depCount, size: area.end - area.start };
+        };
+        let best = possible[0]!,
+          score = rating(best);
+        for (const candidate of possible.slice(1)) {
+          const curr = rating(candidate);
+          if (
+            curr.cross < score.cross ||
+            (curr.cross === score.cross &&
+              (curr.depCount < score.depCount ||
+                (curr.depCount === score.depCount && curr.size > score.size)))
+          ) {
+            best = candidate;
+            score = curr;
+          }
+        }
+        const area = areas[best]!;
+        position = (area.start + area.end) / 2;
+        areas.splice(best, 1);
+        if ((area.end - area.start) / 2 >= criticalThreshold) {
+          const replacement = [];
+          if (area.start <= position - criticalThreshold)
+            replacement.push({ start: area.start, end: position - criticalThreshold });
+          if (position + criticalThreshold <= area.end)
+            replacement.push({ start: position + criticalThreshold, end: area.end });
+          areas.splice(best, 0, ...replacement);
+        }
+      }
+      const partner = segments.length;
+      const outgoing = segment.outgoing;
+      segment.outgoing = [position];
+      segment.partner = partner;
+      Object.assign(segment, extent(segment));
+      segments.push({
+        incoming: [position],
+        outgoing,
+        ...extent({ incoming: [position], outgoing }),
+        slot: 0,
+        partner: index,
+      });
+      dependencies = dependencies.filter((d) => d.source !== index && d.target !== index);
+      add(index, causing, true, 1);
+      add(causing, partner, true, 1);
+      for (let other = 0; other < segments.length; other++)
+        if (other !== index && other !== partner && other !== causing) {
+          create(other, index);
+          create(other, partner);
+        }
+    }
+  }
+  const regular = detectOrthogonalCycles(segments.length, dependencies, false, random);
+  // Reversal appends to both adjacency lists, just like ELK's setters.
+  for (const backwards of regular.backwards) {
+    dependencies.splice(dependencies.indexOf(backwards), 1);
+    if (backwards.weight > 0)
+      dependencies.push({ ...backwards, source: backwards.target, target: backwards.source });
+  }
+  const inCount = segments.map((_, i) => dependencies.filter((d) => d.target === i).length),
+    outCount = segments.map((_, i) => dependencies.filter((d) => d.source === i).length);
+  const sources = inCount.flatMap((n, i) => (n === 0 ? [i] : [])),
+    targets = outCount.flatMap((n, i) =>
+      n === 0 && segments[i]!.incoming.length === 0 ? [i] : [],
+    );
+  let maxRank = -1;
+  while (sources.length) {
+    const index = sources.shift()!;
+    for (const d of dependencies.filter((d) => d.source === index)) {
+      segments[d.target]!.slot = Math.max(segments[d.target]!.slot, segments[index]!.slot + 1);
+      maxRank = Math.max(maxRank, segments[d.target]!.slot);
+      if (--inCount[d.target]! === 0) sources.push(d.target);
+    }
+  }
+  if (maxRank > -1) {
+    for (const index of targets) segments[index]!.slot = maxRank;
+    while (targets.length) {
+      const index = targets.shift()!;
+      for (const d of dependencies.filter((d) => d.target === index)) {
+        if (segments[d.source]!.incoming.length) continue;
+        segments[d.source]!.slot = Math.min(segments[d.source]!.slot, segments[index]!.slot - 1);
+        if (--outCount[d.source]! === 0) targets.push(d.source);
+      }
+    }
+  }
+  return { segments, dependencies };
+}

package/src/layered/placement-orientation.ts

@@ -0,0 +1,22 @@
+import type { AcyclicOrientation, LayeredPhaseInput, LayerOrder } from "./types";
+
+const orientationByInput = new WeakMap<LayeredPhaseInput, AcyclicOrientation>();
+
+/** Retain the active acyclic topology without altering authored endpoints or public output. */
+export function setPlacementOrientation(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+): void {
+  orientationByInput.set(input, orientation);
+}
+export function getPlacementOrientation(input: LayeredPhaseInput): AcyclicOrientation | undefined {
+  return orientationByInput.get(input);
+}
+
+const orderByInput = new WeakMap<LayeredPhaseInput, LayerOrder>();
+export function setPlacementOrder(input: LayeredPhaseInput, order: LayerOrder): void {
+  orderByInput.set(input, order);
+}
+export function getPlacementOrder(input: LayeredPhaseInput): LayerOrder | undefined {
+  return orderByInput.get(input);
+}