@crazyhappyone/auto-graph 0.2.4 → 0.2.6

package/dist/cli/index.cjs

@@ -2252,6 +2252,69 @@ 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";
+  const minGap = input.minSiblingGap ?? 8;
+  for (const swimlane of input.swimlanes) {
+    if (swimlane.layout === "contract") continue;
+    const isVertical = swimlane.orientation !== "horizontal";
+    const axis = isVertical ? "x" : "y";
+    const mainSize = isVertical ? "width" : "height";
+    for (const lane of swimlane.lanes) {
+      if (lane.children.length < 2) continue;
+      const unlocked = [];
+      const reserved = [];
+      for (const childId of lane.children) {
+        const box = boxes.get(childId);
+        if (box === void 0) continue;
+        if (locks.has(childId)) {
+          const lock = locks.get(childId);
+          if (lock.source === "fixed-position") {
+            unlocked.push({ id: childId, box });
+            continue;
+          }
+          reserved.push(intervalForBox(box, axis, mainSize));
+          continue;
+        }
+        unlocked.push({ id: childId, box });
+      }
+      if (unlocked.length < 2) continue;
+      const contentStart = isVertical ? Math.min(...unlocked.map((c) => c.box.x)) : Math.min(...unlocked.map((c) => c.box.y));
+      const contentEnd = isVertical ? Math.max(...unlocked.map((c) => c.box.x + c.box.width)) : Math.max(...unlocked.map((c) => c.box.y + c.box.height));
+      const contentSpan = contentEnd - contentStart;
+      const totalChildSpan = unlocked.reduce((s, c) => s + c.box[mainSize], 0);
+      const reservedSpan = reserved.reduce((s, r) => s + (r.end - r.start), 0);
+      let effectiveGap = minGap;
+      const remaining = contentSpan - totalChildSpan - reservedSpan - minGap * (unlocked.length - 1);
+      if (spread && remaining > 0) {
+        effectiveGap = minGap + remaining / (unlocked.length - 1);
+      }
+      unlocked.sort((a, b) => a.box[axis] - b.box[axis]);
+      let pos = contentStart;
+      for (const child of unlocked) {
+        pos = advancePastReserved(pos, child.box[mainSize], reserved, minGap);
+        const newBox = { ...child.box };
+        if (axis === "x") {
+          newBox.x = pos;
+        } else {
+          newBox.y = pos;
+        }
+        boxes.set(child.id, newBox);
+        locks.delete(child.id);
+        pos += child.box[mainSize] + effectiveGap;
+      }
+      diagnostics.push({
+        severity: "info",
+        code: "intra_container_distributed",
+        message: `Distributed ${unlocked.length} children in swimlane ${lane.id} along ${axis}.`,
+        detail: { containerId: lane.id, count: unlocked.length, axis }
+      });
+    }
+  }
 }
 function intervalForBox(box, axis, mainSize) {
   return { start: box[axis], end: box[axis] + box[mainSize] };
@@ -3664,6 +3727,397 @@ function connectedComponents(nodes, edges) {
   });
 }
 
+// src/layout/recursive.ts
+function buildContainerTree(groups, constraints, edges) {
+  const childrenOf = /* @__PURE__ */ new Map();
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    const children = [];
+    for (const nodeId of group.nodeIds) {
+      children.push(nodeId);
+      parentOf.set(nodeId, group.id);
+    }
+    for (const childGroupId of group.groupIds) {
+      children.push(childGroupId);
+      parentOf.set(childGroupId, group.id);
+    }
+    childrenOf.set(group.id, children);
+  }
+  for (const c of constraints) {
+    if (c.kind !== "containment") continue;
+    for (const childId of c.childIds) {
+      const existing = parentOf.get(childId);
+      if (existing !== void 0) {
+        if (existing === c.containerId) continue;
+        const oldSiblings = childrenOf.get(existing) ?? [];
+        const pruned = oldSiblings.filter((id) => id !== childId);
+        if (pruned.length === 0) {
+          childrenOf.delete(existing);
+        } else {
+          childrenOf.set(existing, pruned);
+        }
+        const newSiblings = childrenOf.get(c.containerId) ?? [];
+        newSiblings.push(childId);
+        childrenOf.set(c.containerId, newSiblings);
+        parentOf.set(childId, c.containerId);
+      } else {
+        const list = childrenOf.get(c.containerId) ?? [];
+        list.push(childId);
+        childrenOf.set(c.containerId, list);
+        parentOf.set(childId, c.containerId);
+      }
+    }
+  }
+  const rootIds = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    if (!parentOf.has(group.id)) {
+      rootIds.add(group.id);
+    }
+  }
+  const edgesInGroup = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const srcParent = parentOf.get(edge.source.nodeId);
+    const tgtParent = parentOf.get(edge.target.nodeId);
+    if (srcParent !== void 0 && srcParent === tgtParent) {
+      const list = edgesInGroup.get(srcParent) ?? [];
+      list.push(edge);
+      edgesInGroup.set(srcParent, list);
+    }
+  }
+  const treeDiagnostics = [];
+  return { childrenOf, rootIds, edgesInGroup, diagnostics: treeDiagnostics };
+}
+function runRecursiveContainerLayout(input) {
+  const diagnostics = [];
+  const boxes = /* @__PURE__ */ new Map();
+  const groupBoxes = /* @__PURE__ */ new Map();
+  const nodeById = new Map(input.nodes.map((n) => [n.id, n]));
+  const groupById = new Map(input.groups.map((g) => [g.id, g]));
+  const groupIdSet = new Set(input.groups.map((g) => g.id));
+  const {
+    childrenOf,
+    rootIds,
+    edgesInGroup,
+    diagnostics: treeDiagnostics
+  } = buildContainerTree(input.groups, input.constraints, input.edges);
+  diagnostics.push(...treeDiagnostics);
+  if (input.groups.length === 0) {
+    const flat = runComponentAwareDagreInitialLayout({
+      direction: input.direction,
+      nodes: input.nodes.map((n) => ({ id: n.id, size: n.size })),
+      edges: input.edges.map((e) => ({
+        id: e.id,
+        sourceId: e.source.nodeId,
+        targetId: e.target.nodeId
+      })),
+      ...input.options === void 0 ? {} : { options: input.options }
+    });
+    diagnostics.push(...flat.diagnostics);
+    for (const [id, box] of flat.boxes) {
+      boxes.set(id, box);
+    }
+    return { boxes, groupBoxes, diagnostics };
+  }
+  const descendants = /* @__PURE__ */ new Map();
+  function collectDescendants(groupId) {
+    const cached = descendants.get(groupId);
+    if (cached !== void 0) return cached;
+    const result = /* @__PURE__ */ new Set();
+    const children = childrenOf.get(groupId) ?? [];
+    for (const childId of children) {
+      result.add(childId);
+      const childDesc = collectDescendants(childId);
+      for (const d of childDesc) result.add(d);
+    }
+    descendants.set(groupId, result);
+    return result;
+  }
+  const groupOrder = topologicalSort(input.groups, childrenOf, groupIdSet);
+  for (const groupId of groupOrder) {
+    const group = groupById.get(groupId);
+    if (group === void 0) continue;
+    const children = childrenOf.get(groupId) ?? [];
+    if (children.length === 0) {
+      const box = {
+        x: 0,
+        y: 0,
+        width: (group.padding?.left ?? 8) + (group.padding?.right ?? 8) + 40,
+        height: (group.padding?.top ?? 8) + (group.padding?.bottom ?? 8) + 20
+      };
+      groupBoxes.set(groupId, box);
+      boxes.set(groupId, box);
+      continue;
+    }
+    const leafNodeIds = [];
+    const nestedGroupIds = [];
+    for (const childId of children) {
+      if (groupIdSet.has(childId)) {
+        nestedGroupIds.push(childId);
+      } else {
+        leafNodeIds.push(childId);
+      }
+    }
+    const childSizes = /* @__PURE__ */ new Map();
+    for (const nodeId of leafNodeIds) {
+      const node = nodeById.get(nodeId);
+      if (node !== void 0) {
+        childSizes.set(nodeId, {
+          width: node.size.width,
+          height: node.size.height
+        });
+      }
+    }
+    for (const nestedId of nestedGroupIds) {
+      const nestedBox = groupBoxes.get(nestedId);
+      if (nestedBox !== void 0) {
+        childSizes.set(nestedId, {
+          width: nestedBox.width,
+          height: nestedBox.height
+        });
+      }
+    }
+    const groupEdges = edgesInGroup.get(groupId) ?? [];
+    const childLayout = runDagreInitialLayout({
+      direction: input.direction,
+      nodes: children.flatMap((childId) => {
+        const size = childSizes.get(childId);
+        return size === void 0 ? [] : [{ id: childId, size }];
+      }),
+      edges: groupEdges.map((e) => ({
+        id: e.id,
+        sourceId: e.source.nodeId,
+        targetId: e.target.nodeId
+      })),
+      options: {
+        ...input.options ?? {},
+        ranksep: (input.options?.ranksep ?? 100) * 0.6,
+        // tighter inside containers
+        nodesep: (input.options?.nodesep ?? 80) * 0.6
+      }
+    });
+    diagnostics.push(...childLayout.diagnostics);
+    if (childLayout.boxes.size === 0) continue;
+    const childBoxes = [...childLayout.boxes.values()];
+    const contentBounds = unionBoxes(childBoxes);
+    const padding = group.padding ?? {
+      top: 8,
+      right: 8,
+      bottom: 8,
+      left: 8
+    };
+    const containerBox = {
+      x: 0,
+      y: 0,
+      width: contentBounds.width + (padding.left ?? 8) + (padding.right ?? 8),
+      height: contentBounds.height + (padding.top ?? 8) + (padding.bottom ?? 8)
+    };
+    const offsetX = padding.left ?? 8;
+    const offsetY = padding.top ?? 8;
+    for (const [childId, childBox] of childLayout.boxes) {
+      boxes.set(childId, {
+        ...childBox,
+        x: childBox.x + offsetX,
+        y: childBox.y + offsetY
+      });
+    }
+    groupBoxes.set(groupId, containerBox);
+    boxes.set(groupId, containerBox);
+  }
+  const allContainedIds = /* @__PURE__ */ new Set();
+  for (const [, childIds] of childrenOf) {
+    for (const cid of childIds) allContainedIds.add(cid);
+  }
+  const topLevelNodeIds = /* @__PURE__ */ new Set();
+  for (const node of input.nodes) {
+    if (!allContainedIds.has(node.id)) {
+      topLevelNodeIds.add(node.id);
+    }
+  }
+  const globalNodes = [];
+  for (const nodeId of topLevelNodeIds) {
+    const node = nodeById.get(nodeId);
+    if (node !== void 0) {
+      globalNodes.push({ id: nodeId, size: node.size });
+    }
+  }
+  for (const rootId of rootIds) {
+    const gb = groupBoxes.get(rootId);
+    if (gb !== void 0) {
+      globalNodes.push({
+        id: rootId,
+        size: { width: gb.width, height: gb.height }
+      });
+    }
+  }
+  function rootContainerOf(id) {
+    for (const rootId of rootIds) {
+      const desc = collectDescendants(rootId);
+      if (desc.has(id)) return rootId;
+    }
+    return void 0;
+  }
+  const globalEdges = input.edges.filter((e) => {
+    for (const group of input.groups) {
+      const desc = collectDescendants(group.id);
+      if (desc.has(e.source.nodeId) && desc.has(e.target.nodeId)) {
+        return false;
+      }
+    }
+    return true;
+  }).map((e) => ({
+    id: e.id,
+    sourceId: rootContainerOf(e.source.nodeId) ?? e.source.nodeId,
+    targetId: rootContainerOf(e.target.nodeId) ?? e.target.nodeId
+  }));
+  if (globalNodes.length > 0) {
+    const globalLayout = runDagreInitialLayout({
+      direction: input.direction,
+      nodes: globalNodes,
+      edges: globalEdges,
+      ...input.options === void 0 ? {} : { options: input.options }
+    });
+    diagnostics.push(...globalLayout.diagnostics);
+    for (const [id, box] of globalLayout.boxes) {
+      if (groupBoxes.has(id)) {
+        groupBoxes.set(id, box);
+        boxes.set(id, box);
+      } else if (topLevelNodeIds.has(id)) {
+        boxes.set(id, box);
+      }
+    }
+    for (const groupId of groupOrder) {
+      const containerBox = groupBoxes.get(groupId);
+      if (containerBox === void 0) continue;
+      const offsetX = containerBox.x;
+      const offsetY = containerBox.y;
+      const children = childrenOf.get(groupId) ?? [];
+      for (const childId of children) {
+        const childBox = boxes.get(childId);
+        if (childBox !== void 0) {
+          boxes.set(childId, {
+            ...childBox,
+            x: childBox.x + offsetX,
+            y: childBox.y + offsetY
+          });
+        }
+        translateDescendants(childId, offsetX, offsetY, boxes, childrenOf);
+      }
+    }
+  }
+  return { boxes, groupBoxes, diagnostics };
+}
+function translateDescendants(groupId, dx, dy, boxes, childrenOf) {
+  const children = childrenOf.get(groupId) ?? [];
+  for (const childId of children) {
+    const box = boxes.get(childId);
+    if (box !== void 0) {
+      boxes.set(childId, { ...box, x: box.x + dx, y: box.y + dy });
+    }
+    translateDescendants(childId, dx, dy, boxes, childrenOf);
+  }
+}
+function topologicalSort(groups, childrenOf, groupIdSet) {
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  function visit(id) {
+    if (visited.has(id)) return;
+    visited.add(id);
+    const children = childrenOf.get(id) ?? [];
+    for (const childId of children) {
+      if (groupIdSet.has(childId)) {
+        visit(childId);
+      }
+    }
+    result.push(id);
+  }
+  for (const group of groups) {
+    visit(group.id);
+  }
+  return result;
+}
+
+// src/routing/binary-heap.ts
+var BinaryHeap = class {
+  _data = [];
+  _nextOrder = 0;
+  get size() {
+    return this._data.length;
+  }
+  push(value, priority) {
+    const entry = { value, priority, order: this._nextOrder++ };
+    this._data.push(entry);
+    this._siftUp(this._data.length - 1);
+  }
+  pop() {
+    if (this._data.length === 0) return void 0;
+    const top = this._data[0];
+    const last = this._data.pop();
+    if (this._data.length > 0) {
+      this._data[0] = last;
+      this._siftDown(0);
+    }
+    return top.value;
+  }
+  peek() {
+    return this._data.length > 0 ? this._data[0].value : void 0;
+  }
+  // -----------------------------------------------------------------------
+  // Internals
+  // -----------------------------------------------------------------------
+  _siftUp(idx) {
+    const entry = this._data[idx];
+    while (idx > 0) {
+      const parentIdx = idx - 1 >> 1;
+      const parent = this._data[parentIdx];
+      if (this._less(entry, parent)) {
+        this._data[idx] = parent;
+        idx = parentIdx;
+      } else {
+        break;
+      }
+    }
+    this._data[idx] = entry;
+  }
+  _siftDown(idx) {
+    const entry = this._data[idx];
+    const size = this._data.length;
+    while (true) {
+      let smallestIdx = idx;
+      const leftIdx = (idx << 1) + 1;
+      const rightIdx = leftIdx + 1;
+      if (leftIdx < size && this._less(
+        this._data[leftIdx],
+        this._data[smallestIdx]
+      )) {
+        smallestIdx = leftIdx;
+      }
+      if (rightIdx < size && this._less(
+        this._data[rightIdx],
+        this._data[smallestIdx]
+      )) {
+        smallestIdx = rightIdx;
+      }
+      if (smallestIdx !== idx) {
+        this._data[idx] = this._data[smallestIdx];
+        idx = smallestIdx;
+      } else {
+        break;
+      }
+    }
+    this._data[idx] = entry;
+  }
+  /**
+   * Two entries are compared first by priority, then by insertion order
+   * when priorities are equal.  The insertion-order tie-break makes the
+   * heap deterministic: for a given sequence of {value, priority} pushes,
+   * the extraction order is always the same.
+   */
+  _less(a, b) {
+    if (a.priority !== b.priority) return a.priority < b.priority;
+    return a.order < b.order;
+  }
+};
+
 // src/routing/astar.ts
 function findObstacleFreePath(source, target, obstacles, options = {}, diagnostics) {
   const margin = options.margin ?? 0;
@@ -3671,8 +4125,17 @@ function findObstacleFreePath(source, target, obstacles, options = {}, diagnosti
   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);
+  const useCorridor = options.corridorPrefilter ?? true;
+  const corridorMargin = options.corridorMargin ?? 32;
+  const filtered = useCorridor ? filterObstaclesByCorridor(
+    source,
+    target,
+    obstacles,
+    endpointObstacles,
+    corridorMargin
+  ) : obstacles;
+  const xs = collectXs(source, target, filtered, margin);
+  const ys = collectYs(source, target, filtered, margin);
   if (xs.length * ys.length > maxNodes) {
     diagnostics?.push({
       severity: "warning",
@@ -3687,8 +4150,8 @@ function findObstacleFreePath(source, target, obstacles, options = {}, diagnosti
     return null;
   }
   const { nodes, nodeIndex } = buildGraph(xs, ys);
-  connectHorizontalEdges(nodes, ys, obstacles, endpointObstacles, margin);
-  connectVerticalEdges(nodes, xs, obstacles, endpointObstacles, margin);
+  connectHorizontalEdges(nodes, ys, filtered, endpointObstacles, margin);
+  connectVerticalEdges(nodes, xs, filtered, endpointObstacles, margin);
   const path = aStarSearch(
     nodes,
     nodeIndex,
@@ -3700,6 +4163,22 @@ function findObstacleFreePath(source, target, obstacles, options = {}, diagnosti
   if (path === null) return null;
   return simplifyRoute(path);
 }
+function filterObstaclesByCorridor(source, target, obstacles, endpointObstacles, margin) {
+  const cx1 = Math.min(source.x, target.x) - margin;
+  const cx2 = Math.max(source.x, target.x) + margin;
+  const cy1 = Math.min(source.y, target.y) - margin;
+  const cy2 = Math.max(source.y, target.y) + margin;
+  const result = [];
+  for (const obs of obstacles) {
+    if (obs.x + obs.width >= cx1 && obs.x <= cx2 && obs.y + obs.height >= cy1 && obs.y <= cy2) {
+      result.push(obs);
+    }
+  }
+  for (const ep of endpointObstacles) {
+    result.push(ep);
+  }
+  return result;
+}
 function collectXs(source, target, obstacles, margin) {
   const raw = [];
   for (const obs of obstacles) {
@@ -3843,25 +4322,17 @@ function aStarSearch(nodes, nodeIndex, source, target, turnPenalty, segmentPenal
   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) {
+  const openSet = new BinaryHeap();
+  openSet.push(startId, manhattan(source, target));
+  while (openSet.size > 0) {
+    const currentId = openSet.pop();
+    const currentG = gScore.get(currentId);
+    if (currentG === void 0) continue;
+    if (currentId === goalId) {
       return reconstructPath(nodes, cameFrom, goalId);
     }
-    const node = nodes[current.id];
-    const currentG = gScore.get(current.id);
-    const prevDir = cameFromDir.get(current.id);
+    const node = nodes[currentId];
+    const prevDir = cameFromDir.get(currentId);
     for (const [neighborId, edgeCost] of node.neighbors) {
       const neighbor = nodes[neighborId];
       const tentativeG = currentG + edgeCost * segmentPenalty;
@@ -3871,10 +4342,10 @@ function aStarSearch(nodes, nodeIndex, source, target, turnPenalty, segmentPenal
       const existingG = gScore.get(neighborId);
       if (existingG === void 0 || totalG < existingG) {
         gScore.set(neighborId, totalG);
-        cameFrom.set(neighborId, current.id);
+        cameFrom.set(neighborId, currentId);
         cameFromDir.set(neighborId, newDir);
         const f = totalG + manhattan(neighbor, target);
-        openSet.push({ id: neighborId, f });
+        openSet.push(neighborId, f);
       }
     }
   }
@@ -3911,6 +4382,292 @@ function areCollinear(a, b, c) {
   return a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y;
 }
 
+// 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 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 }
+    });
+    return null;
+  }
+  if (obstacles.length === 0) {
+    return simplifyRoute2([source, target]);
+  }
+  const expandedObstacles = margin === 0 ? obstacles : obstacles.map((o) => expandBox2(o, margin));
+  const edges = buildVisibilityEdges(
+    vertices,
+    expandedObstacles,
+    endpointObstacles
+  );
+  const path = aStarSearch2(
+    vertices,
+    edges,
+    source,
+    target,
+    segmentPenalty,
+    turnPenalty
+  );
+  if (path === null) return null;
+  return simplifyRoute2(path, expandedObstacles);
+}
+function collectCornerVertices(source, target, obstacles, margin = 0) {
+  const vertices = [
+    { point: { x: source.x, y: source.y }, obstacleIndex: -1 },
+    { point: { x: target.x, y: target.y }, obstacleIndex: -1 }
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  seen.add(`${source.x},${source.y}`);
+  seen.add(`${target.x},${target.y}`);
+  const addVertex = (p, obstacleIndex) => {
+    const key = `${p.x},${p.y}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    vertices.push({ point: p, obstacleIndex });
+  };
+  for (let i = 0; i < obstacles.length; i++) {
+    const obs = obstacles[i];
+    const c0 = { x: obs.x - margin, y: obs.y - margin };
+    const c1 = { x: obs.x + obs.width + margin, y: obs.y - margin };
+    const c2 = {
+      x: obs.x + obs.width + margin,
+      y: obs.y + obs.height + margin
+    };
+    const c3 = { x: obs.x - margin, y: obs.y + obs.height + margin };
+    for (const c of [c0, c1, c2, c3]) {
+      addVertex(c, i);
+    }
+  }
+  for (const p of [source, target]) {
+    for (let i = 0; i < obstacles.length; i++) {
+      const obs = obstacles[i];
+      addVertex({ x: obs.x - margin, y: p.y }, i);
+      addVertex({ x: obs.x + obs.width + margin, y: p.y }, i);
+      addVertex({ x: p.x, y: obs.y - margin }, i);
+      addVertex({ x: p.x, y: obs.y + obs.height + margin }, i);
+      if (p.x > obs.x && p.x < obs.x + obs.width) {
+        addVertex({ x: p.x, y: obs.y - margin }, i);
+        addVertex({ x: p.x, y: obs.y + obs.height + margin }, i);
+      }
+      if (p.y > obs.y && p.y < obs.y + obs.height) {
+        addVertex({ x: obs.x - margin, y: p.y }, i);
+        addVertex({ x: obs.x + obs.width + margin, y: p.y }, i);
+      }
+    }
+  }
+  return vertices;
+}
+function buildVisibilityEdges(vertices, obstacles, endpointObstacles) {
+  const edges = [];
+  for (let i = 0; i < vertices.length; i++) {
+    const v = vertices[i];
+    const right = visibleInDirection(
+      v,
+      vertices,
+      obstacles,
+      endpointObstacles,
+      "right"
+    );
+    const left = visibleInDirection(
+      v,
+      vertices,
+      obstacles,
+      endpointObstacles,
+      "left"
+    );
+    const down = visibleInDirection(
+      v,
+      vertices,
+      obstacles,
+      endpointObstacles,
+      "down"
+    );
+    const up = visibleInDirection(
+      v,
+      vertices,
+      obstacles,
+      endpointObstacles,
+      "up"
+    );
+    for (const neighbor of [right, left, down, up]) {
+      if (neighbor !== null && neighbor.index > i) {
+        edges.push({
+          from: i,
+          to: neighbor.index,
+          cost: neighbor.distance
+        });
+      }
+    }
+  }
+  return edges;
+}
+function visibleInDirection(origin, vertices, obstacles, endpointObstacles, dir) {
+  const candidates = [];
+  for (let i = 0; i < vertices.length; i++) {
+    const v = vertices[i];
+    const dx = v.point.x - origin.point.x;
+    const dy = v.point.y - origin.point.y;
+    switch (dir) {
+      case "right":
+        if (dx > 0 && dy === 0) candidates.push({ index: i, dist: dx });
+        break;
+      case "left":
+        if (dx < 0 && dy === 0) candidates.push({ index: i, dist: -dx });
+        break;
+      case "down":
+        if (dy > 0 && dx === 0) candidates.push({ index: i, dist: dy });
+        break;
+      case "up":
+        if (dy < 0 && dx === 0) candidates.push({ index: i, dist: -dy });
+        break;
+    }
+  }
+  candidates.sort((a, b) => a.dist - b.dist);
+  for (const c of candidates) {
+    if (isSegmentVisible(
+      origin.point,
+      vertices[c.index].point,
+      obstacles,
+      endpointObstacles,
+      origin.obstacleIndex,
+      vertices[c.index].obstacleIndex
+    )) {
+      return { index: c.index, distance: c.dist };
+    }
+  }
+  return null;
+}
+function isSegmentVisible(a, b, obstacles, endpointObstacles, _aObsIdx, _bObsIdx) {
+  for (let i = 0; i < obstacles.length; i++) {
+    if (segmentEntersBox(a, b, obstacles[i])) return false;
+  }
+  for (const ep of endpointObstacles) {
+    if (segmentEntersBox(a, b, ep)) return false;
+  }
+  return true;
+}
+function segmentEntersBox(start, end, box) {
+  const left = box.x;
+  const right = box.x + box.width;
+  const top = box.y;
+  const bottom = box.y + box.height;
+  const inside = (p) => p.x > left && p.x < right && p.y > top && p.y < bottom;
+  if (inside(start) || inside(end)) return true;
+  if (start.x === end.x) {
+    return start.x > left && start.x < right && Math.max(start.y, end.y) > top && Math.min(start.y, end.y) < bottom;
+  }
+  if (start.y === end.y) {
+    return start.y > top && start.y < bottom && Math.max(start.x, end.x) > left && Math.min(start.x, end.x) < right;
+  }
+  return false;
+}
+function expandBox2(box, margin) {
+  return {
+    x: box.x - margin,
+    y: box.y - margin,
+    width: box.width + margin * 2,
+    height: box.height + margin * 2
+  };
+}
+function aStarSearch2(vertices, edges, source, target, segmentPenalty, turnPenalty) {
+  const startId = 0;
+  const goalId = 1;
+  const gScore = /* @__PURE__ */ new Map();
+  gScore.set(startId, 0);
+  const cameFrom = /* @__PURE__ */ new Map();
+  const cameFromDir = /* @__PURE__ */ new Map();
+  const openSet = new BinaryHeap();
+  openSet.push(startId, manhattan2(source, target));
+  const neighborMap = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    let list = neighborMap.get(e.from);
+    if (list === void 0) {
+      list = [];
+      neighborMap.set(e.from, list);
+    }
+    list.push({ to: e.to, cost: e.cost });
+    list = neighborMap.get(e.to);
+    if (list === void 0) {
+      list = [];
+      neighborMap.set(e.to, list);
+    }
+    list.push({ to: e.from, cost: e.cost });
+  }
+  while (openSet.size > 0) {
+    const currentId = openSet.pop();
+    const currentG = gScore.get(currentId);
+    if (currentG === void 0) continue;
+    if (currentId === goalId) {
+      return reconstructPath2(vertices, cameFrom, goalId);
+    }
+    const prevDir = cameFromDir.get(currentId);
+    const neighbors = neighborMap.get(currentId) ?? [];
+    for (const { to, cost } of neighbors) {
+      const tentativeG = currentG + cost * segmentPenalty;
+      const toV = vertices[to];
+      const curV = vertices[currentId];
+      const newDir = toV.point.y === curV.point.y ? "h" : "v";
+      const turnCost = prevDir !== void 0 && prevDir !== newDir ? turnPenalty : 0;
+      const totalG = tentativeG + turnCost;
+      const existingG = gScore.get(to);
+      if (existingG === void 0 || totalG < existingG) {
+        gScore.set(to, totalG);
+        cameFrom.set(to, currentId);
+        cameFromDir.set(to, newDir);
+        const f = totalG + manhattan2(toV.point, target);
+        openSet.push(to, f);
+      }
+    }
+  }
+  return null;
+}
+function manhattan2(a, b) {
+  return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+}
+function reconstructPath2(vertices, cameFrom, goalId) {
+  const path = [];
+  let current = goalId;
+  while (current !== void 0) {
+    const v = vertices[current];
+    path.unshift({ x: v.point.x, y: v.point.y });
+    current = cameFrom.get(current);
+  }
+  return path;
+}
+function simplifyRoute2(points, obstacles = []) {
+  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];
+    const collinear = prev.x === curr.x && curr.x === next.x || prev.y === curr.y && curr.y === next.y;
+    if (!collinear) {
+      result.push(curr);
+      continue;
+    }
+    if (segmentCrossesAnyObstacle(prev, next, obstacles)) {
+      result.push(curr);
+    }
+  }
+  result.push(points[points.length - 1]);
+  return result;
+}
+function segmentCrossesAnyObstacle(a, b, obstacles) {
+  for (const obs of obstacles) {
+    if (segmentEntersBox(a, b, obs)) return true;
+  }
+  return false;
+}
+
 // src/routing/routes.ts
 function checkBacktracking(points, source, target, diagnostics) {
   if (points.length < 2) return;
@@ -4000,13 +4757,18 @@ function routeEdge(input) {
         input.source.center,
         targetAnchor
       );
-      const path = findObstacleFreePath(
+      const cornerPath = findCornerGraphPath(
         source,
         target,
         [...softObstacles, ...hardObstacles],
-        {
-          endpointObstacles
-        },
+        { endpointObstacles, margin: 2 },
+        diagnostics
+      );
+      const path = cornerPath ?? findObstacleFreePath(
+        source,
+        target,
+        [...softObstacles, ...hardObstacles],
+        { endpointObstacles, margin: 0 },
         diagnostics
       );
       if (path !== null && path.length >= 2) {
@@ -4249,7 +5011,7 @@ function routeEdge(input) {
   };
 }
 function finalizeRoute(points, softObstacles, hardObstacles, diagnostics, softObstacleIndex, hardObstacleIndex) {
-  const simplified = simplifyRoute2(points);
+  const simplified = simplifyRoute3(points);
   if (simplified.length >= 3) {
     return simplified;
   }
@@ -4553,7 +5315,7 @@ function squaredDistance2(a, b) {
   const dy = a.y - b.y;
   return dx * dx + dy * dy;
 }
-function simplifyRoute2(points) {
+function simplifyRoute3(points) {
   const withoutDuplicates = [];
   for (const point2 of points) {
     const previous = withoutDuplicates.at(-1);
@@ -4893,7 +5655,21 @@ function solveDiagram(diagram, options = {}) {
   );
   const constraints = stableByConstraintId(diagram.constraints);
   const initialLayoutMode = options.initialLayout ?? "dagre";
-  const layout2 = runInitialLayout({
+  const useRecursive = options.recursiveLayout === true;
+  if (useRecursive && initialLayoutMode === "positions") {
+    diagnostics.push({
+      severity: "warning",
+      code: "layout.recursive-ignores-positions",
+      message: 'recursiveLayout overrides initialLayout "positions" \u2014 seed positions are ignored for bottom-up container layout.'
+    });
+  }
+  const layout2 = useRecursive ? runRecursiveContainerLayout({
+    direction: diagram.direction,
+    nodes: styledNodes,
+    groups: styledGroups,
+    edges: styledEdges,
+    constraints
+  }) : runInitialLayout({
     mode: initialLayoutMode,
     componentAware: options.maxStackDepth === void 0,
     direction: diagram.direction,
@@ -4909,12 +5685,32 @@ function solveDiagram(diagram, options = {}) {
     options,
     diagnostics
   );
+  if ((diagram.direction === "TB" || diagram.direction === "BT") && options.maxRowDepth !== void 0) {
+    const rewrapped = wrapHorizontalStackIfNeeded(
+      initialNodeBoxes,
+      styledNodes,
+      diagram.direction,
+      options,
+      diagnostics
+    );
+    for (const [id, box] of rewrapped) {
+      initialNodeBoxes.set(id, box);
+    }
+  }
+  if (useRecursive && "groupBoxes" in layout2) {
+    const recursiveLayout = layout2;
+    for (const [groupId, groupBox] of recursiveLayout.groupBoxes) {
+      initialNodeBoxes.set(groupId, groupBox);
+    }
+  }
   expandNodeBoxesForPorts(styledNodes, initialNodeBoxes, options, diagnostics);
   const constrained = applyLayoutConstraints({
     direction: diagram.direction,
     overlapSpacing: options?.overlapSpacing ?? 40,
     ...options.minSiblingGap === void 0 ? {} : { minSiblingGap: options.minSiblingGap },
     distributeContainedChildren: options.distributeContainedChildren ?? true,
+    distributeSwimlaneChildren: options.distributeSwimlaneChildren ?? "spread",
+    swimlanes: styledSwimlanes,
     boxes: initialNodeBoxes,
     nodes: styledNodes,
     constraints
@@ -5574,7 +6370,7 @@ function wrapVerticalStackIfNeeded(boxes, nodes, edges, direction, options, diag
     );
     return wrapped;
   }
-  if (edges.length > 0 || !isVerticalRunaway(wrapped, nodes, direction, options)) {
+  if (edges.length > 0 || !isStackRunaway(wrapped, nodes, direction, options)) {
     reportVerticalRunaway(
       wrapped,
       nodes,
@@ -5625,8 +6421,57 @@ function wrapVerticalStackIfNeeded(boxes, nodes, edges, direction, options, diag
   });
   return wrapped;
 }
+function wrapHorizontalStackIfNeeded(boxes, nodes, direction, options, diagnostics) {
+  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);
+  }
+  const ordered = [...nodes].sort((a, b) => {
+    const ba = boxes.get(a.id);
+    const bb = boxes.get(b.id);
+    if (ba === void 0 || bb === void 0) return 0;
+    const dx = ba.x - bb.x;
+    return dx !== 0 ? dx : ba.y - bb.y;
+  });
+  const rows = Math.ceil(ordered.length / maxRowDepth);
+  const wrapped = new Map(boxes);
+  const rowSpacing = options.overlapSpacing ?? 40;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxH = 0;
+  for (const n of ordered) {
+    const b = boxes.get(n.id);
+    if (b !== void 0) {
+      minX = Math.min(minX, b.x);
+      minY = Math.min(minY, b.y);
+      maxH = Math.max(maxH, b.height);
+    }
+  }
+  for (let ri = 0; ri < rows; ri++) {
+    const rowNodes = ordered.slice(ri * maxRowDepth, (ri + 1) * maxRowDepth);
+    let x = minX;
+    const y = minY + ri * (maxH + rowSpacing);
+    for (const node of rowNodes) {
+      const box = boxes.get(node.id);
+      if (box === void 0) continue;
+      wrapped.set(node.id, { ...box, x, y });
+      x += box.width + rowSpacing;
+    }
+  }
+  diagnostics.push({
+    severity: "warning",
+    code: "horizontal_runaway",
+    message: `Single-row layout exceeded maxRowDepth ${maxRowDepth}; wrapped into ${rows} rows.`,
+    path: ["nodes"],
+    detail: { nodeCount: ordered.length, maxRowDepth, rows }
+  });
+  return wrapped;
+}
 function reportVerticalRunaway(boxes, nodes, edges, direction, options, diagnostics) {
-  if (!isVerticalRunaway(boxes, nodes, direction, options)) {
+  if (!isStackRunaway(boxes, nodes, direction, options)) {
     return;
   }
   diagnostics.push({
@@ -5642,7 +6487,7 @@ function reportVerticalRunaway(boxes, nodes, edges, direction, options, diagnost
     }
   });
 }
-function isVerticalRunaway(boxes, nodes, direction, options) {
+function isStackRunaway(boxes, nodes, direction, options) {
   if (options.maxStackDepth === void 0 && options.preferredAspectRatio === void 0) {
     return false;
   }
@@ -6233,7 +7078,7 @@ function coordinateNodes(nodes, boxes, options, diagnostics) {
       });
       continue;
     }
-    const ports = node.ports === void 0 ? void 0 : coordinatePorts(node, box, options.portShifting);
+    const ports = node.ports === void 0 ? void 0 : coordinatePorts(node, box, options.portShifting, diagnostics);
     const geometry = computeShapeGeometry({
       shape: node.shape,
       box,
@@ -6327,7 +7172,7 @@ function expandNodeBoxesForPorts(nodes, boxes, options, diagnostics) {
     }
   }
 }
-function coordinatePorts(node, nodeBox, portShifting) {
+function coordinatePorts(node, nodeBox, portShifting, diagnostics) {
   const portsBySide = /* @__PURE__ */ new Map();
   for (const port of node.ports ?? []) {
     const ports = portsBySide.get(port.side) ?? [];
@@ -6350,7 +7195,9 @@ function coordinatePorts(node, nodeBox, portShifting) {
         side,
         index,
         sorted.length,
-        portShifting
+        portShifting,
+        diagnostics,
+        node.id
       );
       const box = portBox(anchor);
       coordinated.push({ ...port, box, anchor });
@@ -6358,16 +7205,32 @@ function coordinatePorts(node, nodeBox, portShifting) {
   }
   return coordinated.sort((a, b) => a.id.localeCompare(b.id));
 }
-function portAnchor(nodeBox, side, index, count, portShifting) {
+function portAnchor(nodeBox, side, index, count, portShifting, diagnostics, nodeId) {
   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 spacing = shiftingEnabled && count > 1 ? Math.max(
+  const effectiveSpacing = 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":