@crazyhappyone/auto-graph 0.2.8 → 0.2.10

package/dist/index.js

@@ -176,6 +176,28 @@ function applyLayoutConstraints(input) {
   if (input.distributeContainedChildren) {
     yieldFixedPositionLocks(input, boxes, locks);
   }
+  if (input.swimlanes !== void 0 && input.swimlanes.length > 0 && input.distributeSwimlaneChildren) {
+    for (const swimlane of input.swimlanes) {
+      if (swimlane.layout === "contract") continue;
+      for (const lane of swimlane.lanes) {
+        const fixedChildren = [];
+        let participantCount = 0;
+        for (const childId of lane.children) {
+          const lock = locks.get(childId);
+          if (lock === void 0) {
+            participantCount += 1;
+          } else if (lock.source === "fixed-position") {
+            participantCount += 1;
+            fixedChildren.push(childId);
+          }
+        }
+        if (participantCount < 2) continue;
+        for (const childId of fixedChildren) {
+          locks.delete(childId);
+        }
+      }
+    }
+  }
   applyContainment(input.constraints, boxes, locks, diagnostics, false);
   applyRelative(input.constraints, boxes, locks, diagnostics);
   applyAlign(input.constraints, boxes, locks, diagnostics);
@@ -195,6 +217,9 @@ function applyLayoutConstraints(input) {
     applyDistributeContained(input, boxes, locks, diagnostics);
     dedupReplayDiagnostics(diagnostics, diagBefore);
   }
+  if (input.swimlanes !== void 0 && input.swimlanes.length > 0 && input.distributeSwimlaneChildren) {
+    distributeSwimlaneChildren(input, boxes, locks, diagnostics);
+  }
   removeResolvedConstraintDiagnostics(input.constraints, boxes, diagnostics);
   reportOverlaps(
     boxes,
@@ -1034,9 +1059,6 @@ function applyDistributeContained(input, boxes, locks, diagnostics) {
       }
     });
   }
-  if (input.swimlanes !== void 0 && input.swimlanes.length > 0 && input.distributeSwimlaneChildren) {
-    distributeSwimlaneChildren(input, boxes, locks, diagnostics);
-  }
 }
 function distributeSwimlaneChildren(input, boxes, locks, diagnostics) {
   const spread = input.distributeSwimlaneChildren === "spread";
@@ -1076,6 +1098,7 @@ function distributeSwimlaneChildren(input, boxes, locks, diagnostics) {
         effectiveGap = minGap + remaining / (unlocked.length - 1);
       }
       unlocked.sort((a, b) => a.box[axis] - b.box[axis]);
+      reserved.sort((a, b) => a.start - b.start);
       let pos = contentStart;
       for (const child of unlocked) {
         pos = advancePastReserved(pos, child.box[mainSize], reserved, minGap);
@@ -4726,15 +4749,12 @@ var BinaryHeap = class {
       let smallestIdx = idx;
       const leftIdx = (idx << 1) + 1;
       const rightIdx = leftIdx + 1;
-      if (leftIdx < size && this._less(
-        this._data[leftIdx],
-        this._data[smallestIdx]
-      )) {
+      if (leftIdx < size && this._less(this._data[leftIdx], entry)) {
         smallestIdx = leftIdx;
       }
       if (rightIdx < size && this._less(
         this._data[rightIdx],
-        this._data[smallestIdx]
+        smallestIdx === leftIdx ? this._data[leftIdx] : entry
       )) {
         smallestIdx = rightIdx;
       }
@@ -4785,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;
@@ -4801,8 +4824,66 @@ function findObstacleFreePath(source, target, obstacles, options = {}, diagnosti
     turnPenalty,
     segmentPenalty
   );
-  if (path === null) return null;
-  return simplifyRoute(path);
+  if (path !== null) {
+    const simplified = simplifyRoute(path);
+    const filteredSet = new Set(filtered);
+    if (useCorridor && obstacles.some((o) => !filteredSet.has(o))) {
+      let crossesExcluded = false;
+      for (let i = 0; i < simplified.length - 1; i++) {
+        const a = simplified[i];
+        const b = simplified[i + 1];
+        for (const obs of obstacles) {
+          if (filteredSet.has(obs)) continue;
+          if (segmentCrossesBoxStrict(a, b, obs, margin)) {
+            crossesExcluded = true;
+            break;
+          }
+        }
+        if (crossesExcluded) break;
+      }
+      if (!crossesExcluded) return simplified;
+    } else {
+      return simplified;
+    }
+  }
+  if (!useCorridor) return null;
+  const xsFull = collectXs(source, target, obstacles, margin);
+  const ysFull = collectYs(source, target, obstacles, margin);
+  if (xsFull.length * ysFull.length > maxNodes) {
+    diagnostics?.push({
+      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,
+        obstacleCount: obstacles.length,
+        stage: "full-retry",
+        ...corridorMargin === void 0 ? {} : { corridorMargin }
+      }
+    });
+    return null;
+  }
+  const { nodes: nodesFull, nodeIndex: idxFull } = buildGraph(xsFull, ysFull);
+  connectHorizontalEdges(
+    nodesFull,
+    ysFull,
+    obstacles,
+    endpointObstacles,
+    margin
+  );
+  connectVerticalEdges(nodesFull, xsFull, obstacles, endpointObstacles, margin);
+  const pathFull = aStarSearch(
+    nodesFull,
+    idxFull,
+    source,
+    target,
+    turnPenalty,
+    segmentPenalty
+  );
+  if (pathFull === null) return null;
+  return simplifyRoute(pathFull);
 }
 function filterObstaclesByCorridor(source, target, obstacles, endpointObstacles, margin) {
   const cx1 = Math.min(source.x, target.x) - margin;
@@ -5023,20 +5104,83 @@ 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;
   const turnPenalty = options.turnPenalty ?? 50;
   const segmentPenalty = options.segmentPenalty ?? 1;
   const endpointObstacles = options.endpointObstacles ?? [];
-  const maxCorners = options.maxCorners ?? 300;
+  const maxCorners = options.maxCorners ?? 600;
   const vertices = collectCornerVertices(source, target, obstacles, margin);
   if (vertices.length > maxCorners) {
     diagnostics?.push({
       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;
   }
@@ -5310,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;
@@ -5320,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",
@@ -5338,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,
@@ -5398,18 +5554,59 @@ function routeEdge(input) {
         input.source.center,
         targetAnchor
       );
-      const cornerPath = findCornerGraphPath(
+      const allObstacles = [...softObstacles, ...hardObstacles];
+      const corridorMargin = input.corridorMargin ?? 32;
+      const corridorObstacles = filterObstaclesByCorridor(
         source,
         target,
-        [...softObstacles, ...hardObstacles],
-        { endpointObstacles, margin: 2 },
+        allObstacles,
+        [],
+        // endpointObstacles passed separately via options
+        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,
+          maxCorners: budget.maxCorners,
+          corridorMargin
+        },
         diagnostics
       );
+      if (cornerPath === null && cornerObstacles.length < allObstacles.length) {
+        cornerPath = findCornerGraphPath(
+          source,
+          target,
+          allObstacles,
+          {
+            endpointObstacles,
+            margin: 2,
+            maxCorners: budget.maxCorners,
+            corridorMargin
+          },
+          diagnostics
+        );
+      }
       const path = cornerPath ?? findObstacleFreePath(
         source,
         target,
-        [...softObstacles, ...hardObstacles],
-        { endpointObstacles, margin: 0 },
+        allObstacles,
+        {
+          endpointObstacles,
+          margin: 0,
+          corridorMargin,
+          maxNodes: budget.maxNodes
+        },
         diagnostics
       );
       if (path !== null && path.length >= 2) {
@@ -5426,9 +5623,100 @@ 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,
+              maxCorners: budget.maxCorners,
+              corridorMargin
+            },
+            diagnostics
+          ) : null;
+          if (fullCornerPath !== null && fullCornerPath.length >= 2) {
+            const fullFinalized = finalizeRoute(
+              fullCornerPath,
+              softObstacles,
+              hardObstacles,
+              diagnostics,
+              softObstacleIndex,
+              hardObstacleIndex
+            );
+            if (!routeIntersectsObstacles(
+              fullFinalized,
+              softObstacles,
+              softObstacleIndex
+            ) && !routeIntersectsObstacles(
+              fullFinalized,
+              hardObstacles,
+              hardObstacleIndex
+            )) {
+              checkBacktracking(
+                fullFinalized,
+                source,
+                target,
+                diagnostics,
+                input.maxBacktrackingRatio
+              );
+              return { points: fullFinalized, diagnostics };
+            }
+            recordRejected(fullFinalized);
+          }
+          const gridPath = findObstacleFreePath(
+            source,
+            target,
+            allObstacles,
+            {
+              endpointObstacles,
+              margin: 0,
+              corridorMargin,
+              maxNodes: budget.maxNodes
+            },
+            diagnostics
+          );
+          if (gridPath !== null && gridPath.length >= 2) {
+            const gridFinalized = finalizeRoute(
+              gridPath,
+              softObstacles,
+              hardObstacles,
+              diagnostics,
+              softObstacleIndex,
+              hardObstacleIndex
+            );
+            if (!routeIntersectsObstacles(
+              gridFinalized,
+              softObstacles,
+              softObstacleIndex
+            ) && !routeIntersectsObstacles(
+              gridFinalized,
+              hardObstacles,
+              hardObstacleIndex
+            )) {
+              checkBacktracking(
+                gridFinalized,
+                source,
+                target,
+                diagnostics,
+                input.maxBacktrackingRatio
+              );
+              return { points: gridFinalized, diagnostics };
+            }
+            recordRejected(gridFinalized);
+          }
+        }
       }
     }
   }
@@ -5490,7 +5778,8 @@ function routeEdge(input) {
         finalizedClean,
         candidate.points[0],
         candidate.points[candidate.points.length - 1],
-        diagnostics
+        diagnostics,
+        input.maxBacktrackingRatio
       );
       return { points: finalizedClean, diagnostics };
     }
@@ -5556,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
     };
   }
@@ -5594,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",
@@ -5641,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
   };
 }
@@ -6146,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];
@@ -6529,7 +6908,7 @@ function solveDiagram(diagram, options = {}) {
     edges: styledEdges
   });
   diagnostics.push(...layout2.diagnostics);
-  const initialNodeBoxes = initialLayoutMode === "positions" ? layout2.boxes : wrapVerticalStackIfNeeded(
+  const initialNodeBoxes = initialLayoutMode === "positions" || diagram.direction !== "LR" && diagram.direction !== "RL" ? layout2.boxes : wrapVerticalStackIfNeeded(
     layout2.boxes,
     styledNodes,
     styledEdges,
@@ -6537,7 +6916,8 @@ function solveDiagram(diagram, options = {}) {
     options,
     diagnostics
   );
-  if ((diagram.direction === "TB" || diagram.direction === "BT") && options.maxRowDepth !== void 0) {
+  if ((diagram.direction === "TB" || diagram.direction === "BT") && (options.maxRowDepth !== void 0 || options.targetAspectRatio !== void 0)) {
+    const diagCountBefore = diagnostics.length;
     const rewrapped = wrapHorizontalStackIfNeeded(
       initialNodeBoxes,
       styledNodes,
@@ -6548,6 +6928,20 @@ function solveDiagram(diagram, options = {}) {
     for (const [id, box] of rewrapped) {
       initialNodeBoxes.set(id, box);
     }
+    if (diagnostics.length > diagCountBefore) {
+      for (const node of styledNodes) {
+        if (node.position !== void 0 && rewrapped.has(node.id)) {
+          const rwBox = rewrapped.get(node.id);
+          const idx = styledNodes.indexOf(node);
+          if (idx !== -1) {
+            styledNodes[idx] = {
+              ...node,
+              position: { x: rwBox.x, y: rwBox.y }
+            };
+          }
+        }
+      }
+    }
   }
   if (useRecursive && "groupBoxes" in layout2) {
     const recursiveLayout = layout2;
@@ -6561,7 +6955,7 @@ function solveDiagram(diagram, options = {}) {
     overlapSpacing: options?.overlapSpacing ?? 40,
     ...options.minSiblingGap === void 0 ? {} : { minSiblingGap: options.minSiblingGap },
     distributeContainedChildren: options.distributeContainedChildren ?? true,
-    distributeSwimlaneChildren: options.distributeSwimlaneChildren ?? "spread",
+    ...options.distributeSwimlaneChildren !== void 0 ? { distributeSwimlaneChildren: options.distributeSwimlaneChildren } : {},
     swimlanes: styledSwimlanes,
     boxes: initialNodeBoxes,
     nodes: styledNodes,
@@ -6576,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);
@@ -6743,7 +7138,8 @@ function solveDiagram(diagram, options = {}) {
     diagram.direction,
     options,
     diagnostics,
-    coordinatedGroups
+    coordinatedGroups,
+    contentBounds
   );
   const edgeTextAnnotations = coordinateEdgeTextAnnotations(
     coordinatedEdges,
@@ -7165,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();
@@ -7184,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);
@@ -7280,9 +7678,14 @@ function wrapHorizontalStackIfNeeded(boxes, nodes, direction, options, diagnosti
   if (!isStackRunaway(boxes, nodes, direction, options)) {
     return new Map(boxes);
   }
-  const maxRowDepth = options.maxRowDepth;
-  if (maxRowDepth === void 0 || nodes.length <= maxRowDepth) {
-    return new Map(boxes);
+  let maxRowDepth = options.maxRowDepth;
+  if (maxRowDepth === void 0 || maxRowDepth <= 0 || nodes.length <= maxRowDepth) {
+    if (maxRowDepth === void 0 && options.targetAspectRatio !== void 0) {
+      maxRowDepth = Math.ceil(Math.sqrt(nodes.length));
+      if (nodes.length <= maxRowDepth) return new Map(boxes);
+    } else {
+      return new Map(boxes);
+    }
   }
   const ordered = [...nodes].sort((a, b) => {
     const ba = boxes.get(a.id);
@@ -7343,10 +7746,10 @@ function reportVerticalRunaway(boxes, nodes, edges, direction, options, diagnost
   });
 }
 function isStackRunaway(boxes, nodes, direction, options) {
-  if (options.maxStackDepth === void 0 && options.preferredAspectRatio === void 0) {
+  if (options.maxStackDepth === void 0 && options.preferredAspectRatio === void 0 && options.targetAspectRatio === void 0 && options.maxRowDepth === void 0) {
     return false;
   }
-  if (nodes.length < 2 || direction !== "LR" && direction !== "RL") {
+  if (nodes.length < 2) {
     return false;
   }
   const nodeBoxes = nodes.map((node) => boxes.get(node.id)).filter((box) => box !== void 0);
@@ -7354,17 +7757,24 @@ function isStackRunaway(boxes, nodes, direction, options) {
     return false;
   }
   const bounds = unionBoxes(nodeBoxes);
-  const aspectRatio = bounds.width <= 0 ? Number.POSITIVE_INFINITY : bounds.height / bounds.width;
-  const preferred = options.preferredAspectRatio ?? 3;
-  if (aspectRatio < preferred) {
+  const isHorizontal = direction === "TB" || direction === "BT";
+  const aspectRatio = isHorizontal ? bounds.height <= 0 ? Number.POSITIVE_INFINITY : bounds.width / bounds.height : bounds.width <= 0 ? Number.POSITIVE_INFINITY : bounds.height / bounds.width;
+  const preferred = isHorizontal ? options.targetAspectRatio ?? options.preferredAspectRatio ?? 3 : options.preferredAspectRatio ?? 3;
+  if ((options.preferredAspectRatio !== void 0 || options.targetAspectRatio !== void 0) && aspectRatio < preferred) {
     return false;
   }
+  if (isHorizontal) {
+    const yCenters = nodeBoxes.map((box) => box.y + box.height / 2);
+    const ySpread = Math.max(...yCenters) - Math.min(...yCenters);
+    const maxHeight = Math.max(...nodeBoxes.map((box) => box.height));
+    return ySpread <= Math.max(maxHeight, options.overlapSpacing ?? 40);
+  }
   const xCenters = nodeBoxes.map((box) => box.x + box.width / 2);
   const xSpread = Math.max(...xCenters) - Math.min(...xCenters);
   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) => {
@@ -7389,7 +7799,9 @@ function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes
       locks,
       diagnostics,
       movedChildIds,
-      laneGutter
+      laneGutter,
+      constraints,
+      distributeContainedChildren
     );
   }
   return applyHorizontalSwimlaneContract(
@@ -7404,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);
@@ -7422,7 +7850,18 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
   );
   const rankSpacing = Math.max(96, maxRankStackHeight + padding);
   const contentHeight = maxRank === 0 ? maxChildHeight : maxRankStackHeight + maxRank * rankSpacing;
-  const slotWidth = Math.max(...populatedBounds.map((box) => box.width)) + padding * 2;
+  const spreadWidth = maxCrossAxisSpreadWidth(
+    swimlane,
+    nodeBoxes,
+    flowRanks,
+    locks,
+    rankStackGap,
+    containedChildIds
+  );
+  const slotWidth = Math.max(
+    Math.max(...populatedBounds.map((box) => box.width)),
+    spreadWidth
+  ) + padding * 2;
   const laneStep = slotWidth + laneGutter;
   const laneContentTop = top + headerHeight + padding;
   for (let index = 0; index < swimlane.lanes.length; index += 1) {
@@ -7436,6 +7875,27 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       y: laneContentTop
     };
     if (maxRank === 0) {
+      const distributable = lane.children.filter(
+        (childId) => !locks.has(childId)
+      );
+      const coveredByContainment = lane.children.some(
+        (childId) => containedChildIds.has(childId)
+      );
+      if (!coveredByContainment && distributable.length >= CROSS_AXIS_SPREAD_THRESHOLD) {
+        moveRankedVerticalLaneChildren(
+          lane.children,
+          nodeBoxes,
+          locks,
+          diagnostics,
+          movedChildIds,
+          flowRanks,
+          rankSpacing,
+          rankStackGap,
+          { x: target.x, y: laneContentTop },
+          slotWidth - padding * 2
+        );
+        continue;
+      }
       moveLaneChildren(
         lane.children,
         nodeBoxes,
@@ -7449,6 +7909,9 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       );
       continue;
     }
+    const rankedCoveredByContainment = lane.children.some(
+      (childId) => containedChildIds.has(childId)
+    );
     moveRankedVerticalLaneChildren(
       lane.children,
       nodeBoxes,
@@ -7458,10 +7921,9 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       flowRanks,
       rankSpacing,
       rankStackGap,
-      {
-        x: target.x - bounds.x,
-        y: laneContentTop
-      }
+      { x: target.x, y: laneContentTop },
+      slotWidth - padding * 2,
+      rankedCoveredByContainment
     );
   }
   return {
@@ -7570,31 +8032,102 @@ function maxVerticalRankStackHeight(swimlane, nodeBoxes, flowRanks, gap) {
   }
   return maxHeight;
 }
-function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target) {
+var CROSS_AXIS_SPREAD_THRESHOLD = 3;
+function crossAxisSpreadWidth(items, gap) {
+  return items.reduce(
+    (sum, item, index) => sum + item.box.width + (index === 0 ? 0 : gap),
+    0
+  );
+}
+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,
+      flowRanks
+    ).values()) {
+      const unlocked = stack.filter((item) => !locks.has(item.childId));
+      if (unlocked.length < CROSS_AXIS_SPREAD_THRESHOLD) continue;
+      maxWidth = Math.max(maxWidth, crossAxisSpreadWidth(unlocked, gap));
+    }
+  }
+  return maxWidth;
+}
+function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target, contentWidth, suppressSpread) {
   for (const [rank, stack] of rankStacks(childIds, nodeBoxes, flowRanks)) {
-    let yOffset = 0;
+    const unlocked = [];
     for (const item of stack) {
-      const { childId, box } = item;
-      if (locks.has(childId)) {
+      if (locks.has(item.childId)) {
         diagnostics.push({
           severity: "warning",
           code: "constraints.locked-target-not-moved",
-          message: `Locked child ${childId} was not moved into contract swimlane slot.`,
+          message: `Locked child ${item.childId} was not moved into contract swimlane slot.`,
           path: ["swimlanes"],
-          detail: { nodeId: childId }
+          detail: { nodeId: item.childId }
         });
-        continue;
+      } else {
+        unlocked.push(item);
       }
+    }
+    if (unlocked.length === 0) continue;
+    if (unlocked.length === 1) {
+      const { childId, box } = unlocked[0];
       const next = {
         ...box,
-        x: box.x + target.x,
-        y: target.y + rank * rankSpacing + yOffset
+        x: target.x + (contentWidth - box.width) / 2,
+        y: target.y + rank * rankSpacing
       };
       if (next.x !== box.x || next.y !== box.y) {
         movedChildIds.add(childId);
       }
       nodeBoxes.set(childId, next);
-      yOffset += box.height + rankStackGap;
+    } else {
+      const shouldSpread = !suppressSpread && unlocked.length >= CROSS_AXIS_SPREAD_THRESHOLD;
+      if (!shouldSpread) {
+        let yOffset = 0;
+        for (const { childId, box } of unlocked) {
+          const next = {
+            ...box,
+            x: target.x + (contentWidth - box.width) / 2,
+            y: target.y + rank * rankSpacing + yOffset
+          };
+          if (next.x !== box.x || next.y !== box.y) {
+            movedChildIds.add(childId);
+          }
+          nodeBoxes.set(childId, next);
+          yOffset += box.height + rankStackGap;
+        }
+      } else {
+        const packedWidth = crossAxisSpreadWidth(unlocked, rankStackGap);
+        let xCursor = target.x + Math.max(0, (contentWidth - packedWidth) / 2);
+        for (const { childId, box } of unlocked) {
+          const next = {
+            ...box,
+            x: xCursor,
+            y: target.y + rank * rankSpacing
+          };
+          if (next.x !== box.x || next.y !== box.y) {
+            movedChildIds.add(childId);
+          }
+          nodeBoxes.set(childId, next);
+          xCursor += box.width + rankStackGap;
+        }
+        diagnostics.push({
+          severity: "info",
+          code: "swimlane_contract.cross_axis_distributed",
+          message: `Spread ${unlocked.length} same-rank children horizontally in contract lane (rank ${rank}).`,
+          path: ["swimlanes"],
+          detail: {
+            rank,
+            childCount: unlocked.length,
+            contentWidth
+          }
+        });
+      }
     }
   }
 }
@@ -7933,7 +8466,7 @@ function coordinateNodes(nodes, boxes, options, diagnostics) {
       });
       continue;
     }
-    const ports = node.ports === void 0 ? void 0 : coordinatePorts(node, box, options.portShifting, diagnostics);
+    const ports = node.ports === void 0 ? void 0 : coordinatePorts(node, box, options.portShifting);
     const geometry = computeShapeGeometry({
       shape: node.shape,
       box,
@@ -8027,7 +8560,7 @@ function expandNodeBoxesForPorts(nodes, boxes, options, diagnostics) {
     }
   }
 }
-function coordinatePorts(node, nodeBox, portShifting, diagnostics) {
+function coordinatePorts(node, nodeBox, portShifting) {
   const portsBySide = /* @__PURE__ */ new Map();
   for (const port of node.ports ?? []) {
     const ports = portsBySide.get(port.side) ?? [];
@@ -8050,9 +8583,7 @@ function coordinatePorts(node, nodeBox, portShifting, diagnostics) {
         side,
         index,
         sorted.length,
-        portShifting,
-        diagnostics,
-        node.id
+        portShifting
       );
       const box = portBox(anchor);
       coordinated.push({ ...port, box, anchor });
@@ -8060,32 +8591,16 @@ function coordinatePorts(node, nodeBox, portShifting, diagnostics) {
   }
   return coordinated.sort((a, b) => a.id.localeCompare(b.id));
 }
-function portAnchor(nodeBox, side, index, count, portShifting, diagnostics, nodeId) {
+function portAnchor(nodeBox, side, index, count, portShifting) {
   const shiftingEnabled = portShifting?.enabled ?? true;
   const requestedSpacing = portShifting?.spacing ?? 24;
   const maxOffset = side === "left" || side === "right" ? nodeBox.height / 2 : nodeBox.width / 2;
   const availableSpan = 2 * maxOffset;
   const minSpacing = PORT_BOX_SIZE + MIN_PORT_EDGE_GAP;
-  const effectiveSpacing = shiftingEnabled && count > 1 ? Math.max(
+  const spacing = shiftingEnabled && count > 1 ? Math.max(
     Math.min(requestedSpacing, availableSpan / (count - 1)),
     minSpacing
   ) : requestedSpacing;
-  if (shiftingEnabled && count > 1 && effectiveSpacing < requestedSpacing && diagnostics !== void 0 && nodeId !== void 0) {
-    diagnostics.push({
-      severity: "warning",
-      code: "port_constraint_overlap",
-      message: `Port spacing on ${nodeId} ${side} compressed from ${requestedSpacing}px to ${Math.round(effectiveSpacing)}px for ${count} ports.`,
-      path: ["nodes", nodeId, "ports"],
-      detail: {
-        nodeId,
-        side,
-        requestedSpacing,
-        effectiveSpacing: Math.round(effectiveSpacing),
-        portCount: count
-      }
-    });
-  }
-  const spacing = effectiveSpacing;
   const centeredOffset = shiftingEnabled ? (index - (count - 1) / 2) * spacing : 0;
   switch (side) {
     case "left":
@@ -8700,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);
@@ -8729,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)
     );
@@ -8751,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) => ({