@statelyai/layout 0.3.0 → 0.4.1

package/src/layered/label-dummy-switcher.ts

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2012, 2017 Kiel University and others.
+ * Native adaptation of ELK LabelDummySwitcher (v0.11.0).
+ * SPDX-License-Identifier: EPL-2.0
+ */
+import type { GraphEdge } from "@statelyai/graph";
+import type { LayerOrder } from "./types";
+import type { LongEdgeExpansion } from "./long-edges";
+import type { CenterLabelExpansion } from "./center-labels";
+import { inheritCycleRandom } from "./cycle-random";
+
+/** Before placement: move labels along their own proper long-edge chain without changing crossing order. */
+export function switchCenterLabelDummies(
+  expansion: LongEdgeExpansion,
+  labels: CenterLabelExpansion,
+  order: LayerOrder,
+): { expansion: LongEdgeExpansion; order: LayerOrder } {
+  if (!labels.dummyById.size) return { expansion, order };
+  const input = expansion.input;
+  const horizontal = input.direction === "left" || input.direction === "right";
+  const layers = order.layers.map((layer) => [...layer]);
+  const layerByNodeId = new Map(expansion.assignment.layerByNodeId);
+  const widths = layers.map((layer) =>
+    Math.max(
+      0,
+      ...layer
+        .filter((id) => !id.startsWith("__layout_dummy:"))
+        .map((id) => {
+          const size = input.sizes.get(id);
+          return horizontal ? (size?.width ?? 0) : (size?.height ?? 0);
+        }),
+    ),
+  );
+  let edges = [...input.graph.edges];
+  const alignments = new Map<string, "LEFT" | "RIGHT">();
+  const nodeIds = new Set(input.graph.nodes.map((node) => node.id));
+  const longDummy = (id: string) =>
+    nodeIds.has(id) &&
+    id.startsWith("__layout_dummy:") &&
+    !labels.dummyById.has(id) &&
+    !id.startsWith("__layout_dummy:inverted:") &&
+    !id.startsWith("__layout_dummy:north-south:");
+  const orientedSource = (edge: GraphEdge) =>
+    expansion.orientation.reversedEdgeIds.has(edge.id) ? edge.targetId : edge.sourceId;
+  const orientedTarget = (edge: GraphEdge) =>
+    expansion.orientation.reversedEdgeIds.has(edge.id) ? edge.sourceId : edge.targetId;
+  const infos = layers
+    .flatMap((layer) => layer.filter((id) => labels.dummyById.has(id)))
+    .map((id) => {
+      const label = labels.dummyById.get(id)!;
+      const walk = (backward: boolean) => {
+        const result: string[] = [],
+          seen = new Set([id]);
+        let current = id;
+        for (;;) {
+          const edge = edges.find(
+            (edge) => (backward ? orientedTarget(edge) : orientedSource(edge)) === current,
+          );
+          if (!edge) break;
+          current = backward ? orientedSource(edge) : orientedTarget(edge);
+          if (!longDummy(current) || seen.has(current)) break;
+          seen.add(current);
+          result.push(current);
+        }
+        return backward ? result.reverse() : result;
+      };
+      const chain = [...walk(true), id, ...walk(false)];
+      const strategy = String(
+        input.edgeSettings?.(label.edge)?.["edgeLabels.centerLabelPlacementStrategy"] ??
+          input.settings["edgeLabels.centerLabelPlacementStrategy"] ??
+          "MEDIAN_LAYER",
+      );
+      return {
+        id,
+        chain,
+        strategy,
+        reversed: label.reversed,
+        width: horizontal ? input.sizes.get(id)!.width : input.sizes.get(id)!.height,
+      };
+    });
+  type Info = (typeof infos)[number];
+  const assign = (info: Info, target: number) => {
+    const other = info.chain.find((id) => layerByNodeId.get(id) === target)!;
+    if (other !== info.id) {
+      const original = layerByNodeId.get(info.id)!;
+      const firstSlot = layers[original]!.indexOf(info.id),
+        secondSlot = layers[target]!.indexOf(other);
+      layers[original]![firstSlot] = other;
+      layers[target]![secondSlot] = info.id;
+      layerByNodeId.set(info.id, target);
+      layerByNodeId.set(other, original);
+      edges = edges.map((edge) => {
+        const swap = (id: string) => (id === info.id ? other : id === other ? info.id : id);
+        const sourceId = swap(edge.sourceId),
+          targetId = swap(edge.targetId);
+        const reversed = expansion.orientation.reversedEdgeIds.has(edge.id);
+        return {
+          ...edge,
+          sourceId,
+          targetId,
+          sourcePort:
+            sourceId === info.id
+              ? reversed
+                ? "input"
+                : "output"
+              : edge.sourceId === info.id
+                ? undefined
+                : edge.sourcePort,
+          targetPort:
+            targetId === info.id
+              ? reversed
+                ? "output"
+                : "input"
+              : edge.targetId === info.id
+                ? undefined
+                : edge.targetPort,
+        };
+      });
+    }
+    widths[target] = Math.max(widths[target]!, info.width);
+  };
+  const validLayers = (info: Info) =>
+    info.chain.map((id) => layerByNodeId.get(id)!).sort((a, b) => a - b);
+  const widest = (valid: number[]) =>
+    valid.reduce((best, layer) => (widths[layer]! > widths[best]! ? layer : best), valid[0]!);
+  // ELK processes strategies independent of width before width-dependent strategies.
+  for (const strategy of [
+    "MEDIAN_LAYER",
+    "HEAD_LAYER",
+    "TAIL_LAYER",
+    "CENTER_LAYER",
+    "WIDEST_LAYER",
+  ]) {
+    for (const info of infos.filter((info) => info.strategy === strategy)) {
+      const valid = validLayers(info);
+      let target = valid[Math.floor((valid.length - 1) / 2)]!;
+      if (strategy === "HEAD_LAYER" || strategy === "TAIL_LAYER") {
+        const right = (strategy === "HEAD_LAYER") !== info.reversed;
+        target = right ? valid.at(-1)! : valid[0]!;
+        alignments.set(info.id, right ? "RIGHT" : "LEFT");
+      } else if (strategy === "WIDEST_LAYER") target = widest(valid);
+      else if (strategy === "CENTER_LAYER") {
+        const spacing = Math.max(
+          Number(input.settings["spacing.edgeNodeBetweenLayers"] ?? 10) * 2,
+          input.spacing.layer,
+        );
+        let sum = -spacing;
+        const sums = valid.map((layer) => {
+          sum += widths[layer]! + spacing;
+          return sum;
+        });
+        target = valid[sums.findIndex((value) => value >= sum / 2)]!;
+      }
+      assign(info, target);
+    }
+  }
+  const pending: Info[] = [];
+  for (const info of infos.filter((info) => info.strategy === "SPACE_EFFICIENT_LAYER")) {
+    const valid = validLayers(info),
+      wide = valid.find((layer) => widths[layer]! >= info.width);
+    if (valid.length === 1 || wide !== undefined) assign(info, wide ?? valid[0]!);
+    else pending.push(info);
+  }
+  pending.sort((a, b) => b.width - a.width);
+  for (const [index, info] of pending.entries()) {
+    const valid = validLayers(info);
+    let target = valid[0]!,
+      best = 0;
+    for (const layer of valid) {
+      if (widths[layer]! >= info.width) {
+        target = layer;
+        break;
+      }
+      let potential = widths[layer]!;
+      // Preserve ELK's last eligible pending-label selection and first-layer tie breaking.
+      for (const other of pending.slice(index + 1))
+        if (validLayers(other).includes(layer)) potential = Math.max(widths[layer]!, other.width);
+      if (potential > best) {
+        target = layer;
+        best = potential;
+      }
+    }
+    assign(info, target);
+  }
+  return {
+    expansion: {
+      ...expansion,
+      assignment: { ...expansion.assignment, layerByNodeId },
+      input: inheritCycleRandom(input, {
+        ...input,
+        graph: { ...input.graph, edges },
+        nodeSettings: (node) => ({
+          ...input.nodeSettings?.(node),
+          ...(alignments.has(node.id) ? { alignment: alignments.get(node.id)! } : {}),
+        }),
+      }),
+    },
+    order: { ...order, layers },
+  };
+}

package/src/layered/long-edges.ts

@@ -1,3 +1,4 @@
+import { inheritCycleRandom } from "./cycle-random";
 import type { GraphEdge, GraphNode, Point } from "@statelyai/graph";
 import type {
   AcyclicOrientation,
@@ -14,6 +15,8 @@ export interface LongEdgeExpansion {
   assignment: LayerAssignment;
   segmentIdsByEdgeId: ReadonlyMap<string, readonly string[]>;
   labelDummyIdByEdgeId: ReadonlyMap<string, string>;
+  /** Physical incoming adjacency after cycle reversal and long-edge retargeting. */
+  incomingEdgeOrderByNodeId?: ReadonlyMap<string, readonly string[]>;
 }
 
 function uniqueDummyId(usedIds: Set<string>, edgeId: string, layer: number): string {
@@ -41,50 +44,15 @@ export function splitLongEdges(
   const originalEdgeBySegmentId = new Map<string, GraphEdge>();
   const usedNodeIds = new Set(nodes.map((node) => node.id));
   const originalNodeIds = new Set(usedNodeIds);
-  const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
-  const forwardSourceSide =
-    input.direction === "right"
-      ? "EAST"
-      : input.direction === "left"
-        ? "WEST"
-        : input.direction === "down"
-          ? "SOUTH"
-          : "NORTH";
-  const forwardTargetSide =
-    input.direction === "right"
-      ? "WEST"
-      : input.direction === "left"
-        ? "EAST"
-        : input.direction === "down"
-          ? "NORTH"
-          : "SOUTH";
 
   for (const edge of input.graph.edges) {
     const sourceLayer = layerByNodeId.get(edge.sourceId) ?? 0;
     const targetLayer = layerByNodeId.get(edge.targetId) ?? 0;
     const span = Math.abs(targetLayer - sourceLayer);
-    const source = nodeById.get(edge.sourceId);
-    const target = nodeById.get(edge.targetId);
-    const sourcePort = source?.ports?.find((port) => port.name === edge.sourcePort);
-    const targetPort = target?.ports?.find((port) => port.name === edge.targetPort);
-    const sourceSide =
-      source && sourcePort ? input.portSettings?.(sourcePort, source)?.["port.side"] : undefined;
-    const targetSide =
-      target && targetPort ? input.portSettings?.(targetPort, target)?.["port.side"] : undefined;
-    const hasFixedPortSide = (node: GraphNode | undefined): boolean => {
-      if (!node) return false;
-      const constraints = String(input.nodeSettings?.(node)?.portConstraints ?? "UNDEFINED");
-      return constraints !== "UNDEFINED" && constraints !== "FREE";
-    };
-    const fixedSideFeedback =
-      sourceLayer > targetLayer &&
-      ((hasFixedPortSide(source) && sourceSide === forwardSourceSide) ||
-        (hasFixedPortSide(target) && targetSide === forwardTargetSide));
     if (
       span <= 1 ||
       edge.sourceId === edge.targetId ||
-      (input.settings.feedbackEdges === true && orientation.reversedEdgeIds.has(edge.id)) ||
-      fixedSideFeedback
+      (input.settings.feedbackEdges === true && orientation.reversedEdgeIds.has(edge.id))
     ) {
       edges.push(edge);
       originalEdgeBySegmentId.set(edge.id, edge);
@@ -175,10 +143,58 @@ export function splitLongEdges(
     segmentIdsByEdgeId.set(edge.id, segmentIds);
   }
 
+  const incomingEdgeOrderByNodeId = new Map<string, string[]>();
+  const orientedSource = (edge: GraphEdge) =>
+    orientation.reversedEdgeIds.has(edge.id) ? edge.targetId : edge.sourceId;
+  const orientedTarget = (edge: GraphEdge) =>
+    orientation.reversedEdgeIds.has(edge.id) ? edge.sourceId : edge.targetId;
+  const appendIncoming = (edge: GraphEdge) => {
+    const target = orientedTarget(edge);
+    incomingEdgeOrderByNodeId.set(target, [
+      ...(incomingEdgeOrderByNodeId.get(target) ?? []),
+      edge.id,
+    ]);
+  };
+  for (const edge of input.graph.edges)
+    if (!orientation.reversedEdgeIds.has(edge.id)) appendIncoming(edge);
+  for (const id of orientation.reversedEdgeIds) {
+    const edge = input.graph.edges.find((candidate) => candidate.id === id);
+    if (edge) appendIncoming(edge);
+  }
+  // Upstream walks source layers, nodes, then their existing ports. Splitting
+  // retargets the last chain segment, appending it to its physical target port.
+  const sourceNodes = [...input.graph.nodes].sort(
+    (a, b) => (assignment.layerByNodeId.get(a.id) ?? 0) - (assignment.layerByNodeId.get(b.id) ?? 0),
+  );
+  for (const node of sourceNodes) {
+    const outgoing = input.graph.edges.filter((edge) => orientedSource(edge) === node.id);
+    const portIndex = (edge: GraphEdge) =>
+      node.ports?.findIndex(
+        (port) =>
+          port.name ===
+          (orientation.reversedEdgeIds.has(edge.id) ? edge.targetPort : edge.sourcePort),
+      ) ?? -1;
+    outgoing.sort(
+      (a, b) =>
+        portIndex(a) - portIndex(b) ||
+        Number(orientation.reversedEdgeIds.has(a.id)) -
+          Number(orientation.reversedEdgeIds.has(b.id)),
+    );
+    for (const edge of outgoing) {
+      if ((segmentIdsByEdgeId.get(edge.id)?.length ?? 0) < 2) continue;
+      const target = orientedTarget(edge);
+      incomingEdgeOrderByNodeId.set(
+        target,
+        incomingEdgeOrderByNodeId.get(target)!.filter((id) => id !== edge.id),
+      );
+      appendIncoming(edge);
+    }
+  }
+
   // ELK creates long-edge dummies while walking layers. Thus dummies for an
   // edge whose source is in the next layer can precede later parts of an edge
   // that started in an earlier layer. Preserve that order for crossing ties.
-  const maximumLayer = Math.max(0, ...layerByNodeId.values());
+  const maximumLayer = Math.max(0, (assignment.layerCount ?? 1) - 1, ...layerByNodeId.values());
   const nodesByLayer = Array.from({ length: maximumLayer + 1 }, () => [] as string[]);
   for (const node of input.graph.nodes) {
     nodesByLayer[layerByNodeId.get(node.id) ?? 0]?.push(node.id);
@@ -223,10 +239,25 @@ export function splitLongEdges(
       ),
   ];
   const graph = { ...input.graph, nodes: orderedNodes, edges } as LayeredPhaseInput["graph"];
+  const edgeIdByLabelDummyId = new Map<string, string>();
+  for (const [edgeId, id] of labelDummyIdByEdgeId)
+    if (!edgeIdByLabelDummyId.has(id)) edgeIdByLabelDummyId.set(id, edgeId);
+  const inputEdgeById = new Map<string, (typeof input.graph.edges)[number]>();
+  for (const edge of input.graph.edges)
+    if (!inputEdgeById.has(edge.id)) inputEdgeById.set(edge.id, edge);
   return {
-    input: {
+    input: inheritCycleRandom(input, {
       ...input,
       graph,
+      modelOrderByEdgeId: new Map(
+        edges.map((edge) => {
+          const original = originalEdgeBySegmentId.get(edge.id) ?? edge;
+          return [
+            edge.id,
+            input.modelOrderByEdgeId?.get(original.id) ?? input.graph.edges.indexOf(original),
+          ];
+        }),
+      ),
       sizes,
       edgeSettings: (edge) => {
         const original = originalEdgeBySegmentId.get(edge.id) ?? edge;
@@ -234,9 +265,9 @@ export function splitLongEdges(
       },
       nodeSettings: (node) => {
         const original = input.nodeSettings?.(node);
-        const edgeId = [...labelDummyIdByEdgeId].find(([, id]) => id === node.id)?.[0];
+        const edgeId = edgeIdByLabelDummyId.get(node.id);
         if (!edgeId) return original;
-        const edge = input.graph.edges.find((candidate) => candidate.id === edgeId);
+        const edge = inputEdgeById.get(edgeId);
         const strategy = String(
           (edge && input.edgeSettings?.(edge)?.["edgeLabels.centerLabelPlacementStrategy"]) ??
             input.settings["edgeLabels.centerLabelPlacementStrategy"] ??
@@ -257,7 +288,8 @@ export function splitLongEdges(
               : {}),
         };
       },
-    },
+    }),
+    incomingEdgeOrderByNodeId,
     orientation: { reversedEdgeIds },
     assignment: { ...assignment, layerByNodeId },
     segmentIdsByEdgeId,
@@ -289,6 +321,9 @@ export function joinLongEdgeRoutes(
   preserveInternalDuplicates = false,
   convertLongSplines = false,
   longSplineEdgeNodeSpacing = 10,
+  preserveOrthogonalCorners = false,
+  restoredJunctionCounts?: ReadonlyMap<string, number>,
+  reversedSegmentIds?: ReadonlySet<string>,
 ): EdgeRoutes {
   const simplify = (points: readonly Point[]): Point[] => {
     const result: Point[] = [];
@@ -381,7 +416,36 @@ export function joinLongEdgeRoutes(
       }
     }
     const points: Point[] = [];
-    if (!preserveInternalDuplicates && segmentIds.length > 1) {
+    // ELK joins segment bend lists without their dummy anchors. Orthogonal
+    // compaction can collapse bends; those original bends still remain public.
+    if (!preserveInternalDuplicates && preserveOrthogonalCorners && segmentIds.length > 1) {
+      const joined = segmentIds.flatMap((segmentId, segmentIndex) => {
+        const segment = routes.pointsByEdgeId.get(segmentId) ?? [];
+        return segment.map((point, index) => ({
+          point,
+          dummyAnchor:
+            (index === 0 && segmentIndex !== 0) ||
+            (index === segment.length - 1 && segmentIndex !== segmentIds.length - 1),
+        }));
+      });
+      // Native dummy anchors may supply a real corner. Discard only redundant
+      // anchors; retain segment bends even when compaction made them collinear.
+      for (let index = 1; index + 1 < joined.length;) {
+        const first = joined[index - 1]!.point;
+        const middle = joined[index]!;
+        const last = joined[index + 1]!.point;
+        const equal = (a: number, b: number) => Math.abs(a - b) < 1e-9;
+        if (
+          middle.dummyAnchor &&
+          ((equal(first.x, middle.point.x) && equal(middle.point.x, last.x)) ||
+            (equal(first.y, middle.point.y) && equal(middle.point.y, last.y)))
+        ) {
+          joined.splice(index, 1);
+          index = Math.max(1, index - 1);
+        } else index++;
+      }
+      points.push(...joined.map(({ point }) => point));
+    } else if (!preserveInternalDuplicates && segmentIds.length > 1) {
       const segments = segmentIds.map((segmentId) => routes.pointsByEdgeId.get(segmentId) ?? []);
       const firstPoint = segments[0]?.[0];
       if (firstPoint) points.push(firstPoint);
@@ -399,8 +463,35 @@ export function joinLongEdgeRoutes(
     }
     pointsByEdgeId.set(
       edgeId,
-      preserveInternalDuplicates || segmentIds.length === 1 ? points : simplify(points),
+      preserveInternalDuplicates || preserveOrthogonalCorners || segmentIds.length === 1
+        ? points
+        : simplify(points),
     );
   }
-  return { pointsByEdgeId, outsideFeedbackEdgeIds };
+  const junctionPointsByEdgeId =
+    routes.junctionPointsByEdgeId &&
+    new Map(
+      [...segmentIdsByEdgeId].map(([edgeId, ids]) => [
+        edgeId,
+        // ELK restores north/south branches after long-edge joining. Keep
+        // those appended junctions after all original routing junctions.
+        [
+          // Long-edge joining runs before edge-direction restoration. Its
+          // junction chain retains physical flow order on reversed edges.
+          ...(reversedSegmentIds?.has(ids[0]!) ? [...ids].reverse() : ids).flatMap((id) => {
+            const points = routes.junctionPointsByEdgeId?.get(id) ?? [];
+            return points.slice(0, points.length - (restoredJunctionCounts?.get(id) ?? 0));
+          }),
+          ...ids.flatMap((id) => {
+            const count = restoredJunctionCounts?.get(id) ?? 0;
+            return count ? (routes.junctionPointsByEdgeId?.get(id) ?? []).slice(-count) : [];
+          }),
+        ],
+      ]),
+    );
+  return {
+    pointsByEdgeId,
+    outsideFeedbackEdgeIds,
+    ...(junctionPointsByEdgeId ? { junctionPointsByEdgeId } : {}),
+  };
 }

package/src/layered/loop-envelopes.ts

@@ -0,0 +1,184 @@
+import type { GraphEdge } from "@statelyai/graph";
+import type { LayeredPhaseInput, NodePlacement } from "./types";
+import { getPortPoint } from "./strategies";
+import {
+  fixedSelfLoopLabels,
+  fixedSelfLoopSide,
+  routeFixedSelfLoop,
+  selfLoopTracks,
+} from "./fixed-self-loop";
+
+export interface LoopEnvelope {
+  before: number;
+  after: number;
+  flowBefore: number;
+  flowAfter: number;
+}
+
+/** Unconstrained implicit loop ports are restored on loop faces after the sweep. */
+export function hasMovableLoopPorts(input: LayeredPhaseInput, edge: GraphEdge): boolean {
+  if (
+    edge.sourceId !== edge.targetId ||
+    edge.sourcePort !== undefined ||
+    edge.targetPort !== undefined
+  )
+    return false;
+  const node = input.graph.nodes.find((candidate) => candidate.id === edge.sourceId);
+  const constraints = node && input.nodeSettings?.(node)?.portConstraints;
+  return constraints === undefined || constraints === "FREE" || constraints === "UNDEFINED";
+}
+
+export function loopEnvelopes(input: LayeredPhaseInput): ReadonlyMap<string, LoopEnvelope> {
+  const envelopes = new Map<string, LoopEnvelope>();
+  if ((input.settings.edgeRouting ?? "ORTHOGONAL") !== "ORTHOGONAL") return envelopes;
+  for (const node of input.graph.nodes) {
+    const allLoops = input.graph.edges.filter(
+      (edge) => edge.sourceId === node.id && edge.targetId === node.id,
+    );
+    const constraints = input.nodeSettings?.(node)?.portConstraints;
+    if (
+      allLoops.length &&
+      constraints &&
+      constraints !== "FREE" &&
+      constraints !== "UNDEFINED" &&
+      allLoops.every(
+        (edge) =>
+          edge.sourcePort !== undefined &&
+          edge.targetPort !== undefined &&
+          input.edgeSettings?.(edge)?.["edgeLabels.inline"] !== true &&
+          (((edge.width ?? 0) === 0 && (edge.height ?? 0) === 0) ||
+            (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER"),
+      )
+    ) {
+      const size = input.sizes.get(node.id) ?? { width: 0, height: 0 };
+      const rect = { x: 0, y: 0, ...size };
+      const envelope = { before: 0, after: 0, flowBefore: 0, flowAfter: 0 };
+      const horizontal = input.direction === "right" || input.direction === "left";
+      const reverse = input.direction === "left" || input.direction === "up";
+      const spacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
+      let supported = true;
+      const tracks = selfLoopTracks(allLoops);
+      for (const edge of allLoops) {
+        const from = node.ports?.find((port) => port.name === edge.sourcePort);
+        const to = node.ports?.find((port) => port.name === edge.targetPort);
+        const sourceSide =
+          from && fixedSelfLoopSide(input.portSettings?.(from, node)?.["port.side"]);
+        const targetSide = to && fixedSelfLoopSide(input.portSettings?.(to, node)?.["port.side"]);
+        const labeled = (edge.width ?? 0) > 0 || (edge.height ?? 0) > 0;
+        if (!sourceSide || !targetSide || (labeled && sourceSide !== targetSide)) {
+          supported = false;
+          break;
+        }
+        const start = getPortPoint(
+          node,
+          edge.sourcePort,
+          rect,
+          { x: 0, y: 0 },
+          input.direction,
+          input,
+        );
+        const end = getPortPoint(
+          node,
+          edge.targetPort,
+          rect,
+          { x: 0, y: 0 },
+          input.direction,
+          input,
+        );
+        const route = routeFixedSelfLoop(
+          rect,
+          start,
+          end,
+          sourceSide,
+          targetSide,
+          spacing * (tracks.get(edge.id)! + 1),
+          input.direction,
+        );
+        if (labeled) {
+          const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
+          const { width = 0, height = 0 } = edge;
+          for (const label of fixedSelfLoopLabels(route, sourceSide, width, height, labelSpacing))
+            route.push(label, { x: label.x + width, y: label.y + height });
+        }
+        for (const point of route) {
+          const cross = horizontal ? point.y : point.x;
+          const flow = horizontal ? point.x : point.y;
+          const flowSize = horizontal ? size.width : size.height;
+          envelope.before = Math.max(envelope.before, -cross);
+          envelope.after = Math.max(
+            envelope.after,
+            cross - (horizontal ? size.height : size.width),
+          );
+          envelope.flowBefore = Math.max(envelope.flowBefore, reverse ? flow - flowSize : -flow);
+          envelope.flowAfter = Math.max(envelope.flowAfter, reverse ? -flow : flow - flowSize);
+        }
+      }
+      if (supported) {
+        envelopes.set(node.id, envelope);
+        continue;
+      }
+    }
+    const loops = allLoops.filter((edge) => hasMovableLoopPorts(input, edge));
+    // Inline labels remain owned by the existing labeled-loop phase. Move
+    // the entire node together when that phase is ported, rather than mixing
+    // two different loop distributions and reservations on the same node.
+    if (
+      loops.length === 0 ||
+      loops.some((edge) => input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true)
+    )
+      continue;
+    const settings = input.nodeSettings?.(node);
+    const distribution = settings?.["edgeRouting.selfLoopDistribution"] ?? "NORTH";
+    const ordering = settings?.["edgeRouting.selfLoopOrdering"] ?? "STACKED";
+    const spacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
+    const envelope = { before: 0, after: 0, flowBefore: 0, flowAfter: 0 };
+    const sides =
+      distribution === "EQUALLY"
+        ? (["before", "after", "flowAfter", "flowBefore"] as const)
+        : distribution === "NORTH_SOUTH"
+          ? (["before", "after"] as const)
+          : (["before"] as const);
+    for (const side of sides) {
+      const selected = loops.filter((_, index) => sides[index % sides.length] === side);
+      const horizontal = input.direction === "right" || input.direction === "left";
+      const crossSize =
+        side === "before" || side === "after"
+          ? horizontal
+            ? "height"
+            : "width"
+          : horizontal
+            ? "width"
+            : "height";
+      const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
+      envelope[side] =
+        spacing * (ordering === "SEQUENCED" ? Math.min(1, selected.length) : selected.length) +
+        selected.reduce(
+          (sum, edge) =>
+            sum + ((edge[crossSize] ?? 0) > 0 ? (edge[crossSize] ?? 0) + labelSpacing : 0),
+          0,
+        );
+    }
+    envelopes.set(node.id, envelope);
+  }
+  return envelopes;
+}
+
+const reservedByPlacement = new WeakMap<NodePlacement, ReadonlySet<string>>();
+export function recordLoopEnvelopes(placement: NodePlacement, ids: ReadonlySet<string>): void {
+  reservedByPlacement.set(placement, ids);
+}
+export function hasPlacementLoopEnvelope(placement: NodePlacement, id: string): boolean {
+  return reservedByPlacement.get(placement)?.has(id) ?? false;
+}
+
+const preparedByInput = new WeakMap<LayeredPhaseInput, ReadonlyMap<string, LoopEnvelope>>();
+export function prepareLoopEnvelopes(input: LayeredPhaseInput): ReadonlyMap<string, LoopEnvelope> {
+  const envelopes = loopEnvelopes(input);
+  preparedByInput.set(input, envelopes);
+  return envelopes;
+}
+export function preparedLoopEnvelopes(
+  input: LayeredPhaseInput,
+): ReadonlyMap<string, LoopEnvelope> | undefined {
+  return preparedByInput.get(input);
+}