@weasel-js/diagram 1.15.0 → 1.15.2

package/dist/{chunk-FDCODMFW.js → chunk-7BV2MBED.js}

@@ -1,4 +1,4 @@
-import { boundsOfPath, transformPath, ellipsePath, polylineFromPoints, pathFromD, worldCoords, 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 { boundsOfPath, transformPath, ellipsePath, pathFromD, polylineFromPoints, worldCoords, 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 { PathBuilder, rectPath, polygonFromPoints, AUTO_POSE_DESCRIPTOR, rotatePoint, PATH_M, PATH_L, PATH_C, flattenCubic, PATH_Q, PATH_Z, pointAlongPath } from '@weasel-js/core/math';
 import { cssFamilyName } from '@weasel-js/font/metrics';
 import { createSimulation } from '@weasel-js/simulation';
@@ -372,7 +372,34 @@ var doubleEllipse = {
   },
   boxForContent: (c) => ({ width: c.width * Math.SQRT2 + RING * 2, height: c.height * Math.SQRT2 + RING * 2 })
 };
-var FIGURE_OUTLINES = { roundRect, triangle, octagon, cloud, actor, doubleEllipse };
+var HEAD = 0.24;
+var NECK = 0.04;
+var SHOULDER = 18;
+var FOOT = 6;
+function personParts({ y, width: w, height: h }) {
+  const d = Math.min(HEAD * h, 0.4 * w);
+  const top = y + d + NECK * h;
+  const body = y + h - top;
+  return { d, top, body, shoulder: Math.min(SHOULDER, w / 4, body / 2), foot: Math.min(FOOT, w / 6, body / 4) };
+}
+var person = {
+  path: (b) => {
+    const { x, y, width: w, height: h } = b;
+    const { d, top, shoulder: r, foot: f } = personParts(b);
+    const k = r * KAPPA;
+    const q = f * KAPPA;
+    const p = new PathBuilder().moveTo(x + r, top).lineTo(x + w - r, top).curveTo(x + w - r + k, top, x + w, top + r - k, x + w, top + r).lineTo(x + w, y + h - f).curveTo(x + w, y + h - f + q, x + w - f + q, y + h, x + w - f, y + h).lineTo(x + f, y + h).curveTo(x + f - q, y + h, x, y + h - f + q, x, y + h - f).lineTo(x, top + r).curveTo(x, top + r - k, x + r - k, top, x + r, top).close().moveTo(x + w / 2 + d / 2, y + d / 2);
+    arc(p, x + w / 2, y + d / 2, d / 2, 0, Math.PI * 2);
+    return p.close().build();
+  },
+  content: (b) => {
+    const { top, body, shoulder } = personParts(b);
+    const i = shoulder * BITE;
+    return { x: b.x + i, y: top + i, width: b.width - i * 2, height: body - i * 2 };
+  },
+  boxForContent: (c) => ({ width: c.width + SHOULDER * BITE * 2, height: (c.height + SHOULDER * BITE * 2) / (1 - HEAD - NECK) })
+};
+var FIGURE_OUTLINES = { roundRect, triangle, octagon, cloud, actor, doubleEllipse, person };
 
 // src/outlines/bpmn.ts
 var STRIP = 32;
@@ -474,6 +501,10 @@ var globe = device(
   ring2(0.5, 0.6, 0.4),
   "M0.1 0.6H0.9M0.1536 0.4H0.8464M0.1536 0.8H0.8464M0.5 0.2V1M0.5 0.2A0.17 0.4 0 0 0 0.5 1A0.17 0.4 0 0 0 0.5 0.2"
 );
+var disk = device(
+  "M0.1 0.42H0.9Q0.94 0.42 0.94 0.46V0.96Q0.94 1 0.9 1H0.1Q0.06 1 0.06 0.96V0.46Q0.06 0.42 0.1 0.42Z",
+  `${ring2(0.42, 0.71, 0.22)}${ring2(0.42, 0.71, 0.03)}${ring2(0.8, 0.53, 0.03)}M0.78 0.55L0.5 0.8`
+);
 var NETWORK_OUTLINES = {
   server,
   router,
@@ -484,7 +515,8 @@ var NETWORK_OUTLINES = {
   phone,
   printer,
   user,
-  globe
+  globe,
+  disk
 };
 var ICON = { width: 14, height: 12, tab: { width: 6, height: 3 }, margin: 6 };
 var ICON_SIDE = ICON.margin * 2 + ICON.width + ICON.tab.width / 2;
@@ -520,6 +552,88 @@ var doubleRect = {
   boxForContent: (c) => ({ width: c.width + GAP * 2, height: c.height + GAP * 2 })
 };
 var MODELING_OUTLINES = { component, doubleRect };
+function square({ x, y, width: w, height: h }) {
+  const side = Math.min(w, h);
+  return { x: x + (w - side) / 2, y: y + (h - side) / 2, width: side, height: side };
+}
+function scaled(b, k) {
+  const w = b.width * k;
+  const h = b.height * k;
+  return { x: b.x + (b.width - w) / 2, y: b.y + (b.height - h) / 2, width: w, height: h };
+}
+var BULLSEYE = 0.55;
+var BAR = 6;
+var circle = (b) => ellipsePath(square(b));
+var start = {
+  path: circle,
+  solid: circle
+};
+var end = {
+  path: circle,
+  solid: (b) => ellipsePath(scaled(square(b), BULLSEYE))
+};
+function barOf({ x, y, width: w, height: h }) {
+  if (w >= h) {
+    const t2 = Math.min(BAR, h);
+    return { x, y: y + (h - t2) / 2, width: w, height: t2 };
+  }
+  const t = Math.min(BAR, w);
+  return { x: x + (w - t) / 2, y, width: t, height: h };
+}
+var bar = {
+  path: (b) => {
+    const r = barOf(b);
+    return rectPath(r.x, r.y, r.width, r.height);
+  },
+  solid: (b) => {
+    const r = barOf(b);
+    return rectPath(r.x, r.y, r.width, r.height);
+  }
+};
+var STATE_OUTLINES = { start, end, bar };
+var SHARE2 = 0.75;
+var ring3 = (cx, cy, rx, ry) => `M${cx + rx} ${cy}A${rx} ${ry} 0 1 1 ${cx - rx} ${cy}A${rx} ${ry} 0 1 1 ${cx + rx} ${cy}Z`;
+var boundary = figureOver(outlineFromD(`${ring3(0.7, 0.5, 0.4 / 1.5, 0.4)}M0.04 0.1V0.9M0.04 0.5H${0.7 - 0.4 / 1.5}`), 1.5, SHARE2);
+var control = figureOver(outlineFromD(ring3(0.5, 0.55, 0.42, 0.42), { detail: "M0.6 0.02L0.46 0.13L0.6 0.24" }), 1, SHARE2);
+var entity = figureOver(outlineFromD(`${ring3(0.5, 0.45, 0.42, 0.42)}M0.08 0.97H0.92`), 1, SHARE2);
+var offsetOf = (w, h) => Math.min(6, w / 8, h / 8);
+var collections = {
+  path: ({ x, y, width: w, height: h }) => {
+    const o = offsetOf(w, h);
+    return new PathBuilder().moveTo(x + o, y).lineTo(x + w, y).lineTo(x + w, y + h - o).lineTo(x + w - o, y + h - o).lineTo(x + w - o, y + h).lineTo(x, y + h).lineTo(x, y + o).lineTo(x + o, y + o).close().build();
+  },
+  detail: ({ x, y, width: w, height: h }) => {
+    const o = offsetOf(w, h);
+    return new PathBuilder().moveTo(x + o, y + o).lineTo(x + w - o, y + o).lineTo(x + w - o, y + h - o).build();
+  },
+  content: ({ x, y, width: w, height: h }) => {
+    const o = offsetOf(w, h);
+    return { x, y: y + o, width: w - o, height: h - o };
+  },
+  boxForContent: (c) => ({ width: c.width + 6, height: c.height + 6 })
+};
+var capOf2 = (w, h) => Math.min(w * 0.12, h * 0.3);
+var queue = {
+  path: ({ x, y, width: w, height: h }) => {
+    const r = capOf2(w, h);
+    const cy = y + h / 2;
+    const ry = h / 2;
+    return new PathBuilder().moveTo(x + r, y).lineTo(x + w - r, y).curveTo(x + w - r + r * KAPPA, y, x + w, cy - ry * KAPPA, x + w, cy).curveTo(x + w, cy + ry * KAPPA, x + w - r + r * KAPPA, y + h, x + w - r, y + h).lineTo(x + r, y + h).curveTo(x + r - r * KAPPA, y + h, x, cy + ry * KAPPA, x, cy).curveTo(x, cy - ry * KAPPA, x + r - r * KAPPA, y, x + r, y).close().build();
+  },
+  detail: ({ x, y, width: w, height: h }) => {
+    const r = capOf2(w, h);
+    const cy = y + h / 2;
+    const ry = h / 2;
+    const rim = x + w - r;
+    return new PathBuilder().moveTo(rim, y).curveTo(rim - r * KAPPA, y, rim - r, cy - ry * KAPPA, rim - r, cy).curveTo(rim - r, cy + ry * KAPPA, rim - r * KAPPA, y + h, rim, y + h).build();
+  },
+  content: ({ x, y, width: w, height: h }) => {
+    const r = capOf2(w, h);
+    return { x: x + r, y, width: Math.max(w - r * 3, 0), height: h };
+  },
+  boxForContent: (c) => ({ width: c.width / 0.64, height: c.height })
+};
+var PARTICIPANT_OUTLINES = { boundary, control, entity, collections, queue };
 
 // src/outlines/table.ts
 var BUILTINS = {
@@ -528,7 +642,9 @@ var BUILTINS = {
   ...STORAGE_OUTLINES,
   ...NETWORK_OUTLINES,
   ...BPMN_OUTLINES,
-  ...MODELING_OUTLINES
+  ...MODELING_OUTLINES,
+  ...STATE_OUTLINES,
+  ...PARTICIPANT_OUTLINES
 };
 var table = new Map(
   Object.entries(BUILTINS).map(([name, def]) => [name, [def]])
@@ -563,6 +679,10 @@ function outlineDetail(outline, bounds) {
   if (typeof outline !== "string" || bounds.width <= 0 || bounds.height <= 0) return null;
   return resolveOutline(outline).detail?.(bounds) ?? null;
 }
+function outlineSolid(outline, bounds) {
+  if (typeof outline !== "string" || bounds.width <= 0 || bounds.height <= 0) return null;
+  return resolveOutline(outline).solid?.(bounds) ?? null;
+}
 function contentBox(outline, bounds) {
   if (typeof outline !== "string") return bounds;
   return resolveOutline(outline).content?.(bounds) ?? bounds;
@@ -681,6 +801,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 ("seq" in trait || "sequence" in trait) return null;
   if (trait.container?.role === "lane") return null;
   return trait;
 };
@@ -753,7 +874,7 @@ function placerOf(node, pose, opts) {
   const cx = bounds.x + bounds.width / 2;
   const cy = bounds.y + bounds.height / 2;
   const poly = trait.outline === void 0 || bounds.width <= 0 || bounds.height <= 0 ? null : outlinePolyline(trait.outline, bounds);
-  const place = (spec, at2, given) => {
+  const place2 = (spec, at2, given) => {
     const anchored = {
       x: bounds.x + at2.u * bounds.width,
       y: bounds.y + at2.v * bounds.height
@@ -772,7 +893,7 @@ function placerOf(node, pose, opts) {
       ...extrasOf(spec)
     };
   };
-  return { specs: trait.ports ?? DEFAULT_PORTS, place };
+  return { specs: trait.ports ?? DEFAULT_PORTS, place: place2 };
 }
 function extrasOf(spec) {
   return {
@@ -1271,10 +1392,10 @@ function packClusters(graph, rows, preferred2, axes, nodeGap) {
     }
     return items.map((item, i) => ({ item, i })).sort((a, b) => a.item.center - b.item.center || a.i - b.i).map(({ item }) => item);
   });
-  const settle2 = (byRow, start2, nodeFloor, origin) => {
+  const settle2 = (byRow, start3, nodeFloor, origin) => {
     const nodeAt = /* @__PURE__ */ new Map();
     let ends2 = [];
-    for (let pass = 0; pass <= start2.size; pass++) {
+    for (let pass = 0; pass <= start3.size; pass++) {
       let raised = false;
       ends2 = byRow.map((items) => {
         let cursor = origin;
@@ -1285,10 +1406,10 @@ function packClusters(graph, rows, preferred2, axes, nodeGap) {
             cursor = x2 + width(item.node) + nodeGap;
             continue;
           }
-          const s = start2.get(item.span);
+          const s = start3.get(item.span);
           const x = Math.max(s, cursor);
           if (x > s) {
-            start2.set(item.span, x);
+            start3.set(item.span, x);
             raised = true;
           }
           cursor = x + outer(item.span) + nodeGap;
@@ -1324,15 +1445,15 @@ function packClusters(graph, rows, preferred2, axes, nodeGap) {
     return blockOf(span).width + inset2.crossLo + inset2.crossHi;
   }
   const roots = spans.filter((s) => s.parent === void 0);
-  const start = new Map(roots.map((s) => [s, centerOf.get(s) - outer(s) / 2]));
-  const { nodeAt: at2 } = settle2(itemsByRow(void 0, roots), start, pref, -Infinity);
-  const place = (span, from) => {
+  const start2 = new Map(roots.map((s) => [s, centerOf.get(s) - outer(s) / 2]));
+  const { nodeAt: at2 } = settle2(itemsByRow(void 0, roots), start2, pref, -Infinity);
+  const place2 = (span, from) => {
     const origin = from + insets.get(span).crossLo;
     const block = blockOf(span);
     for (const [id, local] of block.nodeAt) at2.set(id, origin + local);
-    for (const [child, local] of block.childAt) place(child, origin + local);
+    for (const [child, local] of block.childAt) place2(child, origin + local);
   };
-  for (const root of roots) place(root, start.get(root));
+  for (const root of roots) place2(root, start2.get(root));
   return at2;
 }
 function centersOf(spans, rows, center2) {
@@ -1426,24 +1547,24 @@ function subpathOf(path, index) {
   if (path.kind !== "polygon") return index === 0 ? path : null;
   const { commands, coords } = path;
   let seen = -1;
-  let start = -1;
+  let start2 = -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;
+        if (start2 === 0 && i === commands.length) return path;
         return {
           kind: "polygon",
           fillRule: path.fillRule,
-          commands: commands.slice(start, i),
+          commands: commands.slice(start2, i),
           coords: coords.slice(startCoord, coord2),
           ...path.origin ? { origin: path.origin } : {}
         };
       }
       seen++;
-      start = i;
+      start2 = i;
       startCoord = coord2;
     }
     if (cmd !== void 0) coord2 += PATH_CMD_LENGTHS[cmd] ?? 0;
@@ -1503,7 +1624,12 @@ function labelCenter(whole, label, size) {
   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);
+  const beside = besideStation(station.point, station.tangent, at2.offset ?? 0, size);
+  const end2 = label.placed !== void 0 || label.inset === void 0 ? 0 : label.at === "start" ? 1 : label.at === "end" ? -1 : 0;
+  if (end2 === 0) return beside;
+  const { x: tx, y: ty } = station.tangent;
+  const reach = end2 * (label.inset + (Math.abs(tx) * size.width + Math.abs(ty) * size.height) / 2);
+  return { x: beside.x + tx * reach, y: beside.y + ty * reach };
 }
 function halfDepth(tangent, size) {
   return (Math.abs(tangent.y) * size.width + Math.abs(tangent.x) * size.height) / 2;
@@ -1546,8 +1672,8 @@ function labelSpotAt(whole, center2, size) {
 }
 
 // src/edgeTrait.ts
-function layoutOwnsPort(end) {
-  return end.port === void 0 || end.port === end.laidOut;
+function layoutOwnsPort(end2) {
+  return end2.port === void 0 || end2.port === end2.laidOut;
 }
 function layoutOwnsRoute(edge) {
   const points = edge.waypoints ?? [];
@@ -1567,8 +1693,6 @@ function diagramEdgeOf(node) {
   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);
@@ -1577,11 +1701,8 @@ function runsAlong(d, normal, sign) {
   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;
+  const { t, dist } = nearestOnLine(p.x, p.y, a.x, a.y, b.x, b.y);
+  return dist <= EPS2 * Math.max(1, Math.hypot(b.x - a.x, b.y - a.y)) ? t : null;
 }
 function routeHolds(from, to, waypoints, route) {
   const points = [from.point, ...route, to.point];
@@ -1605,442 +1726,180 @@ function routeHolds(from, to, waypoints, route) {
   return true;
 }
 
-// src/forceGroups.ts
-function resolve(groups, byId) {
-  const out = [];
-  for (const group of groups) {
-    const members = group.members.map((id) => byId.get(id)).filter((b) => b !== void 0);
-    if (members.length > 0) out.push({ members, group, children: [] });
-  }
-  const byGroup = new Map(out.map((g) => [g.group.id, g]));
-  for (const g of out) {
-    const parent = g.group.parent === void 0 ? void 0 : byGroup.get(g.group.parent);
-    if (parent === void 0) continue;
-    g.parent = parent;
-    parent.children.push(g);
-  }
-  return out;
+// src/layered/cycles.ts
+function backEdges(graph) {
+  const back = /* @__PURE__ */ new Set();
+  const done = /* @__PURE__ */ new Set();
+  const onStack = /* @__PURE__ */ new Set();
+  const walk = (id) => {
+    if (done.has(id)) return;
+    onStack.add(id);
+    for (const edge of graph.outgoing(id)) {
+      if (edge.to === id) continue;
+      if (onStack.has(edge.to)) back.add(edge.id);
+      else walk(edge.to);
+    }
+    onStack.delete(id);
+    done.add(id);
+  };
+  for (const node of graph.nodes) walk(node.id);
+  return back;
 }
-function groupCohesion(groups, byId, strength) {
-  const resolved = resolve(groups, byId);
-  return (alpha) => {
-    for (const { members } of resolved) {
-      let cx = 0;
-      let cy = 0;
-      for (const m of members) {
-        cx += m.x;
-        cy += m.y;
-      }
-      cx /= members.length;
-      cy /= members.length;
-      for (const m of members) {
-        m.vx += (cx - m.x) * strength * alpha;
-        m.vy += (cy - m.y) * strength * alpha;
-      }
+function ranksOf(graph, back) {
+  const ranks = /* @__PURE__ */ new Map();
+  const resolving = /* @__PURE__ */ new Set();
+  const rankOf = (id) => {
+    const known = ranks.get(id);
+    if (known !== void 0) return known;
+    if (resolving.has(id)) return 0;
+    resolving.add(id);
+    let rank = 0;
+    for (const edge of graph.incoming(id)) {
+      if (back.has(edge.id) || edge.from === id) continue;
+      rank = Math.max(rank, rankOf(edge.from) + 1);
     }
+    resolving.delete(id);
+    ranks.set(id, rank);
+    return rank;
   };
+  for (const node of graph.nodes) rankOf(node.id);
+  return ranks;
 }
-function boxOf(g) {
-  let x0 = Infinity;
-  let y0 = Infinity;
-  let x1 = -Infinity;
-  let y1 = -Infinity;
-  for (const m of g.members) {
-    x0 = Math.min(x0, m.x - m.hw);
-    y0 = Math.min(y0, m.y - m.hh);
-    x1 = Math.max(x1, m.x + m.hw);
-    y1 = Math.max(y1, m.y + m.hh);
+
+// src/route.ts
+var FACES = {
+  down: { out: "s", in: "n" },
+  up: { out: "n", in: "s" },
+  right: { out: "e", in: "w" },
+  left: { out: "w", in: "e" }
+};
+function layeredRoutes(input) {
+  const { ranks, members, compass } = input;
+  const faces = FACES[input.direction ?? "down"];
+  const span = (id) => {
+    const rs = (members.get(id) ?? [id]).map((m) => ranks.get(m)).filter((r) => r !== void 0);
+    return rs.length === 0 ? null : [Math.min(...rs), Math.max(...rs)];
+  };
+  const routes = /* @__PURE__ */ new Map();
+  for (const edge of input.edges) {
+    const from = span(edge.from);
+    const to = span(edge.to);
+    const route = {};
+    if (from !== null && to !== null && (from[1] < to[0] || to[1] < from[0])) {
+      const ahead = from[1] < to[0];
+      if (compass.has(edge.from)) route.fromPort = ahead ? faces.out : faces.in;
+      if (compass.has(edge.to)) route.toPort = ahead ? faces.in : faces.out;
+    }
+    const waypoints = input.waypoints.get(edge.id);
+    if (waypoints !== void 0 && waypoints.length > 0) {
+      route.waypoints = waypoints;
+      const label = input.labels?.get(edge.id);
+      if (label !== void 0) route.labelAt = label;
+    }
+    if (route.fromPort !== void 0 || route.toPort !== void 0 || route.waypoints !== void 0) {
+      routes.set(edge.id, route);
+    }
   }
-  for (const child of g.children) {
-    const b = boxOf(child);
-    x0 = Math.min(x0, b.x0);
-    y0 = Math.min(y0, b.y0);
-    x1 = Math.max(x1, b.x1);
-    y1 = Math.max(y1, b.y1);
+  return routes;
+}
+function layeredPorts(graph, ranks, direction) {
+  const faces = FACES[direction ?? "down"];
+  const compass = new Set(graph.groups?.map((g) => g.id) ?? []);
+  for (const node of graph.nodes) {
+    if (hasCompassPort(node, faces.out) && hasCompassPort(node, faces.in)) compass.add(node.id);
   }
-  const { inset: inset2 } = g.group;
-  return { x0: x0 - inset2.left, y0: y0 - inset2.top, x1: x1 + inset2.right, y1: y1 + inset2.bottom };
+  const edges = /* @__PURE__ */ new Map();
+  for (const e of graph.edges) {
+    const id = e.origin?.id ?? e.id;
+    if (!edges.has(id)) edges.set(id, { id, from: e.origin?.from ?? e.from, to: e.origin?.to ?? e.to });
+  }
+  const routes = layeredRoutes({
+    edges: [...edges.values()],
+    ranks,
+    waypoints: /* @__PURE__ */ new Map(),
+    members: new Map((graph.groups ?? []).map((g) => [g.id, g.members])),
+    compass,
+    ...direction !== void 0 ? { direction } : {}
+  });
+  return new Map([...routes].map(([id, r]) => [id, {
+    ...r.fromPort !== void 0 ? { from: r.fromPort } : {},
+    ...r.toPort !== void 0 ? { to: r.toPort } : {}
+  }]));
 }
-function clearance(a, b, padding) {
-  const gapX = Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0) + padding;
-  const gapY = Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0) + padding;
-  if (gapX <= 0 || gapY <= 0) return null;
-  const dx = b.x0 + b.x1 - (a.x0 + a.x1);
-  const dy = b.y0 + b.y1 - (a.y0 + a.y1);
-  return gapX < gapY ? { x: (Math.sign(dx) || 1) * gapX, y: 0 } : { x: 0, y: (Math.sign(dy) || 1) * gapY };
+function hasCompassPort(node, face) {
+  const point = COMPASS[face];
+  return (node.ports ?? DEFAULT_PORTS).some((p) => p.id === face && p.at.u === point.u && p.at.v === point.v);
 }
-function holds(outer, inner) {
-  for (let at2 = inner.parent; at2 !== void 0; at2 = at2.parent) {
-    if (at2 === outer) return true;
+function authoredOver(edges, plan) {
+  return new Map(edges.map((e) => {
+    const ports = plan.ports?.get(e.id);
+    const planned = plan.waypoints?.get(e.id);
+    const fromPort = e.fromPort ?? ports?.from;
+    const toPort = e.toPort ?? ports?.to;
+    const waypoints = e.waypoints ?? (planned !== void 0 && planned.length > 0 ? planned : void 0);
+    const labelAt = e.waypoints === void 0 && waypoints !== void 0 ? plan.labels?.get(e.id) : void 0;
+    return [e.id, {
+      ...fromPort ? { fromPort } : {},
+      ...toPort ? { toPort } : {},
+      ...waypoints ? { waypoints } : {},
+      ...labelAt !== void 0 ? { labelAt } : {}
+    }];
+  }));
+}
+
+// src/layered/rank.ts
+var GROUP_WEIGHT = 4;
+function ranksByLength(graph, back) {
+  const index = /* @__PURE__ */ new Map();
+  graph.nodes.forEach((node, i) => index.set(node.id, i));
+  const arcs = [];
+  for (const edge of graph.edges) {
+    const from = index.get(edge.from);
+    const to = index.get(edge.to);
+    if (from === void 0 || to === void 0 || from === to) continue;
+    arcs.push(back.has(edge.id) ? { tail: to, head: from, weight: 1, minlen: 1 } : { tail: from, head: to, weight: 1, minlen: 1 });
   }
-  return false;
+  let count = graph.nodes.length;
+  for (const group of graph.groups ?? []) {
+    const members = [...new Set(group.members.map((id) => index.get(id)).filter((i) => i !== void 0))];
+    if (members.length < 2) continue;
+    const [top, bottom] = [count, count + 1];
+    count += 2;
+    for (const m of members) {
+      arcs.push({ tail: top, head: m, weight: GROUP_WEIGHT, minlen: 0 });
+      arcs.push({ tail: m, head: bottom, weight: GROUP_WEIGHT, minlen: 0 });
+    }
+  }
+  const real = graph.nodes.length;
+  const start2 = longestPath(count, arcs);
+  const ranks = /* @__PURE__ */ new Map();
+  for (const part of components(count, arcs)) {
+    const rank = part.nodes.map((g) => start2[g]);
+    simplex(part.arcs, rank);
+    const own = part.nodes.flatMap((g, i) => g < real ? [i] : []);
+    const min = Math.min(...own.map((i) => rank[i]));
+    for (const i of own) ranks.set(graph.nodes[part.nodes[i]].id, rank[i] - min);
+  }
+  return ranks;
 }
-function shove(bodies, x, y) {
-  for (const body of bodies) {
-    body.vx += x;
-    body.vy += y;
+function longestPath(count, arcs) {
+  const rank = new Array(count).fill(0);
+  const pending = new Array(count).fill(0);
+  const out = Array.from({ length: count }, () => []);
+  for (const arc2 of arcs) {
+    pending[arc2.head]++;
+    out[arc2.tail].push(arc2);
+  }
+  const ready = [];
+  for (let i = 0; i < count; i++) if (pending[i] === 0) ready.push(i);
+  for (let k = 0; k < ready.length; k++) {
+    const u = ready[k];
+    for (const { head: v, minlen } of out[u]) {
+      rank[v] = Math.max(rank[v], rank[u] + minlen);
+      if (--pending[v] === 0) ready.push(v);
+    }
   }
-}
-function separateGroups(groups, bodies, byId, padding) {
-  const resolved = resolve(groups, byId);
-  const memberSets = resolved.map((g) => new Set(g.members));
-  return () => {
-    const boxes = resolved.map(boxOf);
-    for (let i = 0; i < resolved.length; i++) {
-      for (let j = i + 1; j < resolved.length; j++) {
-        if (holds(resolved[i], resolved[j]) || holds(resolved[j], resolved[i])) continue;
-        const push = clearance(boxes[i], boxes[j], padding);
-        if (push === null) continue;
-        shove(resolved[i].members, -push.x / 2, -push.y / 2);
-        shove(resolved[j].members, push.x / 2, push.y / 2);
-      }
-      for (const body of bodies) {
-        if (memberSets[i].has(body)) continue;
-        const box = { x0: body.x - body.hw, y0: body.y - body.hh, x1: body.x + body.hw, y1: body.y + body.hh };
-        const push = clearance(boxes[i], box, padding);
-        if (push === null) continue;
-        shove(resolved[i].members, -push.x / 2, -push.y / 2);
-        body.vx += push.x / 2;
-        body.vy += push.y / 2;
-      }
-    }
-  };
-}
-
-// src/force.ts
-var DEFAULTS = {
-  iterations: 300,
-  linkDistance: 160,
-  linkStrength: 0.35,
-  charge: -3e3,
-  gravity: 0.02,
-  padding: 24,
-  groupStrength: 0.2
-};
-var GOLDEN = Math.PI * (3 - Math.sqrt(5));
-var NUDGE2 = 0.5;
-function charge(bodies, strength) {
-  return (alpha) => {
-    for (let i = 0; i < bodies.length; i++) {
-      const a = bodies[i];
-      for (let j = i + 1; j < bodies.length; j++) {
-        const b = bodies[j];
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        const d2 = dx * dx + dy * dy;
-        if (d2 === 0) continue;
-        const w = strength * alpha / d2;
-        a.vx += dx * w;
-        a.vy += dy * w;
-        b.vx -= dx * w;
-        b.vy -= dy * w;
-      }
-    }
-  };
-}
-function links(bodies, graph, distance, strength) {
-  return (alpha) => {
-    for (const edge of graph.edges) {
-      const a = bodies.get(edge.from);
-      const b = bodies.get(edge.to);
-      if (a === void 0 || b === void 0 || a === b) continue;
-      const dx = b.x - a.x;
-      const dy = b.y - a.y;
-      const d = Math.hypot(dx, dy);
-      if (d === 0) continue;
-      const pull = (d - distance) / d * alpha * strength;
-      a.vx += dx * pull;
-      a.vy += dy * pull;
-      b.vx -= dx * pull;
-      b.vy -= dy * pull;
-    }
-  };
-}
-function separateBoxes(bodies, padding) {
-  return () => {
-    for (let i = 0; i < bodies.length; i++) {
-      const a = bodies[i];
-      for (let j = i + 1; j < bodies.length; j++) {
-        const b = bodies[j];
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        const gapX = a.hw + b.hw + padding - Math.abs(dx);
-        const gapY = a.hh + b.hh + padding - Math.abs(dy);
-        if (gapX <= 0 || gapY <= 0) continue;
-        if (gapX < gapY) {
-          const push = (Math.sign(dx) || 1) * gapX * 0.5;
-          a.vx -= push;
-          b.vx += push;
-        } else {
-          const push = (Math.sign(dy) || 1) * gapY * 0.5;
-          a.vy -= push;
-          b.vy += push;
-        }
-      }
-    }
-  };
-}
-function gravity(bodies, at2, strength) {
-  return (alpha) => {
-    for (const body of bodies) {
-      body.vx += (at2.x - body.x) * strength * alpha;
-      body.vy += (at2.y - body.y) * strength * alpha;
-    }
-  };
-}
-function forceRelaxation(graph, opts = {}) {
-  const {
-    linkDistance = DEFAULTS.linkDistance,
-    linkStrength = DEFAULTS.linkStrength,
-    charge: chargeStrength = DEFAULTS.charge,
-    gravity: gravityStrength = DEFAULTS.gravity,
-    padding = DEFAULTS.padding,
-    groupStrength = DEFAULTS.groupStrength
-  } = opts;
-  const pinned = pinnedSet(graph, opts);
-  const bodies = graph.nodes.map((node) => {
-    const body = {
-      id: node.id,
-      x: center(node.bounds, "x"),
-      y: center(node.bounds, "y"),
-      hw: node.bounds.width / 2,
-      hh: node.bounds.height / 2
-    };
-    if (pinned.has(node.id)) {
-      body.fx = body.x;
-      body.fy = body.y;
-    }
-    return body;
-  });
-  separate(bodies);
-  const byId = new Map(bodies.map((b) => [b.id, b]));
-  const centroid = {
-    x: bodies.reduce((sum, b) => sum + b.x, 0) / bodies.length,
-    y: bodies.reduce((sum, b) => sum + b.y, 0) / bodies.length
-  };
-  const groups = graph.groups ?? [];
-  const sim = createSimulation({
-    nodes: bodies,
-    forces: [
-      charge(bodies, chargeStrength),
-      links(byId, graph, linkDistance, linkStrength),
-      gravity(bodies, centroid, gravityStrength),
-      separateBoxes(bodies, padding),
-      ...groups.length > 0 ? [groupCohesion(groups, byId, groupStrength), separateGroups(groups, bodies, byId, padding)] : []
-    ]
-  });
-  return {
-    bodies,
-    byId,
-    pinned,
-    sim,
-    placed() {
-      const placed = /* @__PURE__ */ new Map();
-      for (const node of graph.nodes) {
-        const body = byId.get(node.id);
-        placed.set(node.id, {
-          x: body.x - node.bounds.width / 2,
-          y: body.y - node.bounds.height / 2
-        });
-      }
-      return placed;
-    }
-  };
-}
-var force = (graph, opts = {}) => {
-  if (graph.nodes.length === 0) return /* @__PURE__ */ new Map();
-  const relaxation = forceRelaxation(graph, opts);
-  relaxation.sim.tick(opts.iterations ?? DEFAULTS.iterations);
-  return translated(graph, relaxation.placed(), relaxation.pinned, opts.tolerance);
-};
-function separate(bodies) {
-  const seen = /* @__PURE__ */ new Map();
-  bodies.forEach((body, i) => {
-    const key = `${body.x},${body.y}`;
-    const nth = seen.get(key) ?? 0;
-    seen.set(key, nth + 1);
-    if (nth === 0 || body.fx != null || body.fy != null) return;
-    const angle = GOLDEN * i;
-    const radius = NUDGE2 * nth;
-    body.x += Math.cos(angle) * radius;
-    body.y += Math.sin(angle) * radius;
-  });
-}
-
-// src/layered/cycles.ts
-function backEdges(graph) {
-  const back = /* @__PURE__ */ new Set();
-  const done = /* @__PURE__ */ new Set();
-  const onStack = /* @__PURE__ */ new Set();
-  const walk = (id) => {
-    if (done.has(id)) return;
-    onStack.add(id);
-    for (const edge of graph.outgoing(id)) {
-      if (edge.to === id) continue;
-      if (onStack.has(edge.to)) back.add(edge.id);
-      else walk(edge.to);
-    }
-    onStack.delete(id);
-    done.add(id);
-  };
-  for (const node of graph.nodes) walk(node.id);
-  return back;
-}
-function ranksOf(graph, back) {
-  const ranks = /* @__PURE__ */ new Map();
-  const resolving = /* @__PURE__ */ new Set();
-  const rankOf = (id) => {
-    const known = ranks.get(id);
-    if (known !== void 0) return known;
-    if (resolving.has(id)) return 0;
-    resolving.add(id);
-    let rank = 0;
-    for (const edge of graph.incoming(id)) {
-      if (back.has(edge.id) || edge.from === id) continue;
-      rank = Math.max(rank, rankOf(edge.from) + 1);
-    }
-    resolving.delete(id);
-    ranks.set(id, rank);
-    return rank;
-  };
-  for (const node of graph.nodes) rankOf(node.id);
-  return ranks;
-}
-
-// src/route.ts
-var FACES = {
-  down: { out: "s", in: "n" },
-  up: { out: "n", in: "s" },
-  right: { out: "e", in: "w" },
-  left: { out: "w", in: "e" }
-};
-function layeredRoutes(input) {
-  const { ranks, members, compass } = input;
-  const faces = FACES[input.direction ?? "down"];
-  const span = (id) => {
-    const rs = (members.get(id) ?? [id]).map((m) => ranks.get(m)).filter((r) => r !== void 0);
-    return rs.length === 0 ? null : [Math.min(...rs), Math.max(...rs)];
-  };
-  const routes = /* @__PURE__ */ new Map();
-  for (const edge of input.edges) {
-    const from = span(edge.from);
-    const to = span(edge.to);
-    const route = {};
-    if (from !== null && to !== null && (from[1] < to[0] || to[1] < from[0])) {
-      const ahead = from[1] < to[0];
-      if (compass.has(edge.from)) route.fromPort = ahead ? faces.out : faces.in;
-      if (compass.has(edge.to)) route.toPort = ahead ? faces.in : faces.out;
-    }
-    const waypoints = input.waypoints.get(edge.id);
-    if (waypoints !== void 0 && waypoints.length > 0) {
-      route.waypoints = waypoints;
-      const label = input.labels?.get(edge.id);
-      if (label !== void 0) route.labelAt = label;
-    }
-    if (route.fromPort !== void 0 || route.toPort !== void 0 || route.waypoints !== void 0) {
-      routes.set(edge.id, route);
-    }
-  }
-  return routes;
-}
-function layeredPorts(graph, ranks, direction) {
-  const faces = FACES[direction ?? "down"];
-  const compass = new Set(graph.groups?.map((g) => g.id) ?? []);
-  for (const node of graph.nodes) {
-    if (hasCompassPort(node, faces.out) && hasCompassPort(node, faces.in)) compass.add(node.id);
-  }
-  const edges = /* @__PURE__ */ new Map();
-  for (const e of graph.edges) {
-    const id = e.origin?.id ?? e.id;
-    if (!edges.has(id)) edges.set(id, { id, from: e.origin?.from ?? e.from, to: e.origin?.to ?? e.to });
-  }
-  const routes = layeredRoutes({
-    edges: [...edges.values()],
-    ranks,
-    waypoints: /* @__PURE__ */ new Map(),
-    members: new Map((graph.groups ?? []).map((g) => [g.id, g.members])),
-    compass,
-    ...direction !== void 0 ? { direction } : {}
-  });
-  return new Map([...routes].map(([id, r]) => [id, {
-    ...r.fromPort !== void 0 ? { from: r.fromPort } : {},
-    ...r.toPort !== void 0 ? { to: r.toPort } : {}
-  }]));
-}
-function hasCompassPort(node, face) {
-  const point = COMPASS[face];
-  return (node.ports ?? DEFAULT_PORTS).some((p) => p.id === face && p.at.u === point.u && p.at.v === point.v);
-}
-function authoredOver(edges, plan) {
-  return new Map(edges.map((e) => {
-    const ports = plan.ports?.get(e.id);
-    const planned = plan.waypoints?.get(e.id);
-    const fromPort = e.fromPort ?? ports?.from;
-    const toPort = e.toPort ?? ports?.to;
-    const waypoints = e.waypoints ?? (planned !== void 0 && planned.length > 0 ? planned : void 0);
-    const labelAt = e.waypoints === void 0 && waypoints !== void 0 ? plan.labels?.get(e.id) : void 0;
-    return [e.id, {
-      ...fromPort ? { fromPort } : {},
-      ...toPort ? { toPort } : {},
-      ...waypoints ? { waypoints } : {},
-      ...labelAt !== void 0 ? { labelAt } : {}
-    }];
-  }));
-}
-
-// src/layered/rank.ts
-var GROUP_WEIGHT = 4;
-function ranksByLength(graph, back) {
-  const index = /* @__PURE__ */ new Map();
-  graph.nodes.forEach((node, i) => index.set(node.id, i));
-  const arcs = [];
-  for (const edge of graph.edges) {
-    const from = index.get(edge.from);
-    const to = index.get(edge.to);
-    if (from === void 0 || to === void 0 || from === to) continue;
-    arcs.push(back.has(edge.id) ? { tail: to, head: from, weight: 1, minlen: 1 } : { tail: from, head: to, weight: 1, minlen: 1 });
-  }
-  let count = graph.nodes.length;
-  for (const group of graph.groups ?? []) {
-    const members = [...new Set(group.members.map((id) => index.get(id)).filter((i) => i !== void 0))];
-    if (members.length < 2) continue;
-    const [top, bottom] = [count, count + 1];
-    count += 2;
-    for (const m of members) {
-      arcs.push({ tail: top, head: m, weight: GROUP_WEIGHT, minlen: 0 });
-      arcs.push({ tail: m, head: bottom, weight: GROUP_WEIGHT, minlen: 0 });
-    }
-  }
-  const real = graph.nodes.length;
-  const start = longestPath(count, arcs);
-  const ranks = /* @__PURE__ */ new Map();
-  for (const part of components(count, arcs)) {
-    const rank = part.nodes.map((g) => start[g]);
-    simplex(part.arcs, rank);
-    const own = part.nodes.flatMap((g, i) => g < real ? [i] : []);
-    const min = Math.min(...own.map((i) => rank[i]));
-    for (const i of own) ranks.set(graph.nodes[part.nodes[i]].id, rank[i] - min);
-  }
-  return ranks;
-}
-function longestPath(count, arcs) {
-  const rank = new Array(count).fill(0);
-  const pending = new Array(count).fill(0);
-  const out = Array.from({ length: count }, () => []);
-  for (const arc2 of arcs) {
-    pending[arc2.head]++;
-    out[arc2.tail].push(arc2);
-  }
-  const ready = [];
-  for (let i = 0; i < count; i++) if (pending[i] === 0) ready.push(i);
-  for (let k = 0; k < ready.length; k++) {
-    const u = ready[k];
-    for (const { head: v, minlen } of out[u]) {
-      rank[v] = Math.max(rank[v], rank[u] + minlen);
-      if (--pending[v] === 0) ready.push(v);
-    }
-  }
-  return rank;
+  return rank;
 }
 function components(count, arcs) {
   const near = Array.from({ length: count }, () => []);
@@ -2194,16 +2053,16 @@ function tighten(rank, arcs, inTree) {
   const adj = treeAdjacency(rank.length, arcs, inTree);
   const seen = rank.map(() => false);
   seen[0] = true;
-  const queue = [0];
-  for (let k = 0; k < queue.length; k++) {
-    const v = queue[k];
+  const queue2 = [0];
+  for (let k = 0; k < queue2.length; k++) {
+    const v = queue2[k];
     for (const a of adj[v]) {
       const arc2 = arcs[a];
       const w = arc2.tail === v ? arc2.head : arc2.tail;
       if (seen[w]) continue;
       seen[w] = true;
       rank[w] = arc2.tail === v ? rank[v] + arc2.minlen : rank[v] - arc2.minlen;
-      queue.push(w);
+      queue2.push(w);
     }
   }
 }
@@ -2302,13 +2161,13 @@ function expand(graph, nodeRanks, back, opts) {
     if (a === null || b === null || a[1] >= b[0]) continue;
     if (d.authored && b[0] - a[1] > 1) continue;
     const group = sharedGroup(from, to);
-    const start = crossCenter(from);
-    const end = crossCenter(to);
+    const start2 = crossCenter(from);
+    const end2 = crossCenter(to);
     const crossings = b[0] - a[1] - 1;
     const now = d.waypoints?.length === crossings * 2 ? d.waypoints : void 0;
     const seed = (j) => {
       if (now !== void 0) return now[(d.back ? crossings - 1 - j : j) * 2][axes.cross];
-      return start + (end - start) * (j + 1) / (crossings + 1);
+      return start2 + (end2 - start2) * (j + 1) / (crossings + 1);
     };
     const labelRow = labeled.labelRow.get(d.id);
     let prev = inRank(from, a[1]);
@@ -2409,22 +2268,22 @@ function settlePlaces(rows, hops) {
   if (!hops.some((h) => h.fromPlaces !== void 0 || h.toPlaces !== void 0)) return [...hops];
   const pos = /* @__PURE__ */ new Map();
   for (const row of rows) row.forEach((n, i) => pos.set(n.id, i));
-  const sides = sidesOf(hops);
+  const sides2 = sidesOf(hops);
   return hops.map((h) => {
     if (h.fromPlaces === void 0 && h.toPlaces === void 0) return h;
     const { fromPlaces, toPlaces, ...rest } = h;
     return {
       ...rest,
-      ...fromPlaces !== void 0 ? { fromAt: placeAmong(fromPlaces, h.to, sides.down.get(h.from) ?? [], pos) } : {},
-      ...toPlaces !== void 0 ? { toAt: placeAmong(toPlaces, h.from, sides.up.get(h.to) ?? [], pos) } : {}
+      ...fromPlaces !== void 0 ? { fromAt: placeAmong(fromPlaces, h.to, sides2.down.get(h.from) ?? [], pos) } : {},
+      ...toPlaces !== void 0 ? { toAt: placeAmong(toPlaces, h.from, sides2.up.get(h.to) ?? [], pos) } : {}
     };
   });
 }
 
 // src/layered/order.ts
-function ends(p, pos, sides) {
-  const fa = p.fromPlaces === void 0 ? p.fromAt : placeAmong(p.fromPlaces, p.to, sides.down.get(p.from) ?? [], pos);
-  const fb = p.toPlaces === void 0 ? p.toAt : placeAmong(p.toPlaces, p.from, sides.up.get(p.to) ?? [], pos);
+function ends(p, pos, sides2) {
+  const fa = p.fromPlaces === void 0 ? p.fromAt : placeAmong(p.fromPlaces, p.to, sides2.down.get(p.from) ?? [], pos);
+  const fb = p.toPlaces === void 0 ? p.toAt : placeAmong(p.toPlaces, p.from, sides2.up.get(p.to) ?? [], pos);
   return [at(pos.get(p.from), fa), at(pos.get(p.to), fb)];
 }
 var at = (pos, frac) => pos + 0.25 + frac / 2;
@@ -2445,16 +2304,16 @@ function positions(rows) {
   for (const row of rows) row.forEach((n, i) => pos.set(n.id, i));
   return pos;
 }
-function pairCrossings(pairs, pos, sides) {
-  const met = pairs.map((p) => ends(p, pos, sides)).sort((p, q) => p[0] - q[0] || p[1] - q[1]);
+function pairCrossings(pairs, pos, sides2) {
+  const met = pairs.map((p) => ends(p, pos, sides2)).sort((p, q) => p[0] - q[0] || p[1] - q[1]);
   const lows = [...new Set(met.map(([, b]) => b))].sort((p, q) => p - q);
   const slot = new Map(lows.map((b, i) => [b, i]));
   const width = lows.length;
   const tree2 = new Array(width + 1).fill(0);
   let seen = 0;
   let count = 0;
-  for (const [, end] of met) {
-    const b = slot.get(end);
+  for (const [, end2] of met) {
+    const b = slot.get(end2);
     let atMost = 0;
     for (let i = b + 1; i > 0; i -= i & -i) atMost += tree2[i];
     count += seen - atMost;
@@ -2463,9 +2322,9 @@ function pairCrossings(pairs, pos, sides) {
   }
   return count;
 }
-function total(rows, byRank, pos, sides) {
+function total(rows, byRank, pos, sides2) {
   let sum = 0;
-  for (let r = 0; r + 1 < rows.length; r++) sum += pairCrossings(byRank[r], pos, sides);
+  for (let r = 0; r + 1 < rows.length; r++) sum += pairCrossings(byRank[r], pos, sides2);
   return sum;
 }
 function chainsOf(groups) {
@@ -2517,10 +2376,10 @@ function sortRank(row, key, chainOf, places = /* @__PURE__ */ new Map()) {
   });
   const out = [];
   const flatten = (block) => {
-    const place = block.group === void 0 ? void 0 : places.get(block.group);
+    const place2 = 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;
+      if (place2 !== void 0) {
+        const k = place2.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) };
@@ -2600,15 +2459,15 @@ function orderRows(rows, hops, opts = {}) {
     }
   }
   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, places };
+  const sides2 = sidesOf(hops);
+  const work = { rows: seeded, pos: positions(seeded), ups, downs, sides: sides2, chainOf, places };
   let best = seeded.map((row) => [...row]);
-  let fewest = total(work.rows, byRank, work.pos, sides);
+  let fewest = total(work.rows, byRank, work.pos, sides2);
   for (let sweep = 0, stale = 0; sweep < maxSweeps && stale < patience && fewest > 0; sweep++) {
     if (sweep % 2 === 0) for (let r = 1; r < work.rows.length; r++) reorder(work, r, ups);
     else for (let r = work.rows.length - 2; r >= 0; r--) reorder(work, r, downs);
     transpose(work);
-    const n = total(work.rows, byRank, work.pos, sides);
+    const n = total(work.rows, byRank, work.pos, sides2);
     if (n < fewest) {
       fewest = n;
       best = work.rows.map((row) => [...row]);
@@ -2645,9 +2504,9 @@ function levelRoutes(input) {
       out.ports.set(id, named(graph, [from, face], [to, face]));
       out.waypoints.set(id, around(a, b, others, axes, input.rankGap));
     } else {
-      const sides = SIDES[axes.cross];
+      const sides2 = SIDES[axes.cross];
       const ahead = center(a, axes.cross) < center(b, axes.cross);
-      out.ports.set(id, named(graph, [from, ahead ? sides.high : sides.low], [to, ahead ? sides.low : sides.high]));
+      out.ports.set(id, named(graph, [from, ahead ? sides2.high : sides2.low], [to, ahead ? sides2.low : sides2.high]));
     }
   }
   return out;
@@ -2916,11 +2775,11 @@ function holdPins(input) {
   if (pins.length < 2) return { crossAt: new Map(input.crossAt), gaps: [...input.gaps], depths: natural, rankAt, unheld };
   const anchor = pins[0];
   const a = rowOf.get(anchor.id);
-  let start = 0;
-  for (let r = 0; r < a; r++) start += natural[r] + input.gaps[r];
-  const bandInput = { natural, gaps: input.gaps, minGaps: input.minGaps, home: { rank: a, lo: start } };
+  let start2 = 0;
+  for (let r = 0; r < a; r++) start2 += natural[r] + input.gaps[r];
+  const bandInput = { natural, gaps: input.gaps, minGaps: input.minGaps, home: { rank: a, lo: start2 } };
   const anchorExt = extent(anchor.bounds, axes.rank);
-  const anchorRank = start + (natural[a] - anchorExt) / 2;
+  const anchorRank = start2 + (natural[a] - anchorExt) / 2;
   const anchorWorld = worldOf({ cross: input.crossAt.get(anchor.id), rank: anchorRank }, anchorExt, axes);
   const target = (id) => {
     const node = graph.node(id);
@@ -3284,107 +3143,369 @@ function layeredPlan(graph, opts = {}) {
   }, graph, opts);
   return { ...last, moves };
 }
-function routed(edge, plan) {
-  const { waypoints: _, ...rest } = edge;
-  const route = plan.waypoints.get(edge.origin?.id ?? edge.id);
-  return route === void 0 ? rest : { ...rest, waypoints: route };
+function routed(edge, plan) {
+  const { waypoints: _, ...rest } = edge;
+  const route = plan.waypoints.get(edge.origin?.id ?? edge.id);
+  return route === void 0 ? rest : { ...rest, waypoints: route };
+}
+function planOnce(graph, opts = {}) {
+  const axes = axesFor(opts.direction);
+  const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;
+  const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;
+  const finding = opts.order === "barycenter";
+  const back = backEdges(graph);
+  const ranks = ranksByLength(graph, back);
+  const expanded = expand(graph, ranks, back, { axes, nodeGap });
+  let rows = finding ? orderRows(expanded.rows, expanded.hops, { groups: graph.groups ?? [] }) : expanded.rows;
+  const grouped = (graph.groups?.length ?? 0) > 0;
+  const pinned = pinnedSet(graph, opts);
+  const across = () => {
+    const preferred2 = placeAcross(rows, settlePlaces(rows, expanded.hops), axes.cross, nodeGap);
+    return grouped ? packClusters(graph, rows, preferred2, axes, nodeGap) : preferred2;
+  };
+  let packed = across();
+  for (let turn = 0; turn < rows.length; turn++) {
+    const turned = turnOutward({ graph, rows, crossAt: packed, axes, pinned, hops: expanded.hops });
+    if (turned === void 0) break;
+    rows = turned;
+    packed = across();
+  }
+  const spaced = grouped ? rankGaps(graph, rows, axes, rankGap) : rows.slice(1).map(() => rankGap);
+  const minGaps = spaced.map((gap) => gap - rankGap + rankGap * MIN_GAP);
+  for (const r of expanded.labelRows) {
+    spaced[r - 1] = spaced[r - 1] - rankGap * (1 - LABEL_GAP);
+    spaced[r] = spaced[r] - rankGap * (1 - LABEL_GAP);
+  }
+  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 = 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 });
+    }
+    along += depth + (gaps[i] ?? 0);
+  }
+  const placed = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const slot = slots.get(node.id);
+    if (slot !== void 0) placed.set(node.id, worldOf(slot, extent(node.bounds, axes.rank), axes));
+  }
+  const moves = translated(graph, placed, pinned, opts.tolerance);
+  const offset = anchorOffset(graph, placed, pinned);
+  const displaced = /* @__PURE__ */ new Set();
+  for (const id of pinned) {
+    const at2 = placed.get(id);
+    const node = graph.node(id);
+    if (at2 === void 0 || node === void 0) continue;
+    if (Math.abs(at2.x + offset.x - node.bounds.x) > 0.5 || Math.abs(at2.y + offset.y - node.bounds.y) > 0.5) displaced.add(id);
+  }
+  const waypoints = /* @__PURE__ */ new Map();
+  const labels = /* @__PURE__ */ new Map();
+  const rankOf = /* @__PURE__ */ new Map();
+  rows.forEach((row, r) => row.forEach((n) => rankOf.set(n.id, r)));
+  const reach = boxReach(graph, rows, axes);
+  const widthOf = new Map(rows.flat().map((n) => [n.id, extent(n.bounds, axes.cross)]));
+  for (const [edge, chain2] of expanded.chains) {
+    if (chain2.ends.some((id) => displaced.has(id))) continue;
+    const beside = chain2.ids.indexOf(expanded.labels.get(edge) ?? "");
+    const points = [];
+    for (const id of chain2.ids) {
+      const cross = crossAt.get(id) + (expanded.wires.get(id) ?? widthOf.get(id) / 2);
+      const r = rankOf.get(id);
+      const [lo, hi] = [bands[r][0] - reach.lo[r], bands[r][1] + reach.hi[r]];
+      for (const rank of chain2.back ? [hi, lo] : [lo, hi]) {
+        const at2 = worldOf({ cross, rank }, 0, axes);
+        points.push({ x: at2.x + offset.x, y: at2.y + offset.y });
+      }
+    }
+    waypoints.set(edge, points);
+    if (beside >= 0) {
+      const [a, b] = [points[beside * 2], points[beside * 2 + 1]];
+      labels.set(edge, { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 });
+    }
+  }
+  const ports = layeredPorts(graph, ranks, opts.direction);
+  const boxes = new Map(graph.nodes.map((n) => [n.id, { ...n.bounds, ...moves.get(n.id) }]));
+  const level = levelRoutes({ graph, boxes, axes, rankGap, ...opts.direction !== void 0 ? { direction: opts.direction } : {} });
+  for (const [edge, named2] of level.ports) {
+    ports.set(edge, named2);
+    waypoints.delete(edge);
+    labels.delete(edge);
+  }
+  for (const [edge, points] of level.waypoints) waypoints.set(edge, points);
+  return { moves, ranks, back, waypoints, labels, ports, unheld };
+}
+
+// src/layered.ts
+var layered = Object.assign(
+  (graph, opts = {}) => layeredPlan(graph, opts).moves,
+  { plan: layeredPlan }
+);
+
+// src/forceGroups.ts
+function resolve(groups, byId) {
+  const out = [];
+  for (const group of groups) {
+    const members = group.members.map((id) => byId.get(id)).filter((b) => b !== void 0);
+    if (members.length > 0) out.push({ members, group, children: [] });
+  }
+  const byGroup = new Map(out.map((g) => [g.group.id, g]));
+  for (const g of out) {
+    const parent = g.group.parent === void 0 ? void 0 : byGroup.get(g.group.parent);
+    if (parent === void 0) continue;
+    g.parent = parent;
+    parent.children.push(g);
+  }
+  return out;
+}
+function groupCohesion(groups, byId, strength) {
+  const resolved = resolve(groups, byId);
+  return (alpha) => {
+    for (const { members } of resolved) {
+      let cx = 0;
+      let cy = 0;
+      for (const m of members) {
+        cx += m.x;
+        cy += m.y;
+      }
+      cx /= members.length;
+      cy /= members.length;
+      for (const m of members) {
+        m.vx += (cx - m.x) * strength * alpha;
+        m.vy += (cy - m.y) * strength * alpha;
+      }
+    }
+  };
+}
+function boxOf(g) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const m of g.members) {
+    x0 = Math.min(x0, m.x - m.hw);
+    y0 = Math.min(y0, m.y - m.hh);
+    x1 = Math.max(x1, m.x + m.hw);
+    y1 = Math.max(y1, m.y + m.hh);
+  }
+  for (const child of g.children) {
+    const b = boxOf(child);
+    x0 = Math.min(x0, b.x0);
+    y0 = Math.min(y0, b.y0);
+    x1 = Math.max(x1, b.x1);
+    y1 = Math.max(y1, b.y1);
+  }
+  const { inset: inset2 } = g.group;
+  return { x0: x0 - inset2.left, y0: y0 - inset2.top, x1: x1 + inset2.right, y1: y1 + inset2.bottom };
+}
+function clearance(a, b, padding) {
+  const gapX = Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0) + padding;
+  const gapY = Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0) + padding;
+  if (gapX <= 0 || gapY <= 0) return null;
+  const dx = b.x0 + b.x1 - (a.x0 + a.x1);
+  const dy = b.y0 + b.y1 - (a.y0 + a.y1);
+  return gapX < gapY ? { x: (Math.sign(dx) || 1) * gapX, y: 0 } : { x: 0, y: (Math.sign(dy) || 1) * gapY };
+}
+function holds(outer, inner) {
+  for (let at2 = inner.parent; at2 !== void 0; at2 = at2.parent) {
+    if (at2 === outer) return true;
+  }
+  return false;
+}
+function shove(bodies, x, y) {
+  for (const body of bodies) {
+    body.vx += x;
+    body.vy += y;
+  }
+}
+function separateGroups(groups, bodies, byId, padding) {
+  const resolved = resolve(groups, byId);
+  const memberSets = resolved.map((g) => new Set(g.members));
+  return () => {
+    const boxes = resolved.map(boxOf);
+    for (let i = 0; i < resolved.length; i++) {
+      for (let j = i + 1; j < resolved.length; j++) {
+        if (holds(resolved[i], resolved[j]) || holds(resolved[j], resolved[i])) continue;
+        const push = clearance(boxes[i], boxes[j], padding);
+        if (push === null) continue;
+        shove(resolved[i].members, -push.x / 2, -push.y / 2);
+        shove(resolved[j].members, push.x / 2, push.y / 2);
+      }
+      for (const body of bodies) {
+        if (memberSets[i].has(body)) continue;
+        const box = { x0: body.x - body.hw, y0: body.y - body.hh, x1: body.x + body.hw, y1: body.y + body.hh };
+        const push = clearance(boxes[i], box, padding);
+        if (push === null) continue;
+        shove(resolved[i].members, -push.x / 2, -push.y / 2);
+        body.vx += push.x / 2;
+        body.vy += push.y / 2;
+      }
+    }
+  };
+}
+
+// src/force.ts
+var DEFAULTS = {
+  iterations: 300,
+  linkDistance: 160,
+  linkStrength: 0.35,
+  charge: -3e3,
+  gravity: 0.02,
+  padding: 24,
+  groupStrength: 0.2
+};
+var GOLDEN = Math.PI * (3 - Math.sqrt(5));
+var NUDGE2 = 0.5;
+function charge(bodies, strength) {
+  return (alpha) => {
+    for (let i = 0; i < bodies.length; i++) {
+      const a = bodies[i];
+      for (let j = i + 1; j < bodies.length; j++) {
+        const b = bodies[j];
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const d2 = dx * dx + dy * dy;
+        if (d2 === 0) continue;
+        const w = strength * alpha / d2;
+        a.vx += dx * w;
+        a.vy += dy * w;
+        b.vx -= dx * w;
+        b.vy -= dy * w;
+      }
+    }
+  };
+}
+function links(bodies, graph, distance, strength) {
+  return (alpha) => {
+    for (const edge of graph.edges) {
+      const a = bodies.get(edge.from);
+      const b = bodies.get(edge.to);
+      if (a === void 0 || b === void 0 || a === b) continue;
+      const dx = b.x - a.x;
+      const dy = b.y - a.y;
+      const d = Math.hypot(dx, dy);
+      if (d === 0) continue;
+      const pull = (d - distance) / d * alpha * strength;
+      a.vx += dx * pull;
+      a.vy += dy * pull;
+      b.vx -= dx * pull;
+      b.vy -= dy * pull;
+    }
+  };
+}
+function separateBoxes(bodies, padding) {
+  return () => {
+    for (let i = 0; i < bodies.length; i++) {
+      const a = bodies[i];
+      for (let j = i + 1; j < bodies.length; j++) {
+        const b = bodies[j];
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const gapX = a.hw + b.hw + padding - Math.abs(dx);
+        const gapY = a.hh + b.hh + padding - Math.abs(dy);
+        if (gapX <= 0 || gapY <= 0) continue;
+        if (gapX < gapY) {
+          const push = (Math.sign(dx) || 1) * gapX * 0.5;
+          a.vx -= push;
+          b.vx += push;
+        } else {
+          const push = (Math.sign(dy) || 1) * gapY * 0.5;
+          a.vy -= push;
+          b.vy += push;
+        }
+      }
+    }
+  };
 }
-function planOnce(graph, opts = {}) {
-  const axes = axesFor(opts.direction);
-  const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;
-  const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;
-  const finding = opts.order === "barycenter";
-  const back = backEdges(graph);
-  const ranks = ranksByLength(graph, back);
-  const expanded = expand(graph, ranks, back, { axes, nodeGap });
-  let rows = finding ? orderRows(expanded.rows, expanded.hops, { groups: graph.groups ?? [] }) : expanded.rows;
-  const grouped = (graph.groups?.length ?? 0) > 0;
-  const pinned = pinnedSet(graph, opts);
-  const across = () => {
-    const preferred2 = placeAcross(rows, settlePlaces(rows, expanded.hops), axes.cross, nodeGap);
-    return grouped ? packClusters(graph, rows, preferred2, axes, nodeGap) : preferred2;
+function gravity(bodies, at2, strength) {
+  return (alpha) => {
+    for (const body of bodies) {
+      body.vx += (at2.x - body.x) * strength * alpha;
+      body.vy += (at2.y - body.y) * strength * alpha;
+    }
   };
-  let packed = across();
-  for (let turn = 0; turn < rows.length; turn++) {
-    const turned = turnOutward({ graph, rows, crossAt: packed, axes, pinned, hops: expanded.hops });
-    if (turned === void 0) break;
-    rows = turned;
-    packed = across();
-  }
-  const spaced = grouped ? rankGaps(graph, rows, axes, rankGap) : rows.slice(1).map(() => rankGap);
-  const minGaps = spaced.map((gap) => gap - rankGap + rankGap * MIN_GAP);
-  for (const r of expanded.labelRows) {
-    spaced[r - 1] = spaced[r - 1] - rankGap * (1 - LABEL_GAP);
-    spaced[r] = spaced[r] - rankGap * (1 - LABEL_GAP);
-  }
-  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 = 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 });
+}
+function forceRelaxation(graph, opts = {}) {
+  const {
+    linkDistance = DEFAULTS.linkDistance,
+    linkStrength = DEFAULTS.linkStrength,
+    charge: chargeStrength = DEFAULTS.charge,
+    gravity: gravityStrength = DEFAULTS.gravity,
+    padding = DEFAULTS.padding,
+    groupStrength = DEFAULTS.groupStrength
+  } = opts;
+  const pinned = pinnedSet(graph, opts);
+  const bodies = graph.nodes.map((node) => {
+    const body = {
+      id: node.id,
+      x: center(node.bounds, "x"),
+      y: center(node.bounds, "y"),
+      hw: node.bounds.width / 2,
+      hh: node.bounds.height / 2
+    };
+    if (pinned.has(node.id)) {
+      body.fx = body.x;
+      body.fy = body.y;
     }
-    along += depth + (gaps[i] ?? 0);
-  }
-  const placed = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    const slot = slots.get(node.id);
-    if (slot !== void 0) placed.set(node.id, worldOf(slot, extent(node.bounds, axes.rank), axes));
-  }
-  const moves = translated(graph, placed, pinned, opts.tolerance);
-  const offset = anchorOffset(graph, placed, pinned);
-  const displaced = /* @__PURE__ */ new Set();
-  for (const id of pinned) {
-    const at2 = placed.get(id);
-    const node = graph.node(id);
-    if (at2 === void 0 || node === void 0) continue;
-    if (Math.abs(at2.x + offset.x - node.bounds.x) > 0.5 || Math.abs(at2.y + offset.y - node.bounds.y) > 0.5) displaced.add(id);
-  }
-  const waypoints = /* @__PURE__ */ new Map();
-  const labels = /* @__PURE__ */ new Map();
-  const rankOf = /* @__PURE__ */ new Map();
-  rows.forEach((row, r) => row.forEach((n) => rankOf.set(n.id, r)));
-  const reach = boxReach(graph, rows, axes);
-  const widthOf = new Map(rows.flat().map((n) => [n.id, extent(n.bounds, axes.cross)]));
-  for (const [edge, chain2] of expanded.chains) {
-    if (chain2.ends.some((id) => displaced.has(id))) continue;
-    const beside = chain2.ids.indexOf(expanded.labels.get(edge) ?? "");
-    const points = [];
-    for (const id of chain2.ids) {
-      const cross = crossAt.get(id) + (expanded.wires.get(id) ?? widthOf.get(id) / 2);
-      const r = rankOf.get(id);
-      const [lo, hi] = [bands[r][0] - reach.lo[r], bands[r][1] + reach.hi[r]];
-      for (const rank of chain2.back ? [hi, lo] : [lo, hi]) {
-        const at2 = worldOf({ cross, rank }, 0, axes);
-        points.push({ x: at2.x + offset.x, y: at2.y + offset.y });
+    return body;
+  });
+  separate(bodies);
+  const byId = new Map(bodies.map((b) => [b.id, b]));
+  const centroid = {
+    x: bodies.reduce((sum, b) => sum + b.x, 0) / bodies.length,
+    y: bodies.reduce((sum, b) => sum + b.y, 0) / bodies.length
+  };
+  const groups = graph.groups ?? [];
+  const sim = createSimulation({
+    nodes: bodies,
+    forces: [
+      charge(bodies, chargeStrength),
+      links(byId, graph, linkDistance, linkStrength),
+      gravity(bodies, centroid, gravityStrength),
+      separateBoxes(bodies, padding),
+      ...groups.length > 0 ? [groupCohesion(groups, byId, groupStrength), separateGroups(groups, bodies, byId, padding)] : []
+    ]
+  });
+  return {
+    bodies,
+    byId,
+    pinned,
+    sim,
+    placed() {
+      const placed = /* @__PURE__ */ new Map();
+      for (const node of graph.nodes) {
+        const body = byId.get(node.id);
+        placed.set(node.id, {
+          x: body.x - node.bounds.width / 2,
+          y: body.y - node.bounds.height / 2
+        });
       }
+      return placed;
     }
-    waypoints.set(edge, points);
-    if (beside >= 0) {
-      const [a, b] = [points[beside * 2], points[beside * 2 + 1]];
-      labels.set(edge, { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 });
-    }
-  }
-  const ports = layeredPorts(graph, ranks, opts.direction);
-  const boxes = new Map(graph.nodes.map((n) => [n.id, { ...n.bounds, ...moves.get(n.id) }]));
-  const level = levelRoutes({ graph, boxes, axes, rankGap, ...opts.direction !== void 0 ? { direction: opts.direction } : {} });
-  for (const [edge, named2] of level.ports) {
-    ports.set(edge, named2);
-    waypoints.delete(edge);
-    labels.delete(edge);
-  }
-  for (const [edge, points] of level.waypoints) waypoints.set(edge, points);
-  return { moves, ranks, back, waypoints, labels, ports, unheld };
+  };
+}
+var force = (graph, opts = {}) => {
+  if (graph.nodes.length === 0) return /* @__PURE__ */ new Map();
+  const relaxation = forceRelaxation(graph, opts);
+  relaxation.sim.tick(opts.iterations ?? DEFAULTS.iterations);
+  return translated(graph, relaxation.placed(), relaxation.pinned, opts.tolerance);
+};
+function separate(bodies) {
+  const seen = /* @__PURE__ */ new Map();
+  bodies.forEach((body, i) => {
+    const key = `${body.x},${body.y}`;
+    const nth = seen.get(key) ?? 0;
+    seen.set(key, nth + 1);
+    if (nth === 0 || body.fx != null || body.fy != null) return;
+    const angle = GOLDEN * i;
+    const radius = NUDGE2 * nth;
+    body.x += Math.cos(angle) * radius;
+    body.y += Math.sin(angle) * radius;
+  });
 }
-
-// src/layered.ts
-var layered = Object.assign(
-  (graph, opts = {}) => layeredPlan(graph, opts).moves,
-  { plan: layeredPlan }
-);
 
 // src/chainGroups.ts
 function depths(groups) {
@@ -3446,8 +3567,8 @@ function nearest(members, from, index) {
   }
   return best;
 }
-function clearColumns(graph, ordered, index, owner, start) {
-  const level = new Map(start);
+function clearColumns(graph, ordered, index, owner, start2) {
+  const level = new Map(start2);
   const columns = /* @__PURE__ */ new Map();
   for (const node of graph.nodes) {
     if (index.has(node.id)) continue;
@@ -3482,19 +3603,19 @@ function lineGaps(graph, line, hanging, rankGap, axes, packed) {
   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 levels2 = Array.from(levelSize, () => []);
+  for (const node of graph.nodes) (levels2[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) => {
+  return bandGaps(graph, levels2, 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) {
+function bandGaps(graph, bands, axes, gaps, start2) {
   const insets = rankGaps(graph, bands, axes, 0);
   const out = gaps.map((gap, i) => gap + (insets[i] ?? 0));
   const groups = graph.groups ?? [];
@@ -3507,7 +3628,7 @@ function bandGaps(graph, bands, axes, gaps, start) {
   const span = (id, now) => {
     let [lo, hi] = [Infinity, -Infinity];
     for (const m of byId.get(id).members) {
-      const at2 = start(m);
+      const at2 = start2(m);
       const band = bandOf.get(m);
       const node = graph.node(m);
       if (at2 === void 0 || band === void 0 || node === void 0) continue;
@@ -3517,7 +3638,7 @@ function bandGaps(graph, bands, axes, gaps, start) {
     return { lo, hi };
   };
   widenForMinWidth(deepestFirst(groups).map((g) => {
-    const placed = g.members.flatMap((id) => bandOf.has(id) && start(id) !== void 0 ? [bandOf.get(id)] : []);
+    const placed = g.members.flatMap((id) => bandOf.has(id) && start2(id) !== void 0 ? [bandOf.get(id)] : []);
     return {
       id: g.id,
       ...g.minWidth !== void 0 ? { minWidth: g.minWidth } : {},
@@ -3589,8 +3710,8 @@ function sidesOf2(graph, hanging, moves, axes, before) {
   return byLine;
 }
 var SIDE_TRACK_GAP = 12;
-function turning(sides) {
-  const sideways = sides.filter((s) => Math.abs(s.hung - s.port) > 0.5);
+function turning(sides2) {
+  const sideways = sides2.filter((s) => Math.abs(s.hung - s.port) > 0.5);
   return [
     sideways.filter((s) => s.hung < s.port).sort((a, b) => a.port - b.port),
     sideways.filter((s) => s.hung > s.port).sort((a, b) => b.port - a.port)
@@ -3598,18 +3719,18 @@ function turning(sides) {
 }
 function tracksNeeded(graph, hanging, moves, axes, before) {
   let most = 0;
-  for (const sides of sidesOf2(graph, hanging, moves, axes, before).values()) {
-    const [low, high] = turning(sides);
+  for (const sides2 of sidesOf2(graph, hanging, moves, axes, before).values()) {
+    const [low, high] = turning(sides2);
     most = Math.max(most, low.length, high.length);
   }
   return most;
 }
 function sideRoutes(graph, hanging, moves, axes, before) {
   const out = /* @__PURE__ */ new Map();
-  for (const sides of sidesOf2(graph, hanging, moves, axes, before).values()) {
-    const [low, high] = turning(sides);
-    const lineEdge = sides[0].lineEdge;
-    const hungEdge = before ? Math.max(...sides.map((s) => s.hungEdge)) : Math.min(...sides.map((s) => s.hungEdge));
+  for (const sides2 of sidesOf2(graph, hanging, moves, axes, before).values()) {
+    const [low, high] = turning(sides2);
+    const lineEdge = sides2[0].lineEdge;
+    const hungEdge = before ? Math.max(...sides2.map((s) => s.hungEdge)) : Math.min(...sides2.map((s) => s.hungEdge));
     const step = (hungEdge - lineEdge) / (Math.max(low.length, high.length) + 1);
     for (const run of [low, high]) {
       run.forEach((s, k) => {
@@ -3661,12 +3782,12 @@ function lineOf(graph, ids) {
   if (given.length > 0) return given;
   const back = backEdges(graph);
   const ranks = ranksOf(graph, back);
-  let end;
+  let end2;
   for (const node of graph.nodes) {
-    if (end === void 0 || ranks.get(node.id) > ranks.get(end.id)) end = node;
+    if (end2 === void 0 || ranks.get(node.id) > ranks.get(end2.id)) end2 = node;
   }
   const line = [];
-  for (let at2 = end; at2 !== void 0; ) {
+  for (let at2 = end2; at2 !== void 0; ) {
     line.unshift(at2);
     const rank = ranks.get(at2.id);
     const edge = graph.incoming(at2.id).find((e) => !back.has(e.id) && ranks.get(e.from) === rank - 1);
@@ -3728,10 +3849,10 @@ function chainPlan(graph, opts = {}) {
   };
   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 place2 = (side2) => settle(graph, slots(gaps, across(side2)), opts);
+  let moves = place2(nodeGap);
   const side = (tracksNeeded(graph, hanging, moves, axes, before) + 1) * SIDE_TRACK_GAP;
-  if (side > nodeGap) moves = place(side);
+  if (side > nodeGap) moves = place2(side);
   return { moves, waypoints: sideRoutes(graph, hanging, moves, axes, before) };
 }
 function slotsFor(line, rows, levelSize, axes, gaps, before) {
@@ -3766,6 +3887,97 @@ function slotsFor(line, rows, levelSize, axes, gaps, before) {
   return slots;
 }
 
+// src/grid.ts
+function levels(graph) {
+  const order = graphOrder(graph);
+  const groups = graph.groups ?? [];
+  const first = new Map(groups.map((g) => [g.id, Math.min(...g.members.map(order))]));
+  const at2 = (id) => first.get(id) ?? order(id);
+  const out = /* @__PURE__ */ new Map();
+  const add = (level, id) => out.set(level, [...out.get(level) ?? [], id]);
+  for (const n of graph.nodes) add(n.group ?? null, n.id);
+  for (const g of groups) add(g.parent ?? null, g.id);
+  for (const ids of out.values()) ids.sort((a, b) => at2(a) - at2(b));
+  return out;
+}
+function deal(ids, sizeOf, columns, grid2) {
+  const items = [];
+  let row = 0;
+  let col = 0;
+  for (const id of ids) {
+    col += Math.max(0, Math.floor(grid2.skips?.[id] ?? 0));
+    row += Math.floor(col / columns);
+    col %= columns;
+    const span = Math.min(columns, Math.max(1, Math.floor(grid2.spans?.[id] ?? 1)));
+    if (col + span > columns) {
+      row++;
+      col = 0;
+    }
+    items.push({ id, size: sizeOf(id), row, col, span });
+    col += span;
+  }
+  return { items, columns };
+}
+function place(cells, gap, rowGap) {
+  const width = Math.max(0, ...cells.items.map((i) => (i.size.width - (i.span - 1) * gap) / i.span));
+  const rows = [];
+  for (const i of cells.items) rows[i.row] = Math.max(rows[i.row] ?? 0, i.size.height);
+  const tops = [];
+  let y = 0;
+  for (let r = 0; r < rows.length; r++) {
+    tops[r] = y;
+    y += (rows[r] ?? 0) + rowGap;
+  }
+  const at2 = /* @__PURE__ */ new Map();
+  for (const i of cells.items) {
+    const across = i.span * width + (i.span - 1) * gap;
+    at2.set(i.id, { x: i.col * (width + gap) + (across - i.size.width) / 2, y: tops[i.row] + ((rows[i.row] ?? 0) - i.size.height) / 2 });
+  }
+  const used = Math.max(0, ...cells.items.map((i) => i.col + i.span));
+  return { at: at2, size: { width: used === 0 ? 0 : used * width + (used - 1) * gap, height: rows.length === 0 ? 0 : y - rowGap } };
+}
+var grid = (graph, opts = {}) => {
+  const gap = opts.nodeGap ?? DEFAULT_NODE_GAP;
+  const rowGap = opts.rankGap ?? gap;
+  const spec = opts.grid ?? {};
+  const byLevel = levels(graph);
+  const groups = new Map((graph.groups ?? []).map((g) => [g.id, g]));
+  const inner = /* @__PURE__ */ new Map();
+  const sizeOf = (id) => {
+    const g = groups.get(id);
+    if (g === void 0) return graph.node(id).bounds;
+    const laid = layOut(id);
+    return {
+      width: Math.max(g.minWidth ?? 0, laid.size.width + g.inset.left + g.inset.right),
+      height: laid.size.height + g.inset.top + g.inset.bottom
+    };
+  };
+  const layOut = (level) => {
+    const done = level === null ? void 0 : inner.get(level);
+    if (done !== void 0) return done;
+    const ids = byLevel.get(level) ?? [];
+    const columns = Math.max(1, Math.floor((level === null ? spec.columns : spec.groupColumns?.[level]) ?? ids.length));
+    const laid = place(deal(ids, sizeOf, columns, spec), gap, rowGap);
+    if (level !== null) inner.set(level, laid);
+    return laid;
+  };
+  const placed = /* @__PURE__ */ new Map();
+  const put = (level, origin) => {
+    for (const [id, p] of layOut(level).at) {
+      const corner = { x: origin.x + p.x, y: origin.y + p.y };
+      const g = groups.get(id);
+      if (g === void 0) {
+        placed.set(id, corner);
+        continue;
+      }
+      const slack = sizeOf(id).width - (inner.get(id).size.width + g.inset.left + g.inset.right);
+      put(id, { x: corner.x + g.inset.left + slack / 2, y: corner.y + g.inset.top });
+    }
+  };
+  put(null, { x: 0, y: 0 });
+  return translated(graph, placed, pinnedSet(graph, opts), opts.tolerance);
+};
+
 // src/tree.ts
 function forestOf(graph, crossAxis) {
   const order = graphOrder(graph);
@@ -3866,6 +4078,94 @@ var treeOnce = (graph, opts = {}) => {
   return settle(graph, slots, opts);
 };
 
-export { COMPASS, DEFAULT_GROUP_INSET, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DEVICE_SIZE, DIAGRAM_TRAIT_KEY, DIVIDER_HEIGHT, EVENT_SIZE, GATEWAY_SIZE, 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, outlineDetail, outlineFromD, outlinePath, outlinePolyline, packAcross, packClusters, pinnedSet, planOf, plannerPlan, portLabelBox, portLabelsOf, portOf, portSitesOf, portsOf, portsOnOutline, rankGaps, ranksByLength, ranksOf, rayHit, registerOutline, resolveOutline, routeHolds, rowHeights, samePoints, seededOrder, settle, sizeToBody, subpathOf, subtreeBlocks, translated, tree, untilSettled, widenForMinWidth };
-//# sourceMappingURL=chunk-FDCODMFW.js.map
-//# sourceMappingURL=chunk-FDCODMFW.js.map
+// src/radial.ts
+var radial = (graph, opts = {}) => {
+  const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;
+  const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;
+  const { roots, children } = forestOf(graph, "y");
+  const blocks = subtreeBlocks(children, "y", nodeGap);
+  const order = graphOrder(graph);
+  const placed = /* @__PURE__ */ new Map();
+  let top = 0;
+  for (const root of roots) {
+    const tree2 = mindMap(root, children, order, blocks, nodeGap, rankGap);
+    for (const [id, p] of tree2.at) placed.set(id, { x: p.x, y: p.y - tree2.top + top });
+    top += tree2.bottom - tree2.top + nodeGap;
+  }
+  return translated(graph, placed, pinnedSet(graph, opts), opts.tolerance);
+};
+function mindMap(root, children, order, blocks, nodeGap, rankGap) {
+  const at2 = /* @__PURE__ */ new Map([[root.id, { x: -root.bounds.width / 2, y: -root.bounds.height / 2 }]]);
+  let top = -root.bounds.height / 2;
+  let bottom = root.bounds.height / 2;
+  const [right, left] = sides(root, children, order);
+  for (const [sign, branches] of [[1, right], [-1, left]]) {
+    if (branches.length === 0) continue;
+    const span = branches.reduce((sum, b) => sum + blocks.span(b), 0) + (branches.length - 1) * nodeGap;
+    const ys = /* @__PURE__ */ new Map();
+    let cursor = -span / 2;
+    for (const branch of branches) {
+      blocks.lay(branch, cursor, ys);
+      cursor += blocks.span(branch) + nodeGap;
+    }
+    top = Math.min(top, -span / 2);
+    bottom = Math.max(bottom, span / 2);
+    for (const [id, x] of sideColumns(branches, children, root.bounds.width / 2 + rankGap, rankGap, sign)) {
+      at2.set(id, { x, y: ys.get(id) });
+    }
+  }
+  return { at: at2, top, bottom };
+}
+function sides(root, children, order) {
+  const weight = (node) => 1 + (children.get(node.id) ?? []).reduce((sum, k) => sum + weight(k), 0);
+  const kids = children.get(root.id) ?? [];
+  const half = root.bounds.width / 2;
+  const mid = root.bounds.x + half;
+  const standing = (k) => {
+    const c = k.bounds.x + k.bounds.width / 2 - mid;
+    return c > half ? 1 : c < -half ? -1 : 0;
+  };
+  const stands = new Map(kids.map((k) => [k, standing(k)]));
+  const arranged = [...stands.values()].includes(1) && [...stands.values()].includes(-1);
+  const right = /* @__PURE__ */ new Set();
+  let r = 0;
+  let l = 0;
+  const dealt = arranged ? kids.filter((k) => stands.get(k) !== 0) : [];
+  for (const k of dealt) {
+    if (stands.get(k) === 1) {
+      right.add(k);
+      r += weight(k);
+    } else l += weight(k);
+  }
+  for (const child of kids.filter((k) => !dealt.includes(k)).sort((a, b) => order(a.id) - order(b.id))) {
+    const w = weight(child);
+    if (r <= l) {
+      right.add(child);
+      r += w;
+    } else l += w;
+  }
+  return [kids.filter((k) => right.has(k)), kids.filter((k) => !right.has(k))];
+}
+function sideColumns(branches, children, from, rankGap, sign) {
+  const rows = [];
+  const visit = (node, depth) => {
+    (rows[depth] ??= []).push(node);
+    for (const kid of children.get(node.id) ?? []) visit(kid, depth + 1);
+  };
+  for (const branch of branches) visit(branch, 0);
+  const xs = /* @__PURE__ */ new Map();
+  let start2 = from;
+  for (const row of rows) {
+    const band = Math.max(...row.map((n) => n.bounds.width));
+    for (const node of row) {
+      const near = start2 + (band - node.bounds.width) / 2;
+      xs.set(node.id, sign === 1 ? near : -near - node.bounds.width);
+    }
+    start2 += band + rankGap;
+  }
+  return xs;
+}
+
+export { COMPASS, DEFAULT_GROUP_INSET, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DEVICE_SIZE, DIAGRAM_TRAIT_KEY, DIVIDER_HEIGHT, EVENT_SIZE, GATEWAY_SIZE, 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, grid, grownBy, insetOf, isPinned, isPromise, labelCenter, labelSpotAt, layered, layeredPlan, layeredRoutes, layoutBody, layoutOwnsPort, layoutOwnsRoute, layoutRowPorts, layoutWritesRoute, marginOf, measureBody, outlineDetail, outlineFromD, outlinePath, outlinePolyline, outlineSolid, packAcross, packClusters, pinnedSet, planOf, plannerPlan, portLabelBox, portLabelsOf, portOf, portSitesOf, portsOf, portsOnOutline, radial, rankGaps, ranksByLength, ranksOf, rayHit, registerOutline, resolveOutline, routeHolds, rowHeights, samePoints, seededOrder, settle, sizeToBody, subpathOf, subtreeBlocks, translated, tree, untilSettled, widenForMinWidth };
+//# sourceMappingURL=chunk-7BV2MBED.js.map
+//# sourceMappingURL=chunk-7BV2MBED.js.map