@crazyhappyone/auto-graph 0.1.3 → 0.2.0

package/dist/cli/index.js

@@ -1289,6 +1289,9 @@ function applyLayoutConstraints(input) {
   const nodeById = new Map(input.nodes.map((node) => [node.id, node]));
   applyFixedPositionLocks(input.nodes, boxes, locks, diagnostics);
   applyExactPositions(input.constraints, boxes, locks, diagnostics, nodeById);
+  if (input.distributeContainedChildren) {
+    yieldFixedPositionLocks(input, boxes, locks);
+  }
   applyContainment(input.constraints, boxes, locks, diagnostics, false);
   applyRelative(input.constraints, boxes, locks, diagnostics);
   applyAlign(input.constraints, boxes, locks, diagnostics);
@@ -1302,6 +1305,13 @@ function applyLayoutConstraints(input) {
   );
   applyContainment(input.constraints, boxes, locks, diagnostics, true);
   applyDistributeContained(input, boxes, locks, diagnostics);
+  if (input.distributeContainedChildren) {
+    const diagBefore = diagnostics.length;
+    applyContainment(input.constraints, boxes, locks, diagnostics, true);
+    applyDistributeContained(input, boxes, locks, diagnostics);
+    dedupReplayDiagnostics(diagnostics, diagBefore);
+  }
+  removeResolvedConstraintDiagnostics(input.constraints, boxes, diagnostics);
   reportOverlaps(boxes, diagnostics, containmentOverlapKeys(input.constraints));
   reportIntraContainerOverflow(input, boxes, diagnostics);
   return { boxes, locks, diagnostics };
@@ -1347,6 +1357,62 @@ function applyFixedPositionLocks(nodes, boxes, locks, diagnostics) {
     locks.set(node.id, { nodeId: node.id, source: "fixed-position" });
   }
 }
+function dedupReplayDiagnostics(diagnostics, keepUpTo) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < keepUpTo && i < diagnostics.length; i += 1) {
+    const d = diagnostics[i];
+    if (d === void 0) continue;
+    seen.add(diagnosticFingerprint(d));
+  }
+  for (let i = diagnostics.length - 1; i >= keepUpTo; i -= 1) {
+    const d = diagnostics[i];
+    if (d === void 0) continue;
+    const fp = diagnosticFingerprint(d);
+    if (seen.has(fp)) {
+      diagnostics.splice(i, 1);
+    } else {
+      seen.add(fp);
+    }
+  }
+}
+function diagnosticFingerprint(d) {
+  const nodeId = typeof d.detail?.nodeId === "string" ? d.detail.nodeId : "";
+  const containerId = typeof d.detail?.containerId === "string" ? d.detail.containerId : "";
+  return `${d.code}|${nodeId}|${containerId}`;
+}
+function yieldFixedPositionLocks(input, boxes, locks) {
+  for (const c of input.constraints) {
+    if (c.kind !== "containment") continue;
+    const container = boxes.get(c.containerId);
+    if (container === void 0) continue;
+    const content = contentBox(container, c.padding);
+    const mainAxis = input.direction === "LR" || input.direction === "RL" ? "width" : "height";
+    const crossAxis = mainAxis === "width" ? "height" : "width";
+    let eligible = 0;
+    for (const childId of c.childIds) {
+      const box = boxes.get(childId);
+      if (box === void 0) continue;
+      const lock = locks.get(childId);
+      if (lock?.source === "exact-position") continue;
+      const fits = box[mainAxis] <= content[mainAxis] && box[crossAxis] <= content[crossAxis];
+      if (fits) {
+        eligible += 1;
+      }
+    }
+    if (eligible < 2) continue;
+    for (const childId of c.childIds) {
+      const lock = locks.get(childId);
+      if (lock?.source === "fixed-position") {
+        const box = boxes.get(childId);
+        if (box === void 0) continue;
+        const fits = box[mainAxis] <= content[mainAxis] && box[crossAxis] <= content[crossAxis];
+        if (fits) {
+          locks.delete(childId);
+        }
+      }
+    }
+  }
+}
 function applyExactPositions(constraints, boxes, locks, diagnostics, nodeById) {
   for (const constraint of constraints) {
     if (constraint.kind !== "exact-position") {
@@ -1419,7 +1485,7 @@ function applyContainment(constraints, boxes, locks, diagnostics, reportOverflow
             code: "constraints.locked-target-not-moved",
             message: `Locked child ${childId} was not moved into containment.`,
             path: ["constraints", constraint.id ?? constraint.containerId],
-            detail: { nodeId: childId }
+            detail: { nodeId: childId, containerId: constraint.containerId }
           });
           if (!isInside(child, content)) {
             diagnostics.push({
@@ -1571,6 +1637,60 @@ function repairOverlaps(input, boxes, locks, diagnostics, siblingPairs) {
   }
   reportOverlaps(boxes, diagnostics, ignoredPairs);
 }
+function removeResolvedConstraintDiagnostics(constraints, boxes, diagnostics) {
+  for (let i = diagnostics.length - 1; i >= 0; i -= 1) {
+    const d = diagnostics[i];
+    if (d === void 0) continue;
+    if (d.code === "constraints.overlap.unresolved") {
+      const aId = d.detail?.firstId;
+      const bId = d.detail?.secondId;
+      if (typeof aId !== "string" || typeof bId !== "string") continue;
+      const a = boxes.get(aId);
+      const b = boxes.get(bId);
+      if (a !== void 0 && b !== void 0 && !intersectsAabb(a, b)) {
+        diagnostics.splice(i, 1);
+      }
+      continue;
+    }
+    if (d.code === "constraints.containment.impossible" || d.code === "constraints.locked-target-not-moved" && typeof d.message === "string" && d.message.includes("not moved into containment")) {
+      const nodeId = d.detail?.nodeId;
+      if (typeof nodeId !== "string") continue;
+      const child = boxes.get(nodeId);
+      if (child === void 0) continue;
+      const diagContainerId = typeof d.detail?.containerId === "string" ? d.detail.containerId : void 0;
+      let resolved = false;
+      for (const c of constraints) {
+        if (c.kind !== "containment") continue;
+        if (!c.childIds.includes(nodeId)) continue;
+        if (diagContainerId !== void 0 && c.containerId !== diagContainerId) {
+          continue;
+        }
+        const container = boxes.get(c.containerId);
+        if (container === void 0) continue;
+        const content = contentBox(container, c.padding);
+        if (isInside(child, content)) {
+          diagnostics.splice(i, 1);
+          resolved = true;
+        }
+        break;
+      }
+      if (!resolved && diagContainerId !== void 0) {
+        for (const c of constraints) {
+          if (c.kind !== "containment") continue;
+          if (c.containerId !== diagContainerId) continue;
+          if (!c.childIds.includes(nodeId)) continue;
+          const container = boxes.get(c.containerId);
+          if (container === void 0) continue;
+          const content = contentBox(container, c.padding);
+          if (isInside(child, content)) {
+            diagnostics.splice(i, 1);
+          }
+          break;
+        }
+      }
+    }
+  }
+}
 function reportOverlaps(boxes, diagnostics, ignoredPairs = /* @__PURE__ */ new Set()) {
   const ids = [...boxes.keys()].sort();
   const reported = new Set(
@@ -1878,6 +1998,11 @@ function applyDistributeContained(input, boxes, locks, diagnostics) {
         continue;
       }
       if (locks.has(childId)) {
+        const lock = locks.get(childId);
+        if (lock?.source === "fixed-position") {
+          unlocked.push({ id: childId, box });
+          continue;
+        }
         diagnostics.push({
           severity: "warning",
           code: "constraints.locked-target-not-moved",
@@ -1936,6 +2061,7 @@ function applyDistributeContained(input, boxes, locks, diagnostics) {
         });
       }
       boxes.set(child.id, clamped);
+      locks.delete(child.id);
       pos = clamped[axis] + clamped[mainSize] + minGap;
     }
     diagnostics.push({
@@ -3251,6 +3377,213 @@ function isValidDimension(value) {
   return Number.isFinite(value) && value >= 0;
 }
 
+// src/routing/astar.ts
+function findObstacleFreePath(source, target, obstacles, options = {}) {
+  const margin = options.margin ?? 0;
+  const turnPenalty = options.turnPenalty ?? 50;
+  const segmentPenalty = options.segmentPenalty ?? 1;
+  const endpointObstacles = options.endpointObstacles ?? [];
+  const maxNodes = options.maxNodes ?? 4e3;
+  const xs = collectXs(source, target, obstacles, margin);
+  const ys = collectYs(source, target, obstacles, margin);
+  if (xs.length * ys.length > maxNodes) {
+    return null;
+  }
+  const { nodes, nodeIndex } = buildGraph(xs, ys);
+  connectHorizontalEdges(nodes, ys, obstacles, endpointObstacles, margin);
+  connectVerticalEdges(nodes, xs, obstacles, endpointObstacles, margin);
+  const path = aStarSearch(
+    nodes,
+    nodeIndex,
+    source,
+    target,
+    turnPenalty,
+    segmentPenalty
+  );
+  if (path === null) return null;
+  return simplifyRoute(path);
+}
+function collectXs(source, target, obstacles, margin) {
+  const set = /* @__PURE__ */ new Set();
+  set.add(source.x);
+  set.add(target.x);
+  for (const obs of obstacles) {
+    set.add(obs.x - margin - 2);
+    set.add(obs.x + obs.width + margin + 2);
+  }
+  return [...set].sort((a, b) => a - b);
+}
+function collectYs(source, target, obstacles, margin) {
+  const set = /* @__PURE__ */ new Set();
+  set.add(source.y);
+  set.add(target.y);
+  for (const obs of obstacles) {
+    set.add(obs.y - margin - 2);
+    set.add(obs.y + obs.height + margin + 2);
+  }
+  return [...set].sort((a, b) => a - b);
+}
+function buildGraph(xs, ys) {
+  const nodes = [];
+  const nodeIndex = /* @__PURE__ */ new Map();
+  for (let xi = 0; xi < xs.length; xi++) {
+    for (let yi = 0; yi < ys.length; yi++) {
+      const x = xs[xi];
+      const y = ys[yi];
+      const id = nodes.length;
+      nodes.push({ x, y, id, neighbors: /* @__PURE__ */ new Map() });
+      nodeIndex.set(`${x},${y}`, id);
+    }
+  }
+  return { nodes, nodeIndex };
+}
+function connectHorizontalEdges(nodes, ys, obstacles, endpointObstacles, margin) {
+  for (const y of ys) {
+    const row = nodes.filter((n) => n.y === y).sort((a, b) => a.x - b.x);
+    for (let i = 0; i < row.length - 1; i++) {
+      const a = row[i];
+      const b = row[i + 1];
+      const dx = b.x - a.x;
+      if (dx <= 0) continue;
+      if (segmentCrossesAny(a, b, obstacles, endpointObstacles, margin)) {
+        continue;
+      }
+      a.neighbors.set(b.id, dx);
+      b.neighbors.set(a.id, dx);
+    }
+  }
+}
+function connectVerticalEdges(nodes, xs, obstacles, endpointObstacles, margin) {
+  for (const x of xs) {
+    const col = nodes.filter((n) => n.x === x).sort((a, b) => a.y - b.y);
+    for (let i = 0; i < col.length - 1; i++) {
+      const a = col[i];
+      const b = col[i + 1];
+      const dy = b.y - a.y;
+      if (dy <= 0) continue;
+      if (segmentCrossesAny(a, b, obstacles, endpointObstacles, margin)) {
+        continue;
+      }
+      a.neighbors.set(b.id, dy);
+      b.neighbors.set(a.id, dy);
+    }
+  }
+}
+function segmentCrossesAny(a, b, obstacles, endpointObstacles, margin) {
+  for (const obs of obstacles) {
+    if (segmentCrossesBoxStrict(a, b, obs, margin)) return true;
+  }
+  for (const ep of endpointObstacles) {
+    if (segmentCrossesBoxStrict(a, b, ep, margin)) return true;
+  }
+  return false;
+}
+function segmentCrossesBoxStrict(start, end, box, margin) {
+  const left = box.x - margin;
+  const right = box.x + box.width + margin;
+  const top = box.y - margin;
+  const bottom = box.y + box.height + margin;
+  if (pointInsideStrict(start, left, right, top, bottom)) return true;
+  if (pointInsideStrict(end, left, right, top, bottom)) return true;
+  if (start.x === end.x) {
+    return start.x >= left && start.x <= right && rangesOverlap(start.y, end.y, top, bottom);
+  }
+  if (start.y === end.y) {
+    return start.y >= top && start.y <= bottom && rangesOverlap(start.x, end.x, left, right);
+  }
+  return segmentEdgeIntersect(start, end, left, top, right, top) || segmentEdgeIntersect(start, end, right, top, right, bottom) || segmentEdgeIntersect(start, end, right, bottom, left, bottom) || segmentEdgeIntersect(start, end, left, bottom, left, top);
+}
+function pointInsideStrict(p, left, right, top, bottom) {
+  return p.x > left && p.x < right && p.y > top && p.y < bottom;
+}
+function rangesOverlap(a, b, min, max) {
+  const low = Math.min(a, b);
+  const high = Math.max(a, b);
+  return high > min && low < max;
+}
+function segmentEdgeIntersect(start, end, x1, y1, x2, y2) {
+  const denominator = (end.x - start.x) * (y2 - y1) - (end.y - start.y) * (x2 - x1);
+  if (denominator === 0) return false;
+  const t = ((start.x - x1) * (y2 - y1) - (start.y - y1) * (x2 - x1)) / denominator;
+  const u = ((start.x - x1) * (end.y - start.y) - (start.y - y1) * (end.x - start.x)) / denominator;
+  return t > 0 && t < 1 && u > 0 && u < 1;
+}
+function aStarSearch(nodes, nodeIndex, source, target, turnPenalty, segmentPenalty) {
+  const startId = nodeIndex.get(`${source.x},${source.y}`);
+  const goalId = nodeIndex.get(`${target.x},${target.y}`);
+  if (startId === void 0 || goalId === void 0) return null;
+  const gScore = /* @__PURE__ */ new Map();
+  gScore.set(startId, 0);
+  const cameFrom = /* @__PURE__ */ new Map();
+  const cameFromDir = /* @__PURE__ */ new Map();
+  const openSet = [];
+  openSet.push({
+    id: startId,
+    f: manhattan(source, target)
+  });
+  while (openSet.length > 0) {
+    let bestIdx = 0;
+    for (let i = 1; i < openSet.length; i++) {
+      if (openSet[i].f < openSet[bestIdx].f) {
+        bestIdx = i;
+      }
+    }
+    const current = openSet.splice(bestIdx, 1)[0];
+    if (current.id === goalId) {
+      return reconstructPath(nodes, cameFrom, goalId);
+    }
+    const node = nodes[current.id];
+    const currentG = gScore.get(current.id);
+    const prevDir = cameFromDir.get(current.id);
+    for (const [neighborId, edgeCost] of node.neighbors) {
+      const neighbor = nodes[neighborId];
+      const tentativeG = currentG + edgeCost * segmentPenalty;
+      const newDir = neighbor.y === node.y ? "h" : "v";
+      const turnCost = prevDir !== void 0 && prevDir !== newDir ? turnPenalty : 0;
+      const totalG = tentativeG + turnCost;
+      const existingG = gScore.get(neighborId);
+      if (existingG === void 0 || totalG < existingG) {
+        gScore.set(neighborId, totalG);
+        cameFrom.set(neighborId, current.id);
+        cameFromDir.set(neighborId, newDir);
+        const f = totalG + manhattan(neighbor, target);
+        openSet.push({ id: neighborId, f });
+      }
+    }
+  }
+  return null;
+}
+function manhattan(a, b) {
+  return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+}
+function reconstructPath(nodes, cameFrom, goalId) {
+  const path = [];
+  let current = goalId;
+  while (current !== void 0) {
+    const node = nodes[current];
+    path.unshift({ x: node.x, y: node.y });
+    current = cameFrom.get(current);
+  }
+  return path;
+}
+function simplifyRoute(points) {
+  if (points.length <= 2) return [...points];
+  const result = [points[0]];
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = result[result.length - 1];
+    const curr = points[i];
+    const next = points[i + 1];
+    if (!areCollinear(prev, curr, next)) {
+      result.push(curr);
+    }
+  }
+  result.push(points[points.length - 1]);
+  return result;
+}
+function areCollinear(a, b, c) {
+  return a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y;
+}
+
 // src/routing/routes.ts
 function routeEdge(input) {
   const diagnostics = [];
@@ -3296,6 +3629,43 @@ function routeEdge(input) {
     }
     return { points, diagnostics };
   }
+  if ((input.kind ?? "orthogonal") === "obstacle-avoiding") {
+    const endpointObstacles = endpointObstaclesForAutoAnchors(input);
+    for (const { sourceAnchor, targetAnchor } of routeAnchorPairs(
+      input,
+      defaultAnchors
+    )) {
+      const source = getEdgePort(
+        input.source,
+        input.target.center,
+        sourceAnchor
+      );
+      const target = getEdgePort(
+        input.target,
+        input.source.center,
+        targetAnchor
+      );
+      const path = findObstacleFreePath(
+        source,
+        target,
+        [...softObstacles, ...hardObstacles],
+        {
+          endpointObstacles
+        }
+      );
+      if (path !== null && path.length >= 2) {
+        const finalized = finalizeRoute(
+          path,
+          softObstacles,
+          hardObstacles,
+          diagnostics
+        );
+        if (!routeIntersectsObstacles(finalized, softObstacles) && !routeIntersectsObstacles(finalized, hardObstacles)) {
+          return { points: finalized, diagnostics };
+        }
+      }
+    }
+  }
   const routeLaneObstacles = [...softObstacles, ...hardObstacles];
   const anchorPairs = routeAnchorPairs(input, defaultAnchors);
   const candidateRoutes = anchorPairs.flatMap(
@@ -3385,7 +3755,7 @@ function routeEdge(input) {
       const rerouted = greedyRerouteAroundObstacles(
         bestPoints2,
         allObstacles,
-        Math.min(maxAttempts, 3)
+        maxAttempts
       );
       const reroutedAvoidsEndpointInteriors = !routeIntersectsEndpointInteriors(
         rerouted,
@@ -3498,7 +3868,7 @@ function routeEdge(input) {
   };
 }
 function finalizeRoute(points, softObstacles, hardObstacles, diagnostics) {
-  const simplified = simplifyRoute(points);
+  const simplified = simplifyRoute2(points);
   if (simplified.length >= 3) {
     return simplified;
   }
@@ -3786,7 +4156,7 @@ function squaredDistance2(a, b) {
   const dy = a.y - b.y;
   return dx * dx + dy * dy;
 }
-function simplifyRoute(points) {
+function simplifyRoute2(points) {
   const withoutDuplicates = [];
   for (const point2 of points) {
     const previous = withoutDuplicates.at(-1);
@@ -3798,7 +4168,7 @@ function simplifyRoute(points) {
   for (const point2 of withoutDuplicates) {
     const previous = simplified.at(-1);
     const beforePrevious = simplified.at(-2);
-    if (previous !== void 0 && beforePrevious !== void 0 && areCollinear(beforePrevious, previous, point2)) {
+    if (previous !== void 0 && beforePrevious !== void 0 && areCollinear2(beforePrevious, previous, point2)) {
       simplified[simplified.length - 1] = { ...point2 };
     } else {
       simplified.push({ ...point2 });
@@ -4013,17 +4383,17 @@ function segmentIntersectsBox(start, end, box) {
     return true;
   }
   if (start.x === end.x) {
-    return start.x > left && start.x < right && rangesOverlap(start.y, end.y, top, bottom);
+    return start.x > left && start.x < right && rangesOverlap2(start.y, end.y, top, bottom);
   }
   if (start.y === end.y) {
-    return start.y > top && start.y < bottom && rangesOverlap(start.x, end.x, left, right);
+    return start.y > top && start.y < bottom && rangesOverlap2(start.x, end.x, left, right);
   }
   return segmentIntersectsBoxEdge(start, end, left, top, right, top) || segmentIntersectsBoxEdge(start, end, right, top, right, bottom) || segmentIntersectsBoxEdge(start, end, right, bottom, left, bottom) || segmentIntersectsBoxEdge(start, end, left, bottom, left, top);
 }
 function pointInsideBox(point2, box) {
   return point2.x > box.x && point2.x < box.x + box.width && point2.y > box.y && point2.y < box.y + box.height;
 }
-function rangesOverlap(a, b, min, max) {
+function rangesOverlap2(a, b, min, max) {
   const low = Math.min(a, b);
   const high = Math.max(a, b);
   return high > min && low < max;
@@ -4047,7 +4417,7 @@ function segmentBox(a, b) {
     height: Math.max(1, Math.abs(a.y - b.y))
   };
 }
-function areCollinear(a, b, c) {
+function areCollinear2(a, b, c) {
   return a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y;
 }
 
@@ -4127,6 +4497,7 @@ function solveDiagram(diagram, options = {}) {
     options,
     diagnostics
   );
+  expandNodeBoxesForPorts(styledNodes, initialNodeBoxes, options, diagnostics);
   const constrained = applyLayoutConstraints({
     direction: diagram.direction,
     overlapSpacing: options?.overlapSpacing ?? 40,
@@ -4147,9 +4518,7 @@ function solveDiagram(diagram, options = {}) {
     options?.overlapSpacing ?? 40,
     Math.max(0, options?.minLaneGutter ?? 0)
   );
-  if (swimlaneContracts.layouts.size > 0) {
-    removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
-  }
+  removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
   diagnostics.push(...swimlaneContracts.diagnostics);
   const coordinatedNodes = coordinateNodes(
     styledNodes,
@@ -4192,6 +4561,11 @@ function solveDiagram(diagram, options = {}) {
     swimlanes: coordinatedSwimlanes,
     ...options.textMeasurer === void 0 ? {} : { textMeasurer: options.textMeasurer }
   });
+  const edgeLabelEstimates = estimateEdgeLabelAnnotations(
+    styledEdges,
+    nodeGeometryById,
+    options.textMeasurer
+  );
   const layoutBoxes = [
     ...coordinatedNodes.map((node) => node.box),
     ...coordinatedNodes.flatMap(
@@ -4272,7 +4646,10 @@ function solveDiagram(diagram, options = {}) {
   const frameTextAnnotation = frame === void 0 ? [] : [coordinateFrameTextAnnotation(frame, options.textMeasurer)];
   const routingTextObstacles = [
     ...baseTextAnnotations.filter(isPreRouteTextObstacle),
-    ...frameTextAnnotation.filter(isPreRouteTextObstacle)
+    ...frameTextAnnotation.filter(isPreRouteTextObstacle),
+    // Dry-run edge-label estimates so edges route around
+    // each other's label areas (Issue #41).
+    ...edgeLabelEstimates
   ];
   const margin = options.obstacleMargin ?? 0;
   const softObstacles = [
@@ -4305,7 +4682,8 @@ function solveDiagram(diagram, options = {}) {
     hardObstacles,
     diagram.direction,
     options,
-    diagnostics
+    diagnostics,
+    coordinatedGroups
   );
   const edgeTextAnnotations = coordinateEdgeTextAnnotations(
     coordinatedEdges,
@@ -4418,22 +4796,7 @@ function expandLabelLayoutToNode(layout2, nodeSize) {
       y: layout2.box.y + offsetY,
       width: layout2.box.width,
       height: layout2.box.height
-    },
-    contentBox: {
-      x: layout2.contentBox.x + offsetX,
-      y: layout2.contentBox.y + offsetY,
-      width: layout2.contentBox.width,
-      height: layout2.contentBox.height
-    },
-    lines: layout2.lines.map((line) => ({
-      ...line,
-      box: {
-        x: line.box.x + offsetX,
-        y: line.box.y + offsetY,
-        width: line.box.width,
-        height: line.box.height
-      }
-    }))
+    }
   };
 }
 function reportPageOverflow(contentBounds, pageBounds) {
@@ -5380,6 +5743,7 @@ function coordinateNodes(nodes, boxes, options, diagnostics) {
       });
       continue;
     }
+    const ports = node.ports === void 0 ? void 0 : coordinatePorts(node, box, options.portShifting);
     const geometry = computeShapeGeometry({
       shape: node.shape,
       box,
@@ -5389,7 +5753,7 @@ function coordinateNodes(nodes, boxes, options, diagnostics) {
       id: node.id,
       ...node.label === void 0 ? {} : { label: node.label },
       ...node.style === void 0 ? {} : { style: node.style },
-      ...node.ports === void 0 ? {} : { ports: coordinatePorts(node, box, options.portShifting) },
+      ...ports === void 0 ? {} : { ports },
       ...node.compartments === void 0 ? {} : { compartments: node.compartments },
       ...node.labelLayout === void 0 ? {} : { labelLayout: node.labelLayout },
       shape: node.shape,
@@ -5401,6 +5765,78 @@ function coordinateNodes(nodes, boxes, options, diagnostics) {
   }
   return coordinated;
 }
+var PORT_BOX_SIZE = 10;
+var MIN_PORT_EDGE_GAP = 12;
+function expandNodeBoxesForPorts(nodes, boxes, options, diagnostics) {
+  const shiftingEnabled = options.portShifting?.enabled ?? true;
+  if (!shiftingEnabled) return;
+  const requestedSpacing = options.portShifting?.spacing ?? 24;
+  const minSpacing = Math.max(
+    requestedSpacing,
+    PORT_BOX_SIZE + MIN_PORT_EDGE_GAP
+  );
+  for (const node of nodes) {
+    if (node.ports === void 0 || node.ports.length === 0) continue;
+    const box = boxes.get(node.id);
+    if (box === void 0) continue;
+    let heightExpansion = 0;
+    let widthExpansion = 0;
+    const portsBySide = /* @__PURE__ */ new Map();
+    for (const port of node.ports) {
+      const list = portsBySide.get(port.side) ?? [];
+      list.push(port);
+      portsBySide.set(port.side, list);
+    }
+    for (const [side, ports] of portsBySide) {
+      const count = (ports ?? []).length;
+      if (count <= 1) continue;
+      const isVertical = side === "left" || side === "right";
+      const availableSpan = isVertical ? box.height : box.width;
+      const requiredSpan = (count - 1) * minSpacing + PORT_BOX_SIZE;
+      if (requiredSpan > availableSpan) {
+        const expansion = requiredSpan - availableSpan;
+        if (isVertical) {
+          heightExpansion = Math.max(heightExpansion, expansion);
+        } else {
+          widthExpansion = Math.max(widthExpansion, expansion);
+        }
+        diagnostics.push({
+          severity: "info",
+          code: "port_capacity_overflow",
+          message: `Expanded node ${node.id} ${isVertical ? "height" : "width"} by ${Math.ceil(expansion)} px to fit ${count} port(s) on ${side} side.`,
+          path: ["nodes", node.id, "ports"],
+          detail: {
+            nodeId: node.id,
+            side,
+            portCount: count,
+            expansion: Math.ceil(expansion)
+          }
+        });
+      }
+    }
+    if (heightExpansion > 0) {
+      box.y -= heightExpansion / 2;
+      box.height += heightExpansion;
+    }
+    if (widthExpansion > 0) {
+      box.x -= widthExpansion / 2;
+      box.width += widthExpansion;
+    }
+    if ((heightExpansion > 0 || widthExpansion > 0) && node.labelLayout !== void 0) {
+      const layout2 = node.labelLayout;
+      const newOffsetX = Math.max(0, (box.width - layout2.box.width) / 2);
+      const newOffsetY = Math.max(0, (box.height - layout2.box.height) / 2);
+      node.labelLayout = {
+        ...layout2,
+        box: {
+          ...layout2.box,
+          x: newOffsetX,
+          y: newOffsetY
+        }
+      };
+    }
+  }
+}
 function coordinatePorts(node, nodeBox, portShifting) {
   const portsBySide = /* @__PURE__ */ new Map();
   for (const port of node.ports ?? []) {
@@ -5437,7 +5873,11 @@ function portAnchor(nodeBox, side, index, count, portShifting) {
   const requestedSpacing = portShifting?.spacing ?? 24;
   const maxOffset = side === "left" || side === "right" ? nodeBox.height / 2 : nodeBox.width / 2;
   const availableSpan = 2 * maxOffset;
-  const spacing = shiftingEnabled && count > 1 ? Math.min(requestedSpacing, availableSpan / (count - 1)) : requestedSpacing;
+  const minSpacing = PORT_BOX_SIZE + MIN_PORT_EDGE_GAP;
+  const spacing = shiftingEnabled && count > 1 ? Math.max(
+    Math.min(requestedSpacing, availableSpan / (count - 1)),
+    minSpacing
+  ) : requestedSpacing;
   const centeredOffset = shiftingEnabled ? (index - (count - 1) / 2) * spacing : 0;
   switch (side) {
     case "left":
@@ -5463,7 +5903,7 @@ function portAnchor(nodeBox, side, index, count, portShifting) {
   }
 }
 function portBox(anchor) {
-  const size = 10;
+  const size = PORT_BOX_SIZE;
   return {
     x: anchor.x - size / 2,
     y: anchor.y - size / 2,
@@ -6052,7 +6492,7 @@ function evidenceOverlapDiagnostic(block, conflict) {
     }
   };
 }
-function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacles, textObstacles, hardObstacles, direction, options, diagnostics) {
+function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacles, textObstacles, hardObstacles, direction, options, diagnostics, groups) {
   const coordinated = [];
   const coordinatedNodeById = new Map(
     coordinatedNodes.map((node) => [node.id, node])
@@ -6076,8 +6516,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 connectedTextOwners = edgeConnectedTextOwnerIds(edge);
-    const routeTextObstacles = textObstacles.filter((annotation) => !connectedTextOwners.has(annotation.ownerId)).map((annotation) => annotation.box);
+    const routeTextObstacles = textObstacles.filter((annotation) => !isEdgeConnectedTextAnnotation(edge, annotation)).map((annotation) => annotation.box);
     const route = routeEdge({
       kind: options.routeKind ?? "orthogonal",
       direction,
@@ -6090,9 +6529,11 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacle
           (obstacle) => obstacle !== source.obstacleBox && obstacle !== target.obstacleBox
         ),
         ...softObstacles,
+        ...groupObstaclesForEdge(edge, groups, options.obstacleMargin ?? 0),
         ...routeTextObstacles
       ],
-      hardObstacles
+      hardObstacles,
+      ...options.maxRoutingAttempts === void 0 ? {} : { maxRoutingAttempts: options.maxRoutingAttempts }
     });
     diagnostics.push(
       ...route.diagnostics.map((diagnostic) => ({
@@ -6107,15 +6548,52 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacle
   }
   return coordinated;
 }
-function edgeConnectedTextOwnerIds(edge) {
-  const owners = /* @__PURE__ */ new Set();
-  if (edge.source.portId !== void 0) {
-    owners.add(`${edge.source.nodeId}.${edge.source.portId}`);
+function isEdgeConnectedTextAnnotation(edge, annotation) {
+  switch (annotation.surfaceKind) {
+    case "edge-label":
+      return annotation.ownerId === edge.id;
+    case "node-label":
+    case "compartment-row":
+      return annotation.ownerId === edge.source.nodeId || annotation.ownerId === edge.target.nodeId;
+    case "port-label":
+      return edge.source.portId !== void 0 && annotation.ownerId === `${edge.source.nodeId}.${edge.source.portId}` || edge.target.portId !== void 0 && annotation.ownerId === `${edge.target.nodeId}.${edge.target.portId}`;
+    case "group-label":
+    case "swimlane-label":
+    case "frame-title":
+      return false;
   }
-  if (edge.target.portId !== void 0) {
-    owners.add(`${edge.target.nodeId}.${edge.target.portId}`);
+}
+function ancestorGroupIds(groups, nodeId) {
+  const direct = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    if (group.nodeIds.includes(nodeId)) {
+      direct.add(group.id);
+    }
+  }
+  let previousSize = -1;
+  const ancestors = new Set(direct);
+  while (ancestors.size !== previousSize) {
+    previousSize = ancestors.size;
+    for (const group of groups) {
+      for (const candidate of ancestors) {
+        if (group.groupIds.includes(candidate)) {
+          ancestors.add(group.id);
+          break;
+        }
+      }
+    }
   }
-  return owners;
+  return ancestors;
+}
+function groupObstaclesForEdge(edge, groups, margin) {
+  const sourceAncestors = ancestorGroupIds(groups, edge.source.nodeId);
+  const targetAncestors = ancestorGroupIds(groups, edge.target.nodeId);
+  return groups.filter((group) => {
+    if (sourceAncestors.has(group.id) || targetAncestors.has(group.id)) {
+      return false;
+    }
+    return true;
+  }).map((group) => margin === 0 ? group.box : expandBox(group.box, margin));
 }
 function coordinateBaseTextAnnotations(input) {
   const measurer = input.textMeasurer ?? createDefaultTextMeasurer();
@@ -6303,6 +6781,55 @@ function coordinateEdgeTextAnnotations(edges, obstacleBoxes, textMeasurer, label
   }
   return annotations;
 }
+function estimateEdgeLabelAnnotations(edges, nodes, textMeasurer) {
+  const measurer = textMeasurer ?? createDefaultTextMeasurer();
+  const annotations = [];
+  for (const edge of edges) {
+    if (edge.label?.text === void 0) {
+      continue;
+    }
+    const sourceGeom = nodes.get(edge.source.nodeId);
+    const targetGeom = nodes.get(edge.target.nodeId);
+    if (sourceGeom === void 0 || targetGeom === void 0) {
+      continue;
+    }
+    const layout2 = fitLabel(
+      edge.label.text,
+      {
+        font: typographyTextStyle(edge.label, {
+          fontFamily: "Arial",
+          fontSize: 12,
+          lineHeight: 14
+        }),
+        padding: { top: 0, right: 0, bottom: 0, left: 0 },
+        minSize: { width: 0, height: 0 },
+        maxWidth: 200
+      },
+      measurer
+    );
+    const cx = (sourceGeom.center.x + targetGeom.center.x) / 2;
+    const cy = (sourceGeom.center.y + targetGeom.center.y) / 2;
+    const box = {
+      x: cx - layout2.box.width / 2,
+      y: cy - layout2.box.height / 2,
+      width: layout2.box.width,
+      height: layout2.box.height
+    };
+    annotations.push({
+      text: layout2.text,
+      ownerId: edge.id,
+      surfaceKind: "edge-label",
+      box,
+      anchor: { x: cx, y: cy },
+      paddings: layout2.padding,
+      lines: layout2.lines,
+      fontFamily: normalizeOutputFontFamily(layout2.font),
+      fontSize: layout2.font.fontSize,
+      textBackend: layout2.textBackend
+    });
+  }
+  return annotations;
+}
 function coordinateFrameTextAnnotation(frame, textMeasurer) {
   const layout2 = fitLabel(
     frame.titleTab,
@@ -6423,9 +6950,8 @@ function reportRouteTextClearance(edges, annotations) {
   const diagnostics = [];
   const relevantAnnotations = annotations.filter(isRouteClearanceText);
   for (const edge of edges) {
-    const connectedTextOwners = edgeConnectedTextOwnerIds(edge);
     for (const annotation of relevantAnnotations) {
-      if (annotation.ownerId === edge.id || connectedTextOwners.has(annotation.ownerId)) {
+      if (isEdgeConnectedTextAnnotation(edge, annotation)) {
         continue;
       }
       if (!routeIntersectsTextBox(edge.points, annotation.box)) {
@@ -6449,9 +6975,6 @@ function reportRouteTextClearance(edges, annotations) {
   return diagnostics;
 }
 function isPreRouteTextObstacle(annotation) {
-  if (annotation.surfaceKind === "edge-label") {
-    return false;
-  }
   return isRouteClearanceText(annotation);
 }
 function isRouteClearanceText(annotation) {
@@ -6462,8 +6985,9 @@ function isRouteClearanceText(annotation) {
     case "frame-title":
       return true;
     case "node-label":
-    case "group-label":
     case "compartment-row":
+      return true;
+    case "group-label":
       return textExtendsOutsideAnchor(annotation);
   }
 }
@@ -6496,17 +7020,17 @@ function segmentIntersectsBox2(start, end, box) {
     return true;
   }
   if (start.x === end.x) {
-    return start.x > left && start.x < right && rangesOverlap2(start.y, end.y, top, bottom);
+    return start.x > left && start.x < right && rangesOverlap3(start.y, end.y, top, bottom);
   }
   if (start.y === end.y) {
-    return start.y > top && start.y < bottom && rangesOverlap2(start.x, end.x, left, right);
+    return start.y > top && start.y < bottom && rangesOverlap3(start.x, end.x, left, right);
   }
   return segmentIntersectsBoxEdge2(start, end, left, top, right, top) || segmentIntersectsBoxEdge2(start, end, right, top, right, bottom) || segmentIntersectsBoxEdge2(start, end, right, bottom, left, bottom) || segmentIntersectsBoxEdge2(start, end, left, bottom, left, top);
 }
 function pointInsideBox2(point2, box) {
   return point2.x > box.x && point2.x < box.x + box.width && point2.y > box.y && point2.y < box.y + box.height;
 }
-function rangesOverlap2(a, b, min, max) {
+function rangesOverlap3(a, b, min, max) {
   const low = Math.min(a, b);
   const high = Math.max(a, b);
   return high > min && low < max;
@@ -6575,7 +7099,8 @@ function edgeLabelAnchor(edge, layout2, edges, obstacleBoxes, placedLabelBoxes,
   for (const candidate of edgeLabelAnchorCandidates(
     edge.points,
     placement,
-    layout2
+    layout2,
+    baseOffset
   )) {
     const labelBox = {
       x: candidate.x - layout2.box.width / 2,
@@ -6607,8 +7132,8 @@ function edgeLabelAnchor(edge, layout2, edges, obstacleBoxes, placedLabelBoxes,
   }
   return placement;
 }
-function edgeLabelAnchorCandidates(points, placement, layout2) {
-  const segment = labelSegmentOnPolyline(points);
+function edgeLabelAnchorCandidates(points, placement, layout2, baseOffset = 10) {
+  const segment = labelSegmentOnPolyline(points, baseOffset);
   if (segment === void 0) {
     return [placement];
   }
@@ -6658,7 +7183,7 @@ function edgeLabelAnchorCandidates(points, placement, layout2) {
   }, 0);
   if (totalLen > 200) {
     for (const ratio of [0.25, 0.75]) {
-      const qp = labelPlacementAtRatio(points, ratio, totalLen);
+      const qp = labelPlacementAtRatio(points, ratio, totalLen, baseOffset);
       if (qp !== void 0) {
         candidates.push(qp);
         const qTargetDist = totalLen * ratio;
@@ -6744,7 +7269,7 @@ function labelSegmentOnPolyline(points, baseOffset = 10) {
   if (last === void 0) {
     return void 0;
   }
-  const offset = labelOffset2(last);
+  const offset = labelOffset2(last, baseOffset);
   return {
     start: last.start,
     end: last.end,
@@ -6766,7 +7291,7 @@ function nonZeroSegments2(points) {
   }
   return segments;
 }
-function labelPlacementAtRatio(points, ratio, totalLength) {
+function labelPlacementAtRatio(points, ratio, totalLength, baseOffset = 10) {
   if (points.length < 2 || ratio < 0 || ratio > 1) {
     return void 0;
   }
@@ -6784,7 +7309,10 @@ function labelPlacementAtRatio(points, ratio, totalLength) {
     }
     if (travelled + segLen >= targetDist) {
       const t = (targetDist - travelled) / segLen;
-      const offset = labelOffset2({ start: prev, end: curr, length: segLen });
+      const offset = labelOffset2(
+        { start: prev, end: curr, length: segLen },
+        baseOffset
+      );
       return {
         x: prev.x + (curr.x - prev.x) * t + offset.x,
         y: prev.y + (curr.y - prev.y) * t + offset.y