@weasel-js/diagram 1.11.0 → 1.12.0

package/dist/{chunk-NUMMW5BI.js → chunk-R2XB6D32.js}

@@ -1,5 +1,5 @@
-import { AUTO_POSE_DESCRIPTOR, rotatePoint, rectPath, polygonFromPoints, PATH_M, PATH_L, PATH_C, flattenCubic, PATH_Q, PATH_Z, PathBuilder } from '@weasel-js/core/math';
-import { transformPath } from '@weasel-js/geom';
+import { AUTO_POSE_DESCRIPTOR, rotatePoint, rectPath, polygonFromPoints, PATH_M, PATH_L, PATH_C, flattenCubic, PATH_Q, PATH_Z, PathBuilder, clipNothing, pointAlongPath } from '@weasel-js/core/math';
+import { transformPath, ellipsePath, PATH_M as PATH_M$1, PATH_CMD_LENGTHS, measurePath, forEachSegment, PATH_L as PATH_L$1, nearestOnLine, PATH_Q as PATH_Q$1, nearestOnQuadratic, PATH_C as PATH_C$1, nearestOnCubic } from '@weasel-js/geom';
 import { cssFamilyName } from '@weasel-js/font/metrics';
 import { createSimulation } from '@weasel-js/simulation';
 
@@ -48,6 +48,8 @@ function outlinePath(outline, bounds) {
       ]);
     case "stadium":
       return stadiumPath(x, y, w, h);
+    case "ellipse":
+      return ellipsePath(bounds);
   }
 }
 function stadiumPath(x, y, w, h) {
@@ -85,6 +87,11 @@ function contentBox(outline, bounds) {
       return { x, y: y + h / 4, width: w, height: h / 2 };
     case "hexagon":
       return { x: x + w * POINT, y, width: w * (1 - POINT * 2), height: h };
+    case "ellipse": {
+      const cw = w / Math.SQRT2;
+      const ch = h / Math.SQRT2;
+      return { x: x + (w - cw) / 2, y: y + (h - ch) / 2, width: cw, height: ch };
+    }
     case "stadium": {
       const r = Math.min(w, h) / 2;
       return w >= h ? { x: x + r, y, width: Math.max(w - r * 2, 0), height: h } : { x, y: y + r, width: w, height: Math.max(h - r * 2, 0) };
@@ -106,6 +113,8 @@ function boxForContent(outline, content) {
       return { width: content.width / (1 - POINT * 2), height: content.height };
     case "stadium":
       return { width: content.width + content.height, height: content.height };
+    case "ellipse":
+      return { width: content.width * Math.SQRT2, height: content.height * Math.SQRT2 };
   }
 }
 var TOLERANCE = 0.25;
@@ -217,6 +226,7 @@ var dataKeyReader = (node) => {
   if (trait === null || typeof trait !== "object") return null;
   if ("from" in trait && "to" in trait) return null;
   if ("label" in trait || "anchor" in trait || "mark" in trait) return null;
+  if (trait.container?.role === "lane") return null;
   return trait;
 };
 function createDiagramNodes(entries) {
@@ -492,6 +502,7 @@ function buildBody(spec, at2, opts) {
     layer: opts.layer,
     pose,
     data: opts.body(trait, pose),
+    clipFromPose: clipNothing,
     ...opts.id === void 0 ? {} : { id: opts.id }
   }];
   const leaf = (box, data, rowId) => {
@@ -735,6 +746,10 @@ function crossInset(inset, axes) {
   const c = canonical(inset, axes);
   return { lo: c.crossLo, hi: c.crossHi };
 }
+function rankInset(inset, axes) {
+  const c = canonical(inset, axes);
+  return { lo: c.rankLo, hi: c.rankHi };
+}
 function rankGaps(graph, rows, axes, rankGap) {
   const gaps = rows.slice(1).map(() => rankGap);
   const ends2 = /* @__PURE__ */ new Map();
@@ -922,6 +937,181 @@ function expandGroupEdges(edges, groups) {
   }
   return out;
 }
+function subpathOf(path, index) {
+  if (path.kind !== "polygon") return index === 0 ? path : null;
+  const { commands, coords } = path;
+  let seen = -1;
+  let start = -1;
+  let startCoord = 0;
+  let coord2 = 0;
+  for (let i = 0; i <= commands.length; i++) {
+    const cmd = commands[i];
+    if (i === commands.length || cmd === PATH_M$1) {
+      if (seen === index) {
+        if (start === 0 && i === commands.length) return path;
+        return { kind: "polygon", fillRule: path.fillRule, commands: commands.slice(start, i), coords: coords.slice(startCoord, coord2) };
+      }
+      seen++;
+      start = i;
+      startCoord = coord2;
+    }
+    if (cmd !== void 0) coord2 += PATH_CMD_LENGTHS[cmd] ?? 0;
+  }
+  return null;
+}
+var NAMED = { start: 0, mid: 0.5, end: 1 };
+function nearestStation(path, near) {
+  if (path.kind !== "polygon") return null;
+  const { commands, coords } = path;
+  let best = null;
+  let heading = { x: 1, y: 0 };
+  forEachSegment(commands, coords, (cmd, ci, x0, y0) => {
+    let hit;
+    let d;
+    if (cmd === PATH_L$1) {
+      hit = nearestOnLine(near.x, near.y, x0, y0, coords[ci], coords[ci + 1]);
+      d = { x: coords[ci] - x0, y: coords[ci + 1] - y0 };
+    } else if (cmd === PATH_Q$1) {
+      hit = nearestOnQuadratic(near.x, near.y, x0, y0, coords[ci], coords[ci + 1], coords[ci + 2], coords[ci + 3]);
+      const t = hit.t;
+      d = {
+        x: 2 * (1 - t) * (coords[ci] - x0) + 2 * t * (coords[ci + 2] - coords[ci]),
+        y: 2 * (1 - t) * (coords[ci + 1] - y0) + 2 * t * (coords[ci + 3] - coords[ci + 1])
+      };
+    } else if (cmd === PATH_C$1) {
+      hit = nearestOnCubic(
+        near.x,
+        near.y,
+        x0,
+        y0,
+        coords[ci],
+        coords[ci + 1],
+        coords[ci + 2],
+        coords[ci + 3],
+        coords[ci + 4],
+        coords[ci + 5]
+      );
+      const t = hit.t;
+      const u = 1 - t;
+      d = {
+        x: 3 * u * u * (coords[ci] - x0) + 6 * u * t * (coords[ci + 2] - coords[ci]) + 3 * t * t * (coords[ci + 4] - coords[ci + 2]),
+        y: 3 * u * u * (coords[ci + 1] - y0) + 6 * u * t * (coords[ci + 3] - coords[ci + 1]) + 3 * t * t * (coords[ci + 5] - coords[ci + 3])
+      };
+    } else return;
+    const len = Math.hypot(d.x, d.y);
+    if (len === 0 || best !== null && hit.dist >= best.dist) return;
+    best = hit;
+    heading = { x: d.x / len, y: d.y / len };
+  });
+  const found = best;
+  return found === null ? null : { point: { x: found.x, y: found.y }, tangent: heading };
+}
+function labelCenter(whole, label, size) {
+  const path = subpathOf(whole, 0) ?? whole;
+  const at2 = label.placed ?? label;
+  const station = typeof at2.at === "object" ? nearestStation(path, at2.at.near) ?? pointAlongPath(path, 0.5) : pointAlongPath(path, typeof at2.at === "number" ? at2.at : NAMED[at2.at] ?? 0.5);
+  if (station === null) return null;
+  return besideStation(station.point, station.tangent, at2.offset ?? 0, size);
+}
+function halfDepth(tangent, size) {
+  return (Math.abs(tangent.y) * size.width + Math.abs(tangent.x) * size.height) / 2;
+}
+function besideStation(point, tangent, offset, size) {
+  const reach = offset + Math.sign(offset) * halfDepth(tangent, size);
+  return { x: point.x + tangent.y * reach, y: point.y - tangent.x * reach };
+}
+function offsetFrom(point, tangent, center2, size) {
+  const d = (center2.x - point.x) * tangent.y - (center2.y - point.y) * tangent.x;
+  const offset = Math.sign(d) * Math.max(Math.abs(d) - halfDepth(tangent, size), 0);
+  return offset === 0 ? 0 : offset;
+}
+var NUDGE = 1e-9;
+function labelSpotAt(whole, center2, size) {
+  const measure = measurePath(subpathOf(whole, 0) ?? whole);
+  if (measure === null) return null;
+  const station = measure.nearest(center2);
+  if (measure.length === 0) return { at: 0.5, offset: offsetFrom(station.point, station.tangent, center2, size) };
+  const at2 = station.s / measure.length;
+  const step = NUDGE * measure.length;
+  const before = measure.at(station.s - step).tangent;
+  const after = measure.at(station.s + step).tangent;
+  if (before.x === after.x && before.y === after.y) {
+    return { at: at2, offset: offsetFrom(station.point, station.tangent, center2, size) };
+  }
+  const reads = measure.at(at2 * measure.length).tangent;
+  let best = { at: at2, offset: 0 };
+  let bestDist = Infinity;
+  for (const [tangent, side] of [[before, -1], [after, 1]]) {
+    const offset = offsetFrom(station.point, tangent, center2, size);
+    const back = besideStation(station.point, tangent, offset, size);
+    const dist = Math.hypot(back.x - center2.x, back.y - center2.y);
+    if (dist >= bestDist) continue;
+    const onLeg = reads.x === tangent.x && reads.y === tangent.y;
+    best = { at: onLeg ? at2 : at2 + side * NUDGE, offset };
+    bestDist = dist;
+  }
+  return best;
+}
+
+// src/edgeTrait.ts
+function layoutOwnsPort(end) {
+  return end.port === void 0 || end.port === end.laidOut;
+}
+function layoutOwnsRoute(edge) {
+  const points = edge.waypoints ?? [];
+  if (points.length === 0) return true;
+  return edge.laidOut !== void 0 && samePoints(points, edge.laidOut);
+}
+function layoutWritesRoute(edge) {
+  return edge.router !== "avoid" && layoutOwnsRoute(edge);
+}
+function samePoints(a, b) {
+  return a.length === b.length && a.every((p, i) => p.x === b[i].x && p.y === b[i].y);
+}
+function diagramEdgeOf(node) {
+  const data = node.data;
+  if (data === null || typeof data !== "object") return null;
+  const edge = data.diagram;
+  if (edge === null || typeof edge !== "object") return null;
+  return "from" in edge && "to" in edge ? edge : null;
+}
+
+// src/avoid/holds.ts
+var EPS2 = 1e-6;
+function runsAlong(d, normal, sign) {
+  const len = Math.hypot(d.x, d.y) * Math.hypot(normal.x, normal.y);
+  if (len === 0) return false;
+  const cross = d.x * normal.y - d.y * normal.x;
+  return Math.abs(cross) <= EPS2 * len && sign * (d.x * normal.x + d.y * normal.y) > 0;
+}
+function onSegment(p, a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len2 = dx * dx + dy * dy;
+  const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2));
+  return Math.hypot(a.x + t * dx - p.x, a.y + t * dy - p.y) <= EPS2 * Math.max(1, Math.sqrt(len2)) ? t : null;
+}
+function routeHolds(from, to, waypoints, route) {
+  const points = [from.point, ...route, to.point];
+  const n = points.length;
+  const first = { x: points[1].x - points[0].x, y: points[1].y - points[0].y };
+  const last = { x: points[n - 1].x - points[n - 2].x, y: points[n - 1].y - points[n - 2].y };
+  if (from.normal !== null && !runsAlong(first, from.normal, 1)) return false;
+  if (to.normal !== null && !runsAlong(last, to.normal, -1)) return false;
+  let seg = 0;
+  let along = 0;
+  for (const w of waypoints) {
+    for (; seg < n - 1; seg++, along = 0) {
+      const t = onSegment(w, points[seg], points[seg + 1]);
+      if (t !== null && t >= along) {
+        along = t;
+        break;
+      }
+    }
+    if (seg === n - 1) return false;
+  }
+  return true;
+}
 
 // src/forceGroups.ts
 function resolve(groups, byId) {
@@ -1036,7 +1226,7 @@ var DEFAULTS = {
   groupStrength: 0.2
 };
 var GOLDEN = Math.PI * (3 - Math.sqrt(5));
-var NUDGE = 0.5;
+var NUDGE2 = 0.5;
 function charge(bodies, strength) {
   return (alpha) => {
     for (let i = 0; i < bodies.length; i++) {
@@ -1179,7 +1369,7 @@ function separate(bodies) {
     seen.set(key, nth + 1);
     if (nth === 0 || body.fx != null || body.fy != null) return;
     const angle = GOLDEN * i;
-    const radius = NUDGE * nth;
+    const radius = NUDGE2 * nth;
     body.x += Math.cos(angle) * radius;
     body.y += Math.sin(angle) * radius;
   });
@@ -1786,8 +1976,18 @@ function chainsOf(groups) {
   };
   return (group) => group === void 0 ? [] : chain2(group, /* @__PURE__ */ new Set());
 }
-var newBlock = (first) => ({ items: [], sub: /* @__PURE__ */ new Map(), sum: 0, count: 0, first });
-function sortRank(row, key, chainOf) {
+var newBlock = (first, group) => ({
+  ...group !== void 0 ? { group } : {},
+  items: [],
+  sub: /* @__PURE__ */ new Map(),
+  sum: 0,
+  count: 0,
+  first
+});
+function placesOf(groups) {
+  return new Map(groups.filter((g) => g.ordered !== void 0).map((g) => [g.id, new Map(g.ordered.map((m, i) => [m, i]))]));
+}
+function sortRank(row, key, chainOf, places = /* @__PURE__ */ new Map()) {
   const root = newBlock(0);
   const keyOf = /* @__PURE__ */ new Map();
   const firstOf = /* @__PURE__ */ new Map();
@@ -1797,7 +1997,7 @@ function sortRank(row, key, chainOf) {
     for (const g of chainOf(n.group)) {
       let next = at2.sub.get(g);
       if (next === void 0) {
-        next = newBlock(i);
+        next = newBlock(i, g);
         at2.sub.set(g, next);
         at2.items.push(next);
       }
@@ -1811,7 +2011,12 @@ function sortRank(row, key, chainOf) {
   });
   const out = [];
   const flatten = (block) => {
+    const place = block.group === void 0 ? void 0 : places.get(block.group);
     const items = block.items.map((item) => {
+      if (place !== void 0) {
+        const k = place.get("id" in item ? item.id : item.group) ?? Infinity;
+        return { item, k, first: "id" in item ? firstOf.get(item) : item.first };
+      }
       if ("id" in item) return { item, k: keyOf.get(item), first: firstOf.get(item) };
       return { item, k: item.sum / item.count, first: item.first };
     });
@@ -1837,7 +2042,7 @@ function reorder(work, r, side) {
     if (near === void 0 || near.length === 0) return i;
     return near.reduce((s, m) => s + landing(m, n.id, work) - 0.5, 0) / near.length;
   };
-  work.rows[r] = sortRank(work.rows[r], key, work.chainOf);
+  work.rows[r] = sortRank(work.rows[r], key, work.chainOf, work.places);
   reindex(work, r);
 }
 function between(work, side, u, v) {
@@ -1858,7 +2063,7 @@ function transpose(work) {
       for (let i = 0; i + 1 < row.length; i++) {
         const u = row[i];
         const v = row[i + 1];
-        if (u.group !== v.group) continue;
+        if (u.group !== v.group || u.group !== void 0 && work.places.has(u.group)) continue;
         const now = cost(u.id, v.id);
         pos.set(v.id, i);
         pos.set(u.id, i + 1);
@@ -1878,6 +2083,7 @@ function orderRows(rows, hops, opts = {}) {
   const patience = opts.patience ?? 4;
   const maxSweeps = opts.maxSweeps ?? 24;
   const chainOf = chainsOf(opts.groups ?? []);
+  const places = placesOf(opts.groups ?? []);
   const byRank = hopsByRank(rows, hops);
   const ups = /* @__PURE__ */ new Map();
   const downs = /* @__PURE__ */ new Map();
@@ -1887,9 +2093,9 @@ function orderRows(rows, hops, opts = {}) {
       (ups.get(p.to) ?? ups.set(p.to, []).get(p.to)).push({ id: p.from, frac: p.fromAt, places: p.fromPlaces, side: "down" });
     }
   }
-  const seeded = rows.map((row) => sortRank(row, (_, i) => i, chainOf));
+  const seeded = rows.map((row) => sortRank(row, (_, i) => i, chainOf, places));
   const sides = sidesOf(hops);
-  const work = { rows: seeded, pos: positions(seeded), ups, downs, sides, chainOf };
+  const work = { rows: seeded, pos: positions(seeded), ups, downs, sides, chainOf, places };
   let best = seeded.map((row) => [...row]);
   let fewest = total(work.rows, byRank, work.pos, sides);
   for (let sweep = 0, stale = 0; sweep < maxSweeps && stale < patience && fewest > 0; sweep++) {
@@ -1975,7 +2181,7 @@ function around(a, b, others, axes, rankGap) {
 }
 
 // src/layered/across.ts
-var EPS2 = 1e-6;
+var EPS3 = 1e-6;
 function settleAcross(input) {
   const { graph, rows, axes } = input;
   const groups = new Map((graph.groups ?? []).map((g) => [g.id, g]));
@@ -2034,7 +2240,7 @@ function squeeze(items, order, xs, gap) {
     for (const list of order) {
       let edge = -Infinity;
       for (const i of list) {
-        if (free(i) && xs[i] < edge - EPS2) [xs[i], moved] = [edge, true];
+        if (free(i) && xs[i] < edge - EPS3) [xs[i], moved] = [edge, true];
         edge = Math.max(edge, xs[i] + items[i].width + gap);
       }
     }
@@ -2045,7 +2251,7 @@ function squeeze(items, order, xs, gap) {
       let edge = Infinity;
       for (const i of [...list].reverse()) {
         const most = edge - items[i].width - gap;
-        if (free(i) && xs[i] > most + EPS2) [xs[i], moved] = [most, true];
+        if (free(i) && xs[i] > most + EPS3) [xs[i], moved] = [most, true];
         edge = Math.min(edge, xs[i]);
       }
     }
@@ -2100,7 +2306,7 @@ function clear(items, list, xs, gap) {
     for (const j of list.slice(k + 1)) {
       const pin = (k2) => items[k2].fixed !== void 0 && items[k2].group === void 0;
       if (pin(i) && pin(j)) continue;
-      const apart = xs[j] >= xs[i] + items[i].width + gap - EPS2 || xs[i] >= xs[j] + items[j].width + gap - EPS2;
+      const apart = xs[j] >= xs[i] + items[i].width + gap - EPS3 || xs[i] >= xs[j] + items[j].width + gap - EPS3;
       if (!apart) return false;
     }
   }
@@ -2118,7 +2324,7 @@ function jump(items, list, xs, gap) {
       for (let moved = true; moved; ) {
         moved = false;
         for (const b of blocks) {
-          if (x < b.hi - EPS2 && x + width > b.lo + EPS2) [x, moved] = [dir === 1 ? b.hi : b.lo - width, true];
+          if (x < b.hi - EPS3 && x + width > b.lo + EPS3) [x, moved] = [dir === 1 ? b.hi : b.lo - width, true];
         }
       }
       out[i] = x;
@@ -2134,7 +2340,7 @@ function jump(items, list, xs, gap) {
 }
 
 // src/layered/bands.ts
-var EPS3 = 1e-6;
+var EPS4 = 1e-6;
 function placeBands(input, covers) {
   const { natural, minGaps } = input;
   const n = natural.length;
@@ -2143,7 +2349,7 @@ function placeBands(input, covers) {
   for (let k = 0, lo = -Infinity; k < n; k++) {
     earliest.push(lo);
     const cover = covers.get(k);
-    if (cover !== void 0 && lo > cover.lo + EPS3) return void 0;
+    if (cover !== void 0 && lo > cover.lo + EPS4) return void 0;
     lo = hiOf(k, lo) + (minGaps[k] ?? 0);
   }
   const los = preferred(input, covers, hiOf).map((lo, k) => Math.max(lo, earliest[k]));
@@ -2185,7 +2391,7 @@ function spread(input, covers, los, hiOf) {
     const share = (k) => {
       if (room >= usual) return gaps[k] + (usual > 0 ? (room - usual) * gaps[k] / usual : (room - usual) / ks.length);
       const slack = usual - least;
-      return minGaps[k] + (slack > EPS3 ? (room - least) * (gaps[k] - minGaps[k]) / slack : (room - least) / ks.length);
+      return minGaps[k] + (slack > EPS4 ? (room - least) * (gaps[k] - minGaps[k]) / slack : (room - least) / ks.length);
     };
     for (let k = f + 1; k < g; k++) los[k] = hiOf(k - 1, los[k - 1]) + share(k - 1);
   }
@@ -2490,12 +2696,12 @@ function planOnce(graph, opts = {}) {
     spaced[r] = spaced[r] - rankGap * (1 - LABEL_GAP);
   }
   const pinned = pinnedSet(graph, opts);
-  const { crossAt, gaps, depths, rankAt, unheld } = holdPins({ graph, rows, crossAt: packed, gaps: spaced, pinned, axes, nodeGap, minGaps });
+  const { crossAt, gaps, depths: depths2, rankAt, unheld } = holdPins({ graph, rows, crossAt: packed, gaps: spaced, pinned, axes, nodeGap, minGaps });
   const slots = /* @__PURE__ */ new Map();
   const bands = [];
   let along = 0;
   for (const [i, row] of rows.entries()) {
-    const depth = depths[i];
+    const depth = depths2[i];
     bands.push([along, along + depth]);
     for (const node of row) {
       slots.set(node.id, { cross: crossAt.get(node.id), rank: rankAt.get(node.id) ?? along + (depth - extent(node.bounds, axes.rank)) / 2 });
@@ -2557,6 +2763,173 @@ var layered = Object.assign(
   { plan: layeredPlan }
 );
 
+// src/chainGroups.ts
+function depths(groups) {
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  const depth = /* @__PURE__ */ new Map();
+  const of = (g) => {
+    if (!depth.has(g.id)) {
+      const parent = g.parent === void 0 ? void 0 : byId.get(g.parent);
+      depth.set(g.id, parent === void 0 ? 0 : of(parent) + 1);
+    }
+    return depth.get(g.id);
+  };
+  groups.forEach(of);
+  return depth;
+}
+var deepestFirst = (groups) => {
+  const depth = depths(groups);
+  return [...groups].sort((p, q) => depth.get(q.id) - depth.get(p.id));
+};
+function groupHanging(graph, line, hanging) {
+  const groups = graph.groups ?? [];
+  if (groups.length === 0) return hanging;
+  const index = new Map(line.map((n, i) => [n.id, i]));
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  const onLine = new Map(groups.map((g) => [g.id, g.members.filter((m) => index.has(m))]));
+  const owner = new Map(hanging.owner);
+  for (const node of graph.nodes) {
+    if (index.has(node.id)) continue;
+    const first = index.get(hanging.owner.get(node.id));
+    for (let g = node.group === void 0 ? void 0 : byId.get(node.group); g !== void 0; g = g.parent === void 0 ? void 0 : byId.get(g.parent)) {
+      const members = onLine.get(g.id);
+      if (members.length === 0) continue;
+      owner.set(node.id, nearest(members, first, index));
+      break;
+    }
+  }
+  const ordered = deepestFirst(groups);
+  for (const g of ordered) {
+    if (onLine.get(g.id).length > 0) continue;
+    const hung = g.members.filter((m) => owner.has(m));
+    if (hung.length === 0) continue;
+    const counts = /* @__PURE__ */ new Map();
+    for (const m of hung) counts.set(owner.get(m), (counts.get(owner.get(m)) ?? 0) + 1);
+    let best = owner.get(hung[0]);
+    for (const [id, n] of counts) {
+      const lead = counts.get(best);
+      if (n > lead || n === lead && index.get(id) < index.get(best)) best = id;
+    }
+    for (const m of hung) owner.set(m, best);
+  }
+  return { owner, level: clearColumns(graph, ordered, index, owner, hanging.level) };
+}
+function nearest(members, from, index) {
+  let best = members[0];
+  for (const m of members) {
+    const d = Math.abs(index.get(m) - from);
+    const lead = Math.abs(index.get(best) - from);
+    if (d < lead || d === lead && index.get(m) < index.get(best)) best = m;
+  }
+  return best;
+}
+function clearColumns(graph, ordered, index, owner, start) {
+  const level = new Map(start);
+  const columns = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (index.has(node.id)) continue;
+    const id = owner.get(node.id);
+    columns.set(id, [...columns.get(id) ?? [], node.id]);
+  }
+  for (const [lineId, hung] of columns) {
+    const holding = ordered.filter((g) => g.members.some((m) => m === lineId || hung.includes(m)));
+    const atLine = holding.filter((g) => g.members.includes(lineId));
+    const kept = new Set(atLine.flatMap((g) => g.members));
+    const clear2 = (g, fixed) => {
+      const members = new Set(g.members);
+      const own = hung.filter((id) => members.has(id)).map((id) => level.get(id));
+      const low = members.has(lineId) ? 0 : Math.min(...own);
+      const deep = Math.max(0, ...own);
+      const movers = hung.filter((id) => !members.has(id) && !fixed.has(id) && level.get(id) >= low);
+      if (!movers.some((id) => level.get(id) <= deep)) return;
+      const steps = [...new Set(movers.map((id) => level.get(id)))].sort((p, q) => p - q);
+      for (const id of movers) level.set(id, deep + 1 + steps.indexOf(level.get(id)));
+    };
+    for (const g of holding) if (!atLine.includes(g)) clear2(g, kept);
+    for (const g of atLine) clear2(g, /* @__PURE__ */ new Set());
+  }
+  return level;
+}
+function lineGaps(graph, line, hanging, rankGap, axes, packed) {
+  const index = new Map(line.map((n, i) => [n.id, i]));
+  const columns = line.map((n) => [n]);
+  for (const node of graph.nodes) {
+    if (!index.has(node.id)) columns[index.get(hanging.owner.get(node.id))].push(node);
+  }
+  return bandGaps(graph, columns, axes, columns.slice(1).map(() => rankGap), (id) => packed.get(id)?.rank);
+}
+function levelGaps(graph, hanging, levelSize, axes, before, base) {
+  const levels = Array.from(levelSize, () => []);
+  for (const node of graph.nodes) (levels[hanging.level.get(node.id)] ??= []).push(node);
+  const outward = { rank: axes.cross, cross: axes.rank, sign: before ? -1 : 1 };
+  const from = [0];
+  for (let k = 1; k < levelSize.length; k++) from[k] = from[k - 1] + (levelSize[k - 1] ?? 0);
+  return bandGaps(graph, levels, outward, base, (id) => {
+    const node = graph.node(id);
+    const at2 = hanging.level.get(id);
+    if (node === void 0 || at2 === void 0) return void 0;
+    return at2 === 0 ? (levelSize[0] - extent(node.bounds, outward.rank)) / 2 : from[at2];
+  });
+}
+function bandGaps(graph, bands, axes, gaps, start) {
+  const insets = rankGaps(graph, bands, axes, 0);
+  const out = gaps.map((gap, i) => gap + (insets[i] ?? 0));
+  const groups = graph.groups ?? [];
+  if (axes.rank !== "x" || !groups.some((g) => g.minWidth !== void 0)) return out;
+  const bandOf = /* @__PURE__ */ new Map();
+  bands.forEach((band, i) => band.forEach((n) => bandOf.set(n.id, i)));
+  const children = /* @__PURE__ */ new Map();
+  for (const g of groups) if (g.parent !== void 0) children.set(g.parent, [...children.get(g.parent) ?? [], g.id]);
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  const span = (id, now) => {
+    let [lo, hi] = [Infinity, -Infinity];
+    for (const m of byId.get(id).members) {
+      const at2 = start(m);
+      const band = bandOf.get(m);
+      const node = graph.node(m);
+      if (at2 === void 0 || band === void 0 || node === void 0) continue;
+      const from = at2 + now.slice(0, band).reduce((s, gap) => s + gap, 0);
+      [lo, hi] = [Math.min(lo, from), Math.max(hi, from + extent(node.bounds, axes.rank))];
+    }
+    return { lo, hi };
+  };
+  widenForMinWidth(deepestFirst(groups).map((g) => {
+    const placed = g.members.flatMap((id) => bandOf.has(id) && start(id) !== void 0 ? [bandOf.get(id)] : []);
+    return {
+      id: g.id,
+      ...g.minWidth !== void 0 ? { minWidth: g.minWidth } : {},
+      inset: rankInset(g.inset, axes),
+      children: children.get(g.id) ?? [],
+      before: placed.length === 0 ? -1 : Math.min(...placed) - 1,
+      after: placed.length === 0 ? -1 : Math.max(...placed)
+    };
+  }), out, span);
+  return out;
+}
+function widenForMinWidth(groups, gaps, span) {
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  const boxOf2 = (g, minWidth) => {
+    let { lo, hi } = span(g.id, gaps);
+    [lo, hi] = [lo - g.inset.lo, hi + g.inset.hi];
+    for (const id of g.children) {
+      const child = byId.get(id);
+      if (child === void 0) continue;
+      const box = boxOf2(child, child.minWidth ?? 0);
+      [lo, hi] = [Math.min(lo, box.lo - g.inset.lo), Math.max(hi, box.hi + g.inset.hi)];
+    }
+    const grow = Math.max(0, minWidth - (hi - lo)) / 2;
+    return { lo: lo - grow, hi: hi + grow };
+  };
+  for (const g of groups) {
+    if (g.minWidth === void 0) continue;
+    const box = boxOf2(g, 0);
+    if (!(box.lo <= box.hi)) continue;
+    const half = Math.max(0, g.minWidth - (box.hi - box.lo)) / 2;
+    if (g.before >= 0 && g.before < gaps.length) gaps[g.before] += half;
+    if (g.after >= 0 && g.after < gaps.length) gaps[g.after] += half;
+  }
+}
+
 // src/chainRoutes.ts
 var portOf3 = (node, id) => id === void 0 ? void 0 : node.ports?.find((p) => p.id === id);
 function coord(node, at2, id, axis) {
@@ -2712,7 +3085,7 @@ function chainPlan(graph, opts = {}) {
   const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;
   const line = lineOf(graph, opts.chain);
   if (line.length === 0) return { moves: /* @__PURE__ */ new Map() };
-  const hanging = hangFrom(graph, line);
+  const hanging = groupHanging(graph, line, hangFrom(graph, line));
   const { owner, level } = hanging;
   const rows = new Map(line.map((n) => [n.id, []]));
   const levelSize = [Math.max(...line.map((n) => extent(n.bounds, axes.cross)))];
@@ -2725,24 +3098,31 @@ function chainPlan(graph, opts = {}) {
   }
   for (const [id, column] of rows) if (column[1]) column[1] = inPortOrder(graph, id, column[1], axes);
   const before = opts.chainSide === "before";
-  const place = (side2) => settle(graph, slotsFor(line, rows, levelSize, axes, { node: nodeGap, rank: rankGap, side: side2 }, before), opts);
+  const grouped = (graph.groups?.length ?? 0) > 0;
+  const across = (side2) => {
+    const base = Array.from(levelSize.slice(1), (_, k) => k === 0 ? side2 : nodeGap);
+    return grouped ? levelGaps(graph, hanging, levelSize, axes, before, base) : base;
+  };
+  const slots = (rank, level2) => slotsFor(line, rows, levelSize, axes, { node: nodeGap, rank, level: level2 }, before);
+  const gaps = grouped ? lineGaps(graph, line, hanging, rankGap, axes, slots(line.map(() => 0), [])) : line.map(() => rankGap);
+  const place = (side2) => settle(graph, slots(gaps, across(side2)), opts);
   let moves = place(nodeGap);
   const side = (tracksNeeded(graph, hanging, moves, axes, before) + 1) * SIDE_TRACK_GAP;
   if (side > nodeGap) moves = place(side);
   return { moves, waypoints: sideRoutes(graph, hanging, moves, axes, before) };
 }
 function slotsFor(line, rows, levelSize, axes, gaps, before) {
-  const { node: nodeGap, rank: rankGap } = gaps;
+  const { node: nodeGap, rank: rankGap, level: levelGap } = gaps;
   const rowSpan = (row) => row.reduce((sum, n) => sum + extent(n.bounds, axes.rank), 0) + nodeGap * Math.max(row.length - 1, 0);
   const bandStart = (at2) => {
     let offset = 0;
-    const first = before ? 1 : 0;
-    for (let k = first; k < (before ? at2 + 1 : at2); k++) offset += (levelSize[k] ?? 0) + (k === first ? gaps.side : nodeGap);
+    if (before) for (let k = 1; k <= at2; k++) offset += (levelSize[k] ?? 0) + (levelGap[k - 1] ?? 0);
+    else for (let k = 0; k < at2; k++) offset += (levelSize[k] ?? 0) + (levelGap[k] ?? 0);
     return before ? -offset : offset;
   };
   const slots = /* @__PURE__ */ new Map();
   let cursor = 0;
-  for (const node of line) {
+  line.forEach((node, i) => {
     const column = rows.get(node.id);
     const span = Math.max(extent(node.bounds, axes.rank), ...Array.from(column, (row) => row ? rowSpan(row) : 0));
     slots.set(node.id, {
@@ -2758,8 +3138,8 @@ function slotsFor(line, rows, levelSize, axes, gaps, before) {
         along += extent(hung.bounds, axes.rank) + nodeGap;
       }
     });
-    cursor += span + rankGap;
-  }
+    cursor += span + (rankGap[i] ?? 0);
+  });
   return slots;
 }
 
@@ -2807,13 +3187,13 @@ var treeOnce = (graph, opts = {}) => {
     const at2 = depth.get(node.id) ?? 0;
     bands.set(at2, Math.max(bands.get(at2) ?? 0, extent(node.bounds, axes.rank)));
   }
-  const depths = [...bands.keys()].sort((a, b) => a - b);
-  const rowsAt = depths.map((at2) => graph.nodes.filter((n) => (depth.get(n.id) ?? 0) === at2));
+  const depths2 = [...bands.keys()].sort((a, b) => a - b);
+  const rowsAt = depths2.map((at2) => graph.nodes.filter((n) => (depth.get(n.id) ?? 0) === at2));
   const grouped = (graph.groups?.length ?? 0) > 0;
-  const gaps = grouped ? rankGaps(graph, rowsAt, axes, rankGap) : depths.slice(1).map(() => rankGap);
+  const gaps = grouped ? rankGaps(graph, rowsAt, axes, rankGap) : depths2.slice(1).map(() => rankGap);
   const bandStart = /* @__PURE__ */ new Map();
   let along = 0;
-  for (const [i, at2] of depths.entries()) {
+  for (const [i, at2] of depths2.entries()) {
     bandStart.set(at2, along);
     along += bands.get(at2) + (gaps[i] ?? 0);
   }
@@ -2860,6 +3240,6 @@ var treeOnce = (graph, opts = {}) => {
   return settle(graph, slots, opts);
 };
 
-export { COMPASS, DEFAULT_GROUP_INSET, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, PORT_LABEL_GAP, SIDE_TRACK_GAP, anchorOffset, authoredOver, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, center, chain, contentBox, createDiagramNodes, dataKeyReader, diagramNodeOf, expandGroupEdges, extent, footprintNode, force, forceRelaxation, forestOf, graphOrder, grownBy, insetOf, isPinned, isPromise, layered, layeredPlan, layeredRoutes, layoutBody, layoutRowPorts, marginOf, measureBody, outlinePath, outlinePolyline, packAcross, packClusters, pinnedSet, planOf, plannerPlan, portLabelBox, portLabelsOf, portOf, portSitesOf, portsOf, portsOnOutline, rankGaps, ranksByLength, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree, untilSettled };
-//# sourceMappingURL=chunk-NUMMW5BI.js.map
-//# sourceMappingURL=chunk-NUMMW5BI.js.map
+export { COMPASS, DEFAULT_GROUP_INSET, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, PORT_LABEL_GAP, SIDE_TRACK_GAP, anchorOffset, authoredOver, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, center, chain, contentBox, createDiagramNodes, dataKeyReader, diagramEdgeOf, diagramNodeOf, expandGroupEdges, extent, footprintNode, force, forceRelaxation, forestOf, graphOrder, grownBy, insetOf, isPinned, isPromise, labelCenter, labelSpotAt, layered, layeredPlan, layeredRoutes, layoutBody, layoutOwnsPort, layoutOwnsRoute, layoutRowPorts, layoutWritesRoute, marginOf, measureBody, outlinePath, outlinePolyline, packAcross, packClusters, pinnedSet, planOf, plannerPlan, portLabelBox, portLabelsOf, portOf, portSitesOf, portsOf, portsOnOutline, rankGaps, ranksByLength, ranksOf, rayHit, routeHolds, samePoints, seededOrder, settle, sizeToBody, subpathOf, translated, tree, untilSettled, widenForMinWidth };
+//# sourceMappingURL=chunk-R2XB6D32.js.map
+//# sourceMappingURL=chunk-R2XB6D32.js.map