@crazyhappyone/auto-graph 0.2.9 → 0.2.10

package/dist/index.js

@@ -4805,7 +4805,10 @@ function findObstacleFreePath(source, target, obstacles, options = {}, diagnosti
       detail: {
         xsCount: xs.length,
         ysCount: ys.length,
-        maxNodes
+        maxNodes,
+        obstacleCount: obstacles.length,
+        stage: "corridor-filtered",
+        ...corridorMargin === void 0 ? {} : { corridorMargin }
       }
     });
     return null;
@@ -4851,7 +4854,14 @@ function findObstacleFreePath(source, target, obstacles, options = {}, diagnosti
       severity: "warning",
       code: "routing.astar.grid_overflow",
       message: `A* full-retry grid overflow: ${xsFull.length * ysFull.length} nodes > ${maxNodes} limit. Falling back to heuristic routing.`,
-      detail: { xsCount: xsFull.length, ysCount: ysFull.length, maxNodes }
+      detail: {
+        xsCount: xsFull.length,
+        ysCount: ysFull.length,
+        maxNodes,
+        obstacleCount: obstacles.length,
+        stage: "full-retry",
+        ...corridorMargin === void 0 ? {} : { corridorMargin }
+      }
     });
     return null;
   }
@@ -5094,6 +5104,64 @@ function areCollinear(a, b, c) {
   return a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y;
 }
 
+// src/routing/budget.ts
+var MIN_CORNER_BUDGET = 600;
+var MAX_CORNER_BUDGET = 3e3;
+var MIN_NODE_BUDGET = 4e3;
+var MAX_NODE_BUDGET = 64e3;
+var CORNERS_PER_OBSTACLE = 12;
+var CORNER_HEADROOM = 2;
+var GRID_SAFETY_FACTOR = 3;
+var CORRIDOR_SCALING_K = 0.5;
+var CORRIDOR_SCALING_BASE = 200;
+function computeRoutingBudget(cornerObstacles, allObstacles, corridorMargin, overrides = {}) {
+  const adaptiveMaxCorners = deriveMaxCorners(
+    cornerObstacles.length,
+    corridorMargin
+  );
+  const adaptiveMaxNodes = deriveMaxNodes(
+    allObstacles.length,
+    corridorMargin
+  );
+  return {
+    maxCorners: resolveBudget(
+      overrides.maxCorners,
+      adaptiveMaxCorners,
+      MIN_CORNER_BUDGET,
+      MAX_CORNER_BUDGET
+    ),
+    maxNodes: resolveBudget(
+      overrides.maxNodes,
+      adaptiveMaxNodes,
+      MIN_NODE_BUDGET,
+      MAX_NODE_BUDGET
+    ),
+    cornerObstacleCount: cornerObstacles.length,
+    gridObstacleCount: allObstacles.length,
+    corridorMargin
+  };
+}
+function deriveMaxCorners(obstacleCount, corridorMargin) {
+  const base = 2 + obstacleCount * CORNERS_PER_OBSTACLE * CORNER_HEADROOM;
+  const corridorFactor = corridorScalingFactor(corridorMargin);
+  return Math.ceil(base * corridorFactor);
+}
+function deriveMaxNodes(obstacleCount, corridorMargin) {
+  const base = 4 * obstacleCount * obstacleCount + 4 * obstacleCount + 100;
+  const corridorFactor = corridorScalingFactor(corridorMargin);
+  return Math.ceil(base * GRID_SAFETY_FACTOR * corridorFactor);
+}
+function corridorScalingFactor(corridorMargin) {
+  return 1 + corridorMargin / CORRIDOR_SCALING_BASE * CORRIDOR_SCALING_K;
+}
+function resolveBudget(override, adaptive, min, max) {
+  const chosen = override !== void 0 && Number.isFinite(override) && override >= 1 ? override : adaptive;
+  return clamp(chosen, min, max);
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
 // src/routing/visibility-router.ts
 function findCornerGraphPath(source, target, obstacles, options = {}, diagnostics) {
   const margin = options.margin ?? 0;
@@ -5107,7 +5175,12 @@ function findCornerGraphPath(source, target, obstacles, options = {}, diagnostic
       severity: "warning",
       code: "routing.visibility.corner_overflow",
       message: `Corner graph overflow: ${vertices.length} vertices > ${maxCorners}. Falling back to grid A*.`,
-      detail: { vertexCount: vertices.length, maxCorners }
+      detail: {
+        vertexCount: vertices.length,
+        maxCorners,
+        obstacleCount: obstacles.length,
+        ...options.corridorMargin === void 0 ? {} : { corridorMargin: options.corridorMargin }
+      }
     });
     return null;
   }
@@ -5381,7 +5454,7 @@ function segmentCrossesAnyObstacle(a, b, obstacles) {
 }
 
 // src/routing/routes.ts
-function checkBacktracking(points, source, target, diagnostics) {
+function checkBacktracking(points, source, target, diagnostics, maxRatio) {
   if (points.length < 2) return;
   const direct = Math.hypot(target.x - source.x, target.y - source.y);
   if (direct <= 0) return;
@@ -5391,7 +5464,7 @@ function checkBacktracking(points, source, target, diagnostics) {
     const b = points[i + 1];
     routeLen += Math.hypot(b.x - a.x, b.y - a.y);
   }
-  const threshold = 10;
+  const threshold = maxRatio ?? 20;
   if (routeLen > direct * threshold) {
     diagnostics.push({
       severity: "warning",
@@ -5409,8 +5482,20 @@ function routeEdge(input) {
   const diagnostics = [];
   const softObstacles = input.obstacles ?? [];
   const hardObstacles = input.hardObstacles ?? [];
+  let bestRejectedPath;
+  let bestRejectedCrossings = Number.POSITIVE_INFINITY;
   const softObstacleIndex = input.obstacleIndex ?? createBoxSpatialIndex(indexedBoxes(softObstacles));
   const hardObstacleIndex = input.hardObstacleIndex ?? createBoxSpatialIndex(indexedBoxes(hardObstacles));
+  const recordRejected = (candidate) => {
+    if (routeIntersectsObstacles(candidate, hardObstacles, hardObstacleIndex)) {
+      return;
+    }
+    const crossings = countObstacleCrossings(candidate, softObstacles);
+    if (crossings < bestRejectedCrossings) {
+      bestRejectedCrossings = crossings;
+      bestRejectedPath = candidate;
+    }
+  };
   const maxAttempts = input.maxRoutingAttempts ?? 5;
   const defaultAnchors = defaultAnchorsForGeometry(
     input.source.box,
@@ -5470,20 +5555,32 @@ function routeEdge(input) {
         targetAnchor
       );
       const allObstacles = [...softObstacles, ...hardObstacles];
+      const corridorMargin = input.corridorMargin ?? 32;
       const corridorObstacles = filterObstaclesByCorridor(
         source,
         target,
         allObstacles,
         [],
         // endpointObstacles passed separately via options
-        32
+        corridorMargin
       );
       const cornerObstacles = corridorObstacles.length === 0 && allObstacles.length > 0 ? allObstacles : corridorObstacles;
+      const budget = computeRoutingBudget(
+        cornerObstacles,
+        allObstacles,
+        corridorMargin,
+        { maxCorners: input.maxCorners, maxNodes: input.maxNodes }
+      );
       let cornerPath = findCornerGraphPath(
         source,
         target,
         cornerObstacles,
-        { endpointObstacles, margin: 2 },
+        {
+          endpointObstacles,
+          margin: 2,
+          maxCorners: budget.maxCorners,
+          corridorMargin
+        },
         diagnostics
       );
       if (cornerPath === null && cornerObstacles.length < allObstacles.length) {
@@ -5491,7 +5588,12 @@ function routeEdge(input) {
           source,
           target,
           allObstacles,
-          { endpointObstacles, margin: 2 },
+          {
+            endpointObstacles,
+            margin: 2,
+            maxCorners: budget.maxCorners,
+            corridorMargin
+          },
           diagnostics
         );
       }
@@ -5499,7 +5601,12 @@ function routeEdge(input) {
         source,
         target,
         allObstacles,
-        { endpointObstacles, margin: 0 },
+        {
+          endpointObstacles,
+          margin: 0,
+          corridorMargin,
+          maxNodes: budget.maxNodes
+        },
         diagnostics
       );
       if (path !== null && path.length >= 2) {
@@ -5516,15 +5623,27 @@ function routeEdge(input) {
           softObstacles,
           softObstacleIndex
         ) && !routeIntersectsObstacles(finalized, hardObstacles, hardObstacleIndex)) {
-          checkBacktracking(finalized, source, target, diagnostics);
+          checkBacktracking(
+            finalized,
+            source,
+            target,
+            diagnostics,
+            input.maxBacktrackingRatio
+          );
           return { points: finalized, diagnostics };
         }
+        recordRejected(finalized);
         if (cornerPath !== null) {
           const fullCornerPath = cornerObstacles.length < allObstacles.length ? findCornerGraphPath(
             source,
             target,
             allObstacles,
-            { endpointObstacles, margin: 2 },
+            {
+              endpointObstacles,
+              margin: 2,
+              maxCorners: budget.maxCorners,
+              corridorMargin
+            },
             diagnostics
           ) : null;
           if (fullCornerPath !== null && fullCornerPath.length >= 2) {
@@ -5545,15 +5664,27 @@ function routeEdge(input) {
               hardObstacles,
               hardObstacleIndex
             )) {
-              checkBacktracking(fullFinalized, source, target, diagnostics);
+              checkBacktracking(
+                fullFinalized,
+                source,
+                target,
+                diagnostics,
+                input.maxBacktrackingRatio
+              );
               return { points: fullFinalized, diagnostics };
             }
+            recordRejected(fullFinalized);
           }
           const gridPath = findObstacleFreePath(
             source,
             target,
             allObstacles,
-            { endpointObstacles, margin: 0 },
+            {
+              endpointObstacles,
+              margin: 0,
+              corridorMargin,
+              maxNodes: budget.maxNodes
+            },
             diagnostics
           );
           if (gridPath !== null && gridPath.length >= 2) {
@@ -5574,9 +5705,16 @@ function routeEdge(input) {
               hardObstacles,
               hardObstacleIndex
             )) {
-              checkBacktracking(gridFinalized, source, target, diagnostics);
+              checkBacktracking(
+                gridFinalized,
+                source,
+                target,
+                diagnostics,
+                input.maxBacktrackingRatio
+              );
               return { points: gridFinalized, diagnostics };
             }
+            recordRejected(gridFinalized);
           }
         }
       }
@@ -5640,7 +5778,8 @@ function routeEdge(input) {
         finalizedClean,
         candidate.points[0],
         candidate.points[candidate.points.length - 1],
-        diagnostics
+        diagnostics,
+        input.maxBacktrackingRatio
       );
       return { points: finalizedClean, diagnostics };
     }
@@ -5706,13 +5845,41 @@ function routeEdge(input) {
       code: "routing.obstacle.unavoidable",
       message: "No bounded orthogonal route candidate avoided all soft obstacles."
     });
-    return {
-      points: finalizeRoute(
-        bestPoints2,
+    const finalizedSoftBest = finalizeRoute(
+      bestPoints2,
+      softObstacles,
+      hardObstacles,
+      diagnostics
+    );
+    let softFallback = finalizedSoftBest;
+    if (bestRejectedPath !== void 0) {
+      const finalizedRejected = finalizeRoute(
+        bestRejectedPath,
         softObstacles,
         hardObstacles,
         diagnostics
-      ),
+      );
+      const rejectedCrossings = countObstacleCrossings(
+        finalizedRejected,
+        softObstacles
+      );
+      const heuristicCrossings = countObstacleCrossings(
+        finalizedSoftBest,
+        softObstacles
+      );
+      if (rejectedCrossings < heuristicCrossings) {
+        softFallback = finalizedRejected;
+      }
+    }
+    checkBacktracking(
+      softFallback,
+      softFallback[0],
+      softFallback[softFallback.length - 1],
+      diagnostics,
+      input.maxBacktrackingRatio
+    );
+    return {
+      points: softFallback,
       diagnostics
     };
   }
@@ -5744,6 +5911,22 @@ function routeEdge(input) {
         maxAttempts
       );
     }
+    if (bestRejectedPath !== void 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "routing.obstacle.unavoidable",
+        message: "Using A* route with minor soft-obstacle crossings to avoid hard evidence obstacles."
+      });
+      return {
+        points: finalizeRoute(
+          bestRejectedPath,
+          softObstacles,
+          hardObstacles,
+          diagnostics
+        ),
+        diagnostics
+      };
+    }
     diagnostics.push({
       severity: "error",
       code: "routing.evidence.crossing_forbidden",
@@ -5791,13 +5974,41 @@ function routeEdge(input) {
     code: "routing.obstacle.unavoidable",
     message: "No bounded orthogonal route candidate avoided all obstacles."
   });
-  return {
-    points: finalizeRoute(
-      bestPoints,
+  const finalizedBestPoints = finalizeRoute(
+    bestPoints,
+    softObstacles,
+    hardObstacles,
+    diagnostics
+  );
+  let fallbackPoints = finalizedBestPoints;
+  if (bestRejectedPath !== void 0) {
+    const finalizedRejected = finalizeRoute(
+      bestRejectedPath,
       softObstacles,
       hardObstacles,
       diagnostics
-    ),
+    );
+    const rejectedCrossings = countObstacleCrossings(
+      finalizedRejected,
+      softObstacles
+    );
+    const heuristicCrossings = countObstacleCrossings(
+      finalizedBestPoints,
+      softObstacles
+    );
+    if (rejectedCrossings < heuristicCrossings) {
+      fallbackPoints = finalizedRejected;
+    }
+  }
+  checkBacktracking(
+    fallbackPoints,
+    fallbackPoints[0],
+    fallbackPoints[fallbackPoints.length - 1],
+    diagnostics,
+    input.maxBacktrackingRatio
+  );
+  return {
+    points: fallbackPoints,
     diagnostics
   };
 }
@@ -6296,6 +6507,24 @@ function routeIntersectsObstacles(points, obstacles, spatialIndex) {
   }
   return false;
 }
+function countObstacleCrossings(points, obstacles) {
+  let count = 0;
+  for (const obstacle of obstacles) {
+    validateBox(obstacle);
+    for (let pointIndex = 0; pointIndex < points.length - 1; pointIndex += 1) {
+      const a = points[pointIndex];
+      const b = points[pointIndex + 1];
+      if (a === void 0 || b === void 0) {
+        continue;
+      }
+      if (intersectsAabb(segmentBox2(a, b), obstacle)) {
+        count += 1;
+        break;
+      }
+    }
+  }
+  return count;
+}
 function routeIntersectsEndpointInteriors(points, endpointInteriors) {
   for (let index = 0; index < points.length - 1; index += 1) {
     const a = points[index];
@@ -6741,7 +6970,8 @@ function solveDiagram(diagram, options = {}) {
     constrained.boxes,
     constrained.locks,
     options?.overlapSpacing ?? 40,
-    Math.max(0, options?.minLaneGutter ?? 0)
+    Math.max(0, options?.minLaneGutter ?? 0),
+    options.distributeContainedChildren ?? true
   );
   removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
   diagnostics.push(...swimlaneContracts.diagnostics);
@@ -6908,7 +7138,8 @@ function solveDiagram(diagram, options = {}) {
     diagram.direction,
     options,
     diagnostics,
-    coordinatedGroups
+    coordinatedGroups,
+    contentBounds
   );
   const edgeTextAnnotations = coordinateEdgeTextAnnotations(
     coordinatedEdges,
@@ -7330,7 +7561,7 @@ function reportCjkTypographyDiagnostics(path, typography, previousStyle, diagnos
 function containsCjk(value) {
   return /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/u.test(value);
 }
-function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottomFlow, nodeBoxes, locks, overlapSpacing, laneGutter) {
+function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottomFlow, nodeBoxes, locks, overlapSpacing, laneGutter, distributeContainedChildren) {
   const layouts = /* @__PURE__ */ new Map();
   const diagnostics = [];
   const movedChildIds = /* @__PURE__ */ new Set();
@@ -7349,7 +7580,9 @@ function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottom
       locks,
       diagnostics,
       movedChildIds,
-      laneGutter
+      laneGutter,
+      constraints,
+      distributeContainedChildren
     );
     if (layout2 !== void 0) {
       layouts.set(swimlane.id, layout2);
@@ -7541,7 +7774,7 @@ function isStackRunaway(boxes, nodes, direction, options) {
   const maxWidth = Math.max(...nodeBoxes.map((box) => box.width));
   return xSpread <= Math.max(maxWidth, options.overlapSpacing ?? 40);
 }
-function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, locks, diagnostics, movedChildIds, laneGutter) {
+function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, locks, diagnostics, movedChildIds, laneGutter, constraints, distributeContainedChildren) {
   const headerHeight = swimlane.headerHeight ?? 28;
   const padding = swimlane.padding ?? 16;
   const laneBounds = swimlane.lanes.map((lane) => {
@@ -7566,7 +7799,9 @@ function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes
       locks,
       diagnostics,
       movedChildIds,
-      laneGutter
+      laneGutter,
+      constraints,
+      distributeContainedChildren
     );
   }
   return applyHorizontalSwimlaneContract(
@@ -7581,13 +7816,29 @@ function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes
     laneGutter
   );
 }
-function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds, laneGutter) {
+function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds, laneGutter, constraints, distributeContainedChildren) {
   const populatedBounds = laneBounds.filter(
     (box) => box !== void 0
   );
   const top = Math.min(...populatedBounds.map((box) => box.y));
   const left = Math.min(...populatedBounds.map((box) => box.x));
   const maxChildHeight = Math.max(...populatedBounds.map((box) => box.height));
+  const containedChildIds = /* @__PURE__ */ new Set();
+  if (distributeContainedChildren) {
+    for (const c of constraints) {
+      if (c.kind !== "containment") continue;
+      if (nodeBoxes.get(c.containerId) === void 0) continue;
+      const distributable = c.childIds.filter((childId) => {
+        if (nodeBoxes.get(childId) === void 0) return false;
+        const lock = locks.get(childId);
+        return lock === void 0 || lock.source === "fixed-position";
+      });
+      if (distributable.length < 2) continue;
+      for (const childId of distributable) {
+        containedChildIds.add(childId);
+      }
+    }
+  }
   const flowRanks = topToBottomFlow ? rankVerticalSwimlaneChildren(swimlane, edges) : /* @__PURE__ */ new Map();
   const maxRank = flowRanks.size === 0 ? 0 : Math.max(...Array.from(flowRanks.values()));
   const rankStackGap = Math.max(8, padding / 2);
@@ -7604,7 +7855,8 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
     nodeBoxes,
     flowRanks,
     locks,
-    rankStackGap
+    rankStackGap,
+    containedChildIds
   );
   const slotWidth = Math.max(
     Math.max(...populatedBounds.map((box) => box.width)),
@@ -7626,7 +7878,10 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       const distributable = lane.children.filter(
         (childId) => !locks.has(childId)
       );
-      if (distributable.length >= CROSS_AXIS_SPREAD_THRESHOLD) {
+      const coveredByContainment = lane.children.some(
+        (childId) => containedChildIds.has(childId)
+      );
+      if (!coveredByContainment && distributable.length >= CROSS_AXIS_SPREAD_THRESHOLD) {
         moveRankedVerticalLaneChildren(
           lane.children,
           nodeBoxes,
@@ -7654,6 +7909,9 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       );
       continue;
     }
+    const rankedCoveredByContainment = lane.children.some(
+      (childId) => containedChildIds.has(childId)
+    );
     moveRankedVerticalLaneChildren(
       lane.children,
       nodeBoxes,
@@ -7664,7 +7922,8 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       rankSpacing,
       rankStackGap,
       { x: target.x, y: laneContentTop },
-      slotWidth - padding * 2
+      slotWidth - padding * 2,
+      rankedCoveredByContainment
     );
   }
   return {
@@ -7780,9 +8039,12 @@ function crossAxisSpreadWidth(items, gap) {
     0
   );
 }
-function maxCrossAxisSpreadWidth(swimlane, nodeBoxes, flowRanks, locks, gap) {
+function maxCrossAxisSpreadWidth(swimlane, nodeBoxes, flowRanks, locks, gap, containedChildIds) {
   let maxWidth = 0;
   for (const lane of swimlane.lanes) {
+    if (containedChildIds !== void 0 && lane.children.some((childId) => containedChildIds.has(childId))) {
+      continue;
+    }
     for (const stack of rankStacks(
       lane.children,
       nodeBoxes,
@@ -7795,7 +8057,7 @@ function maxCrossAxisSpreadWidth(swimlane, nodeBoxes, flowRanks, locks, gap) {
   }
   return maxWidth;
 }
-function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target, contentWidth) {
+function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target, contentWidth, suppressSpread) {
   for (const [rank, stack] of rankStacks(childIds, nodeBoxes, flowRanks)) {
     const unlocked = [];
     for (const item of stack) {
@@ -7824,7 +8086,7 @@ function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics,
       }
       nodeBoxes.set(childId, next);
     } else {
-      const shouldSpread = unlocked.length >= CROSS_AXIS_SPREAD_THRESHOLD;
+      const shouldSpread = !suppressSpread && unlocked.length >= CROSS_AXIS_SPREAD_THRESHOLD;
       if (!shouldSpread) {
         let yOffset = 0;
         for (const { childId, box } of unlocked) {
@@ -8953,14 +9215,21 @@ function evidenceOverlapDiagnostic(block, conflict) {
     }
   };
 }
-function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacles, textObstacles, hardObstacles, direction, options, diagnostics, groups) {
+function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacles, textObstacles, hardObstacles, direction, options, diagnostics, groups, contentBounds) {
   const coordinated = [];
   const coordinatedNodeById = new Map(
     coordinatedNodes.map((node) => [node.id, node])
   );
+  const corridorMarginOption = options.corridorMargin ?? "auto";
+  const corridorMargin = typeof corridorMarginOption === "number" ? corridorMarginOption : Math.max(
+    200,
+    Math.hypot(contentBounds.width, contentBounds.height) * 0.3
+  );
+  const routingGutter = options.routingGutter ?? 160;
+  const queryGutter = (options.routeKind ?? "orthogonal") === "obstacle-avoiding" ? Math.max(routingGutter, corridorMargin) : routingGutter;
   const nodeObstacleIndex = createBoxSpatialIndex(
     obstacles.map((box, index) => ({ id: `node-obstacle:${index}`, box })),
-    options.routingGutter ?? 160
+    queryGutter
   );
   for (const edge of edges) {
     const source = nodes.get(edge.source.nodeId);
@@ -8982,11 +9251,7 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacle
     const sourcePort = coordinatedNodeById.get(edge.source.nodeId)?.ports?.find((port) => port.id === edge.source.portId);
     const targetPort = coordinatedNodeById.get(edge.target.nodeId)?.ports?.find((port) => port.id === edge.target.portId);
     const routeTextObstacles = textObstacles.filter((annotation) => !isEdgeConnectedTextAnnotation(edge, annotation)).map((annotation) => annotation.box);
-    const corridor = edgeCorridorBox(
-      source.box,
-      target.box,
-      options.routingGutter ?? 160
-    );
+    const corridor = edgeCorridorBox(source.box, target.box, queryGutter);
     const routeNodeObstacles = queryBoxSpatialIndex(nodeObstacleIndex, corridor).map((entry) => entry.box).filter(
       (obstacle) => !sameBox(obstacle, source.obstacleBox) && !sameBox(obstacle, target.obstacleBox)
     );
@@ -9004,7 +9269,9 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacle
         ...routeTextObstacles
       ],
       hardObstacles,
-      ...options.maxRoutingAttempts === void 0 ? {} : { maxRoutingAttempts: options.maxRoutingAttempts }
+      corridorMargin,
+      ...options.maxRoutingAttempts === void 0 ? {} : { maxRoutingAttempts: options.maxRoutingAttempts },
+      ...options.maxBacktrackingRatio === void 0 ? {} : { maxBacktrackingRatio: options.maxBacktrackingRatio }
     });
     diagnostics.push(
       ...route.diagnostics.map((diagnostic) => ({