@statelyai/layout 0.0.2 → 0.0.4

package/src/layered/index.ts

@@ -29,6 +29,7 @@ import {
   breakCyclesWithModelOrderBreadthFirstSearch,
   breakCyclesWithDepthFirstSearch,
   getPolylineMidpoint,
+  getOrientedPortDirection,
   minimizeCrossingsWithBarycenter,
   minimizeCrossingsWithMedian,
   minimizeCrossingsInteractively,
@@ -1332,6 +1333,37 @@ function runLayeredPipeline<N, E, G, P>(
           left: options.padding?.left ?? 12,
         };
   const switchedSideByPort = new Map<string, "NORTH" | "SOUTH" | "WEST" | "EAST">();
+  const parallelPortIndexByKey = new Map<string, number>();
+  const labeledEdgesByPair = new Map<string, GraphEdge[]>();
+  for (const edge of graph.edges as GraphEdge[]) {
+    const settings = options.edgeSettings?.(edge);
+    if (
+      edge.sourcePort === undefined ||
+      edge.targetPort === undefined ||
+      edge.sourceId === edge.targetId ||
+      (edge.width ?? 0) <= 0 ||
+      (edge.height ?? 0) <= 0 ||
+      (settings?.["edgeLabels.placement"] ?? "CENTER") !== "CENTER" ||
+      settings?.["edgeLabels.inline"] !== true
+    ) {
+      continue;
+    }
+    const key = `${edge.sourceId}\0${edge.targetId}`;
+    const pair = labeledEdgesByPair.get(key) ?? [];
+    pair.push(edge);
+    labeledEdgesByPair.set(key, pair);
+  }
+  for (const pair of labeledEdgesByPair.values()) {
+    if (pair.length < 2) continue;
+    for (const [index, edge] of pair.entries()) {
+      const portIndex =
+        options.settings?.["considerModelOrder.strategy"] === "PREFER_NODES"
+          ? index
+          : pair.length - index - 1;
+      parallelPortIndexByKey.set(`${edge.sourceId}\0${edge.sourcePort}`, portIndex);
+      parallelPortIndexByKey.set(`${edge.targetId}\0${edge.targetPort}`, portIndex);
+    }
+  }
   const input: LayeredPhaseInput = {
     graph: graph as Graph<unknown, unknown, unknown, unknown>,
     sizes: new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)])),
@@ -1352,6 +1384,9 @@ function runLayeredPipeline<N, E, G, P>(
     ...(options.edgeSettings === undefined ? {} : { edgeSettings: options.edgeSettings }),
     portSettings: (port, node) => ({
       ...options.portSettings?.(port, node),
+      ...(parallelPortIndexByKey.has(`${node.id}\0${port.name}`)
+        ? { "port.index": parallelPortIndexByKey.get(`${node.id}\0${port.name}`) }
+        : {}),
       ...(switchedSideByPort.has(`${node.id}\0${port.name}`)
         ? { "port.side": switchedSideByPort.get(`${node.id}\0${port.name}`) }
         : {}),
@@ -1660,7 +1695,7 @@ function runLayeredPipeline<N, E, G, P>(
     }
   }
   measure("port-margin-normalization", () =>
-    normalizePlacementForPortExtents(expanded.input, placement, order),
+    normalizePlacementForPortExtents(expanded.input, placement, order, expanded.orientation),
   );
   {
     const horizontal = direction === "left" || direction === "right";
@@ -1720,10 +1755,288 @@ function runLayeredPipeline<N, E, G, P>(
       : edgeRouting === "SPLINES"
         ? routeEdgesWithSplines
         : routeEdgesOrthogonally);
-  const expandedRoutes = measure("edge-routing", () =>
+  let expandedRoutes = measure("edge-routing", () =>
     edgeRouter(expanded.input, expanded.orientation, placement),
   );
   measure("post-compaction", () => applyPostCompaction(expanded.input, placement, expandedRoutes));
+  const antiparallelLabelPositions = new Map<string, Point>();
+  const outerAntiparallelLabelIds = new Set<string>();
+  const parallelLabelPositions = new Map<string, Point>();
+  const postCompactionNodeCrossDeltas = new Map<string, number>();
+  const horizontalAntiparallelFlow = direction === "left" || direction === "right";
+  const usesVizInteractivePlacementProfile =
+    options.strategies?.routeEdges === undefined &&
+    options.settings?.["cycleBreaking.strategy"] === "MODEL_ORDER" &&
+    options.settings?.["layering.strategy"] === "INTERACTIVE" &&
+    options.settings?.["crossingMinimization.forceNodeModelOrder"] === true &&
+    options.settings?.["nodePlacement.strategy"] === "BRANDES_KOEPF" &&
+    options.settings?.["nodePlacement.favorStraightEdges"] === true &&
+    options.settings?.["compaction.postCompaction.strategy"] === "LEFT" &&
+    options.settings?.["compaction.postCompaction.constraints"] === "SCANLINE";
+  if (usesVizInteractivePlacementProfile) {
+    const neighbors = new Map(graph.nodes.map((node) => [node.id, new Set<string>()]));
+    for (const edge of graph.edges) {
+      if (edge.sourceId === edge.targetId) continue;
+      neighbors.get(edge.sourceId)?.add(edge.targetId);
+      neighbors.get(edge.targetId)?.add(edge.sourceId);
+    }
+    const visited = new Set<string>();
+    for (const node of graph.nodes) {
+      if (visited.has(node.id)) continue;
+      const component: GraphNode[] = [];
+      const pending = [node.id];
+      while (pending.length > 0) {
+        const id = pending.pop()!;
+        if (visited.has(id)) continue;
+        visited.add(id);
+        const member = graph.nodes.find((candidate) => candidate.id === id);
+        if (member) component.push(member);
+        for (const neighbor of neighbors.get(id) ?? []) pending.push(neighbor);
+      }
+      if (component.length < 2) continue;
+      const componentIds = new Set(component.map((member) => member.id));
+      if (
+        !graph.edges.some(
+          (edge) =>
+            componentIds.has(edge.sourceId) &&
+            componentIds.has(edge.targetId) &&
+            expanded.orientation.reversedEdgeIds.has(edge.id),
+        )
+      ) {
+        continue;
+      }
+      const directedPairCounts = new Map<string, number>();
+      for (const edge of graph.edges) {
+        if (!componentIds.has(edge.sourceId) || !componentIds.has(edge.targetId)) continue;
+        const key = `${edge.sourceId}\0${edge.targetId}`;
+        directedPairCounts.set(key, (directedPairCounts.get(key) ?? 0) + 1);
+      }
+      if ([...directedPairCounts.values()].some((count) => count > 1)) continue;
+      if (
+        component.some((member) => {
+          const constraints = options.nodeSettings?.(member)?.portConstraints;
+          return constraints !== undefined && constraints !== "UNDEFINED" && constraints !== "FREE";
+        })
+      ) {
+        continue;
+      }
+      const layerCounts = new Map<number, number>();
+      for (const member of component) {
+        const layer = expanded.assignment.layerByNodeId.get(member.id);
+        if (layer === undefined) continue;
+        layerCounts.set(layer, (layerCounts.get(layer) ?? 0) + 1);
+      }
+      if ([...layerCounts.values()].some((count) => count !== 1)) continue;
+      const rects = component.flatMap((member) => {
+        const rect = mutableRects.get(member.id);
+        return rect ? [{ member, rect }] : [];
+      });
+      if (rects.length !== component.length) continue;
+      const minimumCross = Math.min(
+        ...rects.map(({ rect }) => (horizontalAntiparallelFlow ? rect.y : rect.x)),
+      );
+      const maximumCross = Math.max(
+        ...rects.map(({ rect }) =>
+          horizontalAntiparallelFlow ? rect.y + rect.height : rect.x + rect.width,
+        ),
+      );
+      const center = (minimumCross + maximumCross) / 2;
+      for (const { member, rect } of rects) {
+        const currentCross = horizontalAntiparallelFlow ? rect.y : rect.x;
+        const nextCross = horizontalAntiparallelFlow
+          ? center - rect.height / 2
+          : center - rect.width / 2;
+        postCompactionNodeCrossDeltas.set(member.id, nextCross - currentCross);
+        mutableRects.set(
+          member.id,
+          horizontalAntiparallelFlow ? { ...rect, y: nextCross } : { ...rect, x: nextCross },
+        );
+      }
+    }
+  }
+  {
+    const horizontal = horizontalAntiparallelFlow;
+    const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
+    const pairEdges = new Map<string, GraphEdge[]>();
+    for (const edge of graph.edges) {
+      if (edge.sourceId === edge.targetId || (edge.width ?? 0) <= 0 || (edge.height ?? 0) <= 0) {
+        continue;
+      }
+      const key = [edge.sourceId, edge.targetId].sort().join("\0");
+      const pair = pairEdges.get(key) ?? [];
+      pair.push(edge);
+      pairEdges.set(key, pair);
+    }
+    for (const pair of pairEdges.values()) {
+      if (
+        pair.length !== 2 ||
+        pair[0]!.sourceId !== pair[1]!.targetId ||
+        pair[0]!.targetId !== pair[1]!.sourceId ||
+        pair.some((edge) => {
+          const settings = options.edgeSettings?.(edge);
+          return (
+            (settings?.["edgeLabels.placement"] ?? "CENTER") !== "CENTER" ||
+            settings?.["edgeLabels.inline"] !== true
+          );
+        })
+      ) {
+        continue;
+      }
+      const firstNode = nodesById.get(pair[0]!.sourceId);
+      const secondNode = nodesById.get(pair[0]!.targetId);
+      const firstRect = placement.rectByNodeId.get(pair[0]!.sourceId);
+      const secondRect = placement.rectByNodeId.get(pair[0]!.targetId);
+      if (!firstNode || !secondNode || !firstRect || !secondRect) continue;
+      const nonSelfNeighbors = (nodeId: string) =>
+        new Set(
+          graph.edges.flatMap((edge) =>
+            edge.sourceId === edge.targetId
+              ? []
+              : edge.sourceId === nodeId
+                ? [edge.targetId]
+                : edge.targetId === nodeId
+                  ? [edge.sourceId]
+                  : [],
+          ),
+        );
+      const isolatedAntiparallelPair =
+        nonSelfNeighbors(firstNode.id).size === 1 && nonSelfNeighbors(secondNode.id).size === 1;
+      const hasFlexiblePorts = (node: GraphNode): boolean => {
+        const constraints = options.nodeSettings?.(node)?.portConstraints;
+        return constraints === undefined || constraints === "UNDEFINED" || constraints === "FREE";
+      };
+      const hasFlexiblePairPorts = hasFlexiblePorts(firstNode) && hasFlexiblePorts(secondNode);
+      if (isolatedAntiparallelPair && !hasFlexiblePairPorts) continue;
+
+      const firstBeforeSecond = horizontal
+        ? firstRect.x + firstRect.width / 2 < secondRect.x + secondRect.width / 2
+        : firstRect.y + firstRect.height / 2 < secondRect.y + secondRect.height / 2;
+      const beforeRect = firstBeforeSecond ? firstRect : secondRect;
+      const afterRect = firstBeforeSecond ? secondRect : firstRect;
+      const forward = pair.find((edge) =>
+        firstBeforeSecond
+          ? edge.sourceId === pair[0]!.sourceId
+          : edge.sourceId === pair[0]!.targetId,
+      );
+      if (!forward?.sourcePort || !forward.targetPort) continue;
+
+      let cross = Math.min(
+        horizontal ? firstRect.y : firstRect.x,
+        horizontal ? secondRect.y : secondRect.x,
+      );
+      const edgeSpacing = Number(options.settings?.["spacing.edgeEdge"] ?? 10);
+      for (const edge of pair) {
+        const width = edge.width ?? 0;
+        const height = edge.height ?? 0;
+        antiparallelLabelPositions.set(
+          edge.id,
+          isolatedAntiparallelPair
+            ? horizontal
+              ? {
+                  x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+                  y: cross,
+                }
+              : {
+                  x: cross,
+                  y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2,
+                }
+            : horizontal
+              ? {
+                  x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+                  y:
+                    edge === forward
+                      ? (firstRect.y +
+                          firstRect.height / 2 +
+                          secondRect.y +
+                          secondRect.height / 2) /
+                          2 -
+                        height / 2
+                      : Math.max(firstRect.y + firstRect.height, secondRect.y + secondRect.height) +
+                        edgeSpacing,
+                }
+              : {
+                  x:
+                    edge === forward
+                      ? (firstRect.x + firstRect.width / 2 + secondRect.x + secondRect.width / 2) /
+                          2 -
+                        width / 2
+                      : Math.max(firstRect.x + firstRect.width, secondRect.x + secondRect.width) +
+                        edgeSpacing,
+                  y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2,
+                },
+        );
+        if (!isolatedAntiparallelPair && edge !== forward) {
+          outerAntiparallelLabelIds.add(edge.id);
+        }
+        cross += (horizontal ? height : width) + edgeSpacing;
+      }
+
+      const forwardLabel = antiparallelLabelPositions.get(forward.id)!;
+      const forwardCross = horizontal
+        ? Math.round(forwardLabel.y + (forward.height ?? 0) / 2)
+        : Math.round(forwardLabel.x + (forward.width ?? 0) / 2);
+      const alignPort = (node: GraphNode, portName: string): void => {
+        const rect = placement.rectByNodeId.get(node.id);
+        const port = node.ports?.find((candidate) => candidate.name === portName);
+        if (!rect || !port) return;
+        const placedPort = placePorts(
+          node.ports,
+          rect,
+          direction,
+          (candidate) => input.portSettings?.(candidate, node),
+          { ...options.settings, ...options.nodeSettings?.(node) },
+          (candidate) =>
+            getOrientedPortDirection(expanded.input, expanded.orientation, node, candidate),
+        )?.find((candidate) => candidate.name === portName);
+        if (!placedPort) return;
+        const localCross = horizontal
+          ? (placedPort.y ?? 0) + (placedPort.height ?? 0) / 2
+          : (placedPort.x ?? 0) + (placedPort.width ?? 0) / 2;
+        const nextCross = forwardCross - localCross;
+        const currentCross = horizontal ? rect.y : rect.x;
+        postCompactionNodeCrossDeltas.set(
+          node.id,
+          (postCompactionNodeCrossDeltas.get(node.id) ?? 0) + nextCross - currentCross,
+        );
+        mutableRects.set(
+          node.id,
+          horizontal ? { ...rect, y: nextCross } : { ...rect, x: nextCross },
+        );
+      };
+      if (isolatedAntiparallelPair) {
+        alignPort(nodesById.get(forward.sourceId)!, forward.sourcePort);
+        alignPort(nodesById.get(forward.targetId)!, forward.targetPort);
+      }
+    }
+  }
+  if (postCompactionNodeCrossDeltas.size > 0) {
+    const pointsByEdgeId = new Map(expandedRoutes.pointsByEdgeId);
+    for (const edge of graph.edges) {
+      const points = [...(pointsByEdgeId.get(edge.id) ?? [])];
+      if (points.length === 0) continue;
+      const sourceDelta = postCompactionNodeCrossDeltas.get(edge.sourceId) ?? 0;
+      const targetDelta = postCompactionNodeCrossDeltas.get(edge.targetId) ?? 0;
+      const shiftEndpoint = (endpointIndex: number, adjacentIndex: number, delta: number): void => {
+        if (delta === 0) return;
+        const endpoint = points[endpointIndex];
+        const adjacent = points[adjacentIndex];
+        if (!endpoint) return;
+        const originalCross = horizontalAntiparallelFlow ? endpoint.y : endpoint.x;
+        points[endpointIndex] = horizontalAntiparallelFlow
+          ? { ...endpoint, y: endpoint.y + delta }
+          : { ...endpoint, x: endpoint.x + delta };
+        if (adjacent && (horizontalAntiparallelFlow ? adjacent.y : adjacent.x) === originalCross) {
+          points[adjacentIndex] = horizontalAntiparallelFlow
+            ? { ...adjacent, y: adjacent.y + delta }
+            : { ...adjacent, x: adjacent.x + delta };
+        }
+      };
+      shiftEndpoint(0, 1, sourceDelta);
+      shiftEndpoint(points.length - 1, points.length - 2, targetDelta);
+      pointsByEdgeId.set(edge.id, points);
+    }
+    expandedRoutes = { ...expandedRoutes, pointsByEdgeId };
+  }
   let routes = measure("long-edge-joining", () =>
     joinLongEdgeRoutes(
       expandedRoutes,
@@ -1877,6 +2190,99 @@ function runLayeredPipeline<N, E, G, P>(
         : { ...end, y: end.y + delta };
     (routes.pointsByEdgeId as Map<string, readonly Point[]>).set(edge.id, points);
   }
+  for (const pair of labeledEdgesByPair.values()) {
+    if (pair.length < 2) continue;
+    const sourceRect = mutableRects.get(pair[0]!.sourceId);
+    const targetRect = mutableRects.get(pair[0]!.targetId);
+    if (!sourceRect || !targetRect) continue;
+    const horizontal = direction === "left" || direction === "right";
+    const beforeRect = horizontal
+      ? sourceRect.x <= targetRect.x
+        ? sourceRect
+        : targetRect
+      : sourceRect.y <= targetRect.y
+        ? sourceRect
+        : targetRect;
+    const afterRect = beforeRect === sourceRect ? targetRect : sourceRect;
+    const edgeSpacing = Number(options.settings?.["spacing.edgeEdge"] ?? 10);
+    let cross = horizontal ? padding.top : padding.left;
+    const orderedPair =
+      options.settings?.["considerModelOrder.strategy"] === "PREFER_NODES"
+        ? pair
+        : [...pair].reverse();
+    for (const edge of orderedPair) {
+      const width = edge.width ?? 0;
+      const height = edge.height ?? 0;
+      parallelLabelPositions.set(
+        edge.id,
+        horizontal
+          ? {
+              x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+              y: cross,
+            }
+          : {
+              x: cross,
+              y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2,
+            },
+      );
+      cross += (horizontal ? height : width) + edgeSpacing;
+    }
+
+    const anchorEdge = orderedPair[0]!;
+    const anchorLabel = parallelLabelPositions.get(anchorEdge.id)!;
+    const desiredCross = Math.round(
+      horizontal
+        ? anchorLabel.y + (anchorEdge.height ?? 0) / 2
+        : anchorLabel.x + (anchorEdge.width ?? 0) / 2,
+    );
+    const alignEndpoint = (nodeId: string, portName: string): void => {
+      const node = graph.nodes.find((candidate) => candidate.id === nodeId);
+      const rect = mutableRects.get(nodeId);
+      const port = node?.ports?.find((candidate) => candidate.name === portName);
+      if (!node || !rect || !port) return;
+      const placedPort = placePorts(
+        node.ports,
+        rect,
+        direction,
+        (candidate) => input.portSettings?.(candidate, node),
+        { ...options.settings, ...options.nodeSettings?.(node) },
+        (candidate) =>
+          getOrientedPortDirection(expanded.input, expanded.orientation, node, candidate),
+      )?.find((candidate) => candidate.name === portName);
+      if (!placedPort) return;
+      const localCross = horizontal
+        ? (placedPort.y ?? 0) + (placedPort.height ?? 0) / 2
+        : (placedPort.x ?? 0) + (placedPort.width ?? 0) / 2;
+      const currentCross = horizontal ? rect.y : rect.x;
+      const nextCross = desiredCross - localCross;
+      const delta = nextCross - currentCross;
+      mutableRects.set(nodeId, horizontal ? { ...rect, y: nextCross } : { ...rect, x: nextCross });
+      for (const edge of graph.edges) {
+        const points = [...(routes.pointsByEdgeId.get(edge.id) ?? [])];
+        if (points.length === 0) continue;
+        const index =
+          edge.sourceId === nodeId ? 0 : edge.targetId === nodeId ? points.length - 1 : undefined;
+        if (index === undefined) continue;
+        const endpoint = points[index]!;
+        const originalCross = horizontal ? endpoint.y : endpoint.x;
+        points[index] = horizontal
+          ? { ...endpoint, y: endpoint.y + delta }
+          : { ...endpoint, x: endpoint.x + delta };
+        const adjacentIndex = index === 0 ? 1 : points.length - 2;
+        const adjacent = points[adjacentIndex];
+        if (adjacent && (horizontal ? adjacent.y : adjacent.x) === originalCross) {
+          points[adjacentIndex] = horizontal
+            ? { ...adjacent, y: adjacent.y + delta }
+            : { ...adjacent, x: adjacent.x + delta };
+        }
+        (routes.pointsByEdgeId as Map<string, readonly Point[]>).set(edge.id, points);
+      }
+    };
+    if (anchorEdge.sourcePort && anchorEdge.targetPort) {
+      alignEndpoint(anchorEdge.sourceId, anchorEdge.sourcePort);
+      alignEndpoint(anchorEdge.targetId, anchorEdge.targetPort);
+    }
+  }
   const routedPortAnchors = new Map<string, Point>();
   for (const edge of graph.edges) {
     const points = routes.pointsByEdgeId.get(edge.id);
@@ -1914,6 +2320,7 @@ function runLayeredPipeline<N, E, G, P>(
       direction,
       (port) => input.portSettings?.(port, node),
       { ...options.settings, ...options.nodeSettings?.(node) },
+      (port) => getOrientedPortDirection(expanded.input, expanded.orientation, node, port),
     );
     if (options.nodeSettings?.(node)?.portConstraints === "FIXED_SIDE") {
       ports = ports?.map((port) => {
@@ -2024,8 +2431,9 @@ function runLayeredPipeline<N, E, G, P>(
           .sort((left, right) => right.length - left.length)[0]
       : undefined;
     const sourceNode = graph.nodes.find((node) => node.id === edge.sourceId);
+    const targetNode = graph.nodes.find((node) => node.id === edge.targetId);
     const sourcePort = sourceNode?.ports?.find((port) => port.name === edge.sourcePort);
-    const targetPort = sourceNode?.ports?.find((port) => port.name === edge.targetPort);
+    const targetPort = targetNode?.ports?.find((port) => port.name === edge.targetPort);
     const sourcePortSide =
       sourceNode && sourcePort
         ? options.portSettings?.(sourcePort, sourceNode)?.["port.side"]
@@ -2081,10 +2489,83 @@ function runLayeredPipeline<N, E, G, P>(
               : (labelPlacement === "CENTER" ? midpoint.y : (firstPoint.y + lastPoint.y) / 2) +
                 labelSpacing +
                 Math.round(edgeThickness / 2);
-    const x =
-      labelPlacement === "CENTER" && horizontal && labelDummyRect ? labelDummyRect.x : routeX;
-    const y =
-      labelPlacement === "CENTER" && !horizontal && labelDummyRect ? labelDummyRect.y : routeY;
+    const sourceRect = placement.rectByNodeId.get(edge.sourceId);
+    const targetRect = placement.rectByNodeId.get(edge.targetId);
+    const hasFlexiblePorts = (node: GraphNode | undefined): boolean => {
+      const constraints = node ? options.nodeSettings?.(node)?.portConstraints : undefined;
+      return constraints === undefined || constraints === "UNDEFINED" || constraints === "FREE";
+    };
+    const flexibleFeedbackLabel =
+      labelPlacement === "CENTER" &&
+      inlineLabel &&
+      expanded.orientation.reversedEdgeIds.has(edge.id) &&
+      hasFlexiblePorts(sourceNode) &&
+      hasFlexiblePorts(targetNode) &&
+      sourceRect !== undefined &&
+      targetRect !== undefined;
+    const [beforeFlowRect, afterFlowRect] =
+      sourceRect && targetRect
+        ? horizontal
+          ? sourceRect.x <= targetRect.x
+            ? [sourceRect, targetRect]
+            : [targetRect, sourceRect]
+          : sourceRect.y <= targetRect.y
+            ? [sourceRect, targetRect]
+            : [targetRect, sourceRect]
+        : [undefined, undefined];
+    const antiparallelLabelPosition = antiparallelLabelPositions.get(edge.id);
+    const outerAntiparallelLabelPosition = (() => {
+      if (!outerAntiparallelLabelIds.has(edge.id)) return undefined;
+      const edgeNodeSpacing = Number(options.settings?.["spacing.edgeNode"] ?? 10);
+      if (horizontal) {
+        const x = (beforeFlowRect!.x + beforeFlowRect!.width + afterFlowRect!.x - width) / 2;
+        const blockers = [
+          sourceRect!,
+          targetRect!,
+          ...[...placement.rectByNodeId.values()].filter(
+            (rect) => rect.x < x + width && rect.x + rect.width > x,
+          ),
+        ];
+        return {
+          x,
+          y: Math.max(...blockers.map((rect) => rect.y + rect.height)) + edgeNodeSpacing,
+        };
+      }
+      const y = (beforeFlowRect!.y + beforeFlowRect!.height + afterFlowRect!.y - height) / 2;
+      const blockers = [
+        sourceRect!,
+        targetRect!,
+        ...[...placement.rectByNodeId.values()].filter(
+          (rect) => rect.y < y + height && rect.y + rect.height > y,
+        ),
+      ];
+      return {
+        x: Math.max(...blockers.map((rect) => rect.x + rect.width)) + edgeNodeSpacing,
+        y,
+      };
+    })();
+    const explicitLabelPosition =
+      outerAntiparallelLabelPosition ??
+      antiparallelLabelPosition ??
+      parallelLabelPositions.get(edge.id);
+    const x = explicitLabelPosition
+      ? explicitLabelPosition.x
+      : flexibleFeedbackLabel
+        ? horizontal
+          ? (beforeFlowRect!.x + beforeFlowRect!.width + afterFlowRect!.x - width) / 2
+          : targetRect.x + (targetRect.width - width) / 2
+        : labelPlacement === "CENTER" && horizontal && labelDummyRect
+          ? labelDummyRect.x
+          : routeX;
+    const y = explicitLabelPosition
+      ? explicitLabelPosition.y
+      : flexibleFeedbackLabel
+        ? horizontal
+          ? targetRect.y + (targetRect.height - height) / 2
+          : (beforeFlowRect!.y + beforeFlowRect!.height + afterFlowRect!.y - height) / 2
+        : labelPlacement === "CENTER" && !horizontal && labelDummyRect
+          ? labelDummyRect.y
+          : routeY;
     return {
       ...edge,
       x,

package/src/layered/long-edges.ts

@@ -71,14 +71,15 @@ export function splitLongEdges(
       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 &&
-      ((source !== undefined &&
-        input.nodeSettings?.(source)?.portConstraints === "FIXED_SIDE" &&
-        sourceSide === forwardSourceSide) ||
-        (target !== undefined &&
-          input.nodeSettings?.(target)?.portConstraints === "FIXED_SIDE" &&
-          targetSide === forwardTargetSide));
+      ((hasFixedPortSide(source) && sourceSide === forwardSourceSide) ||
+        (hasFixedPortSide(target) && targetSide === forwardTargetSide));
     if (
       span <= 1 ||
       edge.sourceId === edge.targetId ||