@weasel-js/diagram 1.10.1 → 1.11.0

package/dist/chunk-NUMMW5BI.js

@@ -0,0 +1,2865 @@
+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 { cssFamilyName } from '@weasel-js/font/metrics';
+import { createSimulation } from '@weasel-js/simulation';
+
+// src/outline.ts
+var LEAN = 0.2;
+var POINT = 0.2;
+var KAPPA = 0.5522847498307936;
+function outlinePath(outline, bounds) {
+  const { x, y, width: w, height: h } = bounds;
+  if (w <= 0 || h <= 0) return rectPath(x, y, Math.max(w, 0), Math.max(h, 0));
+  if (typeof outline !== "string") return transformPath(outline, [w, 0, 0, h, x, y]);
+  switch (outline) {
+    case "rect":
+      return rectPath(x, y, w, h);
+    case "diamond":
+      return polygonFromPoints([
+        { x: x + w / 2, y },
+        { x: x + w, y: y + h / 2 },
+        { x: x + w / 2, y: y + h },
+        { x, y: y + h / 2 }
+      ]);
+    case "parallelogram": {
+      const lean = Math.min(w * LEAN, w / 2);
+      return polygonFromPoints([
+        { x: x + lean, y },
+        { x: x + w, y },
+        { x: x + w - lean, y: y + h },
+        { x, y: y + h }
+      ]);
+    }
+    case "trapezoid":
+      return polygonFromPoints([
+        { x, y: y + h / 4 },
+        { x: x + w, y },
+        { x: x + w, y: y + h },
+        { x, y: y + h * 3 / 4 }
+      ]);
+    case "hexagon":
+      return polygonFromPoints([
+        { x, y: y + h / 2 },
+        { x: x + w * POINT, y },
+        { x: x + w * (1 - POINT), y },
+        { x: x + w, y: y + h / 2 },
+        { x: x + w * (1 - POINT), y: y + h },
+        { x: x + w * POINT, y: y + h }
+      ]);
+    case "stadium":
+      return stadiumPath(x, y, w, h);
+  }
+}
+function stadiumPath(x, y, w, h) {
+  const r = Math.min(w, h) / 2;
+  const k = r * KAPPA;
+  const b = new PathBuilder();
+  if (w >= h) {
+    const left2 = x + r;
+    const right2 = x + w - r;
+    const top2 = y;
+    const bottom2 = y + h;
+    const midY = y + h / 2;
+    return b.moveTo(left2, top2).lineTo(right2, top2).curveTo(right2 + k, top2, x + w, midY - k, x + w, midY).curveTo(x + w, midY + k, right2 + k, bottom2, right2, bottom2).lineTo(left2, bottom2).curveTo(left2 - k, bottom2, x, midY + k, x, midY).curveTo(x, midY - k, left2 - k, top2, left2, top2).close().build();
+  }
+  const top = y + r;
+  const bottom = y + h - r;
+  const left = x;
+  const right = x + w;
+  const midX = x + w / 2;
+  return b.moveTo(right, top).lineTo(right, bottom).curveTo(right, bottom + k, midX + k, y + h, midX, y + h).curveTo(midX - k, y + h, left, bottom + k, left, bottom).lineTo(left, top).curveTo(left, top - k, midX - k, y, midX, y).curveTo(midX + k, y, right, top - k, right, top).close().build();
+}
+function contentBox(outline, bounds) {
+  if (typeof outline !== "string") return bounds;
+  const { x, y, width: w, height: h } = bounds;
+  switch (outline) {
+    case "rect":
+      return bounds;
+    case "diamond":
+      return { x: x + w / 4, y: y + h / 4, width: w / 2, height: h / 2 };
+    case "parallelogram": {
+      const lean = Math.min(w * LEAN, w / 2);
+      return { x: x + lean, y, width: Math.max(w - lean * 2, 0), height: h };
+    }
+    case "trapezoid":
+      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 "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) };
+    }
+  }
+}
+function boxForContent(outline, content) {
+  if (typeof outline !== "string") return content;
+  switch (outline) {
+    case "rect":
+      return content;
+    case "diamond":
+      return { width: content.width * 2, height: content.height * 2 };
+    case "parallelogram":
+      return { width: content.width / (1 - LEAN * 2), height: content.height };
+    case "trapezoid":
+      return { width: content.width, height: content.height * 2 };
+    case "hexagon":
+      return { width: content.width / (1 - POINT * 2), height: content.height };
+    case "stadium":
+      return { width: content.width + content.height, height: content.height };
+  }
+}
+var TOLERANCE = 0.25;
+function outlinePolyline(outline, bounds) {
+  const path = outlinePath(outline, bounds);
+  return flattenPath(path);
+}
+function flattenPath(path) {
+  if (path.kind === "rect") {
+    const { x, y, width: w, height: h } = path;
+    return [x, y, x + w, y, x + w, y + h, x, y + h, x, y];
+  }
+  const out = [];
+  const { commands, coords } = path;
+  let ci = 0;
+  let cx = 0;
+  let cy = 0;
+  let sx = 0;
+  let sy = 0;
+  for (const cmd of commands) {
+    if (cmd === PATH_M) {
+      cx = coords[ci];
+      cy = coords[ci + 1];
+      ci += 2;
+      sx = cx;
+      sy = cy;
+      out.push(cx, cy);
+    } else if (cmd === PATH_L) {
+      cx = coords[ci];
+      cy = coords[ci + 1];
+      ci += 2;
+      out.push(cx, cy);
+    } else if (cmd === PATH_C) {
+      const x1 = coords[ci], y1 = coords[ci + 1];
+      const x2 = coords[ci + 2], y2 = coords[ci + 3];
+      const x3 = coords[ci + 4], y3 = coords[ci + 5];
+      ci += 6;
+      flattenCubic(cx, cy, x1, y1, x2, y2, x3, y3, TOLERANCE, out);
+      cx = x3;
+      cy = y3;
+    } else if (cmd === PATH_Q) {
+      const qx = coords[ci], qy = coords[ci + 1];
+      const x3 = coords[ci + 2], y3 = coords[ci + 3];
+      ci += 4;
+      flattenCubic(
+        cx,
+        cy,
+        cx + 2 / 3 * (qx - cx),
+        cy + 2 / 3 * (qy - cy),
+        x3 + 2 / 3 * (qx - x3),
+        y3 + 2 / 3 * (qy - y3),
+        x3,
+        y3,
+        TOLERANCE,
+        out
+      );
+      cx = x3;
+      cy = y3;
+    } else if (cmd === PATH_Z) {
+      out.push(sx, sy);
+      cx = sx;
+      cy = sy;
+    }
+  }
+  if (out.length >= 2 && (out[0] !== out[out.length - 2] || out[1] !== out[out.length - 1])) {
+    out.push(out[0], out[1]);
+  }
+  return out;
+}
+function rayHit(poly, center2, point) {
+  const dx = point.x - center2.x;
+  const dy = point.y - center2.y;
+  if (dx === 0 && dy === 0) return null;
+  let bestT = -Infinity;
+  let hit = null;
+  for (let i = 0; i + 3 < poly.length; i += 2) {
+    const ax = poly[i], ay = poly[i + 1];
+    const bx = poly[i + 2], by = poly[i + 3];
+    const ex = bx - ax;
+    const ey = by - ay;
+    const denom = dx * ey - dy * ex;
+    if (denom === 0) continue;
+    const t = ((ax - center2.x) * ey - (ay - center2.y) * ex) / denom;
+    const u = ((ax - center2.x) * dy - (ay - center2.y) * dx) / denom;
+    if (t < 0 || u < 0 || u > 1) continue;
+    if (t > bestT) {
+      bestT = t;
+      hit = { x: center2.x + dx * t, y: center2.y + dy * t };
+    }
+  }
+  return hit;
+}
+function portsOnOutline(ports, outline, bounds) {
+  if (bounds.width <= 0 || bounds.height <= 0) return [...ports];
+  const poly = outlinePolyline(outline, bounds);
+  const center2 = { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
+  return ports.map((port) => {
+    const hit = rayHit(poly, center2, port.point);
+    return hit === null ? port : { ...port, point: hit };
+  });
+}
+
+// src/trait.ts
+var DIAGRAM_TRAIT_KEY = "diagram";
+var dataKeyReader = (node) => {
+  const data = node.data;
+  if (data === null || typeof data !== "object") return null;
+  const trait = data[DIAGRAM_TRAIT_KEY];
+  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;
+  return trait;
+};
+function createDiagramNodes(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (seen.has(entry.name)) {
+      throw new Error(`createDiagramNodes: duplicate entry name "${entry.name}"`);
+    }
+    seen.add(entry.name);
+  }
+  return (node) => {
+    const own = dataKeyReader(node);
+    if (own !== null) return own;
+    for (const entry of entries) {
+      if (!entry.matches(node.data)) continue;
+      return typeof entry.trait === "function" ? entry.trait(node.data) : entry.trait;
+    }
+    return null;
+  };
+}
+function diagramNodeOf(node, read = dataKeyReader) {
+  return read(node);
+}
+function isPinned(node, read) {
+  return diagramNodeOf(node, read)?.pinned === true;
+}
+var COMPASS = {
+  nw: { u: 0, v: 0 },
+  n: { u: 0.5, v: 0 },
+  ne: { u: 1, v: 0 },
+  e: { u: 1, v: 0.5 },
+  se: { u: 1, v: 1 },
+  s: { u: 0.5, v: 1 },
+  sw: { u: 0, v: 1 },
+  w: { u: 0, v: 0.5 }
+};
+var DEFAULT_PORTS = Object.freeze([
+  { id: "n", at: COMPASS.n },
+  { id: "e", at: COMPASS.e },
+  { id: "s", at: COMPASS.s },
+  { id: "w", at: COMPASS.w }
+]);
+function normalOf(at2) {
+  const x = at2.u * 2 - 1;
+  const y = at2.v * 2 - 1;
+  const len = Math.hypot(x, y);
+  if (len === 0) return null;
+  return { x: x / len, y: y / len };
+}
+function portsOf(node, pose, opts = {}) {
+  const placer = placerOf(node, pose, opts);
+  return placer === null ? [] : placer.specs.map((spec) => placer.place(spec, spec.at, spec.normal));
+}
+function portOf(node, pose, portId, opts = {}) {
+  return portsOf(node, pose, opts).find((p) => p.id === portId);
+}
+function portSitesOf(node, pose, portId, opts = {}) {
+  const placer = placerOf(node, pose, opts);
+  const spec = placer?.specs.find((s) => s.id === portId);
+  if (placer === null || spec === void 0) return [];
+  return [placer.place(spec, spec.at, spec.normal), ...(spec.sites ?? []).map((at2) => placer.place(spec, at2, at2.normal))];
+}
+function placerOf(node, pose, opts) {
+  const trait = diagramNodeOf(node, opts.read);
+  if (trait === null) return null;
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  const bounds = geometry.getBounds(pose);
+  const rotation = geometry.getRotation?.(pose) ?? 0;
+  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 anchored = {
+      x: bounds.x + at2.u * bounds.width,
+      y: bounds.y + at2.v * bounds.height
+    };
+    const flat = (poly === null ? null : rayHit(poly, { x: cx, y: cy }, anchored)) ?? anchored;
+    const normal = given === void 0 ? normalOf(at2) : given;
+    if (rotation === 0) {
+      return { id: spec.id, nodeId: node.id, point: flat, normal, ...extrasOf(spec) };
+    }
+    return {
+      id: spec.id,
+      nodeId: node.id,
+      point: rotatePoint(flat.x, flat.y, cx, cy, rotation),
+      // A direction rotates about the origin, not about the node's center.
+      normal: normal === null ? null : rotatePoint(normal.x, normal.y, 0, 0, rotation),
+      ...extrasOf(spec)
+    };
+  };
+  return { specs: trait.ports ?? DEFAULT_PORTS, place };
+}
+function extrasOf(spec) {
+  return {
+    ...spec.type === void 0 ? {} : { type: spec.type },
+    ...spec.label === void 0 ? {} : { label: spec.label }
+  };
+}
+
+// src/portLabels.ts
+var PORT_LABEL_GAP = 4;
+var EPS = 1e-6;
+function portLabelBox(port, size, gap = PORT_LABEL_GAP) {
+  const { point: p, normal: n } = port;
+  const { width, height } = size;
+  if (n === null) return { x: p.x - width / 2, y: p.y - gap - height, width, height };
+  const outX = n.x > 0 ? p.x + gap : p.x - gap - width;
+  const outY = n.y > 0 ? p.y + gap : p.y - gap - height;
+  const lean = Math.abs(n.x) - Math.abs(n.y);
+  if (lean > EPS) return { x: outX, y: p.y - gap / 2 - height, width, height };
+  if (lean < -EPS) return { x: p.x + gap / 2, y: outY, width, height };
+  return { x: outX, y: outY, width, height };
+}
+function portLabelsOf(trait, bounds, size) {
+  const out = [];
+  for (const port of portsOf({ id: "", kind: "container", data: null }, bounds, { read: () => trait })) {
+    if (port.label === void 0) continue;
+    const labeled = port;
+    out.push({ port: labeled, box: portLabelBox(labeled, size(labeled.label)) });
+  }
+  return out;
+}
+function marginOf(bounds, boxes) {
+  if (boxes.length === 0) return void 0;
+  const m = { top: 0, right: 0, bottom: 0, left: 0 };
+  for (const b of boxes) {
+    m.top = Math.max(m.top, bounds.y - b.y);
+    m.left = Math.max(m.left, bounds.x - b.x);
+    m.right = Math.max(m.right, b.x + b.width - (bounds.x + bounds.width));
+    m.bottom = Math.max(m.bottom, b.y + b.height - (bounds.y + bounds.height));
+  }
+  return m;
+}
+function withLabels(ports, labels) {
+  if (labels === void 0) return [...ports];
+  return ports.map((p) => Object.hasOwn(labels, p.id) ? { ...p, label: labels[p.id] } : p);
+}
+var DEFAULT_PADDING = 8;
+var DEFAULT_GAP = 4;
+var FALLBACK_LINE = 16;
+function canvasMeasure(ctx) {
+  return (text, style) => {
+    const size = style.fontSize ?? FALLBACK_LINE;
+    ctx.font = `${style.bold === true ? "bold " : ""}${size}px ${cssFamilyName(style.fontFamily ?? "sans-serif")}`;
+    return { width: ctx.measureText(text).width, height: Math.ceil(size * 1.2) };
+  };
+}
+function measureRow(row, measure) {
+  const text = (s, style) => measure === void 0 ? {
+    width: s.length * (style?.fontSize ?? FALLBACK_LINE) * 0.6,
+    height: style?.fontSize === void 0 ? FALLBACK_LINE : Math.ceil(style.fontSize * 1.2)
+  } : measure(s, style ?? {});
+  switch (row.kind) {
+    case "label":
+      return text(row.text, row.style);
+    case "field": {
+      const l = text(row.label, row.style);
+      const v = text(row.value, row.style);
+      const room = row.room === void 0 ? 0 : text(row.room, row.style).width;
+      return { width: l.width + DEFAULT_GAP * 2 + Math.max(v.width, room), height: Math.max(l.height, v.height) };
+    }
+    case "ports": {
+      const side = (ports) => (ports ?? []).reduce((w, p) => Math.max(w, p.label === void 0 ? 0 : text(p.label).width), 0);
+      const rows = Math.max(row.left?.length ?? 0, row.right?.length ?? 0, 1);
+      return {
+        width: side(row.left) + DEFAULT_GAP * 2 + side(row.right),
+        height: row.height ?? rows * FALLBACK_LINE
+      };
+    }
+    case "slot":
+      return { width: row.width ?? 0, height: row.height };
+  }
+}
+function measureBody(spec, measure) {
+  const padding = spec.padding ?? DEFAULT_PADDING;
+  const gap = spec.gap ?? DEFAULT_GAP;
+  let width = 0;
+  let height = 0;
+  for (const [i, row] of spec.rows.entries()) {
+    const m = measureRow(row, measure);
+    width = Math.max(width, m.width);
+    height += m.height + (i > 0 ? gap : 0);
+  }
+  const box = boxForContent(spec.outline, {
+    width: width + padding * 2,
+    height: height + padding * 2
+  });
+  return { minWidth: box.width, minHeight: box.height };
+}
+function sizeToBody(pose, floor) {
+  const width = Math.max(pose.width, floor.minWidth);
+  const height = Math.max(pose.height, floor.minHeight);
+  if (width === pose.width && height === pose.height) return pose;
+  return { ...pose, width, height };
+}
+function layoutBody(spec, bounds, measure) {
+  const padding = spec.padding ?? DEFAULT_PADDING;
+  const gap = spec.gap ?? DEFAULT_GAP;
+  const inner = contentBox(spec.outline, bounds);
+  const width = Math.max(inner.width - padding * 2, 0);
+  const heights = spec.rows.map((row) => measureRow(row, measure).height);
+  const used = heights.reduce((sum, h) => sum + h, 0) + gap * Math.max(heights.length - 1, 0);
+  const slack = Math.max(inner.height - padding * 2 - used, 0);
+  const share = { top: 0, center: 0.5, bottom: 1 }[spec.verticalAlign ?? "center"];
+  let y = inner.y + padding + slack * share;
+  return spec.rows.map((row, index) => {
+    const h = heights[index];
+    const w = row.kind === "slot" && row.width !== void 0 ? Math.min(row.width, width) : width;
+    const box = { row, index, x: inner.x + padding + (width - w) / 2, y, width: w, height: h };
+    y += h + gap;
+    return box;
+  });
+}
+function layoutRowPorts(row, box, measure) {
+  const width = (label) => label === void 0 ? 0 : measureRow({ kind: "label", text: label }, measure).width;
+  const slots = Math.max(row.left?.length ?? 0, row.right?.length ?? 0, 1);
+  const slotHeight = box.height / slots;
+  const out = [];
+  const side = (ports, which) => {
+    for (const [index, port] of (ports ?? []).entries()) {
+      const w = width(port.label);
+      out.push({
+        port,
+        side: which,
+        index,
+        x: which === "left" ? box.x : box.x + box.width - w,
+        y: box.y + index * slotHeight,
+        width: w,
+        height: slotHeight
+      });
+    }
+  };
+  side(row.left, "left");
+  side(row.right, "right");
+  return out;
+}
+function bodyTrait(spec, bounds, measure) {
+  const outline = spec.outline;
+  const compass = withLabels(spec.ports ?? DEFAULT_PORTS, spec.portLabels);
+  if (bounds.height <= 0) return { outline, ports: compass };
+  const rowPorts = [];
+  let hasLeft = false;
+  let hasRight = false;
+  for (const box of layoutBody(spec, bounds, measure)) {
+    if (box.row.kind !== "ports") continue;
+    for (const pb of layoutRowPorts(box.row, box, measure)) {
+      if (pb.side === "left") hasLeft = true;
+      else hasRight = true;
+      const v = (pb.y + pb.height / 2 - bounds.y) / bounds.height;
+      rowPorts.push(withType(
+        { id: pb.port.id, at: { u: pb.side === "left" ? 0 : 1, v } },
+        pb.port.type
+      ));
+    }
+  }
+  const kept = spec.ports !== void 0 ? compass : compass.filter((p) => !(p.id === "w" && hasLeft) && !(p.id === "e" && hasRight));
+  const trait = { outline, ports: [...kept, ...rowPorts] };
+  const margin = marginOf(bounds, portLabelsOf(trait, bounds, labelSize(measure)).map((l) => l.box));
+  return margin === void 0 ? trait : { ...trait, margin };
+}
+var labelSize = (measure) => (text) => measureRow({ kind: "label", text }, measure);
+function withType(spec, type) {
+  return type === void 0 ? spec : { ...spec, type };
+}
+function bodyOutline(spec, bounds) {
+  return outlinePath(spec.outline, bounds);
+}
+function buildBody(spec, at2, opts) {
+  const pose = sizeToBody(at2, measureBody(spec, opts.measure));
+  const trait = bodyTrait(spec, pose, opts.measure);
+  const specs = [{
+    kind: "container",
+    layer: opts.layer,
+    pose,
+    data: opts.body(trait, pose),
+    ...opts.id === void 0 ? {} : { id: opts.id }
+  }];
+  const leaf = (box, data, rowId) => {
+    specs.push({
+      kind: "leaf",
+      layer: opts.layer,
+      pose: { ...pose, x: box.x, y: box.y, width: box.width, height: box.height },
+      data,
+      pickable: false,
+      ...opts.id === void 0 ? {} : { parent: opts.id },
+      ...opts.id !== void 0 && rowId !== void 0 ? { id: `${opts.id}/${rowId}` } : {}
+    });
+  };
+  const portLabel = opts.portLabel;
+  for (const box of layoutBody(spec, pose, opts.measure)) {
+    const data = opts.row(rowText(box.row), box);
+    if (data !== null) leaf(box, data, "id" in box.row ? box.row.id : void 0);
+    if (portLabel === void 0 || box.row.kind !== "ports") continue;
+    for (const pb of layoutRowPorts(box.row, box, opts.measure)) {
+      if (pb.port.label === void 0) continue;
+      const labelData = portLabel(pb.port.label, pb);
+      if (labelData !== null) leaf(pb, labelData);
+    }
+  }
+  const perimeter = portLabel === void 0 ? [] : portLabelsOf(trait, pose, labelSize(opts.measure));
+  for (const { port, box } of perimeter) {
+    const labelData = portLabel(port.label, { ...box, port: trait.ports.find((p) => p.id === port.id), side: "outside" });
+    if (labelData !== null) leaf(box, labelData);
+  }
+  return { pose, specs };
+}
+function rowText(row) {
+  if (row.kind === "label") return row.text;
+  if (row.kind === "field") return `${row.label}: ${row.value}`;
+  return "";
+}
+
+// src/footprint.ts
+function anchorIn(box, p) {
+  return {
+    u: box.width > 0 ? (p.x - box.x) / box.width : 0.5,
+    v: box.height > 0 ? (p.y - box.y) / box.height : 0.5
+  };
+}
+function grownBy(bounds, margin) {
+  if (margin === void 0) return bounds;
+  return {
+    x: bounds.x - margin.left,
+    y: bounds.y - margin.top,
+    width: bounds.width + margin.left + margin.right,
+    height: bounds.height + margin.top + margin.bottom
+  };
+}
+function footprintNode(node) {
+  const m = node.margin;
+  if (m === void 0) return node;
+  const b = node.bounds;
+  const bounds = grownBy(b, m);
+  const specs = node.ports ?? DEFAULT_PORTS;
+  const trait = { ports: specs, ...node.outline !== void 0 ? { outline: node.outline } : {} };
+  const ports = specs.map((spec) => {
+    const [at2, ...sites] = portSitesOf({ id: node.id, kind: "leaf", data: null }, b, spec.id, { read: () => trait });
+    if (at2 === void 0) return spec;
+    return {
+      ...spec,
+      at: anchorIn(bounds, at2.point),
+      normal: at2.normal,
+      ...spec.sites !== void 0 ? { sites: sites.map((s) => ({ ...anchorIn(bounds, s.point), normal: s.normal })) } : {}
+    };
+  });
+  const { outline: _o, margin: _m, ...kept } = node;
+  return { ...kept, bounds, ports };
+}
+function planWithMargins(graph, plan) {
+  if (!graph.nodes.some((n) => n.margin !== void 0)) return plan(graph);
+  const nodes = graph.nodes.map(footprintNode);
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const back = (out2) => {
+    const moves = /* @__PURE__ */ new Map();
+    for (const [id, at2] of out2.moves) {
+      const m = graph.node(id)?.margin;
+      moves.set(id, m === void 0 ? at2 : { x: at2.x + m.left, y: at2.y + m.top });
+    }
+    return { ...out2, moves };
+  };
+  const out = plan({ ...graph, nodes, node: (id) => byId.get(id) });
+  return isPromise(out) ? out.then(back) : back(out);
+}
+var isPromise = (answer) => typeof answer?.then === "function";
+
+// src/layout.ts
+function planOf(layout, graph, opts) {
+  return planWithMargins(graph, (g) => layout.plan !== void 0 ? layout.plan(g, opts) : { moves: layout(g, opts) });
+}
+function plannerPlan(planner, graph, opts) {
+  return planWithMargins(graph, (g) => planner.plan(g, opts));
+}
+var DEFAULT_NODE_GAP = 48;
+var DEFAULT_RANK_GAP = 96;
+var DEFAULT_TOLERANCE = 1e-6;
+function axesFor(direction = "down") {
+  switch (direction) {
+    case "up":
+      return { rank: "y", cross: "x", sign: -1 };
+    case "right":
+      return { rank: "x", cross: "y", sign: 1 };
+    case "left":
+      return { rank: "x", cross: "y", sign: -1 };
+    default:
+      return { rank: "y", cross: "x", sign: 1 };
+  }
+}
+function extent(bounds, axis) {
+  return axis === "x" ? bounds.width : bounds.height;
+}
+function center(bounds, axis) {
+  return axis === "x" ? bounds.x + bounds.width / 2 : bounds.y + bounds.height / 2;
+}
+function pinnedSet(graph, opts = {}) {
+  const pinned = new Set(opts.pin ?? []);
+  for (const node of graph.nodes) {
+    if (node.pinned) pinned.add(node.id);
+  }
+  return pinned;
+}
+function settle(graph, slots, opts = {}) {
+  const axes = axesFor(opts.direction);
+  const pinned = pinnedSet(graph, opts);
+  const tolerance = opts.tolerance ?? DEFAULT_TOLERANCE;
+  const placed = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const slot = slots.get(node.id);
+    if (slot === void 0) continue;
+    placed.set(node.id, worldOf(slot, extent(node.bounds, axes.rank), axes));
+  }
+  return translated(graph, placed, pinned, tolerance);
+}
+function worldOf(slot, depth, axes) {
+  const along = axes.sign === 1 ? slot.rank : -(slot.rank + depth);
+  return axes.rank === "y" ? { x: slot.cross, y: along } : { x: along, y: slot.cross };
+}
+function untilSettled(once, graph, opts = {}, passes = 8) {
+  const first = once(graph, opts);
+  if (first.size === 0) return first;
+  const at2 = new Map(first);
+  for (let pass = 1; pass < passes; pass++) {
+    const nodes = graph.nodes.map((node) => {
+      const to = at2.get(node.id);
+      return to === void 0 ? node : { ...node, bounds: { ...node.bounds, x: to.x, y: to.y } };
+    });
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const next = once({ ...graph, nodes, node: (id) => byId.get(id) }, opts);
+    if (next.size === 0) break;
+    for (const [id, to] of next) at2.set(id, to);
+  }
+  const tolerance = opts.tolerance ?? DEFAULT_TOLERANCE;
+  const out = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const to = at2.get(node.id);
+    if (to === void 0) continue;
+    if (Math.abs(to.x - node.bounds.x) <= tolerance && Math.abs(to.y - node.bounds.y) <= tolerance) continue;
+    out.set(node.id, to);
+  }
+  return out;
+}
+function translated(graph, placed, pinned, tolerance = DEFAULT_TOLERANCE) {
+  const anchor = anchorOffset(graph, placed, pinned);
+  const out = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const at2 = placed.get(node.id);
+    if (at2 === void 0 || pinned.has(node.id)) continue;
+    const x = at2.x + anchor.x;
+    const y = at2.y + anchor.y;
+    if (Math.abs(x - node.bounds.x) <= tolerance && Math.abs(y - node.bounds.y) <= tolerance) {
+      continue;
+    }
+    out.set(node.id, { x, y });
+  }
+  return out;
+}
+function anchorOffset(graph, placed, pinned) {
+  for (const node of graph.nodes) {
+    if (!pinned.has(node.id)) continue;
+    const at2 = placed.get(node.id);
+    if (at2 !== void 0) return { x: node.bounds.x - at2.x, y: node.bounds.y - at2.y };
+  }
+  let minCurX = Infinity;
+  let minCurY = Infinity;
+  let minNewX = Infinity;
+  let minNewY = Infinity;
+  for (const node of graph.nodes) {
+    const at2 = placed.get(node.id);
+    if (at2 === void 0) continue;
+    minCurX = Math.min(minCurX, node.bounds.x);
+    minCurY = Math.min(minCurY, node.bounds.y);
+    minNewX = Math.min(minNewX, at2.x);
+    minNewY = Math.min(minNewY, at2.y);
+  }
+  if (!Number.isFinite(minCurX)) return { x: 0, y: 0 };
+  return { x: minCurX - minNewX, y: minCurY - minNewY };
+}
+function packAcross(nodes, axis, gap) {
+  const at2 = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  for (const node of nodes) {
+    at2.set(node.id, cursor);
+    cursor += extent(node.bounds, axis) + gap;
+  }
+  return { at: at2, span: nodes.length === 0 ? 0 : cursor - gap };
+}
+function seededOrder(nodes, axis, indexOf) {
+  return [...nodes].sort((a, b) => {
+    const d = center(a.bounds, axis) - center(b.bounds, axis);
+    return d !== 0 ? d : indexOf(a.id) - indexOf(b.id);
+  });
+}
+function graphOrder(graph) {
+  const index = /* @__PURE__ */ new Map();
+  graph.nodes.forEach((node, i) => index.set(node.id, i));
+  return (id) => index.get(id) ?? Number.MAX_SAFE_INTEGER;
+}
+
+// src/cluster.ts
+function insetOf(inset) {
+  if (typeof inset === "number") return { top: inset, right: inset, bottom: inset, left: inset };
+  return {
+    top: inset?.top ?? DEFAULT_GROUP_INSET,
+    right: inset?.right ?? DEFAULT_GROUP_INSET,
+    bottom: inset?.bottom ?? DEFAULT_GROUP_INSET,
+    left: inset?.left ?? DEFAULT_GROUP_INSET
+  };
+}
+var DEFAULT_GROUP_INSET = 12;
+function canonical(inset, axes) {
+  if (axes.rank === "y") {
+    return axes.sign === 1 ? { crossLo: inset.left, crossHi: inset.right, rankLo: inset.top, rankHi: inset.bottom } : { crossLo: inset.left, crossHi: inset.right, rankLo: inset.bottom, rankHi: inset.top };
+  }
+  return axes.sign === 1 ? { crossLo: inset.top, crossHi: inset.bottom, rankLo: inset.left, rankHi: inset.right } : { crossLo: inset.top, crossHi: inset.bottom, rankLo: inset.right, rankHi: inset.left };
+}
+function crossInset(inset, axes) {
+  const c = canonical(inset, axes);
+  return { lo: c.crossLo, hi: c.crossHi };
+}
+function rankGaps(graph, rows, axes, rankGap) {
+  const gaps = rows.slice(1).map(() => rankGap);
+  const ends2 = /* @__PURE__ */ new Map();
+  const starts = /* @__PURE__ */ new Map();
+  const reach = (span, side) => {
+    const own = canonical(span.group.inset, axes)[side === "lo" ? "rankLo" : "rankHi"];
+    const flush = span.children.filter((c) => c[side] === span[side]);
+    return own + Math.max(0, ...flush.map((c) => reach(c, side)));
+  };
+  for (const span of groupSpans(graph, rows)) {
+    ends2.set(span.hi, Math.max(ends2.get(span.hi) ?? 0, reach(span, "hi")));
+    starts.set(span.lo, Math.max(starts.get(span.lo) ?? 0, reach(span, "lo")));
+  }
+  for (let i = 0; i < gaps.length; i++) {
+    gaps[i] = Math.max(gaps[i], rankGap + (ends2.get(i) ?? 0) + (starts.get(i + 1) ?? 0));
+  }
+  return gaps;
+}
+function groupSpans(graph, rows) {
+  const rankOf = /* @__PURE__ */ new Map();
+  rows.forEach((row, i) => row.forEach((n) => rankOf.set(n.id, i)));
+  const spans = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const group of graph.groups ?? []) {
+    const ranks = group.members.map((id) => rankOf.get(id)).filter((r) => r !== void 0);
+    if (ranks.length === 0) continue;
+    const span = { group, lo: Math.min(...ranks), hi: Math.max(...ranks), children: [] };
+    spans.push(span);
+    byId.set(group.id, span);
+  }
+  for (const span of spans) {
+    const parent = span.group.parent === void 0 ? void 0 : byId.get(span.group.parent);
+    if (parent === void 0) continue;
+    span.parent = parent;
+    parent.children.push(span);
+  }
+  return spans;
+}
+function packClusters(graph, rows, preferred2, axes, nodeGap) {
+  const spans = groupSpans(graph, rows);
+  const spanById = new Map(spans.map((s) => [s.group.id, s]));
+  const spanOf4 = (n) => n.group === void 0 ? void 0 : spanById.get(n.group);
+  const width = (n) => extent(n.bounds, axes.cross);
+  const pref = (n) => preferred2.get(n.id) ?? 0;
+  const insets = new Map(spans.map((s) => [s, canonical(s.group.inset, axes)]));
+  const centerOf = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const inside = new Set(span.group.members);
+    let sum = 0;
+    let count = 0;
+    for (const row of rows) {
+      for (const n of row) {
+        if (!inside.has(n.id)) continue;
+        sum += pref(n) + width(n) / 2;
+        count++;
+      }
+    }
+    centerOf.set(span, count === 0 ? 0 : sum / count);
+  }
+  const itemsByRow = (owner, among) => rows.map((row, r) => {
+    const items = [];
+    for (const node of row) {
+      if (spanOf4(node) === owner) items.push({ kind: "node", node, center: pref(node) + width(node) / 2 });
+    }
+    for (const span of among) {
+      if (r >= span.lo && r <= span.hi) items.push({ kind: "group", span, center: centerOf.get(span) });
+    }
+    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 nodeAt = /* @__PURE__ */ new Map();
+    let ends2 = [];
+    for (let pass = 0; pass <= start2.size; pass++) {
+      let raised = false;
+      ends2 = byRow.map((items) => {
+        let cursor = origin;
+        for (const item of items) {
+          if (item.kind === "node") {
+            const x2 = Math.max(nodeFloor(item.node), cursor);
+            nodeAt.set(item.node.id, x2);
+            cursor = x2 + width(item.node) + nodeGap;
+            continue;
+          }
+          const s = start2.get(item.span);
+          const x = Math.max(s, cursor);
+          if (x > s) {
+            start2.set(item.span, x);
+            raised = true;
+          }
+          cursor = x + outer(item.span) + nodeGap;
+        }
+        return items.length === 0 ? origin : cursor - nodeGap;
+      });
+      if (!raised) break;
+    }
+    return { nodeAt, ends: ends2 };
+  };
+  const blocks = /* @__PURE__ */ new Map();
+  const blockOf = (span) => {
+    const known = blocks.get(span);
+    if (known !== void 0) return known;
+    const byRow = itemsByRow(span, span.children);
+    const base = Math.min(...rows.flat().filter((n) => span.group.members.includes(n.id) || spanOf4(n) === span).map(pref));
+    const childAt = new Map(span.children.map((c) => [c, Math.max(0, centerOf.get(c) - outer(c) / 2 - base)]));
+    const { nodeAt, ends: ends2 } = settle2(byRow, childAt, (n) => pref(n) - base, 0);
+    const block = { width: Math.max(0, ...ends2), nodeAt, childAt };
+    const slack = widen(block, span.group, insets.get(span), axes);
+    for (const [id, x] of nodeAt) nodeAt.set(id, x + slack);
+    blocks.set(span, block);
+    return block;
+  };
+  function outer(span) {
+    const inset = insets.get(span);
+    return blockOf(span).width + inset.crossLo + inset.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 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 root of roots) place(root, start.get(root));
+  return at2;
+}
+function widen(block, group, inset, axes) {
+  const floor = axes.cross === "x" ? (group.minWidth ?? 0) - inset.crossLo - inset.crossHi : 0;
+  const slack = Math.max(0, floor - block.width) / 2;
+  block.width += 2 * slack;
+  for (const [child, local] of block.childAt) block.childAt.set(child, local + slack);
+  return slack;
+}
+function expandGroupEdges(edges, groups) {
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  if (byId.size === 0) return [...edges];
+  const within = (id, group) => {
+    if (!byId.has(id)) return group.members.includes(id);
+    for (let at2 = byId.get(id); at2 !== void 0; at2 = at2.parent === void 0 ? void 0 : byId.get(at2.parent)) {
+      if (at2 === group) return true;
+    }
+    return false;
+  };
+  const entries = /* @__PURE__ */ new Map();
+  const exits = /* @__PURE__ */ new Map();
+  for (const g of groups) {
+    const inside = new Set(g.members);
+    const pointedAt = /* @__PURE__ */ new Set();
+    const pointing = /* @__PURE__ */ new Set();
+    for (const e of edges) {
+      if (inside.has(e.from) && inside.has(e.to) && e.from !== e.to) {
+        pointedAt.add(e.to);
+        pointing.add(e.from);
+      }
+    }
+    const entry = g.members.filter((m) => !pointedAt.has(m));
+    const exit = g.members.filter((m) => !pointing.has(m));
+    entries.set(g.id, entry.length > 0 ? entry : g.members);
+    exits.set(g.id, exit.length > 0 ? exit : g.members);
+  }
+  const out = [];
+  for (const e of edges) {
+    const fromGroup = byId.has(e.from) ? e.from : void 0;
+    const toGroup = byId.has(e.to) ? e.to : void 0;
+    if (fromGroup === void 0 && toGroup === void 0) {
+      out.push(e);
+      continue;
+    }
+    if (fromGroup !== void 0 && within(e.to, byId.get(fromGroup))) continue;
+    if (toGroup !== void 0 && within(e.from, byId.get(toGroup))) continue;
+    const froms = fromGroup !== void 0 ? exits.get(fromGroup) : [e.from];
+    const tos = toGroup !== void 0 ? entries.get(toGroup) : [e.to];
+    let k = 0;
+    const ports = {
+      ...fromGroup === void 0 && e.fromPort !== void 0 ? { fromPort: e.fromPort } : {},
+      ...toGroup === void 0 && e.toPort !== void 0 ? { toPort: e.toPort } : {},
+      ...e.label !== void 0 ? { label: e.label } : {},
+      ...e.waypoints !== void 0 ? { waypoints: e.waypoints } : {},
+      ...e.authored ? { authored: true } : {}
+    };
+    for (const from of froms) {
+      for (const to of tos) out.push({ id: `${e.id}#${k++}`, from, to, ...ports, origin: { id: e.id, from: e.from, to: e.to } });
+    }
+  }
+  return out;
+}
+
+// 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 } = g.group;
+  return { x0: x0 - inset.left, y0: y0 - inset.top, x1: x1 + inset.right, y1: y1 + inset.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 NUDGE = 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 = NUDGE * 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
+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 } : { tail: from, head: to });
+  }
+  const start = longestPath(graph.nodes.length, arcs);
+  const ranks = /* @__PURE__ */ new Map();
+  for (const part of components(graph.nodes.length, arcs)) {
+    const rank = part.nodes.map((g) => start[g]);
+    simplex(part.arcs, rank);
+    const min = Math.min(...rank);
+    part.nodes.forEach((g, i) => ranks.set(graph.nodes[g].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 arc of arcs) {
+    pending[arc.head]++;
+    out[arc.tail].push(arc.head);
+  }
+  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 v of out[u]) {
+      rank[v] = Math.max(rank[v], rank[u] + 1);
+      if (--pending[v] === 0) ready.push(v);
+    }
+  }
+  return rank;
+}
+function components(count, arcs) {
+  const near = Array.from({ length: count }, () => []);
+  for (const arc of arcs) {
+    near[arc.tail].push(arc.head);
+    near[arc.head].push(arc.tail);
+  }
+  const part = new Array(count).fill(-1);
+  const parts = [];
+  for (let seed = 0; seed < count; seed++) {
+    if (part[seed] !== -1) continue;
+    const id = parts.length;
+    const found = [seed];
+    part[seed] = id;
+    for (let k = 0; k < found.length; k++) {
+      for (const v of near[found[k]]) {
+        if (part[v] === -1) {
+          part[v] = id;
+          found.push(v);
+        }
+      }
+    }
+    parts.push({ nodes: found.sort((a, b) => a - b), arcs: [] });
+  }
+  const local = new Array(count);
+  for (const p of parts) p.nodes.forEach((g, i) => local[g] = i);
+  for (const arc of arcs) {
+    parts[part[arc.tail]].arcs.push({ tail: local[arc.tail], head: local[arc.head] });
+  }
+  return parts;
+}
+var slackOf = (arc, rank) => rank[arc.head] - rank[arc.tail] - 1;
+function simplex(arcs, rank) {
+  if (arcs.length === 0 || arcs.some((arc) => slackOf(arc, rank) < 0)) return;
+  const inTree = feasibleTree(arcs, rank);
+  const cap = 4 * arcs.length + 100;
+  for (let round = 0; round < cap; round++) {
+    const tree2 = postorder(rank.length, arcs, inTree);
+    let leave = -1;
+    let tailInside = false;
+    for (let a = 0; a < arcs.length && leave === -1; a++) {
+      if (!inTree[a]) continue;
+      const cut = cutValue(arcs, a, tree2);
+      if (cut.value < 0) {
+        leave = a;
+        tailInside = cut.tailInside;
+      }
+    }
+    if (leave === -1) return;
+    const inside = insideOf(tree2, childOf(arcs[leave], leave, tree2));
+    let enter = -1;
+    for (let a = 0; a < arcs.length; a++) {
+      const arc = arcs[a];
+      if (inTree[a]) continue;
+      const crosses = tailInside ? !inside(arc.tail) && inside(arc.head) : inside(arc.tail) && !inside(arc.head);
+      if (crosses && (enter === -1 || slackOf(arc, rank) < slackOf(arcs[enter], rank))) enter = a;
+    }
+    if (enter === -1) return;
+    inTree[leave] = false;
+    inTree[enter] = true;
+    tighten(rank, arcs, inTree);
+  }
+}
+function feasibleTree(arcs, rank) {
+  const inTree = arcs.map(() => false);
+  const has = rank.map(() => false);
+  has[0] = true;
+  let size = 1;
+  const grow = () => {
+    for (let changed = true; changed; ) {
+      changed = false;
+      arcs.forEach((arc, a) => {
+        if (has[arc.tail] === has[arc.head] || slackOf(arc, rank) !== 0) return;
+        inTree[a] = true;
+        has[arc.tail] = has[arc.head] = true;
+        size++;
+        changed = true;
+      });
+    }
+  };
+  grow();
+  while (size < rank.length) {
+    let best = -1;
+    arcs.forEach((arc2, a) => {
+      if (has[arc2.tail] === has[arc2.head]) return;
+      if (best === -1 || slackOf(arc2, rank) < slackOf(arcs[best], rank)) best = a;
+    });
+    const arc = arcs[best];
+    const delta = has[arc.head] ? -slackOf(arc, rank) : slackOf(arc, rank);
+    for (let v = 0; v < rank.length; v++) if (has[v]) rank[v] += delta;
+    grow();
+  }
+  return inTree;
+}
+function treeAdjacency(count, arcs, inTree) {
+  const adj = Array.from({ length: count }, () => []);
+  arcs.forEach((arc, a) => {
+    if (!inTree[a]) return;
+    adj[arc.tail].push(a);
+    adj[arc.head].push(a);
+  });
+  return adj;
+}
+function postorder(count, arcs, inTree) {
+  const adj = treeAdjacency(count, arcs, inTree);
+  const low = new Array(count).fill(0);
+  const lim = new Array(count).fill(0);
+  const parentArc = new Array(count).fill(-1);
+  let next = 1;
+  const stack = [{ v: 0, i: 0 }];
+  low[0] = next;
+  while (stack.length > 0) {
+    const top = stack[stack.length - 1];
+    const a = adj[top.v][top.i++];
+    if (a === void 0) {
+      lim[top.v] = next++;
+      stack.pop();
+      continue;
+    }
+    if (a === parentArc[top.v]) continue;
+    const arc = arcs[a];
+    const w = arc.tail === top.v ? arc.head : arc.tail;
+    parentArc[w] = a;
+    low[w] = next;
+    stack.push({ v: w, i: 0 });
+  }
+  return { low, lim, parentArc };
+}
+function childOf(arc, a, tree2) {
+  return tree2.parentArc[arc.tail] === a ? arc.tail : arc.head;
+}
+function insideOf(tree2, child) {
+  const lo = tree2.low[child];
+  const hi = tree2.lim[child];
+  return (v) => lo <= tree2.lim[v] && tree2.lim[v] <= hi;
+}
+function cutValue(arcs, a, tree2) {
+  const treeArc = arcs[a];
+  const child = childOf(treeArc, a, tree2);
+  const inside = insideOf(tree2, child);
+  const tailInside = child === treeArc.tail;
+  let value = 0;
+  for (const arc of arcs) {
+    const from = inside(arc.tail);
+    if (from === inside(arc.head)) continue;
+    value += from === tailInside ? 1 : -1;
+  }
+  return { value, tailInside };
+}
+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];
+    for (const a of adj[v]) {
+      const arc = arcs[a];
+      const w = arc.tail === v ? arc.head : arc.tail;
+      if (seen[w]) continue;
+      seen[w] = true;
+      rank[w] = arc.tail === v ? rank[v] + 1 : rank[v] - 1;
+      queue.push(w);
+    }
+  }
+}
+
+// src/layered/types.ts
+var PLACEHOLDER = "\0hop:";
+var isPlaceholder = (id) => id.startsWith(PLACEHOLDER);
+
+// src/layered/expand.ts
+function labelRowsOf(drawn, ranks, span) {
+  const gapOf = /* @__PURE__ */ new Map();
+  for (const d of drawn) {
+    if (d.label === void 0) continue;
+    const a = span(d.back ? d.to : d.from, ranks);
+    const b = span(d.back ? d.from : d.to, ranks);
+    if (a === null || b === null || a[1] >= b[0]) continue;
+    gapOf.set(d.id, a[1] + Math.floor((b[0] - a[1] - 1) / 2));
+  }
+  const gaps = [...new Set(gapOf.values())];
+  const rowOf = (r) => r + gaps.filter((g) => g < r).length;
+  const rows = new Map([...ranks].map(([id, r]) => [id, rowOf(r)]));
+  return { rows, labelRow: new Map([...gapOf].map(([id, g]) => [id, rowOf(g) + 1])) };
+}
+function labelRoom(room, axes, back, nodeGap) {
+  const across = extent({ width: room.width, height: room.height }, axes.cross);
+  const depth = extent({ width: room.width, height: room.height }, axes.rank);
+  const offset = room.offset ?? 0;
+  if (offset === 0) return { size: across, depth, wire: across / 2 };
+  const left = (axes.rank === "y" ? 1 : -1) * axes.sign * (back ? -1 : 1);
+  const margin = nodeGap / 4;
+  const size = margin + Math.abs(offset) + across;
+  return { size, depth, wire: left * Math.sign(offset) > 0 ? margin : size - margin };
+}
+var MIDDLE = [0.5];
+function portPlaces(node, port, axes) {
+  if (node === void 0 || port === void 0) return MIDDLE;
+  const { bounds } = node;
+  const trait = { ...node.ports !== void 0 ? { ports: node.ports } : {}, ...node.outline !== void 0 ? { outline: node.outline } : {} };
+  const sites = portSitesOf({ id: node.id, kind: "leaf", data: null }, bounds, port, { read: () => trait });
+  const size = extent(bounds, axes.cross);
+  if (sites.length === 0 || size <= 0) return MIDDLE;
+  const low = axes.cross === "x" ? bounds.x : bounds.y;
+  return sites.map((p) => (p.point[axes.cross] - low) / size);
+}
+function portOf2(places, side) {
+  const at2 = places[0];
+  if (side === "from") return places.length > 1 ? { fromAt: at2, fromPlaces: places } : { fromAt: at2 };
+  return places.length > 1 ? { toAt: at2, toPlaces: places } : { toAt: at2 };
+}
+function expand(graph, nodeRanks, back, opts) {
+  const { axes } = opts;
+  const groups = new Map((graph.groups ?? []).map((g) => [g.id, g]));
+  const spanIn = (id, ranks2) => {
+    const ids = groups.get(id)?.members ?? [id];
+    const rs = ids.map((m) => ranks2.get(m)).filter((r) => r !== void 0);
+    return rs.length === 0 ? null : [Math.min(...rs), Math.max(...rs)];
+  };
+  const drawn = drawnEdges(graph.edges, back);
+  const labeled = labelRowsOf(drawn, nodeRanks, spanIn);
+  const ranks = labeled.rows;
+  const span = (id) => spanIn(id, ranks);
+  const inRank = (id, r) => (groups.get(id)?.members ?? [id]).filter((m) => ranks.get(m) === r && graph.node(m) !== void 0);
+  const ancestry = (id) => {
+    const out = [];
+    let at2 = groups.has(id) ? groups.get(id).parent : graph.node(id)?.group;
+    while (at2 !== void 0) {
+      out.push(at2);
+      at2 = groups.get(at2)?.parent;
+    }
+    return out;
+  };
+  const sharedGroup = (a, b) => {
+    const up = new Set(ancestry(b));
+    return ancestry(a).find((g) => up.has(g));
+  };
+  const crossCenter = (id) => {
+    const node = graph.node(id);
+    if (node !== void 0) return center(node.bounds, axes.cross);
+    const ms = (groups.get(id)?.members ?? []).map((m) => graph.node(m)).filter((n) => n !== void 0);
+    return ms.length === 0 ? 0 : ms.reduce((s, n) => s + center(n.bounds, axes.cross), 0) / ms.length;
+  };
+  const byRank = /* @__PURE__ */ new Map();
+  const add = (r, n) => byRank.set(r, [...byRank.get(r) ?? [], n]);
+  for (const node of graph.nodes) add(ranks.get(node.id) ?? 0, node);
+  const hops = [];
+  const chains = /* @__PURE__ */ new Map();
+  const labels = /* @__PURE__ */ new Map();
+  const wires = /* @__PURE__ */ new Map();
+  for (const d of drawn) {
+    const [from, to] = d.back ? [d.to, d.from] : [d.from, d.to];
+    const [fromPort, toPort] = d.back ? [d.toPort, d.fromPort] : [d.fromPort, d.toPort];
+    const leave = (id) => id === from ? portOf2(portPlaces(graph.node(id), fromPort, axes), "from") : {};
+    const arrive = (id) => id === to ? portOf2(portPlaces(graph.node(id), toPort, axes), "to") : {};
+    const a = span(from);
+    const b = span(to);
+    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 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);
+    };
+    const labelRow = labeled.labelRow.get(d.id);
+    let prev = inRank(from, a[1]);
+    let prevAt = null;
+    const chain2 = [];
+    for (let r = a[1] + 1; r < b[0]; r++) {
+      const id = `${PLACEHOLDER}${d.id}:${r}`;
+      const room = r === labelRow && d.label !== void 0 ? labelRoom(d.label, axes, d.back, opts.nodeGap) : { size: opts.nodeGap / 2, depth: 0, wire: opts.nodeGap / 4 };
+      const at2 = seed(r - a[1] - 1) - room.wire;
+      const bounds = axes.cross === "x" ? { x: at2, y: 0, width: room.size, height: room.depth } : { x: 0, y: at2, width: room.depth, height: room.size };
+      add(r, { id, bounds, pinned: false, ...group !== void 0 ? { group } : {} });
+      const toAt = room.wire / room.size;
+      for (const p of prev) hops.push({ from: p, to: id, edge: d.id, ...prevAt ?? leave(p), toAt });
+      if (r === labelRow) {
+        labels.set(d.id, id);
+        wires.set(id, room.wire);
+      }
+      prev = [id];
+      prevAt = { fromAt: toAt };
+      chain2.push(id);
+    }
+    for (const p of prev) for (const q of inRank(to, b[0])) hops.push({ from: p, to: q, edge: d.id, ...prevAt ?? leave(p), ...arrive(q) });
+    if (chain2.length > 0) {
+      const ends2 = [...groups.get(from)?.members ?? [from], ...groups.get(to)?.members ?? [to]];
+      chains.set(d.id, { ids: d.back ? chain2.reverse() : chain2, back: d.back, ends: ends2 });
+    }
+  }
+  const order = graphOrder(graph);
+  const top = Math.max(-1, ...byRank.keys());
+  const rows = [];
+  for (let r = 0; r <= top; r++) {
+    const row = byRank.get(r) ?? [];
+    rows.push(seededOrder(row, axes.cross, order));
+  }
+  return { rows, hops: dedupe(hops), chains, labelRows: new Set(labeled.labelRow.values()), labels, wires };
+}
+function drawnEdges(edges, back) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const id = e.origin?.id ?? e.id;
+    if (seen.has(id)) continue;
+    const from = e.origin?.from ?? e.from;
+    const to = e.origin?.to ?? e.to;
+    if (from === to) continue;
+    seen.set(id, {
+      id,
+      from,
+      to,
+      ...e.fromPort !== void 0 ? { fromPort: e.fromPort } : {},
+      ...e.toPort !== void 0 ? { toPort: e.toPort } : {},
+      ...e.label !== void 0 ? { label: e.label } : {},
+      ...e.waypoints !== void 0 ? { waypoints: e.waypoints } : {},
+      ...e.authored ? { authored: true } : {},
+      back: back.has(e.id)
+    });
+  }
+  return [...seen.values()];
+}
+function dedupe(hops) {
+  const seen = /* @__PURE__ */ new Set();
+  return hops.filter((h) => {
+    const key = `${h.from}\0${h.to}\0${h.edge}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function depthOf(row, axes) {
+  return Math.max(0, ...row.map((n) => extent(n.bounds, axes.rank)));
+}
+
+// src/layered/places.ts
+function sidesOf(hops) {
+  const down = /* @__PURE__ */ new Map();
+  const up = /* @__PURE__ */ new Map();
+  for (const h of hops) {
+    (down.get(h.from) ?? down.set(h.from, []).get(h.from)).push(h.to);
+    (up.get(h.to) ?? up.set(h.to, []).get(h.to)).push(h.from);
+  }
+  return { down, up };
+}
+function placeAmong(places, other, neighbors, pos) {
+  const p = pos.get(other) ?? 0;
+  let before = 0;
+  let level = 0;
+  for (const n of neighbors) {
+    const q = pos.get(n) ?? 0;
+    if (q < p) before++;
+    else if (q === p) level++;
+  }
+  const count = Math.max(neighbors.length, 1);
+  const expected = (before + Math.max(level, 1) / 2) / count;
+  let best = places[0];
+  for (const at2 of places) if (Math.abs(at2 - expected) < Math.abs(best - expected)) best = at2;
+  return best;
+}
+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);
+  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) } : {}
+    };
+  });
+}
+
+// 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);
+  return [at(pos.get(p.from), fa), at(pos.get(p.to), fb)];
+}
+var at = (pos, frac) => pos + 0.25 + frac / 2;
+function hopsByRank(rows, hops) {
+  const rank = /* @__PURE__ */ new Map();
+  rows.forEach((row, r) => row.forEach((n) => rank.set(n.id, r)));
+  const out = rows.map(() => []);
+  for (const h of hops) {
+    const r = rank.get(h.from);
+    if (r !== void 0 && rank.get(h.to) === r + 1) {
+      out[r].push({ from: h.from, to: h.to, fromAt: h.fromAt ?? 0.5, toAt: h.toAt ?? 0.5, fromPlaces: h.fromPlaces, toPlaces: h.toPlaces });
+    }
+  }
+  return out;
+}
+function positions(rows) {
+  const pos = /* @__PURE__ */ new Map();
+  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]);
+  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);
+    let atMost = 0;
+    for (let i = b + 1; i > 0; i -= i & -i) atMost += tree2[i];
+    count += seen - atMost;
+    for (let i = b + 1; i <= width; i += i & -i) tree2[i]++;
+    seen++;
+  }
+  return count;
+}
+function total(rows, byRank, pos, sides) {
+  let sum = 0;
+  for (let r = 0; r + 1 < rows.length; r++) sum += pairCrossings(byRank[r], pos, sides);
+  return sum;
+}
+function chainsOf(groups) {
+  const parent = new Map(groups.map((g) => [g.id, g.parent]));
+  const cache = /* @__PURE__ */ new Map();
+  const chain2 = (id, seen) => {
+    const known = cache.get(id);
+    if (known !== void 0) return known;
+    const up = parent.get(id);
+    seen.add(id);
+    const out = up === void 0 || seen.has(up) ? [id] : [...chain2(up, seen), id];
+    cache.set(id, out);
+    return out;
+  };
+  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) {
+  const root = newBlock(0);
+  const keyOf = /* @__PURE__ */ new Map();
+  const firstOf = /* @__PURE__ */ new Map();
+  row.forEach((n, i) => {
+    const k = key(n, i);
+    let at2 = root;
+    for (const g of chainOf(n.group)) {
+      let next = at2.sub.get(g);
+      if (next === void 0) {
+        next = newBlock(i);
+        at2.sub.set(g, next);
+        at2.items.push(next);
+      }
+      next.sum += k;
+      next.count++;
+      at2 = next;
+    }
+    at2.items.push(n);
+    keyOf.set(n, k);
+    firstOf.set(n, i);
+  });
+  const out = [];
+  const flatten = (block) => {
+    const items = block.items.map((item) => {
+      if ("id" in item) return { item, k: keyOf.get(item), first: firstOf.get(item) };
+      return { item, k: item.sum / item.count, first: item.first };
+    });
+    items.sort((a, b) => a.k - b.k || a.first - b.first);
+    for (const { item } of items) {
+      if ("id" in item) out.push(item);
+      else flatten(item);
+    }
+  };
+  flatten(root);
+  return out;
+}
+function landing(near, self, work) {
+  const frac = near.places === void 0 ? near.frac : placeAmong(near.places, self, work.sides[near.side].get(near.id) ?? [], work.pos);
+  return at(work.pos.get(near.id), frac);
+}
+function reindex(work, r) {
+  work.rows[r].forEach((n, i) => work.pos.set(n.id, i));
+}
+function reorder(work, r, side) {
+  const key = (n, i) => {
+    const near = side.get(n.id);
+    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);
+  reindex(work, r);
+}
+function between(work, side, u, v) {
+  const nu = side.get(u);
+  const nv = side.get(v);
+  if (nu === void 0 || nv === void 0) return 0;
+  let n = 0;
+  for (const a of nu) for (const b of nv) if (landing(a, u, work) > landing(b, v, work)) n++;
+  return n;
+}
+function transpose(work) {
+  const { rows, pos, ups, downs } = work;
+  const cost = (a, b) => between(work, ups, a, b) + between(work, downs, a, b);
+  let improved = true;
+  while (improved) {
+    improved = false;
+    for (const row of rows) {
+      for (let i = 0; i + 1 < row.length; i++) {
+        const u = row[i];
+        const v = row[i + 1];
+        if (u.group !== v.group) continue;
+        const now = cost(u.id, v.id);
+        pos.set(v.id, i);
+        pos.set(u.id, i + 1);
+        if (cost(v.id, u.id) < now) {
+          row[i] = v;
+          row[i + 1] = u;
+          improved = true;
+        } else {
+          pos.set(u.id, i);
+          pos.set(v.id, i + 1);
+        }
+      }
+    }
+  }
+}
+function orderRows(rows, hops, opts = {}) {
+  const patience = opts.patience ?? 4;
+  const maxSweeps = opts.maxSweeps ?? 24;
+  const chainOf = chainsOf(opts.groups ?? []);
+  const byRank = hopsByRank(rows, hops);
+  const ups = /* @__PURE__ */ new Map();
+  const downs = /* @__PURE__ */ new Map();
+  for (const pairs of byRank) {
+    for (const p of pairs) {
+      (downs.get(p.from) ?? downs.set(p.from, []).get(p.from)).push({ id: p.to, frac: p.toAt, places: p.toPlaces, side: "up" });
+      (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 sides = sidesOf(hops);
+  const work = { rows: seeded, pos: positions(seeded), ups, downs, sides, chainOf };
+  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++) {
+    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);
+    if (n < fewest) {
+      fewest = n;
+      best = work.rows.map((row) => [...row]);
+      stale = 0;
+    } else stale++;
+  }
+  return best;
+}
+
+// src/layered/level.ts
+var SIDES = { x: { low: "w", high: "e" }, y: { low: "n", high: "s" } };
+var spanOf = (b, axis) => {
+  const lo = axis === "x" ? b.x : b.y;
+  return { lo, hi: lo + extent(b, axis) };
+};
+var overlaps = (p, q) => p.lo < q.hi && q.lo < p.hi;
+function levelRoutes(input) {
+  const { graph, boxes, axes } = input;
+  const out = { ports: /* @__PURE__ */ new Map(), waypoints: /* @__PURE__ */ new Map() };
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of graph.edges) {
+    const id = e.origin?.id ?? e.id;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const from = e.origin?.from ?? e.from;
+    const to = e.origin?.to ?? e.to;
+    const a = boxes.get(from);
+    const b = boxes.get(to);
+    if (from === to || a === void 0 || b === void 0) continue;
+    if (!overlaps(spanOf(a, axes.rank), spanOf(b, axes.rank)) || overlaps(spanOf(a, axes.cross), spanOf(b, axes.cross))) continue;
+    const others = [...boxes].filter(([n]) => n !== from && n !== to).map(([, box]) => box);
+    if (between2(a, b, others, axes)) {
+      const face = FACES[input.direction ?? "down"].out;
+      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 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]));
+    }
+  }
+  return out;
+}
+function named(graph, [from, f], [to, t]) {
+  const has = (id, face) => {
+    const node = graph.node(id);
+    return node !== void 0 && hasCompassPort(node, face);
+  };
+  return { ...has(from, f) ? { from: f } : {}, ...has(to, t) ? { to: t } : {} };
+}
+function between2(a, b, others, axes) {
+  const [ca, cb] = [spanOf(a, axes.cross), spanOf(b, axes.cross)];
+  const gap = ca.hi <= cb.lo ? { lo: ca.hi, hi: cb.lo } : { lo: cb.hi, hi: ca.lo };
+  const [ma, mb] = [center(a, axes.rank), center(b, axes.rank)];
+  const run = { lo: Math.min(ma, mb), hi: Math.max(ma, mb) };
+  return others.some((o) => {
+    const r = spanOf(o, axes.rank);
+    return overlaps(spanOf(o, axes.cross), gap) && r.lo <= run.hi && r.hi >= run.lo;
+  });
+}
+function around(a, b, others, axes, rankGap) {
+  const ahead = (box) => axes.sign === 1 ? spanOf(box, axes.rank).hi : -spanOf(box, axes.rank).lo;
+  const behind = (box) => axes.sign === 1 ? spanOf(box, axes.rank).lo : -spanOf(box, axes.rank).hi;
+  const edge = Math.max(ahead(a), ahead(b));
+  const [ma, mb] = [center(a, axes.cross), center(b, axes.cross)];
+  const run = { lo: Math.min(ma, mb), hi: Math.max(ma, mb) };
+  let standoff = rankGap / 2;
+  for (const o of others) {
+    const room = behind(o) - edge;
+    const c = spanOf(o, axes.cross);
+    if (room > 0 && c.lo <= run.hi && c.hi >= run.lo) standoff = Math.min(standoff, room / 2);
+  }
+  const rank = axes.sign * (edge + standoff);
+  const point = (cross) => axes.cross === "x" ? { x: cross, y: rank } : { x: rank, y: cross };
+  return [point(ma), point(mb)];
+}
+
+// src/layered/across.ts
+var EPS2 = 1e-6;
+function settleAcross(input) {
+  const { graph, rows, axes } = input;
+  const groups = new Map((graph.groups ?? []).map((g) => [g.id, g]));
+  const rankOf = /* @__PURE__ */ new Map();
+  const sizes = /* @__PURE__ */ new Map();
+  const chains = /* @__PURE__ */ new Map();
+  for (const [r, row] of rows.entries()) {
+    for (const node of row) {
+      rankOf.set(node.id, r);
+      sizes.set(node.id, extent(node.bounds, axes.cross));
+      const chain2 = [];
+      for (let g = node.group === void 0 ? void 0 : groups.get(node.group); g !== void 0; g = g.parent === void 0 ? void 0 : groups.get(g.parent)) chain2.unshift(g);
+      chains.set(node.id, chain2);
+    }
+  }
+  const ctx = { input, groups, rankOf, sizes, chains };
+  const out = new Map(input.preferred);
+  return settleLevel(ctx, [...rankOf.keys()], 0, input.preferred, out) ? out : void 0;
+}
+function settleLevel(ctx, ids, depth, pref, out) {
+  const { held, nodeGap: gap } = ctx.input;
+  const { items, byRank } = itemsAt(ctx, ids, depth, pref);
+  for (const item of items) {
+    const pin = item.members.find((id) => held.has(id));
+    if (pin === void 0) continue;
+    if (item.group === void 0) {
+      item.fixed = held.get(pin);
+      continue;
+    }
+    const shift = held.get(pin) - pref.get(pin);
+    const shifted = new Map(pref);
+    for (const id of item.members) shifted.set(id, pref.get(id) + shift);
+    if (!settleLevel(ctx, item.members, depth + 1, shifted, out)) return false;
+    Object.assign(item, spanOf2(ctx, item.group, item.members, out));
+    item.fixed = item.pref;
+  }
+  const xs = items.map((it) => it.fixed ?? it.pref);
+  const order = byRank.map((list) => [...list].sort((p, q) => xs[p] + items[p].width / 2 - (xs[q] + items[q].width / 2) || p - q));
+  squeeze(items, order, xs, gap);
+  for (const list of order) {
+    if (clear(items, list, xs, gap)) continue;
+    if (list.some((i) => items[i].fixed === void 0 && items[i].tall)) return false;
+    jump(items, list, xs, gap);
+    if (!clear(items, list, xs, gap)) return false;
+  }
+  for (const [i, item] of items.entries()) {
+    if (item.fixed !== void 0 && item.group !== void 0) continue;
+    for (const id of item.members) out.set(id, item.fixed !== void 0 ? item.fixed : pref.get(id) + xs[i] - item.pref);
+  }
+  return true;
+}
+function squeeze(items, order, xs, gap) {
+  const free = (i) => items[i].fixed === void 0;
+  for (let moved = true, pass = 0; moved && pass <= items.length; pass++) {
+    moved = false;
+    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];
+        edge = Math.max(edge, xs[i] + items[i].width + gap);
+      }
+    }
+  }
+  for (let moved = true, pass = 0; moved && pass <= items.length; pass++) {
+    moved = false;
+    for (const list of order) {
+      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];
+        edge = Math.min(edge, xs[i]);
+      }
+    }
+  }
+}
+function itemsAt(ctx, ids, depth, pref) {
+  const items = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const ranks = [];
+  for (const id of ids) {
+    const group = ctx.chains.get(id)[depth];
+    const key = group?.id ?? `\0node:${id}`;
+    const r = ctx.rankOf.get(id);
+    let i = byKey.get(key);
+    if (i === void 0) {
+      i = items.length;
+      byKey.set(key, i);
+      items.push({ pref: 0, width: 0, members: [], tall: false, ...group !== void 0 ? { group } : {} });
+      ranks.push([r, r]);
+    }
+    items[i].members.push(id);
+    ranks[i] = [Math.min(ranks[i][0], r), Math.max(ranks[i][1], r)];
+  }
+  for (const [i, item] of items.entries()) {
+    Object.assign(item, spanOf2(ctx, item.group, item.members, pref));
+    item.tall = ranks[i][0] !== ranks[i][1];
+  }
+  const byRank = ctx.input.rows.map(() => []);
+  for (const [i, [lo, hi]] of ranks.entries()) for (let r = lo; r <= hi; r++) byRank[r].push(i);
+  return { items, byRank };
+}
+function spanOf2(ctx, group, members, at2) {
+  const lo = Math.min(...members.map((id) => at2.get(id)));
+  const hi = Math.max(...members.map((id) => at2.get(id) + ctx.sizes.get(id)));
+  const pad = group === void 0 ? { lo: 0, hi: 0 } : padOf(group, ctx.groups, ctx.input.axes);
+  return { pref: lo - pad.lo, width: hi - lo + pad.lo + pad.hi };
+}
+function padOf(group, groups, axes) {
+  const own = crossInset(group.inset, axes);
+  let lo = 0;
+  let hi = 0;
+  for (const child of groups.values()) {
+    if (child.parent !== group.id) continue;
+    const pad = padOf(child, groups, axes);
+    lo = Math.max(lo, pad.lo);
+    hi = Math.max(hi, pad.hi);
+  }
+  return { lo: own.lo + lo, hi: own.hi + hi };
+}
+function clear(items, list, xs, gap) {
+  for (const [k, i] of list.entries()) {
+    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;
+      if (!apart) return false;
+    }
+  }
+  return true;
+}
+function jump(items, list, xs, gap) {
+  const blocks = list.filter((i) => items[i].fixed !== void 0).map((i) => ({ lo: xs[i] - gap, hi: xs[i] + items[i].width + gap }));
+  const free = list.filter((i) => items[i].fixed === void 0);
+  const along = (dir) => {
+    const out = [];
+    let cursor = dir * -Infinity;
+    for (const i of dir === 1 ? free : [...free].reverse()) {
+      const width = items[i].width;
+      let x = dir === 1 ? Math.max(items[i].pref, cursor) : Math.min(items[i].pref, cursor - width);
+      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];
+        }
+      }
+      out[i] = x;
+      cursor = dir === 1 ? x + width + gap : x - gap;
+    }
+    return out;
+  };
+  const cost = (ys) => free.reduce((sum, i) => sum + Math.abs(ys[i] - items[i].pref), 0);
+  const up = along(1);
+  const down = along(-1);
+  const best = cost(up) <= cost(down) ? up : down;
+  for (const i of free) xs[i] = best[i];
+}
+
+// src/layered/bands.ts
+var EPS3 = 1e-6;
+function placeBands(input, covers) {
+  const { natural, minGaps } = input;
+  const n = natural.length;
+  const hiOf = (k, lo) => Math.max(lo + natural[k], covers.get(k)?.hi ?? -Infinity);
+  const earliest = [];
+  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;
+    lo = hiOf(k, lo) + (minGaps[k] ?? 0);
+  }
+  const los = preferred(input, covers, hiOf).map((lo, k) => Math.max(lo, earliest[k]));
+  for (let k = n - 1; k >= 0; k--) {
+    if (k < n - 1) los[k] = Math.min(los[k], los[k + 1] - minGaps[k] - natural[k]);
+    const cover = covers.get(k);
+    if (cover !== void 0) los[k] = Math.min(los[k], cover.lo);
+  }
+  return spread(input, covers, los, hiOf);
+}
+function preferred(input, covers, hiOf) {
+  const { natural, gaps, home } = input;
+  const cover = (k, lo) => {
+    const c = covers.get(k);
+    return c === void 0 ? lo : Math.min(c.lo, Math.max(lo, c.hi - natural[k]));
+  };
+  const los = [];
+  los[home.rank] = cover(home.rank, home.lo);
+  for (let k = home.rank + 1; k < natural.length; k++) los[k] = cover(k, hiOf(k - 1, los[k - 1]) + gaps[k - 1]);
+  for (let k = home.rank - 1; k >= 0; k--) los[k] = cover(k, los[k + 1] - gaps[k] - natural[k]);
+  return los;
+}
+function spread(input, covers, los, hiOf) {
+  const { natural, gaps, minGaps } = input;
+  const n = natural.length;
+  const held = [...covers.keys()].sort((p, q) => p - q);
+  const first = held[0];
+  const last = held[held.length - 1];
+  for (let k = first - 1; k >= 0; k--) los[k] = los[k + 1] - gaps[k] - natural[k];
+  for (let k = last + 1; k < n; k++) los[k] = hiOf(k - 1, los[k - 1]) + gaps[k - 1];
+  for (let h = 1; h < held.length; h++) {
+    const [f, g] = [held[h - 1], held[h]];
+    if (g === f + 1) continue;
+    let room = los[g] - hiOf(f, los[f]);
+    for (let k = f + 1; k < g; k++) room -= natural[k];
+    const ks = Array.from({ length: g - f }, (_, i) => f + i);
+    const least = ks.reduce((sum, k) => sum + minGaps[k], 0);
+    const usual = ks.reduce((sum, k) => sum + gaps[k], 0);
+    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);
+    };
+    for (let k = f + 1; k < g; k++) los[k] = hiOf(k - 1, los[k - 1]) + share(k - 1);
+  }
+  return { los, his: los.map((lo, k) => hiOf(k, lo)) };
+}
+
+// src/layered/pins.ts
+function holdPins(input) {
+  const { graph, rows, axes, pinned } = input;
+  const natural = rows.map((row) => depthOf(row, axes));
+  const rankAt = /* @__PURE__ */ new Map();
+  const unheld = /* @__PURE__ */ new Set();
+  const rowOf = /* @__PURE__ */ new Map();
+  rows.forEach((row, r) => row.forEach((n) => rowOf.set(n.id, r)));
+  const pins = graph.nodes.filter((n) => pinned.has(n.id) && rowOf.has(n.id));
+  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 } };
+  const anchorExt = extent(anchor.bounds, axes.rank);
+  const anchorRank = start + (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);
+    const x = node.bounds.x - (anchor.bounds.x - anchorWorld.x);
+    const y = node.bounds.y - (anchor.bounds.y - anchorWorld.y);
+    const ext = extent(node.bounds, axes.rank);
+    const rankWorld = axes.rank === "x" ? x : y;
+    return { cross: axes.cross === "x" ? x : y, rank: axes.sign === 1 ? rankWorld : -rankWorld - ext };
+  };
+  const rest = pins.slice(1).sort((p, q) => Math.abs(rowOf.get(p.id) - a) - Math.abs(rowOf.get(q.id) - a));
+  const held = /* @__PURE__ */ new Map([[anchor.id, input.crossAt.get(anchor.id)]]);
+  const ranks = /* @__PURE__ */ new Map([[anchor.id, anchorRank]]);
+  let covers = /* @__PURE__ */ new Map([[a, { lo: anchorRank, hi: anchorRank + anchorExt }]]);
+  let placed = placeBands(bandInput, covers);
+  let crossAt = new Map(input.crossAt);
+  for (const pin of rest) {
+    const r = rowOf.get(pin.id);
+    const at2 = target(pin.id);
+    const was = covers.get(r);
+    const hi = at2.rank + extent(pin.bounds, axes.rank);
+    const next = new Map(covers).set(r, { lo: Math.min(was?.lo ?? at2.rank, at2.rank), hi: Math.max(was?.hi ?? hi, hi) });
+    const bands = placeBands(bandInput, next);
+    const settled = bands && settleAcross({ graph, rows, preferred: input.crossAt, held: new Map(held).set(pin.id, at2.cross), axes, nodeGap: input.nodeGap });
+    if (bands === void 0 || settled === void 0) {
+      unheld.add(pin.id);
+      continue;
+    }
+    held.set(pin.id, at2.cross);
+    ranks.set(pin.id, at2.rank);
+    [covers, placed, crossAt] = [next, bands, settled];
+  }
+  const { los, his } = placed;
+  for (const [id, rank] of ranks) rankAt.set(id, rank - los[0]);
+  const gaps = los.slice(1).map((lo, k) => lo - his[k]);
+  return { crossAt, gaps, depths: los.map((lo, k) => his[k] - lo), rankAt, unheld };
+}
+
+// src/layered/place.ts
+var pairKey = (upper, lower) => `${upper}\0${lower}`;
+function placeAcross(rows, hops, axis, nodeGap) {
+  const frame = { rows: rows.map((row) => row.map((n) => n.id)), size: /* @__PURE__ */ new Map(), gap: nodeGap, ports: /* @__PURE__ */ new Map() };
+  for (const row of rows) for (const node of row) frame.size.set(node.id, extent(node.bounds, axis));
+  for (const hop of hops) {
+    const key = pairKey(hop.from, hop.to);
+    if (!frame.ports.has(key)) frame.ports.set(key, [hop.fromAt ?? 0.5, hop.toAt ?? 0.5]);
+  }
+  const { up, down } = neighborsOf(frame.rows, hops);
+  const conflicts = markConflicts(frame.rows, up);
+  const layouts = [];
+  for (const downward of [true, false]) {
+    for (const right of [false, true]) {
+      layouts.push({ xs: alignedLayout(frame, downward ? up : down, conflicts, downward, right), right });
+    }
+  }
+  const spans = layouts.map(({ xs }) => spanOf3(xs, frame.size));
+  let narrowest = 0;
+  for (let i = 1; i < spans.length; i++) if (spans[i].max - spans[i].min < spans[narrowest].max - spans[narrowest].min) narrowest = i;
+  const target = spans[narrowest];
+  for (const [i, { xs, right }] of layouts.entries()) {
+    const delta = right ? target.max - spans[i].max : target.min - spans[i].min;
+    for (const [id, x] of xs) xs.set(id, x + delta);
+  }
+  const low = /* @__PURE__ */ new Map();
+  let least = Infinity;
+  for (const [id, size] of frame.size) {
+    const four = layouts.map(({ xs }) => xs.get(id)).sort((a, b) => a - b);
+    const corner = (four[1] + four[2]) / 2 - size / 2;
+    low.set(id, corner);
+    least = Math.min(least, corner);
+  }
+  for (const [id, corner] of low) low.set(id, corner - least);
+  return low;
+}
+function neighborsOf(rows, hops) {
+  const rank = /* @__PURE__ */ new Map();
+  const pos = /* @__PURE__ */ new Map();
+  const up = /* @__PURE__ */ new Map();
+  const down = /* @__PURE__ */ new Map();
+  for (const [r, row] of rows.entries()) {
+    for (const [i, id] of row.entries()) {
+      rank.set(id, r);
+      pos.set(id, i);
+      up.set(id, []);
+      down.set(id, []);
+    }
+  }
+  for (const hop of hops) {
+    const from = rank.get(hop.from);
+    const to = rank.get(hop.to);
+    if (from === void 0 || to === void 0 || to !== from + 1) {
+      throw new Error(`placeAcross: hop ${hop.from} -> ${hop.to} does not join adjacent ranks`);
+    }
+    const ups = up.get(hop.to);
+    if (!ups.includes(hop.from)) ups.push(hop.from);
+    const downs = down.get(hop.from);
+    if (!downs.includes(hop.to)) downs.push(hop.to);
+  }
+  const byPos = (a, b) => pos.get(a) - pos.get(b);
+  for (const list of up.values()) list.sort(byPos);
+  for (const list of down.values()) list.sort(byPos);
+  return { up, down };
+}
+var isMarked = (conflicts, a, b) => conflicts.get(a)?.has(b) ?? false;
+function mark(conflicts, a, b) {
+  for (const [x, y] of [[a, b], [b, a]]) {
+    let set = conflicts.get(x);
+    if (set === void 0) conflicts.set(x, set = /* @__PURE__ */ new Set());
+    set.add(y);
+  }
+}
+function markConflicts(rows, up) {
+  const conflicts = /* @__PURE__ */ new Map();
+  for (let r = 1; r < rows.length; r++) {
+    const upperPos = new Map(rows[r - 1].map((id, i) => [id, i]));
+    const lower = rows[r];
+    let k0 = 0;
+    let scan = 0;
+    for (let l1 = 0; l1 < lower.length; l1++) {
+      const v = lower[l1];
+      const inner = isPlaceholder(v) ? up.get(v).find(isPlaceholder) : void 0;
+      if (inner === void 0 && l1 !== lower.length - 1) continue;
+      const k1 = inner !== void 0 ? upperPos.get(inner) : rows[r - 1].length - 1;
+      for (; scan <= l1; scan++) {
+        const w = lower[scan];
+        for (const u of up.get(w)) {
+          const k = upperPos.get(u);
+          if ((k < k0 || k > k1) && !(isPlaceholder(u) && isPlaceholder(w))) mark(conflicts, u, w);
+        }
+      }
+      k0 = k1;
+    }
+  }
+  return conflicts;
+}
+function alignedLayout(frame, nbrs, conflicts, downward, right) {
+  const ranks = downward ? frame.rows : [...frame.rows].reverse();
+  const rows = right ? ranks.map((row) => [...row].reverse()) : ranks;
+  const pos = /* @__PURE__ */ new Map();
+  for (const row of rows) for (const [i, id] of row.entries()) pos.set(id, i);
+  const root = /* @__PURE__ */ new Map();
+  const align = /* @__PURE__ */ new Map();
+  const shift = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    for (const id of row) {
+      root.set(id, id);
+      align.set(id, id);
+      shift.set(id, 0);
+    }
+  }
+  const offset = (id, other) => {
+    const below = frame.ports.get(pairKey(id, other));
+    const frac = below !== void 0 ? below[0] : frame.ports.get(pairKey(other, id))?.[1] ?? 0.5;
+    return ((right ? 1 - frac : frac) - 0.5) * frame.size.get(id);
+  };
+  for (const row of rows) {
+    let taken = -1;
+    for (const v of row) {
+      const ws = [...nbrs.get(v)].sort((a, b) => pos.get(a) - pos.get(b));
+      if (ws.length === 0) continue;
+      const lo = Math.floor((ws.length - 1) / 2);
+      const hi = Math.ceil((ws.length - 1) / 2);
+      for (const m of lo === hi ? [lo] : [lo, hi]) {
+        if (align.get(v) !== v) break;
+        const u = ws[m];
+        if (taken < pos.get(u) && !isMarked(conflicts, u, v)) {
+          align.set(u, v);
+          root.set(v, root.get(u));
+          align.set(v, root.get(v));
+          shift.set(v, shift.get(u) + offset(u, v) - offset(v, u));
+          taken = pos.get(u);
+        }
+      }
+    }
+  }
+  const xs = compact(rows, root, shift, frame);
+  const out = /* @__PURE__ */ new Map();
+  for (const [id, r] of root) {
+    const x = xs.get(r) + shift.get(id);
+    out.set(id, right ? -x : x);
+  }
+  return out;
+}
+function compact(rows, root, shift, frame) {
+  const blocks = [];
+  const preds = /* @__PURE__ */ new Map();
+  const succs = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    for (const id of row) {
+      const r = root.get(id);
+      if (preds.has(r)) continue;
+      blocks.push(r);
+      preds.set(r, /* @__PURE__ */ new Map());
+      succs.set(r, /* @__PURE__ */ new Map());
+    }
+  }
+  for (const row of rows) {
+    for (let j = 1; j < row.length; j++) {
+      const a = row[j - 1];
+      const b = row[j];
+      const ra = root.get(a);
+      const rb = root.get(b);
+      const sep = (frame.size.get(a) + frame.size.get(b)) / 2 + frame.gap + shift.get(a) - shift.get(b);
+      const prior = preds.get(rb).get(ra) ?? -Infinity;
+      if (sep <= prior) continue;
+      preds.get(rb).set(ra, sep);
+      succs.get(ra).set(rb, sep);
+    }
+  }
+  const waiting = new Map(blocks.map((b) => [b, preds.get(b).size]));
+  const order = [];
+  const ready = blocks.filter((b) => waiting.get(b) === 0);
+  while (ready.length > 0) {
+    const b = ready.shift();
+    order.push(b);
+    for (const s of succs.get(b).keys()) {
+      const left = waiting.get(s) - 1;
+      waiting.set(s, left);
+      if (left === 0) ready.push(s);
+    }
+  }
+  if (order.length !== blocks.length) throw new Error("placeAcross: alignment produced crossing blocks");
+  const xs = /* @__PURE__ */ new Map();
+  for (const b of order) {
+    let x = 0;
+    for (const [p, sep] of preds.get(b)) x = Math.max(x, xs.get(p) + sep);
+    xs.set(b, x);
+  }
+  for (let i = order.length - 1; i >= 0; i--) {
+    const b = order[i];
+    let x = Infinity;
+    for (const [s, sep] of succs.get(b)) x = Math.min(x, xs.get(s) - sep);
+    if (x !== Infinity && x > xs.get(b)) xs.set(b, x);
+  }
+  return xs;
+}
+function spanOf3(xs, size) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const [id, x] of xs) {
+    min = Math.min(min, x - size.get(id) / 2);
+    max = Math.max(max, x + size.get(id) / 2);
+  }
+  return { min, max };
+}
+
+// src/layered/plan.ts
+var LABEL_GAP = 0.75;
+var MIN_GAP = 0.25;
+function layeredPlan(graph, opts = {}) {
+  if ((graph.groups?.length ?? 0) === 0 || opts.order === "barycenter") return planOnce(graph, opts);
+  let last;
+  const moves = untilSettled((g, o) => {
+    last = planOnce(last === void 0 ? g : { ...g, edges: g.edges.map((e) => routed(e, last)) }, o);
+    return last.moves;
+  }, 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 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 });
+  const rows = finding ? orderRows(expanded.rows, expanded.hops, { groups: graph.groups ?? [] }) : expanded.rows;
+  const preferred2 = placeAcross(rows, settlePlaces(rows, expanded.hops), axes.cross, nodeGap);
+  const grouped = (graph.groups?.length ?? 0) > 0;
+  const packed = grouped ? packClusters(graph, rows, preferred2, axes, nodeGap) : preferred2;
+  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 pinned = pinnedSet(graph, opts);
+  const { crossAt, gaps, depths, 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];
+    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 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 [lo, hi] = bands[rankOf.get(id)];
+      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/chainRoutes.ts
+var portOf3 = (node, id) => id === void 0 ? void 0 : node.ports?.find((p) => p.id === id);
+function coord(node, at2, id, axis) {
+  const spec = portOf3(node, id);
+  if (spec === void 0) return void 0;
+  const anchor = axis === "x" ? spec.at.u : spec.at.v;
+  return { along: (axis === "x" ? at2.x : at2.y) + anchor * (axis === "x" ? node.bounds.width : node.bounds.height), anchor };
+}
+function sidesOf2(graph, hanging, moves, axes, before) {
+  const at2 = (node) => moves.get(node.id) ?? node.bounds;
+  const byLine = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    const lineFirst = hanging.level.get(edge.from) === 0;
+    const [lineId, hungId] = lineFirst ? [edge.from, edge.to] : [edge.to, edge.from];
+    if (hanging.level.get(lineId) !== 0 || hanging.level.get(hungId) !== 1 || hanging.owner.get(hungId) !== lineId) continue;
+    const line = graph.node(lineId);
+    const hung = graph.node(hungId);
+    const [linePort, hungPort] = lineFirst ? [edge.fromPort, edge.toPort] : [edge.toPort, edge.fromPort];
+    const lineCross = coord(line, at2(line), linePort, axes.cross);
+    const hungCross = coord(hung, at2(hung), hungPort, axes.cross);
+    if (lineCross?.anchor !== (before ? 0 : 1) || hungCross?.anchor !== (before ? 1 : 0)) continue;
+    const side = {
+      edge,
+      lineFirst,
+      port: coord(line, at2(line), linePort, axes.rank).along,
+      hung: coord(hung, at2(hung), hungPort, axes.rank).along,
+      lineEdge: lineCross.along,
+      hungEdge: hungCross.along
+    };
+    const list = byLine.get(lineId);
+    if (list === void 0) byLine.set(lineId, [side]);
+    else list.push(side);
+  }
+  return byLine;
+}
+var SIDE_TRACK_GAP = 12;
+function turning(sides) {
+  const sideways = sides.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)
+  ];
+}
+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);
+    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));
+    const step = (hungEdge - lineEdge) / (Math.max(low.length, high.length) + 1);
+    for (const run of [low, high]) {
+      run.forEach((s, k) => {
+        const track = lineEdge + step * (k + 1);
+        const dir = Math.sign(s.hung - s.port);
+        const half = Math.abs(s.hung - s.port) / 2;
+        const turns = [
+          { rank: s.port + dir * Math.min(Math.abs(track - s.lineEdge), half), cross: track },
+          { rank: s.hung - dir * Math.min(Math.abs(s.hungEdge - track), half), cross: track }
+        ];
+        const points = turns.map((t) => axes.rank === "x" ? { x: t.rank, y: t.cross } : { x: t.cross, y: t.rank });
+        out.set(s.edge.id, s.lineFirst ? points : points.reverse());
+      });
+    }
+  }
+  return out;
+}
+function inPortOrder(graph, lineId, row, axes) {
+  const line = graph.node(lineId);
+  const keyOf = (node) => {
+    const anchors = [
+      ...graph.outgoing(node.id).filter((e) => e.to === lineId).map((e) => e.toPort),
+      ...graph.incoming(node.id).filter((e) => e.from === lineId).map((e) => e.fromPort)
+    ].flatMap((id) => {
+      const spec = portOf3(line, id);
+      return spec === void 0 ? [] : [axes.rank === "x" ? spec.at.u : spec.at.v];
+    });
+    return anchors.length === 0 ? void 0 : axes.sign * anchors.reduce((a, b) => a + b, 0) / anchors.length;
+  };
+  const keyed = row.map((node) => ({ node, key: keyOf(node) }));
+  const slots = keyed.flatMap((k, i) => k.key === void 0 ? [] : [i]);
+  const sorted = keyed.filter((k) => k.key !== void 0).sort((a, b) => a.key - b.key);
+  const out = [...row];
+  slots.forEach((i, j) => {
+    out[i] = sorted[j].node;
+  });
+  return out;
+}
+
+// src/chain.ts
+function lineOf(graph, ids) {
+  const seen = /* @__PURE__ */ new Set();
+  const given = (ids ?? []).flatMap((id) => {
+    const node = graph.node(id);
+    if (node === void 0 || seen.has(id)) return [];
+    seen.add(id);
+    return [node];
+  });
+  if (given.length > 0) return given;
+  const back = backEdges(graph);
+  const ranks = ranksOf(graph, back);
+  let end;
+  for (const node of graph.nodes) {
+    if (end === void 0 || ranks.get(node.id) > ranks.get(end.id)) end = node;
+  }
+  const line = [];
+  for (let at2 = end; 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);
+    at2 = edge === void 0 ? void 0 : graph.node(edge.from);
+  }
+  return line;
+}
+function hangFrom(graph, line) {
+  const owner = new Map(line.map((n) => [n.id, n.id]));
+  const level = new Map(line.map((n) => [n.id, 0]));
+  for (let frontier = line.map((n) => n.id); frontier.length > 0; ) {
+    const next = [];
+    for (const id of frontier) {
+      const near = [...graph.incoming(id).map((e) => e.from), ...graph.outgoing(id).map((e) => e.to)];
+      for (const other of near) {
+        if (owner.has(other) || graph.node(other) === void 0) continue;
+        owner.set(other, owner.get(id));
+        level.set(other, level.get(id) + 1);
+        next.push(other);
+      }
+    }
+    frontier = next;
+  }
+  const last = line[line.length - 1].id;
+  for (const node of graph.nodes) {
+    if (owner.has(node.id)) continue;
+    owner.set(node.id, last);
+    level.set(node.id, 1);
+  }
+  return { owner, level };
+}
+var chain = Object.assign(
+  (graph, opts = {}) => chainPlan(graph, opts).moves,
+  { plan: chainPlan }
+);
+function chainPlan(graph, opts = {}) {
+  const axes = axesFor(opts.direction);
+  const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;
+  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 { owner, level } = hanging;
+  const rows = new Map(line.map((n) => [n.id, []]));
+  const levelSize = [Math.max(...line.map((n) => extent(n.bounds, axes.cross)))];
+  for (const node of graph.nodes) {
+    const at2 = level.get(node.id);
+    if (at2 === 0) continue;
+    const column = rows.get(owner.get(node.id));
+    (column[at2] ??= []).push(node);
+    levelSize[at2] = Math.max(levelSize[at2] ?? 0, extent(node.bounds, axes.cross));
+  }
+  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);
+  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 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);
+    return before ? -offset : offset;
+  };
+  const slots = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  for (const node of line) {
+    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, {
+      cross: (levelSize[0] - extent(node.bounds, axes.cross)) / 2,
+      rank: cursor + (span - extent(node.bounds, axes.rank)) / 2
+    });
+    column.forEach((row, at2) => {
+      if (!row) return;
+      let along = cursor + (span - rowSpan(row)) / 2;
+      for (const hung of row) {
+        const cross = before ? bandStart(at2) + levelSize[at2] - extent(hung.bounds, axes.cross) : bandStart(at2);
+        slots.set(hung.id, { cross, rank: along });
+        along += extent(hung.bounds, axes.rank) + nodeGap;
+      }
+    });
+    cursor += span + rankGap;
+  }
+  return slots;
+}
+
+// src/tree.ts
+function forestOf(graph, crossAxis) {
+  const order = graphOrder(graph);
+  const children = /* @__PURE__ */ new Map();
+  const depth = /* @__PURE__ */ new Map();
+  const roots = [];
+  const claim = (node, at2) => {
+    depth.set(node.id, at2);
+    const kids = [];
+    for (const edge of graph.outgoing(node.id)) {
+      if (edge.to === node.id || depth.has(edge.to)) continue;
+      const child = graph.node(edge.to);
+      if (child === void 0) continue;
+      depth.set(child.id, at2 + 1);
+      kids.push(child);
+    }
+    const ordered = seededOrder(kids, crossAxis, order);
+    children.set(node.id, ordered);
+    for (const child of ordered) claim(child, at2 + 1);
+  };
+  const rootish = graph.nodes.filter((node) => graph.incoming(node.id).every((edge) => edge.from === node.id));
+  for (const node of seededOrder(rootish, crossAxis, order)) {
+    if (depth.has(node.id)) continue;
+    roots.push(node);
+    claim(node, 0);
+  }
+  for (const node of graph.nodes) {
+    if (depth.has(node.id)) continue;
+    roots.push(node);
+    claim(node, 0);
+  }
+  return { roots, children, depth };
+}
+var tree = (graph, opts = {}) => (graph.groups?.length ?? 0) > 0 ? untilSettled(treeOnce, graph, opts) : treeOnce(graph, opts);
+var treeOnce = (graph, opts = {}) => {
+  const axes = axesFor(opts.direction);
+  const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;
+  const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;
+  const { roots, children, depth } = forestOf(graph, axes.cross);
+  const bands = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    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 grouped = (graph.groups?.length ?? 0) > 0;
+  const gaps = grouped ? rankGaps(graph, rowsAt, axes, rankGap) : depths.slice(1).map(() => rankGap);
+  const bandStart = /* @__PURE__ */ new Map();
+  let along = 0;
+  for (const [i, at2] of depths.entries()) {
+    bandStart.set(at2, along);
+    along += bands.get(at2) + (gaps[i] ?? 0);
+  }
+  const slots = /* @__PURE__ */ new Map();
+  const measured = /* @__PURE__ */ new Map();
+  const measure = (node) => {
+    const known = measured.get(node.id);
+    if (known !== void 0) return known;
+    const kids = children.get(node.id) ?? [];
+    let width = 0;
+    for (const child of kids) width += measure(child);
+    if (kids.length > 0) width += nodeGap * (kids.length - 1);
+    const block = Math.max(extent(node.bounds, axes.cross), width);
+    measured.set(node.id, block);
+    return block;
+  };
+  const place = (node, from) => {
+    const kids = children.get(node.id) ?? [];
+    const block = measure(node);
+    const width = kids.reduce((sum, k) => sum + measure(k), 0) + Math.max(0, kids.length - 1) * nodeGap;
+    let cursor2 = from + (block - width) / 2;
+    for (const child of kids) {
+      place(child, cursor2);
+      cursor2 += measure(child) + nodeGap;
+    }
+    const own = extent(node.bounds, axes.cross);
+    const at2 = depth.get(node.id) ?? 0;
+    slots.set(node.id, {
+      cross: from + (block - own) / 2,
+      rank: bandStart.get(at2) + (bands.get(at2) - extent(node.bounds, axes.rank)) / 2
+    });
+  };
+  let cursor = 0;
+  for (const root of roots) {
+    place(root, cursor);
+    cursor += measure(root) + nodeGap;
+  }
+  if (grouped) {
+    const preferred2 = new Map([...slots].map(([id, slot]) => [id, slot.cross]));
+    const ordered = rowsAt.map((row) => [...row].sort((a, b) => preferred2.get(a.id) - preferred2.get(b.id)));
+    const crossAt = packClusters(graph, ordered, preferred2, axes, nodeGap);
+    for (const [id, slot] of slots) slots.set(id, { ...slot, cross: crossAt.get(id) ?? slot.cross });
+  }
+  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