@weasel-js/diagram 1.10.1 → 1.11.1

package/dist/chunk-43LDZ6L4.js

@@ -0,0 +1,2053 @@
+import { grownBy, labelCenter, diagramEdgeOf, DIAGRAM_TRAIT_KEY, insetOf, subpathOf, portsOf, portSitesOf, routeHolds, sizeToBody, measureBody, layoutBody, layoutOwnsRoute, diagramNodeOf, expandGroupEdges, DEFAULT_GROUP_INSET, bodyTrait, authoredOver, chain, force, tree, layered, planOf, buildBody } from './chunk-IM6DHWZO.js';
+import { bodyPredicate, AUTO_POSE_DESCRIPTOR, translatePoseViaDescriptor, createTransformOp, polylineFromPoints, PathBuilder, documentDepOf, documentPose, composeAffordanceLayer, ActionDisabledReason, pageName, pageOfBounds, layoutPages, RECT_POSE_DESCRIPTOR, commandFill, commandStroke, transformPath, registerNodeShape, pathFromD } from '@weasel-js/core';
+import { PathBuilder as PathBuilder$1, polylineFromPoints as polylineFromPoints$1, portCurvePoints } from '@weasel-js/geom';
+import { AUTO_POSE_DESCRIPTOR as AUTO_POSE_DESCRIPTOR$1 } from '@weasel-js/core/math';
+
+function traitOf(node) {
+  const data = node.data;
+  if (data === null || typeof data !== "object") return null;
+  const trait = data[DIAGRAM_TRAIT_KEY];
+  return trait !== null && typeof trait === "object" ? trait : null;
+}
+function diagramGroupOf(node) {
+  const group = traitOf(node)?.group;
+  return group !== null && typeof group === "object" ? group : null;
+}
+function diagramAnchorOf(node) {
+  const anchor = traitOf(node)?.anchor;
+  return anchor !== null && typeof anchor === "object" && "at" in anchor ? anchor : null;
+}
+function groupDerivePose(opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  return (node, deps) => {
+    const group = diagramGroupOf(node);
+    if (group === null) return null;
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const dep of deps) {
+      if (dep === void 0) continue;
+      const b = grownBy(geometry.getBounds(dep.pose), traitOf(dep.node)?.margin);
+      x0 = Math.min(x0, b.x);
+      y0 = Math.min(y0, b.y);
+      x1 = Math.max(x1, b.x + b.width);
+      y1 = Math.max(y1, b.y + b.height);
+    }
+    if (!Number.isFinite(x0)) return null;
+    return geometry.fromBounds(boxAround({ x: x0, y: y0, width: x1 - x0, height: y1 - y0 }, group), node.pose);
+  };
+}
+function boxAround(union, group) {
+  const inset = insetOf(group.inset);
+  const width = union.width + inset.left + inset.right;
+  const grow = Math.max(0, (group.minWidth ?? 0) - width);
+  return {
+    x: union.x - inset.left - grow / 2,
+    y: union.y - inset.top,
+    width: width + grow,
+    height: union.height + inset.top + inset.bottom
+  };
+}
+function anchorDerivePose(opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  return (node, deps) => {
+    const anchor = diagramAnchorOf(node);
+    const dep = deps[0];
+    if (anchor === null || dep === void 0) return null;
+    const target = geometry.getBounds(dep.pose);
+    const own = geometry.getBounds(node.pose);
+    const self = anchor.self ?? anchor.at;
+    const x = target.x + anchor.at.u * target.width + (anchor.offset?.x ?? 0) - self.u * own.width;
+    const y = target.y + anchor.at.v * target.height + (anchor.offset?.y ?? 0) - self.v * own.height;
+    return translatePoseViaDescriptor(node.pose, x - own.x, y - own.y, geometry);
+  };
+}
+var DIAGRAM_GROUP = "diagram:group";
+var DIAGRAM_ANCHOR = "diagram:anchor";
+var GROUP_DERIVE_POSE = groupDerivePose();
+var ANCHOR_DERIVE_POSE = anchorDerivePose();
+
+// src/containers/trait.ts
+function traitOf2(node) {
+  const data = node.data;
+  if (data === null || typeof data !== "object") return null;
+  const trait = data[DIAGRAM_TRAIT_KEY];
+  return trait !== null && typeof trait === "object" ? trait : null;
+}
+function diagramContainerOf(node) {
+  const c = traitOf2(node)?.container;
+  return c !== null && typeof c === "object" && typeof c.role === "string" ? c : null;
+}
+function laneOutlineOf(node) {
+  if (diagramContainerOf(node)?.role !== "lane") return void 0;
+  return traitOf2(node)?.outline;
+}
+var titleIdOf = (containerId) => `${containerId}/title`;
+function headerBox(bounds, header) {
+  if (header === void 0) return null;
+  return header.side === "top" ? { x: bounds.x, y: bounds.y, width: bounds.width, height: Math.min(header.size, bounds.height) } : { x: bounds.x, y: bounds.y, width: Math.min(header.size, bounds.width), height: bounds.height };
+}
+function bodyBox(bounds, header) {
+  const h = headerBox(bounds, header);
+  if (h === null) return { ...bounds };
+  return header.side === "top" ? { x: bounds.x, y: bounds.y + h.height, width: bounds.width, height: bounds.height - h.height } : { x: bounds.x + h.width, y: bounds.y, width: bounds.width - h.width, height: bounds.height };
+}
+
+// src/containers/titlePose.ts
+function titlePose(bounds, header) {
+  const h = headerBox(bounds, header) ?? { ...bounds, height: 0 };
+  if (header?.side !== "left") return { x: h.x, y: h.y, width: h.width, height: h.height };
+  const cx = h.x + h.width / 2;
+  const cy = h.y + h.height / 2;
+  return { x: cx - h.height / 2, y: cy - h.width / 2, width: h.height, height: h.width, rotation: -Math.PI / 2 };
+}
+var center = (p) => ({ x: p.x + p.width / 2, y: p.y + p.height / 2 });
+function titlePoses(container, children, header) {
+  const out = /* @__PURE__ */ new Map();
+  const title = children.find((c) => c.id === titleIdOf(container.id));
+  if (title !== void 0) out.set(title.id, titlePose(container.bounds, header));
+  return out;
+}
+function diagramContainerLayout(opts = {}) {
+  const { header } = opts;
+  return {
+    snap: { pickTarget: (targets) => targets[0] ?? null },
+    childPoses: (container, children) => titlePoses(container, children, header),
+    getDropTargets: (_container, _children, dragged) => [{ pose: dragged.pose, origin: center(dragged.pose) }],
+    reflowPoses: () => /* @__PURE__ */ new Map(),
+    commitDrop: (_container, _children, dragged, target) => [createTransformOp({
+      id: dragged.id,
+      from: dragged.originPose,
+      to: target?.pose ?? dragged.pose,
+      label: "Drop"
+    })],
+    dropRegion(container) {
+      const b = container.bounds;
+      const body = bodyBox(b, header);
+      return { kind: "rect", x: body.x - b.x, y: body.y - b.y, width: body.width, height: body.height };
+    }
+  };
+}
+var POOL_HEADER_SIZE = 32;
+var MIN_LANE_SIZE = 40;
+var poolHeader = (axis, size = POOL_HEADER_SIZE) => ({ side: axis === "y" ? "left" : "top", size });
+function stackedLanes(axis, bounds, header, lanes) {
+  const body = bodyBox(bounds, header);
+  const out = /* @__PURE__ */ new Map();
+  let at = axis === "y" ? bounds.y : bounds.x;
+  for (const { id, size } of lanes) {
+    out.set(id, axis === "y" ? { x: body.x, y: at, width: body.width, height: size } : { x: at, y: body.y, width: size, height: body.height });
+    at += size;
+  }
+  return out;
+}
+function laneStackLayout(opts) {
+  const { axis } = opts;
+  const header = poolHeader(axis, opts.headerSize);
+  const along = (p) => axis === "y" ? p.height : p.width;
+  const mid = (p) => axis === "y" ? p.y + p.height / 2 : p.x + p.width / 2;
+  const lanesOf = (container, children, skip) => children.filter((c) => c.id !== titleIdOf(container.id) && c.id !== skip).sort((a, b) => mid(a.pose) - mid(b.pose));
+  const sized = (lanes) => lanes.map((l) => ({ id: l.id, size: along(l.pose) }));
+  const withTitle = (container, children, poses, bounds = container.bounds) => {
+    if (children.some((c) => c.id === titleIdOf(container.id))) poses.set(titleIdOf(container.id), titlePose(bounds, header));
+    return poses;
+  };
+  const resized = (container, children, lanes) => {
+    const sizes = sized(lanes);
+    const total = Math.max(MIN_LANE_SIZE, sizes.reduce((s, l) => s + l.size, 0));
+    const bounds = axis === "y" ? { ...container.bounds, height: total } : { ...container.bounds, width: total };
+    return { poses: withTitle(container, children, stackedLanes(axis, bounds, header, sizes), bounds), bounds };
+  };
+  const insertAt = (container, children, dragged, index) => {
+    const sizes = sized(lanesOf(container, children, dragged.id));
+    sizes.splice(index, 0, { id: dragged.id, size: along(dragged.pose) });
+    return stackedLanes(axis, container.bounds, header, sizes);
+  };
+  const shifted = (container, children, dragged, target) => {
+    if (target === null) return /* @__PURE__ */ new Map();
+    const poses = insertAt(container, children, dragged, target.meta.index);
+    poses.delete(dragged.id);
+    return poses;
+  };
+  return {
+    snap: {
+      pickTarget(targets, pointer) {
+        const p = axis === "y" ? pointer.y : pointer.x;
+        let best = null;
+        for (const t of targets) {
+          if (best === null || Math.abs(t.origin[axis] - p) < Math.abs(best.origin[axis] - p)) best = t;
+        }
+        return best;
+      }
+    },
+    childPoses(container, children) {
+      const sizes = sized(lanesOf(container, children));
+      const last = sizes[sizes.length - 1];
+      if (last !== void 0) {
+        const slack = along(container.bounds) - sizes.reduce((s, l) => s + l.size, 0);
+        last.size = Math.max(MIN_LANE_SIZE, last.size + slack);
+      }
+      return withTitle(container, children, stackedLanes(axis, container.bounds, header, sizes));
+    },
+    getDropTargets(container, children, dragged) {
+      const count = lanesOf(container, children, dragged.id).length;
+      const self = { id: dragged.id, pose: dragged.pose };
+      const targets = [];
+      for (let index = 0; index <= count; index++) {
+        const pose = insertAt(container, children, self, index).get(dragged.id);
+        targets.push({ pose, origin: { x: pose.x + pose.width / 2, y: pose.y + pose.height / 2 }, meta: { index } });
+      }
+      return targets;
+    },
+    reflowPoses: shifted,
+    commitDrop(container, children, dragged, target) {
+      const ops = [];
+      const poses = shifted(container, children, dragged, target);
+      for (const c of children) {
+        const to = poses.get(c.id);
+        if (to !== void 0 && (to.x !== c.pose.x || to.y !== c.pose.y)) {
+          ops.push(createTransformOp({ id: c.id, from: c.pose, to, label: "Shift lane" }));
+        }
+      }
+      ops.push(createTransformOp({
+        id: dragged.id,
+        from: dragged.originPose,
+        to: target?.pose ?? dragged.pose,
+        label: "Move lane"
+      }));
+      return ops;
+    },
+    arrive: (container, children) => resized(container, children, lanesOf(container, children)),
+    depart: (container, children) => resized(container, children, lanesOf(container, children)),
+    dropRegion(container) {
+      const b = container.bounds;
+      const body = bodyBox(b, header);
+      return { kind: "rect", x: body.x - b.x, y: body.y - b.y, width: body.width, height: body.height };
+    },
+    releaseDrop: () => []
+  };
+}
+
+// src/containers/layouts.ts
+var CONTAINER_HEADER = { side: "top", size: 28 };
+var LANE_HEADER_SIZE = 28;
+var laneHeader = (axis) => ({ side: axis === "y" ? "left" : "top", size: LANE_HEADER_SIZE });
+var DIAGRAM_CONTAINER_LAYOUT = "diagram:container";
+var DIAGRAM_POOL_ROWS_LAYOUT = "diagram:pool-rows";
+var DIAGRAM_POOL_COLUMNS_LAYOUT = "diagram:pool-columns";
+var DIAGRAM_LANE_ROWS_LAYOUT = "diagram:lane-rows";
+var DIAGRAM_LANE_COLUMNS_LAYOUT = "diagram:lane-columns";
+var CONTAINER_LAYOUTS = Object.freeze({
+  [DIAGRAM_CONTAINER_LAYOUT]: diagramContainerLayout({ header: CONTAINER_HEADER }),
+  [DIAGRAM_POOL_ROWS_LAYOUT]: laneStackLayout({ axis: "y" }),
+  [DIAGRAM_POOL_COLUMNS_LAYOUT]: laneStackLayout({ axis: "x" }),
+  [DIAGRAM_LANE_ROWS_LAYOUT]: diagramContainerLayout({ header: laneHeader("y") }),
+  [DIAGRAM_LANE_COLUMNS_LAYOUT]: diagramContainerLayout({ header: laneHeader("x") })
+});
+function containerShape(role, axis = "y") {
+  if (role === "pool") return { layout: axis === "y" ? DIAGRAM_POOL_ROWS_LAYOUT : DIAGRAM_POOL_COLUMNS_LAYOUT, header: poolHeader(axis) };
+  if (role === "lane") return { layout: axis === "y" ? DIAGRAM_LANE_ROWS_LAYOUT : DIAGRAM_LANE_COLUMNS_LAYOUT, header: laneHeader(axis) };
+  return { layout: DIAGRAM_CONTAINER_LAYOUT, header: CONTAINER_HEADER };
+}
+
+// src/labelTrait.ts
+var LABEL_PLACEMENT = { at: "mid", offset: 9 };
+function diagramLabelOf(node) {
+  const data = node.data;
+  if (data === null || typeof data !== "object") return null;
+  const trait = data.diagram;
+  if (trait === null || typeof trait !== "object") return null;
+  const label = trait.label;
+  if (label === null || typeof label !== "object") return null;
+  return "at" in label ? label : null;
+}
+function labelDerivePose(opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  return (node, deps) => {
+    const label = diagramLabelOf(node);
+    if (label === null) return null;
+    const path = deps[0]?.path ?? null;
+    if (path === null) return null;
+    const bounds = geometry.getBounds(node.pose);
+    const center2 = labelCenter(path, label, bounds);
+    if (center2 === null) return null;
+    return translatePoseViaDescriptor(
+      node.pose,
+      center2.x - (bounds.x + bounds.width / 2),
+      center2.y - (bounds.y + bounds.height / 2),
+      geometry
+    );
+  };
+}
+var DIAGRAM_LABEL = "diagram:label";
+var LABEL_DERIVE_POSE = labelDerivePose();
+var LABEL_DRAG_LAYER_ID = "diagram-edge-labels";
+var LABEL_DRAG_AFFORDANCE_KIND = `layer:${LABEL_DRAG_LAYER_ID}`;
+function labelScratchOf(hit) {
+  const payload = hit?.payload;
+  return payload !== void 0 && typeof payload.labelId === "string" && typeof payload.edgeId === "string" ? payload : null;
+}
+var labelEditable = (scene, labelId, edgeId) => !scene.isLocked(labelId) && !scene.isLocked(edgeId) && !scene.isHidden(labelId);
+function* editableLabels(scene, edges) {
+  for (const node of scene.renderOrderNodes()) {
+    const label = diagramLabelOf(node);
+    if (label === null) continue;
+    const deps = node.dependsOn;
+    if (!Array.isArray(deps) || deps.length !== 1) continue;
+    const edgeId = deps[0];
+    if (edges !== void 0 && !edges.has(edgeId)) continue;
+    if (labelEditable(scene, node.id, edgeId)) yield { labelId: node.id, edgeId, label };
+  }
+}
+function* draggableLabels(scene) {
+  for (const { labelId, edgeId } of editableLabels(scene)) {
+    const path = documentDepOf(scene, edgeId)?.path ?? null;
+    if (path === null) continue;
+    const box = AUTO_POSE_DESCRIPTOR.getBounds(documentPose(scene, scene.get(labelId)));
+    yield { labelId, edgeId, box, path };
+  }
+}
+var holds = (b, at) => at.x >= b.x && at.x <= b.x + b.width && at.y >= b.y && at.y <= b.y + b.height;
+function labelUnder(scene, at) {
+  let found = null;
+  for (const { labelId, edgeId, box } of draggableLabels(scene)) {
+    if (holds(box, at)) found = { targetId: labelId, labelId, edgeId };
+  }
+  return found;
+}
+function createLabelDragAffordance(scene, cursor) {
+  return {
+    id: LABEL_DRAG_LAYER_ID,
+    regions() {
+      const out = [];
+      for (const { labelId, edgeId, box } of draggableLabels(scene)) {
+        out.push({
+          id: labelId,
+          targetId: null,
+          shape: { kind: "rect", x: box.x, y: box.y, width: box.width, height: box.height },
+          cursor,
+          strength: "exclusive",
+          claimedKinds: ["pointer"],
+          bind: () => ({ initialScratch: { targetId: labelId, labelId, edgeId } })
+        });
+      }
+      return out;
+    }
+  };
+}
+function labelDragLayer(scene, opts = {}) {
+  return composeAffordanceLayer(
+    LABEL_DRAG_LAYER_ID,
+    "Diagram edge labels",
+    [createLabelDragAffordance(scene, opts.cursor ?? "move")]
+  );
+}
+var labelStyleOf = (font) => ({ ...font, fontSize: font.fontSize - 2 });
+var DEFAULT_FONT = { fontFamily: "sans-serif", fontSize: 12 };
+var GLYPH = 0.6;
+var LABEL_STYLE = labelStyleOf(DEFAULT_FONT);
+var LABEL_FILL = "#dbe7f2";
+function labelSize(text, style, measure) {
+  const size = style.fontSize ?? LABEL_STYLE.fontSize;
+  return { width: measure !== void 0 ? measure(text, style).width : text.length * size * GLYPH, height: size };
+}
+function edgeLabelSpec(edgeId, text, opts) {
+  const style = opts.style ?? LABEL_STYLE;
+  return {
+    id: `${edgeId}/label`,
+    kind: "leaf",
+    layer: opts.layer,
+    pickable: false,
+    pose: { x: 0, y: 0, ...labelSize(text, style, opts.measure) },
+    data: {
+      diagram: { label: opts.label ?? LABEL_PLACEMENT },
+      text,
+      style,
+      fill: { paint: { color: opts.fill ?? LABEL_FILL } }
+    },
+    dependsOn: [edgeId],
+    derivePose: LABEL_DERIVE_POSE
+  };
+}
+function dropEmptyEdgeLabel(scene, id) {
+  const node = scene.get(id);
+  if (node === void 0 || diagramLabelOf(node) === null) return false;
+  const text = node.data.text;
+  if (typeof text === "string" && text.trim() !== "") return false;
+  scene.remove(id);
+  return true;
+}
+var EDIT_EDGE_LABEL_ACTION_ID = "diagram.editEdgeLabel";
+function edgeUnder(deps, at) {
+  if (deps === void 0 || at === void 0) return null;
+  const label = deps.scene === void 0 ? null : labelUnder(deps.scene, at);
+  if (label !== null) return label.edgeId;
+  const id = deps.nodeAtPoint?.(at);
+  const node = id == null ? void 0 : deps.scene?.get(id);
+  return node !== void 0 && diagramEdgeOf(node) !== null ? id : null;
+}
+function beginEditing(edgeId, ctx, look) {
+  const { scene, textEdit } = ctx.deps;
+  if (scene === void 0) return;
+  const labelId = `${edgeId}/label`;
+  if (scene.get(labelId) === void 0) {
+    const edge = scene.get(edgeId);
+    if (edge === void 0) return;
+    scene.add(edgeLabelSpec(edgeId, "", {
+      layer: edge.layer,
+      ...look.style ? { style: look.style } : {},
+      ...look.fill !== void 0 ? { fill: look.fill } : {}
+    }));
+  }
+  textEdit?.startEdit(labelId);
+}
+function editEdgeLabelAction(opts = {}) {
+  const commit = opts.commit ?? ((edgeId, ctx) => beginEditing(edgeId, ctx, opts));
+  return {
+    id: EDIT_EDGE_LABEL_ACTION_ID,
+    label: "Edit edge label",
+    group: "diagram",
+    requires: ["scene", "nodeAtPoint", "textEdit"],
+    eligible: { mode: { in: ["normal", "isolation"] } },
+    invoker: {
+      timing: "immediate",
+      run(deps, params) {
+        const world = { x: Number(params?.worldX), y: Number(params?.worldY) };
+        const pressed = labelScratchOf(params?.affordance);
+        const edgeId = pressed?.edgeId ?? edgeUnder(deps, world);
+        if (edgeId === null) return;
+        const ctx = { world, modifiers: { alt: false, shift: false, meta: false, ctrl: false }, deps };
+        commit(edgeId, ctx);
+      }
+    },
+    enabled: (deps, at) => edgeUnder(deps, at) !== null ? true : ActionDisabledReason.NotApplicable
+  };
+}
+var onBody = bodyPredicate((target) => target === "selected-body" || target === "unselected-body");
+function editEdgeLabelBinding(actionId = EDIT_EDGE_LABEL_ACTION_ID) {
+  return { spec: { kind: "doubleClick", target: { kindOf: onBody } }, actionId };
+}
+
+// src/theme/themes.ts
+var SANS = { family: "sans-serif", size: 12 };
+var INK = "#1f2933";
+var paper = {
+  id: "paper",
+  name: "Paper",
+  roles: {
+    default: { fill: "#ffffff", stroke: "#3e4c59", text: INK },
+    accent: { fill: "#e6f0ff", stroke: "#2f6fd6", text: INK },
+    muted: { fill: "#f3f5f7", stroke: "#9aa5b1", text: "#616e7c" },
+    positive: { fill: "#e8f6ec", stroke: "#2f9e57", text: INK },
+    warning: { fill: "#fdf4dc", stroke: "#c98a0b", text: INK },
+    negative: { fill: "#fdecec", stroke: "#d14343", text: INK }
+  },
+  defaultRole: "default",
+  edge: { stroke: "#3e4c59", width: 2, markerEnd: "arrow" },
+  label: { fill: INK },
+  container: { fill: "rgba(62, 76, 89, 0.04)", stroke: "#7b8794", text: "#52606d", strokeWidth: 1, dash: [4, 3] },
+  lane: {
+    header: { fill: "#e4e7eb", stroke: "#9aa5b1", text: INK, strokeWidth: 1 },
+    bodies: [
+      { fill: "#ffffff", stroke: "#cbd2d9", text: INK, strokeWidth: 1 },
+      { fill: "#f5f7fa", stroke: "#cbd2d9", text: INK, strokeWidth: 1 }
+    ]
+  },
+  page: "#ffffff",
+  font: SANS,
+  series: ["#2f6fd6", "#8b5cf6", "#c98a0b", "#2f9e57", "#e8590c", "#0f9b8e", "#d6336c", "#7b8794"]
+};
+var NIGHT_TEXT = "#dbe7f2";
+var night = {
+  id: "night",
+  name: "Night",
+  roles: {
+    default: { fill: "#16222c", stroke: "#3d566b", text: NIGHT_TEXT, strokeWidth: 1.5 },
+    accent: { fill: "#13263a", stroke: "#6fb3ff", text: NIGHT_TEXT, strokeWidth: 1.5 },
+    muted: { fill: "#121a21", stroke: "#3d566b", text: "#6d8496", strokeWidth: 1.5 },
+    positive: { fill: "#14261c", stroke: "#5ad07f", text: NIGHT_TEXT, strokeWidth: 1.5 },
+    warning: { fill: "#2a2414", stroke: "#f2c14e", text: NIGHT_TEXT, strokeWidth: 1.5 },
+    negative: { fill: "#2c1618", stroke: "#ff5d5d", text: NIGHT_TEXT, strokeWidth: 1.5 }
+  },
+  defaultRole: "default",
+  edge: { stroke: "#7ba7c7", width: 2, markerEnd: "arrow" },
+  label: { fill: NIGHT_TEXT },
+  container: { fill: "rgba(123, 167, 199, 0.08)", stroke: "#7ba7c7", text: "#9fbdd6", strokeWidth: 1, dash: [4, 3] },
+  lane: {
+    header: { fill: "rgba(255, 255, 255, 0.06)", stroke: "rgba(255, 255, 255, 0.06)", text: "#9fbdd6", strokeWidth: 1 },
+    bodies: [
+      { fill: "rgba(255, 255, 255, 0.035)", stroke: "rgba(255, 255, 255, 0.06)", text: "#9fbdd6", strokeWidth: 1 },
+      { fill: "rgba(255, 255, 255, 0)", stroke: "rgba(255, 255, 255, 0.06)", text: "#9fbdd6", strokeWidth: 1 }
+    ]
+  },
+  page: "#0e151b",
+  font: SANS,
+  series: ["#6fb3ff", "#c58bff", "#f2c14e", "#5ad07f", "#ff8a6b", "#4fd1c5", "#e58fb8", "#b0bec5"]
+};
+var LINE = "#e8f1ff";
+var blueprint = {
+  id: "blueprint",
+  name: "Blueprint",
+  roles: {
+    default: { fill: "#1d4a85", stroke: LINE, text: LINE },
+    accent: { fill: "#2560a8", stroke: "#ffe28a", text: "#ffffff" },
+    muted: { fill: "#183f72", stroke: "#8fb1dc", text: "#b9cfee" },
+    positive: { fill: "#1d4a85", stroke: "#8ff0b0", text: LINE },
+    warning: { fill: "#1d4a85", stroke: "#ffd166", text: LINE },
+    negative: { fill: "#1d4a85", stroke: "#ff9b9b", text: LINE }
+  },
+  defaultRole: "default",
+  edge: { stroke: LINE, width: 1.5, markerEnd: "arrow" },
+  label: { fill: LINE },
+  container: { fill: "rgba(232, 241, 255, 0.06)", stroke: "#8fb1dc", text: "#b9cfee", strokeWidth: 1, dash: [6, 4] },
+  lane: {
+    header: { fill: "#1d4a85", stroke: "#8fb1dc", text: LINE, strokeWidth: 1 },
+    bodies: [
+      { fill: "rgba(232, 241, 255, 0.05)", stroke: "#8fb1dc", text: LINE, strokeWidth: 1 },
+      { fill: "rgba(232, 241, 255, 0)", stroke: "#8fb1dc", text: LINE, strokeWidth: 1 }
+    ]
+  },
+  page: "#163a6b",
+  font: { family: "ui-monospace, monospace", size: 12 },
+  series: ["#ffe28a", "#8ff0b0", "#9fd3ff", "#ffb38a", "#d9b8ff", "#7fe3d8", "#ff9b9b", "#c9d6e8"]
+};
+var PLUM = "#4a3b40";
+var pastel = {
+  id: "pastel",
+  name: "Pastel",
+  roles: {
+    default: { fill: "#e3f0ff", stroke: "#7d9cc4", text: PLUM },
+    accent: { fill: "#fde2e4", stroke: "#c9848f", text: PLUM },
+    muted: { fill: "#f4f1ee", stroke: "#bfb5ad", text: "#8a7f78" },
+    positive: { fill: "#dcf5e3", stroke: "#6fb487", text: PLUM },
+    warning: { fill: "#fff1cc", stroke: "#d4a84a", text: PLUM },
+    negative: { fill: "#ffdcd6", stroke: "#d77f73", text: PLUM }
+  },
+  defaultRole: "default",
+  edge: { stroke: "#8a7f99", width: 2, markerEnd: "arrow" },
+  label: { fill: PLUM },
+  container: { fill: "rgba(201, 132, 143, 0.06)", stroke: "#c9b8c2", text: "#7a6670", strokeWidth: 1, dash: [4, 3] },
+  lane: {
+    header: { fill: "#efe6f5", stroke: "#c9b8c2", text: PLUM, strokeWidth: 1 },
+    bodies: [
+      { fill: "#fffaf3", stroke: "#e6dccf", text: PLUM, strokeWidth: 1 },
+      { fill: "#fbf3ea", stroke: "#e6dccf", text: PLUM, strokeWidth: 1 }
+    ]
+  },
+  page: "#fffaf3",
+  font: SANS,
+  series: ["#7d9cc4", "#c9848f", "#d4a84a", "#6fb487", "#b48fd1", "#5fb3ad", "#e08fb0", "#a3a3a3"]
+};
+var BLACK = "#111111";
+var shade = (fill) => ({ fill, stroke: BLACK, text: BLACK });
+var mono = {
+  id: "mono",
+  name: "Mono",
+  roles: {
+    default: shade("#ffffff"),
+    accent: shade("#d9d9d9"),
+    muted: { fill: "#f5f5f5", stroke: "#9e9e9e", text: "#757575" },
+    positive: shade("#ededed"),
+    warning: shade("#c4c4c4"),
+    negative: { fill: "#595959", stroke: BLACK, text: "#ffffff" }
+  },
+  defaultRole: "default",
+  edge: { stroke: BLACK, width: 1.5, markerEnd: "arrow" },
+  label: { fill: BLACK },
+  container: { fill: "rgba(0, 0, 0, 0.03)", stroke: "#757575", text: "#424242", strokeWidth: 1, dash: [4, 3] },
+  lane: {
+    header: { fill: "#e0e0e0", stroke: "#757575", text: BLACK, strokeWidth: 1 },
+    bodies: [
+      { fill: "#ffffff", stroke: "#bdbdbd", text: BLACK, strokeWidth: 1 },
+      { fill: "#f5f5f5", stroke: "#bdbdbd", text: BLACK, strokeWidth: 1 }
+    ]
+  },
+  page: "#ffffff",
+  font: SANS,
+  series: ["#111111", "#555555", "#888888", "#333333", "#777777", "#222222", "#666666", "#999999"]
+};
+var DIAGRAM_THEMES = Object.freeze({ paper, night, blueprint, pastel, mono });
+
+// src/theme/types.ts
+var DIAGRAM_ROLES = [
+  { id: "default", label: "Default" },
+  { id: "accent", label: "Accent" },
+  { id: "muted", label: "Muted" },
+  { id: "positive", label: "Positive" },
+  { id: "warning", label: "Warning" },
+  { id: "negative", label: "Negative" }
+];
+var DIAGRAM_THEME_KEY = "diagram:theme";
+
+// src/theme/resolve.ts
+function roleStyle(theme, role) {
+  return (role !== void 0 ? theme.roles[role] : void 0) ?? theme.roles[theme.defaultRole];
+}
+function roleEdgeStyle(theme, role) {
+  const own = role !== void 0 ? theme.roles[role] : void 0;
+  if (own !== void 0) return { ...theme.edge, stroke: own.stroke, label: own.stroke };
+  return { ...theme.edge, label: theme.edge.label ?? theme.label.fill };
+}
+function themeEdgeStroke(theme) {
+  const { stroke, width, dash, markerStart, markerEnd } = theme.edge;
+  return {
+    paint: { color: stroke },
+    width: width ?? 2,
+    ...dash ? { dash } : {},
+    ...markerStart ? { markerStart } : {},
+    ...markerEnd !== null ? { markerEnd: markerEnd ?? "arrow" } : {}
+  };
+}
+var themeFont = (theme) => ({ fontFamily: theme.font.family, fontSize: theme.font.size });
+var themeLabelFamily = (theme) => theme.label.font?.family ?? theme.font.family;
+var themeLabelFont = (theme, font = themeFont(theme)) => theme.label.font ? { fontFamily: theme.label.font.family, fontSize: theme.label.font.size } : font;
+var themeLabelStyle = (theme) => labelStyleOf(themeLabelFont(theme));
+function diagramThemeFrom(value, fallback = DIAGRAM_THEMES.night) {
+  if (typeof value === "string") return DIAGRAM_THEMES[value] ?? fallback;
+  if (value !== null && typeof value === "object" && "roles" in value) return value;
+  return fallback;
+}
+function diagramThemeOf(scene, fallback) {
+  return diagramThemeFrom(scene.doc.get(DIAGRAM_THEME_KEY), fallback);
+}
+var themeDocValue = (theme) => DIAGRAM_THEMES[theme.id] === theme ? theme.id : theme;
+
+// src/offPage/trait.ts
+var offPageTagId = (edgeId, end) => `${edgeId}/offpage-${end}`;
+function offPageTagOf(node) {
+  const data = node.data;
+  if (data === null || typeof data !== "object") return null;
+  const trait = data.diagram;
+  const tag = trait !== null && typeof trait === "object" ? trait.offPageTag : void 0;
+  if (tag === null || typeof tag !== "object") return null;
+  const { edge, end } = tag;
+  return typeof edge === "string" && (end === "from" || end === "to") ? { edge, end } : null;
+}
+var OFF_PAGE_TAG_PADDING = 3;
+var GAP = 2;
+var offPageTagLook = (theme) => ({ style: themeLabelStyle(theme), fill: theme.label.fill, background: theme.page });
+var offPageTagText = (pageName2, ref) => `${pageName2} \xB7 ${ref}`;
+function offPageFarText(pages, split, end) {
+  const far = end === "from" ? split.to : split.from;
+  const index = pages.findIndex((p) => p.id === far);
+  return offPageTagText(index < 0 ? far : pageName(pages[index], index), split.ref);
+}
+function offPageTagSize(text, look) {
+  const pad = look.padding ?? OFF_PAGE_TAG_PADDING;
+  const size = labelSize(text, look.style, look.measure);
+  return { width: size.width + 2 * pad, height: size.height + 2 * pad };
+}
+function offPageTagData(edgeId, end, text, look) {
+  return {
+    diagram: { offPageTag: { edge: edgeId, end } },
+    text,
+    style: look.style,
+    fill: { paint: { color: look.fill } },
+    background: { paint: { color: look.background } },
+    padding: look.padding ?? OFF_PAGE_TAG_PADDING
+  };
+}
+function offPageTagSpec(edgeId, end, text, look) {
+  return {
+    id: offPageTagId(edgeId, end),
+    kind: "leaf",
+    layer: look.layer,
+    pose: { x: 0, y: 0, ...offPageTagSize(text, look) },
+    data: offPageTagData(edgeId, end, text, look),
+    dependsOn: [edgeId],
+    derivePose: OFF_PAGE_TAG_DERIVE_POSE
+  };
+}
+function offPageTagSpecs(edgeId, split, pages, look) {
+  return ["from", "to"].map((end) => offPageTagSpec(edgeId, end, offPageFarText(pages, split, end), look));
+}
+function stubTip(path, end) {
+  const stub = subpathOf(path, end === "from" ? 0 : 1);
+  if (stub === null || stub.kind !== "polygon" || stub.coords.length < 4) return null;
+  const c = stub.coords;
+  const n = c.length;
+  const [tip, base] = end === "from" ? [{ x: c[n - 2], y: c[n - 1] }, { x: c[0], y: c[1] }] : [{ x: c[0], y: c[1] }, { x: c[n - 2], y: c[n - 1] }];
+  const len = Math.hypot(tip.x - base.x, tip.y - base.y);
+  return len === 0 ? null : { tip, out: { x: (tip.x - base.x) / len, y: (tip.y - base.y) / len } };
+}
+function offPageTagDerivePose(opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  return (node, deps) => {
+    const tag = offPageTagOf(node);
+    const path = deps[0]?.path ?? null;
+    if (tag === null || path === null) return null;
+    const at = stubTip(path, tag.end);
+    if (at === null) return null;
+    const b = geometry.getBounds(node.pose);
+    const reach = GAP + (Math.abs(at.out.x) * b.width + Math.abs(at.out.y) * b.height) / 2;
+    const cx = at.tip.x + at.out.x * reach;
+    const cy = at.tip.y + at.out.y * reach;
+    return translatePoseViaDescriptor(node.pose, cx - (b.x + b.width / 2), cy - (b.y + b.height / 2), geometry);
+  };
+}
+var DIAGRAM_OFF_PAGE_TAG = "diagram:offPageTag";
+var OFF_PAGE_TAG_DERIVE_POSE = offPageTagDerivePose();
+
+// src/selfLoop.ts
+var dot = (a, b) => a.x * b.x + a.y * b.y;
+function selfLoop(ports, standoff) {
+  const facing2 = ports.filter((p) => p.normal !== null);
+  const most = (dir, among) => among.reduce(
+    (best, p) => best === void 0 || dot(p.normal, dir) > dot(best.normal, dir) ? p : best,
+    void 0
+  );
+  const from = most({ x: 1, y: 0 }, facing2);
+  if (from === void 0) return null;
+  const to = most({ x: 0, y: -1 }, facing2.filter((p) => Math.abs(dot(p.normal, from.normal)) < 0.5));
+  if (to === void 0) return null;
+  const out = { x: from.point.x + from.normal.x * standoff, y: from.point.y + from.normal.y * standoff };
+  const reach = dot({ x: to.point.x - out.x, y: to.point.y - out.y }, to.normal) + standoff;
+  return { from, to, via: { x: out.x + to.normal.x * reach, y: out.y + to.normal.y * reach } };
+}
+var ON_ROUTE = 0.5;
+var KAPPA = 0.5523;
+function bulge(u) {
+  if (Math.abs(u.y) < 1e-9) return { x: 0, y: -1 };
+  if (Math.abs(u.x) < 1e-9) return { x: -1, y: 0 };
+  return { x: u.y, y: -u.x };
+}
+function placedOn(a, b, hops) {
+  const len = Math.hypot(b.x - a.x, b.y - a.y);
+  if (len === 0) return [];
+  const ux = (b.x - a.x) / len;
+  const uy = (b.y - a.y) / len;
+  const found = [];
+  for (const hop of hops) {
+    const dx = hop.at.x - a.x;
+    const dy = hop.at.y - a.y;
+    const t = dx * ux + dy * uy;
+    if (Math.abs(dx * uy - dy * ux) > ON_ROUTE || t - hop.r < 0 || t + hop.r > len) continue;
+    found.push({ t, r: hop.r });
+  }
+  found.sort((m, n) => m.t - n.t);
+  const out = [];
+  for (const p of found) {
+    const last = out[out.length - 1];
+    if (last === void 0 || p.t - p.r >= last.t + last.r) out.push(p);
+  }
+  return out;
+}
+function withHops(points, hops) {
+  const b = new PathBuilder$1();
+  const first = points[0];
+  if (first === void 0 || hops.length === 0) return polylineFromPoints$1(points);
+  b.moveTo(first.x, first.y);
+  let arcs = 0;
+  for (let i = 1; i < points.length; i++) {
+    const p = points[i - 1];
+    const q = points[i];
+    const len = Math.hypot(q.x - p.x, q.y - p.y);
+    const u = len === 0 ? { x: 1, y: 0 } : { x: (q.x - p.x) / len, y: (q.y - p.y) / len };
+    const n = bulge(u);
+    for (const { t, r } of placedOn(p, q, hops)) {
+      const c = { x: p.x + u.x * t, y: p.y + u.y * t };
+      const top = { x: c.x + n.x * r, y: c.y + n.y * r };
+      const k = KAPPA * r;
+      b.lineTo(c.x - u.x * r, c.y - u.y * r);
+      b.curveTo(c.x - u.x * r + n.x * k, c.y - u.y * r + n.y * k, top.x - u.x * k, top.y - u.y * k, top.x, top.y);
+      b.curveTo(top.x + u.x * k, top.y + u.y * k, c.x + u.x * r + n.x * k, c.y + u.y * r + n.y * k, c.x + u.x * r, c.y + u.y * r);
+      arcs++;
+    }
+    b.lineTo(q.x, q.y);
+  }
+  return arcs === 0 ? polylineFromPoints$1(points) : b.build();
+}
+var straight = (req) => [req.from.point, ...req.waypoints, req.to.point];
+var orthogonal = (req) => {
+  const stops = [req.from.point, ...req.waypoints, req.to.point];
+  const out = [stops[0]];
+  for (let i = 1; i < stops.length; i++) {
+    const a = out[out.length - 1];
+    const b = stops[i];
+    if (a.x === b.x || a.y === b.y) {
+      out.push(b);
+      continue;
+    }
+    const leaveHorizontal = i === 1 ? isHorizontal(req.from.normal) : out.length > 1 && out[out.length - 2].y === a.y;
+    const arriving = i === stops.length - 1 ? req.to.normal : null;
+    const arriveHorizontal = arriving == null ? !leaveHorizontal : isHorizontal(arriving);
+    if (leaveHorizontal !== arriveHorizontal) {
+      out.push(leaveHorizontal ? { x: b.x, y: a.y } : { x: a.x, y: b.y });
+      out.push(b);
+      continue;
+    }
+    const prev = out.length > 1 ? out[out.length - 2] : null;
+    if (leaveHorizontal) {
+      const mid = (a.x + b.x) / 2;
+      if (prev !== null && (mid - a.x) * (a.x - prev.x) < 0) out.push({ x: a.x, y: b.y }, b);
+      else out.push({ x: mid, y: a.y }, { x: mid, y: b.y }, b);
+    } else {
+      const mid = (a.y + b.y) / 2;
+      if (prev !== null && (mid - a.y) * (a.y - prev.y) < 0) out.push({ x: b.x, y: a.y }, b);
+      else out.push({ x: a.x, y: mid }, { x: b.x, y: mid }, b);
+    }
+  }
+  return out;
+};
+function isHorizontal(normal) {
+  return Math.abs(normal?.x ?? 1) >= Math.abs(normal?.y ?? 0);
+}
+var bezier = (req) => {
+  const stops = [req.from.point, ...req.waypoints, req.to.point];
+  const out = [stops[0]];
+  for (let i = 1; i < stops.length; i++) {
+    const a = stops[i - 1];
+    const b = stops[i];
+    const outN = i === 1 ? req.from.normal : through(stops, i - 1);
+    const inN = i === stops.length - 1 ? req.to.normal : negated(through(stops, i));
+    const leg = portCurvePoints(
+      a.x,
+      a.y,
+      b.x,
+      b.y,
+      outN == null ? null : [outN.x, outN.y],
+      inN == null ? null : [inN.x, inN.y],
+      BEZIER_SAMPLES
+    );
+    for (const [x, y] of leg) out.push({ x, y });
+  }
+  return out;
+};
+var BEZIER_SAMPLES = 16;
+function through(stops, i) {
+  const last = stops.length - 1;
+  const run = (a, b) => a >= 1 && b <= last - 1 && (stops[a].x === stops[b].x || stops[a].y === stops[b].y);
+  const [from, to] = run(i, i + 1) ? [i, i + 1] : run(i - 1, i) ? [i - 1, i] : [i - 1, i + 1];
+  const dx = stops[to].x - stops[from].x;
+  const dy = stops[to].y - stops[from].y;
+  const len = Math.hypot(dx, dy);
+  return len === 0 ? null : { x: dx / len, y: dy / len };
+}
+var negated = (v) => v === null ? null : { x: -v.x, y: -v.y };
+var avoid = (req) => req.route !== void 0 && routeHolds(req.from, req.to, req.waypoints, req.route) ? [req.from.point, ...req.route, req.to.point] : orthogonal(req);
+var ROUTERS = Object.freeze({
+  straight,
+  orthogonal,
+  bezier,
+  avoid
+});
+function resolveEnd(end, dep, toward, opts, allPorts) {
+  if (end.port !== void 0) {
+    const sites = portSitesOf(dep.node, dep.pose, end.port, opts);
+    const ahead = sites.filter((p) => p.normal !== null && p.normal.x * (toward.x - p.point.x) + p.normal.y * (toward.y - p.point.y) > 0);
+    if (sites.length > 0) return ahead.length > 0 ? facing(ahead, toward) : sites[0];
+  }
+  return facing(allPorts(dep), toward);
+}
+function boxCenter(geometry, pose) {
+  const b = geometry.getBounds(pose);
+  return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+}
+function endAims(fromCenter, toCenter, waypoints, route = []) {
+  return {
+    from: route[0] ?? waypoints[0] ?? toCenter,
+    to: route[route.length - 1] ?? waypoints[waypoints.length - 1] ?? fromCenter
+  };
+}
+function facing(ports, toward) {
+  let best;
+  let bestScore = -Infinity;
+  for (const port of ports) {
+    const dx = toward.x - port.point.x;
+    const dy = toward.y - port.point.y;
+    const len = Math.hypot(dx, dy) || 1;
+    const aim = port.normal === null ? 0 : (port.normal.x * dx + port.normal.y * dy) / len;
+    const score = aim - len / 1e6;
+    if (score > bestScore) {
+      bestScore = score;
+      best = port;
+    }
+  }
+  return best;
+}
+function routerOf(edge, routers = ROUTERS) {
+  return edge.router !== void 0 && routers[edge.router] || straight;
+}
+function edgeDerivePath(opts = {}) {
+  const routeOf = edgeRouter(opts);
+  return (node, deps) => {
+    const route = routeOf(node, deps);
+    if (route?.stubs !== void 0) return stubsPath(route.stubs);
+    const points = route?.points;
+    if (points === void 0 || points.length < 2) return null;
+    const hops = diagramEdgeOf(node)?.hops;
+    return hops !== void 0 && hops.length > 0 ? withHops(points, hops) : polylineFromPoints(points);
+  };
+}
+var OFF_PAGE_STUB = 24;
+function stubTip2(port, toward) {
+  const n = port.normal ?? unit(toward.x - port.point.x, toward.y - port.point.y);
+  return { x: port.point.x + n.x * OFF_PAGE_STUB, y: port.point.y + n.y * OFF_PAGE_STUB };
+}
+function unit(x, y) {
+  const len = Math.hypot(x, y);
+  return len === 0 ? { x: 1, y: 0 } : { x: x / len, y: y / len };
+}
+function stubsPath(stubs) {
+  const b = new PathBuilder();
+  for (const run of stubs) run.forEach((p, i) => i === 0 ? b.moveTo(p.x, p.y) : b.lineTo(p.x, p.y));
+  return b.build();
+}
+function edgeRouter(opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  const portOpts = { geometry, ...opts.read ? { read: opts.read } : {} };
+  const allPorts = (d) => portsOf(d.node, d.pose, portOpts);
+  const standoffOf = (d) => {
+    const b = geometry.getBounds(d.pose);
+    return Math.min(b.width, b.height) / 2;
+  };
+  return (node, deps) => {
+    const edge = diagramEdgeOf(node);
+    if (edge === null) return null;
+    const [fromDep, toDep] = deps;
+    if (fromDep === void 0 || toDep === void 0) return null;
+    const loop = fromDep.node.id === toDep.node.id && edge.from.port === void 0 && edge.to.port === void 0 ? selfLoop(allPorts(fromDep), opts.selfLoopStandoff ?? standoffOf(fromDep)) : null;
+    const authored = edge.waypoints ?? [];
+    const aims = endAims(boxCenter(geometry, fromDep.pose), boxCenter(geometry, toDep.pose), authored, edge.route);
+    const from = loop?.from ?? resolveEnd(edge.from, fromDep, aims.from, portOpts, allPorts);
+    const to = loop?.to ?? resolveEnd(edge.to, toDep, aims.to, portOpts, allPorts);
+    if (from === void 0 || to === void 0) return null;
+    const waypoints = loop !== null && authored.length === 0 ? [loop.via] : authored;
+    const points = routerOf(edge, opts.routers)({ from, to, waypoints, route: edge.route });
+    if (edge.offPage === void 0) return { from, to, waypoints, points };
+    const stubs = [[from.point, stubTip2(from, to.point)], [stubTip2(to, from.point), to.point]];
+    return { from, to, waypoints, points, stubs };
+  };
+}
+var DIAGRAM_EDGE = "diagram:edge";
+var EDGE_DERIVE_PATH = edgeDerivePath();
+function withDiagramRegistry(registry = {}) {
+  return {
+    ...registry,
+    derivePath: {
+      [DIAGRAM_EDGE]: EDGE_DERIVE_PATH,
+      ...registry.derivePath
+    },
+    derivePose: {
+      [DIAGRAM_LABEL]: LABEL_DERIVE_POSE,
+      [DIAGRAM_GROUP]: GROUP_DERIVE_POSE,
+      [DIAGRAM_ANCHOR]: ANCHOR_DERIVE_POSE,
+      [DIAGRAM_OFF_PAGE_TAG]: OFF_PAGE_TAG_DERIVE_POSE,
+      ...registry.derivePose
+    },
+    layout: {
+      ...CONTAINER_LAYOUTS,
+      ...registry.layout
+    }
+  };
+}
+
+// src/bodyRelayout.ts
+function bodyLayoutOf(spec, trait) {
+  if (trait.margin !== void 0 || !spec.rows.every((r) => r.kind === "label" || r.kind === "field")) return {};
+  return {
+    body: { padding: spec.padding ?? 8, gap: spec.gap ?? 4, verticalAlign: spec.verticalAlign ?? "center", rows: spec.rows.length }
+  };
+}
+var rowStyle = (s) => ({
+  ...s?.fontSize !== void 0 ? { fontSize: s.fontSize } : {},
+  ...s?.fontFamily !== void 0 ? { fontFamily: s.fontFamily } : {},
+  ...(s?.fontWeight ?? 400) >= 700 ? { bold: true } : {}
+});
+var same = (a, b) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+function relayoutBodies(scene, ids, measure) {
+  for (const id of new Set(ids)) {
+    const node = scene.get(id);
+    const trait = node?.data?.diagram;
+    if (node === void 0 || trait?.body === void 0 || trait.outline === void 0) continue;
+    const layout = trait.body;
+    const rowNodes = /* @__PURE__ */ new Map();
+    for (const child of scene.childrenOf(id)) {
+      const index = scene.get(child)?.data?.bodyRow;
+      if (typeof index === "number") rowNodes.set(index, child);
+    }
+    const rows = Array.from({ length: layout.rows }, (_, i) => {
+      const data = scene.get(rowNodes.get(i))?.data;
+      return { kind: "label", text: typeof data?.text === "string" ? data.text : "", style: rowStyle(data?.style) };
+    });
+    const spec = { outline: trait.outline, rows, padding: layout.padding, gap: layout.gap, verticalAlign: layout.verticalAlign };
+    const pose = node.pose;
+    const grown = sizeToBody(pose, measureBody(spec, measure));
+    if (grown !== pose) scene.setPose(id, grown);
+    for (const box of layoutBody(spec, grown, measure)) {
+      const child = rowNodes.get(box.index);
+      const at = child === void 0 ? void 0 : scene.get(child)?.pose;
+      if (at === void 0) continue;
+      const next = { ...at, x: box.x, y: box.y, width: box.width, height: box.height };
+      if (!same(at, next)) scene.setPose(child, next);
+    }
+  }
+}
+
+// src/dataTypes.ts
+var DEFAULT_POOL_ACROSS = 600;
+var DEFAULT_LANE_SIZE = 120;
+var NODE = { fill: "#16222c", stroke: "#7ba7c7", text: "#dbe7f2" };
+var NODE_STROKE_WIDTH = 2;
+var LANE_STROKE_WIDTH = 1;
+var EDGE_STROKE_WIDTH = 1.5;
+
+// src/containers/regionSpecs.ts
+var NEW_POOL_LANES = 2;
+function regionData(role, axis, style, fitted) {
+  const container = { role, header: containerShape(role, axis).header, ...fitted ? { fitted: true } : {} };
+  return {
+    diagram: { outline: "rect", container },
+    ...role === "lane" ? {} : { fill: { paint: { color: style.fill } } },
+    stroke: { paint: { color: style.stroke }, width: role === "lane" ? LANE_STROKE_WIDTH : style.strokeWidth ?? NODE_STROKE_WIDTH }
+  };
+}
+var titleData = (text, style, fontFamily = DEFAULT_FONT.fontFamily) => ({
+  text,
+  style: { fontFamily, fontSize: 13, fontWeight: 700, align: "center" },
+  verticalAlign: "center",
+  fill: { paint: { color: style.text } }
+});
+function regionSpecs(role, axis, pose, title, opts) {
+  const style = opts.style ?? NODE;
+  const { layout, header } = containerShape(role, axis);
+  const region = {
+    id: opts.id,
+    kind: "container",
+    layer: opts.layer,
+    pose,
+    parent: opts.parent ?? null,
+    data: regionData(role, axis, style, opts.fitted === true),
+    layout: CONTAINER_LAYOUTS[layout]
+  };
+  if (title === null) return [region];
+  return [region, {
+    id: titleIdOf(opts.id),
+    kind: "leaf",
+    layer: opts.layer,
+    parent: opts.id,
+    pickable: false,
+    pose: titlePose(pose, header),
+    data: titleData(title, style, opts.fontFamily)
+  }];
+}
+function firstLanes(poolId, axis, at, opts) {
+  const { header } = containerShape("pool", axis);
+  const size = Math.max(MIN_LANE_SIZE, (axis === "y" ? at.height : at.width) / NEW_POOL_LANES);
+  const out = [];
+  for (let i = 0; i < NEW_POOL_LANES; i++) {
+    const pose = axis === "y" ? { x: at.x + header.size, y: at.y + i * size, width: at.width - header.size, height: size } : { x: at.x + i * size, y: at.y + header.size, width: size, height: at.height - header.size };
+    const bodies = opts.laneStyles?.bodies ?? [];
+    const style = bodies.length > 0 ? bodies[i % bodies.length] : opts.style;
+    out.push(...regionSpecs("lane", axis, pose, `Lane ${i + 1}`, {
+      id: opts.newId(),
+      layer: opts.layer,
+      parent: poolId,
+      ...style ? { style } : {}
+    }));
+  }
+  return out;
+}
+
+// src/dataColors.ts
+var NODE_FIELDS = ["fill", "stroke", "text"];
+function ownNodeStyle(colors) {
+  const own = NODE_FIELDS.filter((f) => colors?.[f] !== void 0);
+  return own.length > 0 ? { ownStyle: own } : {};
+}
+function ownEdgeStyle(colors) {
+  const own = [];
+  if (colors?.stroke !== void 0) own.push("stroke");
+  if (colors?.label !== void 0) own.push("text");
+  return own.length > 0 ? { ownStyle: own } : {};
+}
+function withColors(style, colors) {
+  if (colors === void 0) return style;
+  const out = { ...style };
+  for (const [k, v] of Object.entries(colors)) if (v !== void 0) out[k] = v;
+  return out;
+}
+
+// src/dataStyles.ts
+var EDGE = { stroke: "#7ba7c7" };
+function dataNodeStyle(node, theme) {
+  return withColors(theme ? roleStyle(theme, node.style) : NODE, node.colors);
+}
+function dataEdgeStyle(edge, theme) {
+  return withColors(theme ? roleEdgeStyle(theme, edge.style) : EDGE, edge.colors);
+}
+function dataRegionStyle(region, theme, laneIndex = 0) {
+  return withColors(themeRegionStyle(region, theme, laneIndex), region.colors);
+}
+function themeRegionStyle(r, theme, laneIndex) {
+  if (theme === void 0) return NODE;
+  const own = r.style !== void 0 ? theme.roles[r.style] : void 0;
+  if (own !== void 0) return own;
+  if (r.role === "pool") return theme.lane.header;
+  if (r.role === "lane") return theme.lane.bodies[laneIndex % Math.max(1, theme.lane.bodies.length)] ?? theme.container;
+  return theme.container;
+}
+
+// src/edgeId.ts
+var idPart = (s) => s.replace(/[\\.>:/]/g, "\\$&");
+var edgeIdOf = (e) => {
+  if (e.id !== void 0) return e.id;
+  const part = (mark, p) => p === void 0 ? "" : `${mark}${idPart(p)}`;
+  return `edge:${idPart(e.from)}${part(".", e.fromPort)}->${idPart(e.to)}${part(".", e.toPort)}${part(":", e.label)}`;
+};
+function refAt(n) {
+  let out = "";
+  for (let k = n + 1; k > 0; k = Math.floor((k - 1) / 26)) out = String.fromCharCode(65 + (k - 1) % 26) + out;
+  return out;
+}
+function nextOffPageRef(used) {
+  let n = 0;
+  while (used.has(refAt(n))) n++;
+  return refAt(n);
+}
+function offPageSplits(input) {
+  const used = new Set(input.used ?? []);
+  const out = /* @__PURE__ */ new Map();
+  const fresh = [];
+  for (const edge of input.edges) {
+    const from = pageOfBounds(input.pages, edge.from);
+    const to = pageOfBounds(input.pages, edge.to);
+    if (from === null || to === null || from.id === to.id) {
+      out.set(edge.id, null);
+      continue;
+    }
+    const held = edge.offPage?.ref;
+    if (held !== void 0 && !used.has(held)) {
+      used.add(held);
+      out.set(edge.id, { ref: held, from: from.id, to: to.id });
+    } else {
+      out.set(edge.id, null);
+      fresh.push({ id: edge.id, from: from.id, to: to.id });
+    }
+  }
+  for (const split of fresh) {
+    const ref = nextOffPageRef(used);
+    used.add(ref);
+    out.set(split.id, { ref, from: split.from, to: split.to });
+  }
+  return out;
+}
+function diagramPages(data) {
+  return layoutPages(data.pages ?? [], data.pageLayout);
+}
+function dataOffPage(edges, pages, boxOf, look) {
+  const input = edges.flatMap((e) => {
+    const from = boxOf(e.from);
+    const to = boxOf(e.to);
+    return from === void 0 || to === void 0 ? [] : [{ id: e.id, from, to }];
+  });
+  const splits = /* @__PURE__ */ new Map();
+  const tags = [];
+  for (const [id, split] of offPageSplits({ pages, edges: input })) {
+    if (split === null) continue;
+    splits.set(id, split);
+    tags.push(...offPageTagSpecs(id, split, pages, { ...look, layer: "main" }));
+  }
+  return { splits, tags };
+}
+function scenePageSplits(data, placedAt, specs, edges, look) {
+  const pages = diagramPages(data);
+  if (pages.length === 0) return null;
+  const groups = new Map(specs.filter((s) => diagramGroupOf(s) !== null).map((s) => [String(s.id), s.pose]));
+  return dataOffPage(edges, pages, (id) => placedAt.get(id) ?? groups.get(id), look());
+}
+
+// src/groupTree.ts
+function nestGroups(declared, isNode) {
+  const groupIds = new Set(declared.map((g) => g.id));
+  const parentOf = /* @__PURE__ */ new Map();
+  const claimedNodes = /* @__PURE__ */ new Set();
+  const direct = /* @__PURE__ */ new Map();
+  const isAncestorOrSelf = (candidate, of) => {
+    for (let at = of; at !== void 0; at = parentOf.get(at)) {
+      if (at === candidate) return true;
+    }
+    return false;
+  };
+  for (const group of declared) {
+    const own = [];
+    for (const id of group.members) {
+      if (isNode(id)) {
+        if (claimedNodes.has(id)) continue;
+        claimedNodes.add(id);
+        own.push(id);
+      } else if (groupIds.has(id) && !parentOf.has(id) && !isAncestorOrSelf(id, group.id)) {
+        parentOf.set(id, group.id);
+        own.push(id);
+      }
+    }
+    direct.set(group.id, own);
+  }
+  const flat = /* @__PURE__ */ new Map();
+  const flatten = (id) => {
+    const known = flat.get(id);
+    if (known !== void 0) return known;
+    const out = [];
+    for (const member of direct.get(id)) {
+      if (groupIds.has(member)) out.push(...flatten(member));
+      else out.push(member);
+    }
+    flat.set(id, out);
+    return out;
+  };
+  const live = new Set(declared.filter((g) => flatten(g.id).length > 0).map((g) => g.id));
+  return declared.filter((g) => live.has(g.id)).map((g) => {
+    const parent = parentOf.get(g.id);
+    return {
+      id: g.id,
+      direct: direct.get(g.id).filter((id) => !groupIds.has(id) || live.has(id)),
+      members: flat.get(g.id),
+      ...parent !== void 0 ? { parent } : {}
+    };
+  });
+}
+
+// src/graph.ts
+function buildGraph(source, opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR$1;
+  const nodes = [];
+  const byId = /* @__PURE__ */ new Map();
+  const candidates = [];
+  const groupNodes = [];
+  const routed = /* @__PURE__ */ new Set();
+  const rooms = /* @__PURE__ */ new Map();
+  for (const { node, pose } of source()) {
+    const edge = diagramEdgeOf(node);
+    if (edge !== null) {
+      const deps = node.dependsOn;
+      if (Array.isArray(deps) && deps.length === 2) {
+        candidates.push({
+          id: node.id,
+          from: deps[0],
+          to: deps[1],
+          ...edge.from.port !== void 0 ? { fromPort: edge.from.port } : {},
+          ...edge.to.port !== void 0 ? { toPort: edge.to.port } : {},
+          ...edge.waypoints !== void 0 && edge.waypoints.length > 0 ? { waypoints: edge.waypoints } : {},
+          ...layoutOwnsRoute(edge) ? {} : { authored: true }
+        });
+        if (layoutOwnsRoute(edge)) routed.add(node.id);
+      }
+      continue;
+    }
+    const label = diagramLabelOf(node);
+    if (label !== null) {
+      const deps = node.dependsOn;
+      if (Array.isArray(deps) && deps.length === 1 && labelFollowsLayout(label.at) && !rooms.has(deps[0])) {
+        const { width, height } = geometry.getBounds(pose);
+        rooms.set(deps[0], { width, height, ...label.offset ? { offset: label.offset } : {} });
+      }
+      continue;
+    }
+    const trait = diagramNodeOf(node, opts.read);
+    if (trait === null) continue;
+    if (trait.group !== void 0) {
+      const deps = node.dependsOn;
+      groupNodes.push({
+        id: node.id,
+        members: Array.isArray(deps) ? deps : [],
+        inset: insetOf(trait.group.inset),
+        ...trait.group.minWidth !== void 0 ? { minWidth: trait.group.minWidth } : {},
+        ...trait.group.reorder !== void 0 ? { reorders: true } : {}
+      });
+      continue;
+    }
+    const entry = {
+      id: node.id,
+      bounds: geometry.getBounds(pose),
+      pinned: trait.pinned === true,
+      ...trait.ports !== void 0 ? { ports: trait.ports } : {},
+      ...trait.outline !== void 0 ? { outline: trait.outline } : {},
+      ...trait.margin !== void 0 ? { margin: trait.margin } : {}
+    };
+    nodes.push(entry);
+    byId.set(entry.id, entry);
+  }
+  const declared = new Map(groupNodes.map((g) => [g.id, g]));
+  const live = nestGroups(groupNodes, (id) => byId.has(id)).map((g) => {
+    for (const id of g.direct) {
+      const node = byId.get(id);
+      if (node !== void 0) node.group = g.id;
+    }
+    return {
+      id: g.id,
+      members: g.members,
+      inset: declared.get(g.id).inset,
+      ...declared.get(g.id).minWidth !== void 0 ? { minWidth: declared.get(g.id).minWidth } : {},
+      ...g.parent !== void 0 ? { parent: g.parent } : {},
+      ...declared.get(g.id).reorders === true ? { ordered: g.direct } : {}
+    };
+  });
+  const known = (id) => byId.has(id) || live.some((g) => g.id === id);
+  const roomed = candidates.map((e) => {
+    const room = rooms.get(e.id);
+    return room !== void 0 && routed.has(e.id) ? { ...e, label: room } : e;
+  });
+  return graphOf(nodes, expandGroupEdges(roomed.filter((e) => known(e.from) && known(e.to)), live), live);
+}
+var NONE = Object.freeze([]);
+function graphOf(nodes, edges, groups = []) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const out = /* @__PURE__ */ new Map();
+  const into = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    push(out, edge.from, edge);
+    push(into, edge.to, edge);
+  }
+  return {
+    nodes,
+    edges,
+    groups,
+    node: (id) => byId.get(id),
+    outgoing: (id) => out.get(id) ?? NONE,
+    incoming: (id) => into.get(id) ?? NONE
+  };
+}
+function labelFollowsLayout(at) {
+  return at === "mid" || typeof at === "object";
+}
+function push(index, key, edge) {
+  const list = index.get(key);
+  if (list === void 0) index.set(key, [edge]);
+  else list.push(edge);
+}
+
+// src/rowStyle.ts
+var textFace = (s, font) => ({
+  fontFamily: s?.fontFamily ?? font.fontFamily,
+  fontSize: s?.fontSize ?? font.fontSize,
+  ...s?.bold === true ? { fontWeight: 700 } : {}
+});
+function rowTextStyle(row, font) {
+  const face = textFace(row?.kind === "label" || row?.kind === "field" ? row.style : void 0, font);
+  return row?.kind === "label" ? { ...face, align: "center" } : face;
+}
+function diagramMarkOf(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" || !("mark" in trait)) return null;
+  const mark = trait.mark;
+  return mark !== null && typeof mark === "object" && typeof mark.d === "string" ? mark : null;
+}
+var PARSED = /* @__PURE__ */ new Map();
+var PARSED_MAX = 256;
+function unitPath(d, onWarn) {
+  let path = PARSED.get(d);
+  if (path === void 0) {
+    let warned = false;
+    path = pathFromD(d, (message) => {
+      warned = true;
+      onWarn?.(message);
+    });
+    if (path.kind === "polygon" && path.commands.length === 0) onWarn?.("it draws nothing");
+    else if (!warned) {
+      if (PARSED.size >= PARSED_MAX) PARSED.clear();
+      PARSED.set(d, path);
+    }
+  }
+  return path;
+}
+function checkMarkPath(nodeId, index, d) {
+  unitPath(d, (message) => {
+    throw new Error(`diagramScene: node "${nodeId}", mark ${index}: path data ${JSON.stringify(d)} does not parse: ${message}`);
+  });
+}
+function markShape(opts = {}) {
+  const geometry = opts.geometry ?? RECT_POSE_DESCRIPTOR;
+  return {
+    id: "diagram:mark",
+    matches: (node) => diagramMarkOf(node) !== null,
+    paint: (node, pose) => {
+      const mark = diagramMarkOf(node);
+      if (mark === null) return [];
+      const box = geometry.getBounds(pose);
+      const d = node.data;
+      const fill = d.fill && commandFill(d.fill, box);
+      const stroke = d.stroke && commandStroke(d.stroke, box);
+      return [{
+        kind: "path",
+        path: transformPath(unitPath(mark.d), [box.width, 0, 0, box.height, box.x, box.y]),
+        ...fill ? { fill } : {},
+        ...stroke ? { stroke } : {}
+      }];
+    }
+  };
+}
+function registerMarkShape(opts = {}) {
+  return registerNodeShape(markShape(opts), { priority: "high" });
+}
+function markSpecs(nodeId, marks, box, ctx) {
+  return marks.map((mark, i) => {
+    const id = `${nodeId}/mark:${i}`;
+    if ("d" in mark) {
+      checkMarkPath(nodeId, i, mark.d);
+      const paint = (color) => ({ color, ...mark.opacity !== void 0 ? { opacity: mark.opacity } : {} });
+      const stroke = mark.stroke ?? (mark.fill === void 0 ? ctx.style.stroke : void 0);
+      return {
+        id,
+        kind: "leaf",
+        layer: "main",
+        parent: nodeId,
+        pickable: false,
+        pose: { x: box.x, y: box.y, width: box.width, height: box.height },
+        data: {
+          diagram: { mark: { d: mark.d } },
+          ...mark.fill !== void 0 ? { fill: { paint: paint(mark.fill) } } : {},
+          ...stroke !== void 0 ? { stroke: { paint: paint(stroke), width: mark.strokeWidth ?? 1.5, ...mark.dash ? { dash: mark.dash } : {} } } : {}
+        }
+      };
+    }
+    const size = ctx.measure(mark.text, mark.style ?? {});
+    const self = mark.self ?? mark.at;
+    return {
+      id,
+      kind: "leaf",
+      layer: "main",
+      pickable: false,
+      pose: {
+        x: box.x + mark.at.u * box.width + (mark.offset?.x ?? 0) - self.u * size.width,
+        y: box.y + mark.at.v * box.height + (mark.offset?.y ?? 0) - self.v * size.height,
+        width: size.width,
+        height: size.height
+      },
+      data: {
+        diagram: { anchor: { at: mark.at, self, ...mark.offset ? { offset: mark.offset } : {} } },
+        text: mark.text,
+        style: ctx.textStyle(mark.style),
+        fill: { paint: { color: mark.color ?? ctx.style.text } }
+      },
+      dependsOn: [nodeId],
+      derivePose: ANCHOR_DERIVE_POSE
+    };
+  });
+}
+
+// src/dataContainers.ts
+var EMPTY_CONTAINER = { width: 240, height: 160 };
+function resolveContainers(containers, ids, nodeIds) {
+  const byId = /* @__PURE__ */ new Map();
+  const parentOf = /* @__PURE__ */ new Map();
+  const declare = (r) => {
+    if (ids.has(r.id)) throw new Error(`diagramScene: container id "${r.id}" is already a node, group, or container id`);
+    ids.add(r.id);
+    byId.set(r.id, r);
+  };
+  const base = { direct: [], pinned: false, fitted: false, index: 0 };
+  for (const c of containers) {
+    const axis = c.role === "pool" ? c.axis ?? "y" : "y";
+    declare({
+      ...base,
+      direct: [],
+      id: c.id,
+      role: c.role,
+      axis,
+      pinned: c.pinned === true,
+      ...c.label !== void 0 ? { label: c.label } : {},
+      ...c.style !== void 0 ? { style: c.style } : {},
+      ...c.colors !== void 0 ? { colors: c.colors } : {},
+      ...c.box !== void 0 ? { box: { ...c.box } } : {}
+    });
+    if (c.role !== "pool") continue;
+    (c.lanes ?? []).forEach((l, index) => {
+      declare({
+        ...base,
+        direct: [],
+        id: l.id,
+        role: "lane",
+        axis,
+        index,
+        parent: c.id,
+        ...l.label !== void 0 ? { label: l.label } : {},
+        ...l.size !== void 0 ? { size: l.size } : {},
+        ...l.colors !== void 0 ? { colors: l.colors } : {}
+      });
+      parentOf.set(l.id, c.id);
+      byId.get(c.id).direct.push(l.id);
+    });
+  }
+  const claim = (holder, id) => {
+    if (parentOf.has(id)) return;
+    const region = byId.get(id);
+    if (region === void 0 ? !nodeIds.has(id) : region.role !== "container") return;
+    for (let at = holder.id; at !== void 0; at = parentOf.get(at)) if (at === id) return;
+    parentOf.set(id, holder.id);
+    holder.direct.push(id);
+  };
+  for (const c of containers) {
+    if (c.role === "container") for (const m of c.members ?? []) claim(byId.get(c.id), m);
+    else for (const l of c.lanes ?? []) for (const m of l.members ?? []) claim(byId.get(l.id), m);
+  }
+  const regions = [];
+  const visit = (r) => {
+    const parent = parentOf.get(r.id);
+    if (parent !== void 0) r.parent = parent;
+    r.fitted = r.role === "container" && r.box === void 0 && r.direct.length > 0;
+    regions.push(r);
+    for (const id of r.direct) {
+      const inner = byId.get(id);
+      if (inner !== void 0) visit(inner);
+    }
+  };
+  for (const r of byId.values()) if (!parentOf.has(r.id)) visit(r);
+  return { regions, parentOf };
+}
+var fittedInset = (pad) => ({ top: CONTAINER_HEADER.size + pad, right: pad, bottom: pad, left: pad });
+function laneSizes(lanes, along) {
+  if (along === void 0) return lanes.map((l) => Math.max(MIN_LANE_SIZE, l.size ?? DEFAULT_LANE_SIZE));
+  const given = lanes.reduce((s, l) => s + (l.size ?? 0), 0);
+  const unsized = lanes.filter((l) => l.size === void 0).length;
+  const share = unsized === 0 ? 0 : (along - given) / unsized;
+  const sizes = lanes.map((l) => Math.max(MIN_LANE_SIZE, l.size ?? share));
+  if (sizes.length > 0) sizes[sizes.length - 1] = Math.max(MIN_LANE_SIZE, sizes[sizes.length - 1] + along - sizes.reduce((s, n) => s + n, 0));
+  return sizes;
+}
+function startBox(r, lanes, seed) {
+  if (r.box !== void 0) return r.box;
+  if (r.role !== "pool") return { ...seed, ...EMPTY_CONTAINER };
+  const along = Math.max(MIN_LANE_SIZE, laneSizes(lanes, void 0).reduce((s, n) => s + n, 0));
+  return r.axis === "y" ? { ...seed, width: DEFAULT_POOL_ACROSS, height: along } : { ...seed, width: along, height: DEFAULT_POOL_ACROSS };
+}
+function containerLayoutNodes({ regions, parentOf }, opts) {
+  const byId = new Map(regions.map((r) => [r.id, r]));
+  const rootOf = /* @__PURE__ */ new Map();
+  for (const r of regions) {
+    const outer = r.parent === void 0 ? void 0 : rootOf.get(r.parent);
+    const root = outer ?? (r.fitted ? void 0 : r.id);
+    if (root !== void 0) rootOf.set(r.id, root);
+  }
+  const endOf2 = (id) => {
+    if (byId.has(id)) return rootOf.get(id) ?? id;
+    const parent = parentOf.get(id);
+    return (parent === void 0 ? void 0 : rootOf.get(parent)) ?? id;
+  };
+  const hidden = new Set([...parentOf.keys()].filter((id) => endOf2(id) !== id));
+  const nodes = [];
+  regions.forEach((r, k) => {
+    if (rootOf.get(r.id) !== r.id) return;
+    const lanes = r.direct.flatMap((id) => {
+      const l = byId.get(id);
+      return l?.role === "lane" ? [l] : [];
+    });
+    nodes.push({ id: r.id, bounds: startBox(r, lanes, opts.seed(k)), pinned: r.pinned });
+  });
+  const seen = (id) => !hidden.has(id) && !(byId.get(id)?.fitted ?? false);
+  const below = (r) => r.direct.flatMap((id) => seen(id) ? [id] : byId.get(id)?.fitted === true && !hidden.has(id) ? below(byId.get(id)) : []);
+  const groups = [];
+  const groupOf = /* @__PURE__ */ new Map();
+  for (const r of regions) {
+    if (!r.fitted || hidden.has(r.id) || rootOf.has(r.id)) continue;
+    groups.push({ id: r.id, members: below(r), inset: fittedInset(opts.padding), ...r.parent !== void 0 ? { parent: r.parent } : {} });
+    for (const id of r.direct) if (seen(id)) groupOf.set(id, r.id);
+  }
+  return { nodes, groups, groupOf, hidden, endOf: endOf2 };
+}
+
+// src/dataContainerPlace.ts
+function seedRows(out, ids, body, sizes, pad) {
+  let x = body.x + pad;
+  let y = body.y + pad;
+  let row = 0;
+  for (const id of ids) {
+    const { width, height } = sizes.get(id);
+    if (x > body.x + pad && x + width > body.x + body.width - pad) {
+      x = body.x + pad;
+      y += row + pad;
+      row = 0;
+    }
+    out.set(id, { x, y, width, height });
+    x += width + pad;
+    row = Math.max(row, height);
+  }
+}
+function placeContainers({ regions, parentOf }, layout, placed, sizes, pad) {
+  const byId = new Map(regions.map((r) => [r.id, r]));
+  const start = new Map(layout.nodes.map((n) => [n.id, n.bounds]));
+  const delta = (id) => {
+    const root = layout.endOf(id);
+    const from = start.get(root);
+    const to = placed.get(root);
+    return from === void 0 || to === void 0 ? { x: 0, y: 0 } : { x: to.x - from.x, y: to.y - from.y };
+  };
+  const out = /* @__PURE__ */ new Map();
+  const seated = new Map(sizes);
+  const empty = [];
+  for (const r of regions) {
+    if (r.fitted || r.role === "lane") continue;
+    const own = placed.get(r.id);
+    const d = delta(r.id);
+    const box = own ?? (r.box !== void 0 ? { ...r.box, x: r.box.x + d.x, y: r.box.y + d.y } : null);
+    if (box === null) {
+      empty.push(r.id);
+      seated.set(r.id, EMPTY_CONTAINER);
+      continue;
+    }
+    out.set(r.id, box);
+    if (r.role !== "pool") continue;
+    const lanes = r.direct.map((id) => byId.get(id));
+    const along = r.axis === "y" ? box.height : box.width;
+    const sizes2 = laneSizes(lanes, r.box === void 0 ? void 0 : along);
+    const stacked = stackedLanes(r.axis, box, containerShape("pool", r.axis).header, lanes.map((l, i) => ({ id: l.id, size: sizes2[i] })));
+    for (const [id, pose] of stacked) out.set(id, pose);
+  }
+  const seatOf = (id) => {
+    let at = byId.get(parentOf.get(id) ?? "");
+    while (at !== void 0 && at.fitted) at = byId.get(at.parent ?? "");
+    return at;
+  };
+  const unseated = /* @__PURE__ */ new Map();
+  for (const [id, size] of seated) {
+    if (!layout.hidden.has(id) || byId.has(id) && !empty.includes(id)) continue;
+    if (size.at !== void 0) {
+      const d = delta(id);
+      out.set(id, { x: size.at.x + d.x, y: size.at.y + d.y, width: size.width, height: size.height });
+      continue;
+    }
+    const seat = seatOf(id);
+    unseated.set(seat, [...unseated.get(seat) ?? [], id]);
+  }
+  for (const [seat, ids] of unseated) {
+    seedRows(out, ids, bodyBox(out.get(seat.id), containerShape(seat.role, seat.axis).header), seated, pad);
+  }
+  const footprint = (id) => {
+    if (byId.has(id)) return out.get(id);
+    const at = out.get(id) ?? placed.get(id);
+    return at === void 0 ? void 0 : grownBy(at, sizes.get(id)?.margin);
+  };
+  for (const r of [...regions].reverse()) {
+    if (!r.fitted) continue;
+    const rs = r.direct.map(footprint).filter((b) => b !== void 0);
+    const inset = fittedInset(pad);
+    const x = Math.min(...rs.map((b) => b.x)) - inset.left;
+    const y = Math.min(...rs.map((b) => b.y)) - inset.top;
+    out.set(r.id, {
+      x,
+      y,
+      width: Math.max(...rs.map((b) => b.x + b.width)) + inset.right - x,
+      height: Math.max(...rs.map((b) => b.y + b.height)) + inset.bottom - y
+    });
+  }
+  return out;
+}
+function containerSpecs({ regions }, boxes, theme, fontFamily) {
+  return regions.flatMap((r) => {
+    const box = boxes.get(r.id);
+    if (box === void 0) return [];
+    const specs = regionSpecs(r.role, r.axis, { ...box }, r.label ?? null, {
+      id: r.id,
+      layer: "main",
+      parent: r.parent ?? null,
+      style: dataRegionStyle(r, theme, r.index),
+      fitted: r.fitted,
+      fontFamily
+    });
+    const marks = { ...r.pinned ? { pinned: true } : {}, ...ownNodeStyle(r.colors) };
+    if (Object.keys(marks).length === 0) return specs;
+    const [region, ...rest] = specs;
+    return [{ ...region, data: { ...region.data, diagram: { ...region.data.diagram, ...marks } } }, ...rest];
+  });
+}
+
+// src/dataGroups.ts
+var groupMinWidth = (title, pad) => title + 2 * pad;
+function resolveGroups(groups, ids, nodeIds, opts) {
+  for (const group of groups) {
+    if (ids.has(group.id)) throw new Error(`diagramScene: group id "${group.id}" is already a node or group id`);
+    ids.add(group.id);
+  }
+  const declared = new Map(groups.map((g) => [g.id, g]));
+  const nested = nestGroups(groups, (id) => nodeIds.has(id));
+  const depthOf = /* @__PURE__ */ new Map();
+  const byId = new Map(nested.map((g) => [g.id, g]));
+  const depth = (id) => {
+    const parent = byId.get(id).parent;
+    let d = depthOf.get(id);
+    if (d === void 0) depthOf.set(id, d = parent === void 0 ? 0 : depth(parent) + 1);
+    return d;
+  };
+  return nested.map((g, i) => ({ g, i })).sort((a, b) => depth(a.g.id) - depth(b.g.id) || a.i - b.i).map(({ g }) => {
+    const group = declared.get(g.id);
+    const pad = group.padding ?? opts.padding;
+    const title = group.label ? opts.title(group.label) : null;
+    const inset = { top: pad + (title ? title.height + pad / 2 : 0), right: pad, bottom: pad, left: pad };
+    return {
+      group,
+      direct: g.direct,
+      members: g.members,
+      inset,
+      pad,
+      title,
+      ...title ? { minWidth: groupMinWidth(title.width, pad) } : {},
+      ...g.parent !== void 0 ? { parent: g.parent } : {}
+    };
+  });
+}
+var groupLabelIdOf = (id) => `${id}/label`;
+function labelsByGroup(groups, labels) {
+  const byId = new Map(groups.map((g) => [g.group.id, g]));
+  const holder = /* @__PURE__ */ new Map();
+  for (const g of groups) for (const m of g.direct) holder.set(m, g.group.id);
+  const ancestry = (id) => {
+    const out2 = [];
+    for (let at = byId.has(id) ? byId.get(id).parent : holder.get(id); at !== void 0; at = byId.get(at)?.parent) out2.push(at);
+    return out2;
+  };
+  const out = /* @__PURE__ */ new Map();
+  for (const label of labels) {
+    const up = new Set(ancestry(label.to));
+    const shared = ancestry(label.from).find((g) => up.has(g));
+    if (shared !== void 0) out.set(shared, [...out.get(shared) ?? [], label]);
+  }
+  return out;
+}
+function groupBoxes(groups, placedAt, labels = /* @__PURE__ */ new Map()) {
+  const byId = new Map(groups.map((g) => [g.group.id, g]));
+  const boxes = /* @__PURE__ */ new Map();
+  const boxOf = (id) => {
+    const known = boxes.get(id);
+    if (known !== void 0) return known;
+    const g = byId.get(id);
+    const rs = g.direct.map((m) => byId.has(m) ? boxOf(m) : placedAt.get(m));
+    for (const label of labels.get(id) ?? []) if (label.at !== null) rs.push(label.at);
+    const x = Math.min(...rs.map((r) => r.x));
+    const y = Math.min(...rs.map((r) => r.y));
+    const box = boxAround({
+      x,
+      y,
+      width: Math.max(...rs.map((r) => r.x + r.width)) - x,
+      height: Math.max(...rs.map((r) => r.y + r.height)) - y
+    }, g);
+    boxes.set(id, box);
+    return box;
+  };
+  for (const g of groups) boxOf(g.group.id);
+  return boxes;
+}
+function groupSpecs(groups, placedAt, styleOf, wireLabels2 = []) {
+  const labels = labelsByGroup(groups, wireLabels2);
+  const boxes = groupBoxes(groups, placedAt, labels);
+  const specs = [];
+  for (const g of groups) {
+    const { style, text } = styleOf(g.group);
+    const { x, y, width, height } = boxes.get(g.group.id);
+    specs.push({
+      id: g.group.id,
+      kind: "leaf",
+      layer: "main",
+      pose: { x, y, width, height },
+      data: {
+        diagram: {
+          outline: "rect",
+          group: {
+            inset: g.inset,
+            ...g.minWidth !== void 0 ? { minWidth: g.minWidth } : {},
+            ...g.group.reorder !== void 0 ? { reorder: g.group.reorder } : {}
+          }
+        },
+        fill: { paint: { color: style.fill } },
+        stroke: {
+          paint: { color: style.stroke },
+          width: style.strokeWidth ?? 1,
+          ...style.dash ? { dash: style.dash } : {}
+        }
+      },
+      dependsOn: [...g.direct, ...(labels.get(g.group.id) ?? []).map((l) => l.id)],
+      derivePose: GROUP_DERIVE_POSE
+    });
+    if (g.title === null || !g.group.label) continue;
+    const anchor = { at: { u: 0, v: 0 }, offset: { x: g.pad, y: g.pad } };
+    specs.push({
+      id: groupLabelIdOf(g.group.id),
+      kind: "leaf",
+      layer: "main",
+      pickable: false,
+      pose: { x: x + g.pad, y: y + g.pad, width: g.title.width, height: g.title.height },
+      data: { diagram: { anchor }, text: g.group.label, style: text, fill: { paint: { color: style.text } } },
+      dependsOn: [g.group.id],
+      derivePose: ANCHOR_DERIVE_POSE
+    });
+  }
+  return specs;
+}
+function placementOf(e, route, ctx) {
+  const placement = e.labelPlacement ?? ctx.opts.labelPlacement ?? ctx.labelPlacement;
+  return route?.labelAt === void 0 ? placement : { ...placement, at: { near: route.labelAt } };
+}
+function wireLabels(edges, ctx) {
+  const out = [];
+  for (const e of edges) {
+    if (!e.label) continue;
+    const id = ctx.idOf(e);
+    const route = ctx.routes?.get(id);
+    const size = labelSize(e.label, labelStyleOf(ctx.labelFont ?? ctx.font), ctx.measure);
+    const placement = placementOf(e, route, ctx);
+    const center2 = route?.waypoints !== void 0 && typeof placement.at === "object" ? labelCenter(polylineFromPoints([...route.waypoints]), placement, size) : null;
+    out.push({
+      id: `${id}/label`,
+      from: e.from,
+      to: e.to,
+      at: center2 === null ? null : { x: center2.x - size.width / 2, y: center2.y - size.height / 2, ...size }
+    });
+  }
+  return out;
+}
+var endOf = (own, port) => !port ? {} : own === void 0 ? { port, laidOut: port } : { port };
+function edgeSpecs(edges, ctx) {
+  const specs = [];
+  for (const e of edges) {
+    const id = ctx.idOf(e);
+    const route = ctx.routes?.get(id);
+    const router = e.router ?? ctx.opts.router ?? "bezier";
+    const planned = route ?? {
+      fromPort: e.fromPort ?? e.routedPorts?.from,
+      toPort: e.toPort ?? e.routedPorts?.to,
+      waypoints: e.waypoints ?? e.routed
+    };
+    const { fromPort, toPort } = planned;
+    const waypoints = router === "avoid" ? e.waypoints : planned.waypoints;
+    const laidOut = e.waypoints === void 0 && waypoints !== void 0;
+    const own = ctx.opts.edgeStyle?.(e);
+    const style = own !== void 0 ? withColors(own, e.colors) : dataEdgeStyle(e, ctx.theme);
+    const markerStart = style.markerStart ?? null;
+    const markerEnd = style.markerEnd === void 0 ? "arrow" : style.markerEnd;
+    const split = ctx.splits?.get(id);
+    specs.push({
+      id,
+      kind: "leaf",
+      layer: "main",
+      pickable: false,
+      pose: { x: 0, y: 0, width: 0, height: 0 },
+      data: {
+        diagram: {
+          from: endOf(e.fromPort, fromPort),
+          to: endOf(e.toPort, toPort),
+          router,
+          ...waypoints ? { waypoints } : {},
+          ...laidOut ? { laidOut: waypoints } : {},
+          ...e.style !== void 0 ? { style: e.style } : {},
+          ...ownEdgeStyle(e.colors),
+          ...split !== void 0 ? { offPage: split } : {}
+        },
+        stroke: {
+          paint: { color: style.stroke },
+          width: style.width ?? EDGE_STROKE_WIDTH,
+          ...style.dash ? { dash: style.dash } : {},
+          ...markerStart !== null ? { markerStart } : {},
+          ...markerEnd !== null ? { markerEnd } : {}
+        }
+      },
+      dependsOn: [e.from, e.to],
+      derivePath: EDGE_DERIVE_PATH
+    });
+    if (!e.label) continue;
+    specs.push(edgeLabelSpec(id, e.label, {
+      layer: "main",
+      label: placementOf(e, route, ctx),
+      style: labelStyleOf(ctx.labelFont ?? ctx.font),
+      fill: style.label ?? style.stroke,
+      measure: ctx.measure
+    }));
+  }
+  return specs;
+}
+
+// src/fromData.ts
+var SLOT_FRAME = "M0 0H1V1H0Z";
+var GROUP = { fill: "rgba(123, 167, 199, 0.08)", stroke: "#7ba7c7", text: "#9fbdd6", strokeWidth: 1, dash: [4, 3] };
+var LINE2 = 1.4;
+var MIN_WIDTH = 64;
+var LAYOUTS = { layered, tree, force, chain };
+function labelRoomOf(e, opts, font, measure) {
+  if (!e.label || e.waypoints !== void 0) return null;
+  if (e.labelPlacement !== void 0 && !labelFollowsLayout(e.labelPlacement.at)) return null;
+  const style = labelStyleOf(font);
+  const offset = (e.labelPlacement ?? opts.labelPlacement ?? LABEL_PLACEMENT).offset;
+  return { ...labelSize(e.label, style, measure), ...offset !== void 0 ? { offset } : {} };
+}
+function graphEdgeOf(e, room) {
+  return {
+    id: edgeIdOf(e),
+    from: e.from,
+    to: e.to,
+    ...e.fromPort ? { fromPort: e.fromPort } : {},
+    ...e.toPort ? { toPort: e.toPort } : {},
+    ...room !== null ? { label: room } : {}
+  };
+}
+function nodeSpecs(n, body, box, look) {
+  const { style } = look;
+  const textData = (text, row) => ({ text, style: look.text(row), fill: { paint: { color: style.text } } });
+  const built = buildBody(body, box, {
+    id: n.id,
+    layer: "main",
+    measure: look.measure,
+    body: (trait) => ({
+      diagram: {
+        ...trait,
+        ...bodyLayoutOf(body, trait),
+        ...n.pinned === true ? { pinned: true } : {},
+        ...n.style !== void 0 ? { style: n.style } : {},
+        ...ownNodeStyle(n.colors)
+      },
+      fill: { paint: { color: style.fill } },
+      stroke: { paint: { color: style.stroke }, width: style.strokeWidth ?? NODE_STROKE_WIDTH, ...style.dash ? { dash: style.dash } : {} }
+    }),
+    row: (text, at) => at.row.kind === "slot" ? at.row.id === void 0 ? null : { diagram: { mark: { d: SLOT_FRAME } }, stroke: { paint: { color: style.stroke }, width: 1 } } : text === "" ? null : { ...textData(text, at.row), bodyRow: at.index },
+    portLabel: (text) => textData(text, void 0)
+  });
+  return built.specs.map((s, k) => ({ ...s, ...s.id !== void 0 ? {} : { id: `${n.id}/${k}` } }));
+}
+function diagramScene(data, opts = {}) {
+  const { layer, ...rest } = opts;
+  const specs = mainSpecs(data, rest);
+  return layer === void 0 ? specs : specs.map((s) => ({ ...s, layer }));
+}
+function mainSpecs(data, opts) {
+  const { theme } = opts;
+  const font = opts.font ?? (theme ? themeFont(theme) : DEFAULT_FONT);
+  const labelFont = theme ? themeLabelFont(theme, font) : font;
+  const styleOf = (s) => textFace(s, font);
+  const measure = opts.measure ? (text, s) => opts.measure(text, { ...s, fontFamily: s.fontFamily ?? font.fontFamily, fontSize: s.fontSize ?? font.fontSize }) : (text, s) => {
+    const size = s.fontSize ?? font.fontSize;
+    return { width: text.length * GLYPH * size, height: Math.ceil(LINE2 * size) };
+  };
+  const ids = /* @__PURE__ */ new Set();
+  for (const n of data.nodes) {
+    if (ids.has(n.id)) throw new Error(`diagramScene: node id "${n.id}" appears more than once`);
+    ids.add(n.id);
+  }
+  const nodeIds = new Set(ids);
+  const pad = opts.groupPadding ?? DEFAULT_GROUP_INSET;
+  const regions = resolveContainers(data.containers ?? [], ids, nodeIds);
+  for (const g of data.groups ?? []) {
+    for (const m of g.members) {
+      const region = nodeIds.has(m) ? regions.parentOf.get(m) : void 0;
+      if (region !== void 0) throw new Error(`diagramScene: node "${m}" is in group "${g.id}" and in region "${region}"; a node may be in one or the other`);
+    }
+  }
+  const boxes = containerLayoutNodes(regions, { padding: pad, seed: (k) => ({ x: data.nodes.length + k, y: data.nodes.length + k }) });
+  const titleStyle = { ...font, fontSize: font.fontSize - 1 };
+  const groups = resolveGroups(data.groups ?? [], ids, new Set([...nodeIds].filter((id) => !boxes.hidden.has(id))), {
+    padding: pad,
+    title: (text) => measure(text, titleStyle)
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const edges = data.edges.filter((e) => {
+    const id = edgeIdOf(e);
+    if (seen.has(id) || !ids.has(e.from) || !ids.has(e.to)) return false;
+    seen.add(id);
+    return true;
+  });
+  const bodies = data.nodes.map((n) => ({
+    outline: n.outline ?? opts.outline ?? "rect",
+    rows: n.rows ?? (n.lines ?? []).map((text) => ({ kind: "label", text })),
+    padding: n.padding ?? opts.padding ?? 8,
+    gap: n.gap ?? opts.gap ?? 4,
+    verticalAlign: n.verticalAlign ?? opts.verticalAlign ?? "center",
+    ...n.ports ? { ports: n.ports } : {},
+    ...n.portLabels ? { portLabels: n.portLabels } : {}
+  }));
+  const seeds = data.nodes.map((n, i) => {
+    const pose = sizeToBody(
+      { ...n.at ?? { x: i, y: i }, width: n.width ?? opts.minWidth ?? MIN_WIDTH, height: n.height ?? 0 },
+      measureBody(bodies[i], measure)
+    );
+    const { ports, outline, margin } = bodyTrait(bodies[i], pose, measure);
+    return {
+      id: n.id,
+      bounds: pose,
+      pinned: n.pinned === true,
+      ...ports !== void 0 ? { ports } : {},
+      ...outline !== void 0 ? { outline } : {},
+      ...margin !== void 0 ? { margin } : {}
+    };
+  });
+  const laid = layOut(seeds, edges, groups, boxes, opts, (e) => labelRoomOf(e, opts, labelFont, measure));
+  const specs = [];
+  const sizes = new Map(data.nodes.map((n, i) => [n.id, {
+    ...seeds[i].bounds,
+    ...n.at ? { at: n.at } : {},
+    ...seeds[i].margin ? { margin: seeds[i].margin } : {}
+  }]));
+  const placedAt = new Map([...laid.placed, ...placeContainers(regions, boxes, laid.placed, sizes, pad)]);
+  const routes = laid.plan === null ? null : authoredOver(edges.filter((e) => !laid.remapped.has(e)).map((e) => ({ ...e, id: edgeIdOf(e) })), laid.plan);
+  const edgeCtx = { idOf: edgeIdOf, font, labelFont, measure, labelPlacement: LABEL_PLACEMENT, routes, opts, ...theme ? { theme } : {} };
+  const groupLook = (g) => ({ style: opts.groupStyle?.(g) ?? theme?.container ?? GROUP, text: styleOf(titleStyle) });
+  const footprints = new Map([...placedAt, ...seeds.map((s) => [s.id, grownBy(placedAt.get(s.id), s.margin)])]);
+  specs.push(...containerSpecs(regions, placedAt, theme, font.fontFamily));
+  specs.push(...groupSpecs(groups, footprints, groupLook, wireLabels(edges, edgeCtx)));
+  for (const [i, n] of data.nodes.entries()) {
+    const seed = seeds[i].bounds;
+    const at = placedAt.get(n.id);
+    const own = opts.nodeStyle?.(n);
+    const style = own !== void 0 ? withColors(own, n.colors) : dataNodeStyle(n, theme);
+    const parent = regions.parentOf.get(n.id);
+    const built = nodeSpecs(n, bodies[i], { x: at.x, y: at.y, width: seed.width, height: seed.height }, { style, text: (row) => rowTextStyle(row, font), measure });
+    specs.push(...parent === void 0 ? built : built.map((s) => s.id === n.id ? { ...s, parent } : s));
+    if (n.marks) specs.push(...markSpecs(n.id, n.marks, at, { style, textStyle: styleOf, measure }));
+  }
+  const pages = scenePageSplits(
+    data,
+    placedAt,
+    specs,
+    edges.map((e) => ({ id: edgeIdOf(e), from: e.from, to: e.to })),
+    () => ({ ...offPageTagLook(theme ?? diagramThemeFrom(void 0)), measure })
+  );
+  specs.push(...edgeSpecs(edges, pages === null ? edgeCtx : { ...edgeCtx, splits: pages.splits }), ...pages?.tags ?? []);
+  return specs;
+}
+function layOut(seeds, edges, groups, boxes, opts, room) {
+  const graphGroups = [...groups.map((g) => ({
+    id: g.group.id,
+    members: g.members,
+    inset: g.inset,
+    ...g.minWidth !== void 0 ? { minWidth: g.minWidth } : {},
+    ...g.parent !== void 0 ? { parent: g.parent } : {},
+    ...g.group.reorder !== void 0 ? { ordered: g.direct } : {}
+  })), ...boxes.groups];
+  const visible = [...seeds.filter((s) => !boxes.hidden.has(s.id)), ...boxes.nodes];
+  const seedOf = new Map(visible.map((n) => [n.id, n]));
+  for (const [id, group] of boxes.groupOf) seedOf.get(id).group = group;
+  for (const g of groups) {
+    for (const m of g.direct) {
+      const seed = seedOf.get(m);
+      if (seed !== void 0) seed.group = g.group.id;
+    }
+  }
+  const remapped = /* @__PURE__ */ new Set();
+  const graphEdges = edges.flatMap((e) => {
+    const edge = graphEdgeOf(e, room(e));
+    const from = boxes.endOf(e.from);
+    const to = boxes.endOf(e.to);
+    if (from === e.from && to === e.to) return [edge];
+    remapped.add(e);
+    if (from === to) return [];
+    const { fromPort: _f, toPort: _t, ...rest } = edge;
+    return [{
+      ...rest,
+      from,
+      to,
+      ...from === e.from && e.fromPort ? { fromPort: e.fromPort } : {},
+      ...to === e.to && e.toPort ? { toPort: e.toPort } : {}
+    }];
+  });
+  const graph = graphOf(visible, expandGroupEdges(graphEdges, graphGroups), graphGroups);
+  const layout = typeof opts.layout === "function" ? opts.layout : opts.layout === "none" ? null : LAYOUTS[opts.layout ?? "layered"];
+  const layoutOptions = { order: "barycenter", ...opts.layoutOptions };
+  const plan = layout === null ? null : planOf(layout, graph, layoutOptions);
+  const moved = plan?.moves ?? /* @__PURE__ */ new Map();
+  const placed = new Map(visible.map((n) => {
+    const at = moved.get(n.id) ?? n.bounds;
+    return [n.id, { x: at.x, y: at.y, width: n.bounds.width, height: n.bounds.height }];
+  }));
+  return { placed, plan: layout?.plan === void 0 ? null : plan, remapped };
+}
+
+export { ANCHOR_DERIVE_POSE, CONTAINER_HEADER, CONTAINER_LAYOUTS, DEFAULT_FONT, DEFAULT_LANE_SIZE, DEFAULT_POOL_ACROSS, DIAGRAM_ANCHOR, DIAGRAM_CONTAINER_LAYOUT, DIAGRAM_EDGE, DIAGRAM_GROUP, DIAGRAM_LABEL, DIAGRAM_LANE_COLUMNS_LAYOUT, DIAGRAM_LANE_ROWS_LAYOUT, DIAGRAM_OFF_PAGE_TAG, DIAGRAM_POOL_COLUMNS_LAYOUT, DIAGRAM_POOL_ROWS_LAYOUT, DIAGRAM_ROLES, DIAGRAM_THEMES, DIAGRAM_THEME_KEY, EDGE_DERIVE_PATH, EDGE_STROKE_WIDTH, EDIT_EDGE_LABEL_ACTION_ID, GROUP_DERIVE_POSE, LABEL_DERIVE_POSE, LABEL_DRAG_AFFORDANCE_KIND, LABEL_DRAG_LAYER_ID, LABEL_PLACEMENT, LANE_HEADER_SIZE, LANE_STROKE_WIDTH, MIN_LANE_SIZE, NODE, NODE_STROKE_WIDTH, OFF_PAGE_STUB, OFF_PAGE_TAG_DERIVE_POSE, OFF_PAGE_TAG_PADDING, POOL_HEADER_SIZE, ROUTERS, anchorDerivePose, avoid, bezier, bodyBox, bodyLayoutOf, boxAround, boxCenter, buildGraph, containerShape, dataEdgeStyle, dataNodeStyle, dataOffPage, dataRegionStyle, diagramAnchorOf, diagramContainerLayout, diagramContainerOf, diagramGroupOf, diagramLabelOf, diagramMarkOf, diagramPages, diagramScene, diagramThemeFrom, diagramThemeOf, draggableLabels, dropEmptyEdgeLabel, edgeDerivePath, edgeIdOf, edgeLabelSpec, edgeRouter, editEdgeLabelAction, editEdgeLabelBinding, editableLabels, endAims, firstLanes, groupDerivePose, groupLabelIdOf, groupMinWidth, headerBox, labelDerivePose, labelDragLayer, labelFollowsLayout, labelScratchOf, labelSize, labelStyleOf, labelUnder, laneHeader, laneOutlineOf, laneStackLayout, markShape, nestGroups, nextOffPageRef, offPageFarText, offPageSplits, offPageTagData, offPageTagDerivePose, offPageTagId, offPageTagLook, offPageTagOf, offPageTagSize, offPageTagSpec, offPageTagSpecs, offPageTagText, orthogonal, poolHeader, regionSpecs, registerMarkShape, relayoutBodies, resolveEnd, roleEdgeStyle, roleStyle, routerOf, rowTextStyle, selfLoop, stackedLanes, straight, themeDocValue, themeEdgeStroke, themeFont, themeLabelFamily, themeLabelFont, themeLabelStyle, titleIdOf, titlePose, withDiagramRegistry, withHops };
+//# sourceMappingURL=chunk-43LDZ6L4.js.map
+//# sourceMappingURL=chunk-43LDZ6L4.js.map