@crazyhappyone/auto-graph 0.1.4 → 0.2.1

package/dist/index.cjs

@@ -811,7 +811,6 @@ function applyDistributeContained(input, boxes, locks, diagnostics) {
         const lock = locks.get(childId);
         if (lock?.source === "fixed-position") {
           unlocked.push({ id: childId, box });
-          locks.delete(childId);
           continue;
         }
         diagnostics.push({
@@ -3984,6 +3983,240 @@ function isValidDimension(value) {
   return Number.isFinite(value) && value >= 0;
 }
 
+// src/routing/astar.ts
+function findObstacleFreePath(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 maxNodes = options.maxNodes ?? (obstacles.length > 30 ? 16e3 : 4e3);
+  const xs = collectXs(source, target, obstacles, margin);
+  const ys = collectYs(source, target, obstacles, margin);
+  if (xs.length * ys.length > maxNodes) {
+    diagnostics?.push({
+      severity: "warning",
+      code: "routing.astar.grid_overflow",
+      message: `A* grid overflow: ${xs.length * ys.length} nodes > ${maxNodes} limit. Falling back to heuristic routing.`,
+      detail: {
+        xsCount: xs.length,
+        ysCount: 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 raw = [];
+  for (const obs of obstacles) {
+    raw.push(obs.x - margin - 2, obs.x + obs.width + margin + 2);
+  }
+  const deduped = dedupSorted(raw);
+  for (const v of [source.x, target.x]) {
+    if (!deduped.includes(v)) {
+      deduped.push(v);
+    }
+  }
+  return deduped.sort((a, b) => a - b);
+}
+function collectYs(source, target, obstacles, margin) {
+  const raw = [];
+  for (const obs of obstacles) {
+    raw.push(obs.y - margin - 2, obs.y + obs.height + margin + 2);
+  }
+  const deduped = dedupSorted(raw);
+  for (const v of [source.y, target.y]) {
+    if (!deduped.includes(v)) {
+      deduped.push(v);
+    }
+  }
+  return deduped.sort((a, b) => a - b);
+}
+function dedupSorted(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const result = [];
+  for (const v of sorted) {
+    const last = result[result.length - 1];
+    if (last === void 0 || v - last > 2) {
+      result.push(v);
+    }
+  }
+  return result;
+}
+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 = [];
@@ -4029,6 +4262,44 @@ 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
+        },
+        diagnostics
+      );
+      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(
@@ -4231,7 +4502,7 @@ function routeEdge(input) {
   };
 }
 function finalizeRoute(points, softObstacles, hardObstacles, diagnostics) {
-  const simplified = simplifyRoute(points);
+  const simplified = simplifyRoute2(points);
   if (simplified.length >= 3) {
     return simplified;
   }
@@ -4519,7 +4790,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);
@@ -4531,7 +4802,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 });
@@ -4746,17 +5017,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;
@@ -4780,7 +5051,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;
 }
 
@@ -4860,11 +5131,12 @@ function solveDiagram(diagram, options = {}) {
     options,
     diagnostics
   );
+  expandNodeBoxesForPorts(styledNodes, initialNodeBoxes, options, diagnostics);
   const constrained = applyLayoutConstraints({
     direction: diagram.direction,
     overlapSpacing: options?.overlapSpacing ?? 40,
     ...options.minSiblingGap === void 0 ? {} : { minSiblingGap: options.minSiblingGap },
-    ...options.distributeContainedChildren === void 0 ? {} : { distributeContainedChildren: options.distributeContainedChildren },
+    distributeContainedChildren: options.distributeContainedChildren ?? true,
     boxes: initialNodeBoxes,
     nodes: styledNodes,
     constraints
@@ -4923,6 +5195,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(
@@ -5003,7 +5280,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 = [
@@ -5036,7 +5316,8 @@ function solveDiagram(diagram, options = {}) {
     hardObstacles,
     diagram.direction,
     options,
-    diagnostics
+    diagnostics,
+    coordinatedGroups
   );
   const edgeTextAnnotations = coordinateEdgeTextAnnotations(
     coordinatedEdges,
@@ -5152,22 +5433,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) {
@@ -6114,6 +6380,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,
@@ -6123,7 +6390,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,
@@ -6135,6 +6402,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 ?? []) {
@@ -6171,7 +6510,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":
@@ -6197,7 +6540,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,
@@ -6786,7 +7129,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])
@@ -6810,8 +7153,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,
@@ -6824,6 +7166,7 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacle
           (obstacle) => obstacle !== source.obstacleBox && obstacle !== target.obstacleBox
         ),
         ...softObstacles,
+        ...groupObstaclesForEdge(edge, groups, options.obstacleMargin ?? 0),
         ...routeTextObstacles
       ],
       hardObstacles,
@@ -6842,15 +7185,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();
@@ -7038,6 +7418,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,
@@ -7158,9 +7587,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)) {
@@ -7184,9 +7612,6 @@ function reportRouteTextClearance(edges, annotations) {
   return diagnostics;
 }
 function isPreRouteTextObstacle(annotation) {
-  if (annotation.surfaceKind === "edge-label") {
-    return false;
-  }
   return isRouteClearanceText(annotation);
 }
 function isRouteClearanceText(annotation) {
@@ -7197,8 +7622,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);
   }
 }
@@ -7231,17 +7657,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;
@@ -7869,7 +8295,7 @@ exports.resolveLineHeight = resolveLineHeight;
 exports.resolveOutputFormat = resolveOutputFormat;
 exports.routeEdge = routeEdge;
 exports.runDagreInitialLayout = runDagreInitialLayout;
-exports.simplifyRoute = simplifyRoute;
+exports.simplifyRoute = simplifyRoute2;
 exports.solveDiagram = solveDiagram;
 exports.solveDiagramSafe = solveDiagramSafe;
 exports.sortDslDiagnostics = sortDslDiagnostics;