@dskripchenko/flow 0.0.0-stage → 1.0.1

package/dist/core-DfJMfClV.js

@@ -0,0 +1,4121 @@
+// src/model/types.ts
+/**
+* The graph model: plain JSON, versioned, independent of layout and of the
+* monitoring state. A host stores it as is; the viewer and the editor read
+* and write exactly this shape.
+*/
+/** The model format this package reads and writes. */
+var GRAPH_VERSION = 1;
+/** `enabled` treats a missing flag as enabled. */
+function isEnabled(el) {
+	return el.enabled !== false;
+}
+// src/model/parse.ts
+/**
+* Reading a model from untrusted JSON: shape checks, defaults, and the
+* version gate. Semantic problems (unknown references, unreachable nodes)
+* are left to `validateGraph`, which reports instead of throwing.
+*/
+var GraphError = class extends Error {
+	pointer;
+	name = "GraphError";
+	constructor(message, pointer = "") {
+		super(pointer ? `${message} (at ${pointer})` : message);
+		this.pointer = pointer;
+	}
+};
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function str(o, key, at, required = false) {
+	const v = o[key];
+	if (v === void 0 || v === null) {
+		if (required) throw new GraphError(`"${key}" is required`, `${at}/${key}`);
+		return;
+	}
+	if (typeof v === "number") return String(v);
+	if (typeof v !== "string") throw new GraphError(`"${key}" must be a string`, `${at}/${key}`);
+	return v;
+}
+function bool(o, key, at) {
+	const v = o[key];
+	if (v === void 0 || v === null) return void 0;
+	if (typeof v !== "boolean") throw new GraphError(`"${key}" must be true or false`, `${at}/${key}`);
+	return v;
+}
+function point(v, at) {
+	if (v === void 0 || v === null) return void 0;
+	if (!isObj(v) || typeof v.x !== "number" || typeof v.y !== "number" || !Number.isFinite(v.x) || !Number.isFinite(v.y)) throw new GraphError("\"position\" must be { x: number, y: number }", at);
+	return {
+		x: v.x,
+		y: v.y
+	};
+}
+var SIDES = /* @__PURE__ */ new Set([
+	"top",
+	"right",
+	"bottom",
+	"left"
+]);
+function ports(v, at) {
+	if (v === void 0 || v === null) return void 0;
+	if (!Array.isArray(v)) throw new GraphError("\"ports\" must be an array", at);
+	return v.map((p, i) => {
+		const here = `${at}/${i}`;
+		if (!isObj(p)) throw new GraphError("A port must be an object", here);
+		const side = str(p, "side", here, true);
+		if (!SIDES.has(side)) throw new GraphError(`"side" must be one of top, right, bottom, left`, `${here}/side`);
+		const port = {
+			id: str(p, "id", here, true),
+			side
+		};
+		if (typeof p.offset === "number") port.offset = Math.min(1, Math.max(0, p.offset));
+		if (p.kind === "in" || p.kind === "out" || p.kind === "both") port.kind = p.kind;
+		const label = str(p, "label", here);
+		if (label !== void 0) port.label = label;
+		return port;
+	});
+}
+function data(v, at) {
+	if (v === void 0 || v === null) return void 0;
+	if (!isObj(v)) throw new GraphError("\"data\" must be an object", at);
+	return v;
+}
+function node(v, at) {
+	if (!isObj(v)) throw new GraphError("A node must be an object", at);
+	const n = {
+		id: str(v, "id", at, true),
+		type: str(v, "type", at) ?? "state"
+	};
+	const label = str(v, "label", at);
+	if (label !== void 0) n.label = label;
+	const description = str(v, "description", at);
+	if (description !== void 0) n.description = description;
+	const position = point(v.position, `${at}/position`);
+	if (position) n.position = position;
+	const group = str(v, "group", at);
+	if (group !== void 0) n.group = group;
+	const d = data(v.data, `${at}/data`);
+	if (d) n.data = d;
+	const enabled = bool(v, "enabled", at);
+	if (enabled !== void 0) n.enabled = enabled;
+	if (v.subgraph !== void 0 && v.subgraph !== null) n.subgraph = typeof v.subgraph === "string" ? v.subgraph : parseGraph(v.subgraph, `${at}/subgraph`);
+	const p = ports(v.ports, `${at}/ports`);
+	if (p) n.ports = p;
+	return n;
+}
+function edge(v, at) {
+	if (!isObj(v)) throw new GraphError("An edge must be an object", at);
+	const e = {
+		id: str(v, "id", at, true),
+		from: str(v, "from", at, true),
+		to: str(v, "to", at, true)
+	};
+	for (const key of [
+		"fromPort",
+		"toPort",
+		"label",
+		"condition"
+	]) {
+		const s = str(v, key, at);
+		if (s !== void 0) e[key] = s;
+	}
+	const enabled = bool(v, "enabled", at);
+	if (enabled !== void 0) e.enabled = enabled;
+	if (v.kind === "association" || v.kind === "transition") e.kind = v.kind;
+	const d = data(v.data, `${at}/data`);
+	if (d) e.data = d;
+	return e;
+}
+function group(v, at) {
+	if (!isObj(v)) throw new GraphError("A group must be an object", at);
+	const g = { id: str(v, "id", at, true) };
+	const label = str(v, "label", at);
+	if (label !== void 0) g.label = label;
+	const parent = str(v, "parent", at);
+	if (parent !== void 0) g.parent = parent;
+	return g;
+}
+/**
+* Reads a model from parsed JSON (or a JSON string). Fills defaults, drops
+* unknown fields of nodes and edges, and throws `GraphError` with a JSON
+* pointer when the shape is wrong.
+*/
+function parseGraph(input, at = "") {
+	let v = input;
+	if (typeof v === "string") try {
+		v = JSON.parse(v);
+	} catch (e) {
+		throw new GraphError(`Not valid JSON: ${e.message}`, at);
+	}
+	if (!isObj(v)) throw new GraphError("A graph must be an object", at);
+	const version = v.version ?? 1;
+	if (version !== 1) throw new GraphError(`Unsupported model version ${String(version)}; this package reads version 1`, `${at}/version`);
+	if (!Array.isArray(v.nodes)) throw new GraphError("\"nodes\" must be an array", `${at}/nodes`);
+	const edges = v.edges ?? [];
+	if (!Array.isArray(edges)) throw new GraphError("\"edges\" must be an array", `${at}/edges`);
+	const g = {
+		version: 1,
+		nodes: v.nodes.map((n, i) => node(n, `${at}/nodes/${i}`)),
+		edges: edges.map((e, i) => edge(e, `${at}/edges/${i}`))
+	};
+	if (v.groups !== void 0 && v.groups !== null) {
+		if (!Array.isArray(v.groups)) throw new GraphError("\"groups\" must be an array", `${at}/groups`);
+		g.groups = v.groups.map((x, i) => group(x, `${at}/groups/${i}`));
+	}
+	if (isObj(v.meta)) {
+		const meta = { ...v.meta };
+		if (meta.direction !== void 0 && meta.direction !== "TB" && meta.direction !== "LR") delete meta.direction;
+		g.meta = meta;
+	}
+	return g;
+}
+/** The model as stable JSON text (2-space indent). */
+function stringifyGraph(graph) {
+	return JSON.stringify(graph, null, 2);
+}
+/** An empty model. */
+function emptyGraph(meta) {
+	return meta ? {
+		version: 1,
+		nodes: [],
+		edges: [],
+		meta
+	} : {
+		version: 1,
+		nodes: [],
+		edges: []
+	};
+}
+// src/model/registry.ts
+var BUILTIN_TYPES = Object.freeze({
+	start: {
+		title: "Start",
+		shape: "circle",
+		size: {
+			width: 40,
+			height: 40
+		},
+		icon: "play",
+		labelOutside: true,
+		noIncoming: true
+	},
+	end: {
+		title: "End",
+		shape: "ring",
+		size: {
+			width: 40,
+			height: 40
+		},
+		icon: "stop",
+		labelOutside: true,
+		noOutgoing: true
+	},
+	state: {
+		title: "State",
+		shape: "rounded",
+		minWidth: 160,
+		maxWidth: 240,
+		height: 44
+	},
+	task: {
+		title: "Task",
+		shape: "rect",
+		minWidth: 176,
+		maxWidth: 260,
+		height: 60,
+		icon: "task"
+	},
+	decision: {
+		title: "Decision",
+		shape: "diamond",
+		minWidth: 124,
+		maxWidth: 200,
+		height: 80,
+		icon: "decision"
+	},
+	subprocess: {
+		title: "Sub-process",
+		shape: "rect",
+		minWidth: 192,
+		maxWidth: 260,
+		height: 64,
+		icon: "subprocess",
+		drillable: true
+	},
+	note: {
+		title: "Note",
+		shape: "note",
+		minWidth: 140,
+		maxWidth: 240,
+		height: 48,
+		annotation: true
+	}
+});
+/** A registry with the built-in types plus `custom` (which may override them). */
+function createRegistry(custom = {}) {
+	return new Map(Object.entries({
+		...BUILTIN_TYPES,
+		...custom
+	}));
+}
+var defaultRegistry = createRegistry();
+/** The definition for a node's type; an unknown type is drawn as a state. */
+function typeOf(registry, type) {
+	return registry.get(type) ?? registry.get("state") ?? BUILTIN_TYPES.state;
+}
+/** The ports a node offers: its own, else its type's. */
+function portsOf(registry, node) {
+	return node.ports ?? typeOf(registry, node.type).ports ?? [];
+}
+/** Whether the editor must leave a node alone (its type is locked). */
+function isLocked(registry, node) {
+	return typeOf(registry, node.type).locked === true;
+}
+// src/model/validate.ts
+/**
+* Semantic checks of a model. Cycles are legal (state machines loop); what
+* is reported is what makes a process wrong (errors) or suspicious
+* (warnings). The viewer renders a graph with errors as far as it can; the
+* editor lists the issues and highlights the elements.
+*/
+/** All issues of a graph, errors first, then in model order. */
+function validateGraph(graph, options = {}) {
+	const registry = options.registry ?? defaultRegistry;
+	const issues = [];
+	const add = (severity, code, message, kind, id) => issues.push(kind && id !== void 0 ? {
+		severity,
+		code,
+		message,
+		target: {
+			kind,
+			id
+		}
+	} : {
+		severity,
+		code,
+		message
+	});
+	const seen = /* @__PURE__ */ new Map();
+	const claim = (kind, id) => {
+		if (seen.has(id)) add("error", "duplicate-id", `The id "${id}" is used more than once`, kind, id);
+		else seen.set(id, kind);
+	};
+	const nodes = new Map(graph.nodes.map((n) => [n.id, n]));
+	const groups = new Map((graph.groups ?? []).map((g) => [g.id, g]));
+	for (const n of graph.nodes) claim("node", n.id);
+	for (const e of graph.edges) claim("edge", e.id);
+	for (const g of graph.groups ?? []) claim("group", g.id);
+	for (const g of graph.groups ?? []) {
+		if (g.parent !== void 0 && !groups.has(g.parent)) add("error", "unknown-group", `Group "${g.id}" is inside an unknown group "${g.parent}"`, "group", g.id);
+		let p = g.parent;
+		let steps = 0;
+		while (p !== void 0 && groups.has(p)) {
+			if (p === g.id || ++steps > groups.size) {
+				add("error", "group-cycle", `Group "${g.id}" contains itself`, "group", g.id);
+				break;
+			}
+			p = groups.get(p).parent;
+		}
+	}
+	for (const n of graph.nodes) {
+		if (!registry.has(n.type)) add("warning", "unknown-type", `Node "${n.id}" has an unknown type "${n.type}"; it is drawn as a state`, "node", n.id);
+		if (n.group !== void 0 && !groups.has(n.group)) add("error", "unknown-group", `Node "${n.id}" is in an unknown group "${n.group}"`, "node", n.id);
+		const def = typeOf(registry, n.type);
+		if (!def.labelOutside && !def.annotation && !(n.label ?? "").trim() && n.type !== "decision") add("warning", "empty-label", `Node "${n.id}" has no label`, "node", n.id);
+	}
+	const live = graph.edges.filter((e) => e.kind !== "association");
+	for (const e of graph.edges) for (const end of ["from", "to"]) {
+		const id = e[end];
+		const n = nodes.get(id);
+		if (!n) {
+			add("error", "unknown-node", `Edge "${e.id}" ${end === "from" ? "starts at" : "ends at"} an unknown node "${id}"`, "edge", e.id);
+			continue;
+		}
+		const portId = end === "from" ? e.fromPort : e.toPort;
+		if (portId !== void 0) {
+			const port = portsOf(registry, n).find((p) => p.id === portId);
+			if (!port) add("error", "unknown-port", `Edge "${e.id}" uses an unknown port "${portId}" of "${id}"`, "edge", e.id);
+			else if (end === "from" && port.kind === "in" || end === "to" && port.kind === "out") add("error", "unknown-port", `Port "${portId}" of "${id}" does not take ${end === "from" ? "outgoing" : "incoming"} edges`, "edge", e.id);
+		}
+	}
+	const flowNodes = graph.nodes.filter((n) => !typeOf(registry, n.type).annotation);
+	const starts = flowNodes.filter((n) => typeOf(registry, n.type).noIncoming);
+	const ends = flowNodes.filter((n) => typeOf(registry, n.type).noOutgoing);
+	if ((options.requireStartEnd ?? true) && flowNodes.length > 0) {
+		if (starts.length === 0) add("warning", "missing-start", "The process has no start node");
+		if (ends.length === 0) add("warning", "missing-end", "The process has no end node");
+	}
+	for (const e of live) {
+		const to = nodes.get(e.to);
+		const from = nodes.get(e.from);
+		if (to && typeOf(registry, to.type).noIncoming) add("warning", "start-incoming", `Edge "${e.id}" leads into the start node "${to.id}"`, "edge", e.id);
+		if (from && typeOf(registry, from.type).noOutgoing) add("warning", "end-outgoing", `Edge "${e.id}" leaves the end node "${from.id}"`, "edge", e.id);
+	}
+	if (starts.length > 0) {
+		const out = /* @__PURE__ */ new Map();
+		for (const e of live) {
+			if (!nodes.has(e.from) || !nodes.has(e.to)) continue;
+			const list = out.get(e.from) ?? [];
+			list.push(e.to);
+			out.set(e.from, list);
+		}
+		const reached = /* @__PURE__ */ new Set();
+		const queue = starts.map((s) => s.id);
+		for (const id of queue) reached.add(id);
+		while (queue.length) {
+			const id = queue.shift();
+			for (const next of out.get(id) ?? []) if (!reached.has(next)) {
+				reached.add(next);
+				queue.push(next);
+			}
+		}
+		for (const n of flowNodes) if (!reached.has(n.id)) add("warning", "unreachable", `Node "${n.id}" cannot be reached from the start`, "node", n.id);
+	}
+	const hasOut = new Set(live.filter((e) => nodes.has(e.to)).map((e) => e.from));
+	for (const n of flowNodes) {
+		if (typeOf(registry, n.type).noOutgoing) continue;
+		if (!hasOut.has(n.id)) add("warning", "dead-end", `Node "${n.id}" has no outgoing transition`, "node", n.id);
+	}
+	return issues.sort((a, b) => a.severity === b.severity ? 0 : a.severity === "error" ? -1 : 1);
+}
+/** Issues grouped by element id, for highlighting. */
+function issuesByElement(issues) {
+	const map = /* @__PURE__ */ new Map();
+	for (const i of issues) {
+		if (!i.target) continue;
+		const list = map.get(i.target.id) ?? [];
+		list.push(i);
+		map.set(i.target.id, list);
+	}
+	return map;
+}
+// src/layout/layered/errors.ts
+/**
+* Errors of the layered layout. Copied from @dskripchenko/diagrams
+* (src/core/errors.ts) together with the layout; the name stays so that a
+* later switch to the diagrams export changes nothing for callers.
+*/
+var DiagramError = class extends Error {
+	line;
+	column;
+	hint;
+	name = "DiagramError";
+	constructor(message, line = 0, column = 0, hint) {
+		super(line > 0 ? `${message} (line ${line}${column > 0 ? `, column ${column}` : ""})` : message);
+		this.line = line;
+		this.column = column;
+		this.hint = hint;
+	}
+};
+/** Raised when a graph is too large to lay out in predictable time. */
+function tooLarge(what, count, limit) {
+	return new DiagramError(`The graph has ${count} ${what}; the limit is ${limit}.`, 0, 0, "Split it into sub-processes.");
+}
+// src/layout/layered/graph.ts
+var Graph = class {
+	nodes = /* @__PURE__ */ new Map();
+	edges = [];
+	outMap = /* @__PURE__ */ new Map();
+	inMap = /* @__PURE__ */ new Map();
+	addNode(node) {
+		const full = {
+			...node,
+			rank: 0,
+			order: 0,
+			x: 0,
+			y: 0
+		};
+		this.nodes.set(full.id, full);
+		this.outMap.set(full.id, []);
+		this.inMap.set(full.id, []);
+		return full;
+	}
+	node(id) {
+		const n = this.nodes.get(id);
+		if (!n) throw new Error(`Unknown node ${id}`);
+		return n;
+	}
+	addEdge(edge) {
+		this.edges.push(edge);
+		this.outMap.get(edge.v).push(edge);
+		this.inMap.get(edge.w).push(edge);
+		return edge;
+	}
+	removeEdge(edge) {
+		const remove = (list) => {
+			const i = list.indexOf(edge);
+			if (i >= 0) list.splice(i, 1);
+		};
+		remove(this.edges);
+		remove(this.outMap.get(edge.v));
+		remove(this.inMap.get(edge.w));
+	}
+	out(id) {
+		return this.outMap.get(id) ?? [];
+	}
+	in(id) {
+		return this.inMap.get(id) ?? [];
+	}
+	/** Re-indexes after edges were mutated in place (reversed). */
+	reindex() {
+		for (const id of this.nodes.keys()) {
+			this.outMap.set(id, []);
+			this.inMap.set(id, []);
+		}
+		for (const e of this.edges) {
+			this.outMap.get(e.v).push(e);
+			this.inMap.get(e.w).push(e);
+		}
+	}
+};
+// src/layout/layered/order.ts
+/** The clusters containing a node, outermost first. */
+function chain(cluster, parents) {
+	const out = [];
+	let c = cluster;
+	while (c) {
+		out.unshift(c);
+		c = parents.get(c) ?? null;
+	}
+	return out;
+}
+function buildLayers(g) {
+	const layers = [];
+	for (const n of g.nodes.values()) (layers[n.rank] ??= []).push(n);
+	for (let i = 0; i < layers.length; i++) layers[i] ??= [];
+	return layers;
+}
+/** Initial order: depth-first from the top, so connected nodes start close. */
+function initialOrder(g, layers) {
+	const visited = /* @__PURE__ */ new Set();
+	const next = layers.map(() => 0);
+	const ordered = [...g.nodes.values()].sort((a, b) => a.rank - b.rank);
+	for (const start of ordered) {
+		if (visited.has(start.id)) continue;
+		const stack = [start];
+		while (stack.length > 0) {
+			const n = stack.pop();
+			if (visited.has(n.id)) continue;
+			visited.add(n.id);
+			n.order = next[n.rank]++;
+			const succ = g.out(n.id).map((e) => g.node(e.w));
+			for (let i = succ.length - 1; i >= 0; i--) if (!visited.has(succ[i].id)) stack.push(succ[i]);
+		}
+	}
+	for (const layer of layers) layer.sort((a, b) => a.order - b.order);
+}
+/**
+* Sorts one layer by `key`, keeping clusters contiguous and sibling clusters
+* in their canonical order. Ties keep their current order, or are reversed
+* with `biasRight`.
+*/
+function sortLayer(layer, key, parents, canonical, biasRight = false) {
+	const root = {
+		cluster: null,
+		nodes: [],
+		children: /* @__PURE__ */ new Map(),
+		items: []
+	};
+	for (const n of layer) {
+		let group = root;
+		for (const c of chain(n.cluster, parents)) {
+			let child = group.children.get(c);
+			if (!child) {
+				child = {
+					cluster: c,
+					nodes: [],
+					children: /* @__PURE__ */ new Map(),
+					items: []
+				};
+				group.children.set(c, child);
+				group.items.push(c);
+			}
+			group = child;
+		}
+		group.nodes.push(n);
+		group.items.push(n);
+	}
+	const groupKey = /* @__PURE__ */ new Map();
+	const keyOf = (group) => {
+		const cached = groupKey.get(group);
+		if (cached !== void 0) return cached;
+		let sum = 0;
+		let count = 0;
+		const walk = (g) => {
+			for (const n of g.nodes) {
+				sum += key.get(n.id);
+				count++;
+			}
+			for (const c of g.children.values()) walk(c);
+		};
+		walk(group);
+		const value = count > 0 ? sum / count : 0;
+		groupKey.set(group, value);
+		return value;
+	};
+	const flatten = (group) => {
+		const indexed = group.items.map((item, index) => ({
+			item,
+			index,
+			k: typeof item === "string" ? keyOf(group.children.get(item)) : key.get(item.id)
+		}));
+		indexed.sort((a, b) => a.k - b.k || (biasRight ? b.index - a.index : a.index - b.index));
+		const slots = indexed.flatMap((entry, i) => typeof entry.item === "string" ? [i] : []);
+		const clusters = slots.map((i) => indexed[i].item).sort((a, b) => (canonical.get(a) ?? 0) - (canonical.get(b) ?? 0));
+		slots.forEach((slot, i) => {
+			indexed[slot].item = clusters[i];
+		});
+		const out = [];
+		for (const entry of indexed) if (typeof entry.item === "string") out.push(...flatten(group.children.get(entry.item)));
+		else out.push(entry.item);
+		return out;
+	};
+	return flatten(root);
+}
+/** Crossings between two adjacent layers (Barth, Jünger and Mutzel's accumulator tree). */
+function crossingsBetween(g, upper, lower) {
+	const pos = new Map(lower.map((n, i) => [n.id, i]));
+	const targets = [];
+	upper.forEach((n, ui) => {
+		for (const e of g.out(n.id)) {
+			const l = pos.get(e.w);
+			if (l !== void 0) targets.push({
+				u: ui,
+				l,
+				w: e.weight || 1
+			});
+		}
+	});
+	targets.sort((a, b) => a.u - b.u || a.l - b.l);
+	let first = 1;
+	while (first < lower.length) first <<= 1;
+	const tree = new Array(2 * first - 1).fill(0);
+	first -= 1;
+	let crossings = 0;
+	for (const t of targets) {
+		let index = t.l + first;
+		tree[index] += t.w;
+		let weightSum = 0;
+		while (index > 0) {
+			if (index % 2) weightSum += tree[index + 1];
+			index = index - 1 >> 1;
+			tree[index] += t.w;
+		}
+		crossings += t.w * weightSum;
+	}
+	return crossings;
+}
+/**
+* Edges that pass through a cluster they do not belong to: from the left of
+* its block in one rank to the right of it in the next, or back. Counted as
+* crossings, since that is what the reader sees — a line across a frame.
+*/
+function frameCrossingsBetween(g, upper, lower, parents) {
+	const ranges = (layer) => {
+		const out = /* @__PURE__ */ new Map();
+		layer.forEach((n, i) => {
+			for (const c of chain(n.cluster, parents)) {
+				const r = out.get(c);
+				if (r) r.to = i;
+				else out.set(c, {
+					from: i,
+					to: i
+				});
+			}
+		});
+		return out;
+	};
+	const up = ranges(upper);
+	const down = ranges(lower);
+	if (up.size === 0 || down.size === 0) return 0;
+	const pos = new Map(lower.map((n, i) => [n.id, i]));
+	let count = 0;
+	upper.forEach((n, ui) => {
+		for (const e of g.out(n.id)) {
+			const li = pos.get(e.w);
+			if (li === void 0) continue;
+			for (const [c, a] of up) {
+				const b = down.get(c);
+				if (!b) continue;
+				if (ui < a.from && li > b.to || ui > a.to && li < b.from) count += 2;
+			}
+		}
+	});
+	return count;
+}
+function totalCrossings(g, layers, parents = /* @__PURE__ */ new Map()) {
+	let total = 0;
+	for (let i = 0; i + 1 < layers.length; i++) {
+		total += crossingsBetween(g, layers[i], layers[i + 1]);
+		if (parents.size > 0) total += frameCrossingsBetween(g, layers[i], layers[i + 1], parents);
+	}
+	return total;
+}
+function canonicalClusterOrder(layers, parents) {
+	const sum = /* @__PURE__ */ new Map();
+	const count = /* @__PURE__ */ new Map();
+	for (const layer of layers) layer.forEach((n, i) => {
+		const relative = layer.length > 1 ? i / (layer.length - 1) : .5;
+		for (const c of chain(n.cluster, parents)) {
+			sum.set(c, (sum.get(c) ?? 0) + relative);
+			count.set(c, (count.get(c) ?? 0) + 1);
+		}
+	});
+	const out = /* @__PURE__ */ new Map();
+	for (const [c, s] of sum) out.set(c, s / count.get(c));
+	return out;
+}
+/**
+* Transpose: swaps neighbours in a layer while that removes crossings with
+* the layers above and below. The barycenter sweeps settle in local minima
+* a single swap gets out of — typically a node with one edge that ties with
+* a node pulled two ways. Only nodes in the same cluster are swapped, so
+* clusters stay contiguous.
+*/
+function transpose(g, layers) {
+	const pairs = (us, vs) => {
+		let c = 0;
+		for (const a of us) for (const b of vs) if (a.order > b.order) c += a.w * b.w;
+		return c;
+	};
+	const ends = (n) => ({
+		up: g.in(n.id).map((e) => ({
+			order: g.node(e.v).order,
+			w: e.weight || 1
+		})),
+		down: g.out(n.id).map((e) => ({
+			order: g.node(e.w).order,
+			w: e.weight || 1
+		}))
+	});
+	const cost = (u, v) => pairs(u.up, v.up) + pairs(u.down, v.down);
+	for (let round = 0; round < 8; round++) {
+		let improved = false;
+		for (const layer of layers) {
+			if (layer.length < 2) continue;
+			for (let j = 0; j + 1 < layer.length; j++) {
+				const a = layer[j];
+				const b = layer[j + 1];
+				if (a.cluster !== b.cluster) continue;
+				const ea = ends(a);
+				const eb = ends(b);
+				if (cost(eb, ea) < cost(ea, eb)) {
+					layer[j] = b;
+					layer[j + 1] = a;
+					improved = true;
+				}
+			}
+			layer.forEach((n, k) => n.order = k);
+		}
+		if (!improved) break;
+	}
+}
+/**
+* Orders every layer in place and sets `node.order`.
+* Returns the layers, each in its final order. With `refine`, every sweep
+* is followed by a transpose pass.
+*/
+function order(g, parents, iterations = 24, refine = false) {
+	const layers = buildLayers(g);
+	initialOrder(g, layers);
+	let canonical = canonicalClusterOrder(layers, parents);
+	for (let i = 0; i < layers.length; i++) {
+		const key = new Map(layers[i].map((n, j) => [n.id, j]));
+		layers[i] = sortLayer(layers[i], key, parents, canonical);
+	}
+	const assign = (ls) => ls.forEach((layer) => layer.forEach((n, i) => n.order = i));
+	assign(layers);
+	if (refine) transpose(g, layers);
+	let best = layers.map((l) => l.slice());
+	let bestCrossings = totalCrossings(g, layers, parents);
+	let sinceImprovement = 0;
+	for (let it = 0; it < iterations && bestCrossings > 0 && sinceImprovement < 4; it++) {
+		const down = it % 2 === 0;
+		const biasRight = refine && it % 4 >= 2;
+		const range = down ? Array.from({ length: layers.length - 1 }, (_, i) => i + 1) : Array.from({ length: layers.length - 1 }, (_, i) => layers.length - 2 - i);
+		const fixed = down ? 0 : layers.length - 1;
+		const identity = new Map(layers[fixed].map((n, j) => [n.id, j]));
+		layers[fixed] = sortLayer(layers[fixed], identity, parents, canonical);
+		layers[fixed].forEach((n, j) => n.order = j);
+		for (const i of range) {
+			const layer = layers[i];
+			const key = /* @__PURE__ */ new Map();
+			for (const n of layer) {
+				const neighbours = down ? g.in(n.id).map((e) => ({
+					order: g.node(e.v).order,
+					w: e.weight || 1
+				})) : g.out(n.id).map((e) => ({
+					order: g.node(e.w).order,
+					w: e.weight || 1
+				}));
+				if (neighbours.length === 0) key.set(n.id, n.order);
+				else {
+					let s = 0;
+					let ws = 0;
+					for (const nb of neighbours) {
+						s += nb.order * nb.w;
+						ws += nb.w;
+					}
+					key.set(n.id, s / ws);
+				}
+			}
+			layers[i] = sortLayer(layer, key, parents, canonical, biasRight);
+			layers[i].forEach((n, j) => n.order = j);
+		}
+		if (refine) transpose(g, layers);
+		canonical = canonicalClusterOrder(layers, parents);
+		const crossings = totalCrossings(g, layers, parents);
+		if (crossings < bestCrossings) {
+			bestCrossings = crossings;
+			best = layers.map((l) => l.slice());
+			sinceImprovement = 0;
+		} else sinceImprovement++;
+	}
+	assign(best);
+	return best;
+}
+// src/layout/layered/position.ts
+function isDummy(n) {
+	return n.dummy === "edge" || n.dummy === "label" || n.dummy === "spine";
+}
+function separation(a, b, s) {
+	const gap = isDummy(a) && isDummy(b) ? s.edgeSep : isDummy(a) || isDummy(b) ? (s.nodeSep + s.edgeSep) / 2 : s.nodeSep;
+	return a.width / 2 + gap + b.width / 2;
+}
+function packLeft(layer, s) {
+	let x = 0;
+	layer.forEach((n, i) => {
+		x = i === 0 ? n.width / 2 : x + separation(layer[i - 1], n, s);
+		n.x = x;
+	});
+}
+function median(values) {
+	const sorted = values.slice().sort((a, b) => a - b);
+	const mid = sorted.length >> 1;
+	return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/**
+* One rank of the priority method: nodes move towards `desired` in order of
+* priority; a node may push lower-priority neighbours along, never higher.
+*/
+function placeLayer(layer, desired, priority, s) {
+	const fixed = new Array(layer.length).fill(false);
+	const order = layer.map((_, i) => i).sort((a, b) => priority.get(layer[b].id) - priority.get(layer[a].id) || a - b);
+	for (const i of order) {
+		const node = layer[i];
+		const target = desired.get(node.id);
+		if (target === void 0) {
+			fixed[i] = true;
+			continue;
+		}
+		if (target > node.x) {
+			let limit = Infinity;
+			let span = 0;
+			for (let j = i + 1; j < layer.length; j++) {
+				span += separation(layer[j - 1], layer[j], s);
+				if (fixed[j]) {
+					limit = layer[j].x - span;
+					break;
+				}
+			}
+			const x = Math.min(target, limit);
+			if (x > node.x) {
+				node.x = x;
+				for (let j = i + 1; j < layer.length; j++) {
+					const min = layer[j - 1].x + separation(layer[j - 1], layer[j], s);
+					if (layer[j].x >= min) break;
+					layer[j].x = min;
+				}
+			}
+		} else if (target < node.x) {
+			let limit = -Infinity;
+			let span = 0;
+			for (let j = i - 1; j >= 0; j--) {
+				span += separation(layer[j], layer[j + 1], s);
+				if (fixed[j]) {
+					limit = layer[j].x + span;
+					break;
+				}
+			}
+			const x = Math.max(target, limit);
+			if (x < node.x) {
+				node.x = x;
+				for (let j = i - 1; j >= 0; j--) {
+					const max = layer[j + 1].x - separation(layer[j], layer[j + 1], s);
+					if (layer[j].x <= max) break;
+					layer[j].x = max;
+				}
+			}
+		}
+		fixed[i] = true;
+	}
+}
+function priorityX(g, layers, s, rounds = 4) {
+	for (const layer of layers) packLeft(layer, s);
+	const sweep = (down) => {
+		const indices = down ? Array.from({ length: layers.length - 1 }, (_, i) => i + 1) : Array.from({ length: layers.length - 1 }, (_, i) => layers.length - 2 - i);
+		for (const i of indices) {
+			const layer = layers[i];
+			const desired = /* @__PURE__ */ new Map();
+			const priority = /* @__PURE__ */ new Map();
+			for (const n of layer) {
+				const neighbours = down ? g.in(n.id).map((e) => g.node(e.v)) : g.out(n.id).map((e) => g.node(e.w));
+				if (neighbours.length > 0) desired.set(n.id, median(neighbours.map((m) => m.x)));
+				const p = isDummy(n) && neighbours.some(isDummy) ? 1e6 : neighbours.length;
+				priority.set(n.id, p);
+			}
+			placeLayer(layer, desired, priority, s);
+		}
+	};
+	for (let r = 0; r < rounds; r++) {
+		sweep(true);
+		sweep(false);
+	}
+	for (let i = 0; i < layers.length; i++) {
+		const layer = layers[i];
+		const desired = /* @__PURE__ */ new Map();
+		const priority = /* @__PURE__ */ new Map();
+		for (const n of layer) {
+			const neighbours = [...g.in(n.id).map((e) => g.node(e.v)), ...g.out(n.id).map((e) => g.node(e.w))];
+			if (neighbours.length > 0) desired.set(n.id, median(neighbours.map((m) => m.x)));
+			priority.set(n.id, isDummy(n) ? 1e6 : neighbours.length);
+		}
+		placeLayer(layer, desired, priority, s);
+	}
+}
+/**
+* Assigns x and y to every node.
+*/
+function position(g, layers, parents, s) {
+	priorityX(g, layers, s);
+	compactClusters(g, layers, parents, s);
+	let min = Infinity;
+	for (const n of g.nodes.values()) min = Math.min(min, n.x - n.width / 2);
+	if (Number.isFinite(min)) for (const n of g.nodes.values()) n.x -= min;
+	let y = 0;
+	layers.forEach((layer, i) => {
+		let h = 0;
+		for (const n of layer) h = Math.max(h, n.height);
+		if (i > 0) y += s.rankSep / 2;
+		for (const n of layer) n.y = y + h / 2;
+		y += h;
+	});
+}
+/** Members of every cluster (all descendants), and the root's under null. */
+function membership(g, parents) {
+	const members = /* @__PURE__ */ new Map();
+	for (const n of g.nodes.values()) {
+		let c = n.cluster;
+		for (;;) {
+			const list = members.get(c) ?? [];
+			list.push(n);
+			members.set(c, list);
+			if (c === null) break;
+			c = parents.get(c) ?? null;
+		}
+	}
+	return members;
+}
+function childClusters(parents) {
+	const children = /* @__PURE__ */ new Map();
+	for (const [c, p] of parents) {
+		const list = children.get(p) ?? [];
+		list.push(c);
+		children.set(p, list);
+	}
+	return children;
+}
+/**
+* The horizontal frame of every cluster from the current node positions:
+* its direct nodes and its child frames, plus padding.
+*/
+function clusterFrames(g, parents, padding, frameLeft) {
+	const children = childClusters(parents);
+	const direct = /* @__PURE__ */ new Map();
+	for (const n of g.nodes.values()) {
+		if (n.cluster === null) continue;
+		const list = direct.get(n.cluster) ?? [];
+		list.push(n);
+		direct.set(n.cluster, list);
+	}
+	const frames = /* @__PURE__ */ new Map();
+	const visit = (c) => {
+		const cached = frames.get(c);
+		if (cached) return cached;
+		let left = Infinity;
+		let right = -Infinity;
+		for (const n of direct.get(c) ?? []) {
+			left = Math.min(left, n.x - n.width / 2);
+			right = Math.max(right, n.x + n.width / 2);
+		}
+		for (const child of children.get(c) ?? []) {
+			const f = visit(child);
+			left = Math.min(left, f.left);
+			right = Math.max(right, f.right);
+		}
+		if (!Number.isFinite(left)) {
+			left = 0;
+			right = 0;
+		}
+		const frame = {
+			left: left - padding - (frameLeft?.get(c) ?? 0),
+			right: right + padding
+		};
+		frames.set(c, frame);
+		return frame;
+	};
+	for (const c of parents.keys()) visit(c);
+	return frames;
+}
+/**
+* Pushes clusters apart as rigid blocks, bottom-up: a cluster's content is
+* settled first, then the cluster is a single unit to its parent. In every
+* rank, consecutive units must not overlap; units only ever move right, so
+* the separation established before is kept.
+*/
+function compactClusters(g, layers, parents, s) {
+	if (parents.size === 0) return;
+	const children = childClusters(parents);
+	const members = membership(g, parents);
+	const unitOf = (n, level) => {
+		let c = n.cluster;
+		let prev = null;
+		while (c !== level) {
+			if (c === null) return null;
+			prev = c;
+			c = parents.get(c) ?? null;
+		}
+		return prev ?? n.id;
+	};
+	const compact = (level) => {
+		for (const child of children.get(level) ?? []) compact(child);
+		const frames = clusterFrames(g, parents, s.clusterPadding, s.frameLeft);
+		const units = /* @__PURE__ */ new Map();
+		for (const n of members.get(level) ?? []) {
+			const id = unitOf(n, level);
+			if (id === null || units.has(id)) continue;
+			if (id === n.id) units.set(id, {
+				cluster: false,
+				left: n.x - n.width / 2,
+				right: n.x + n.width / 2,
+				dummy: isDummy(n)
+			});
+			else {
+				const f = frames.get(id);
+				units.set(id, {
+					cluster: true,
+					left: f.left,
+					right: f.right,
+					dummy: false
+				});
+			}
+		}
+		const edges = /* @__PURE__ */ new Map();
+		const indegree = new Map([...units.keys()].map((id) => [id, 0]));
+		for (const layer of layers) {
+			let prev = null;
+			for (const n of layer) {
+				const id = unitOf(n, level);
+				if (id === null || id === prev) continue;
+				if (prev !== null) {
+					const a = units.get(prev);
+					const b = units.get(id);
+					const gap = a.dummy && b.dummy ? s.edgeSep : a.dummy || b.dummy ? (s.nodeSep + s.edgeSep) / 2 : s.nodeSep;
+					const out = edges.get(prev) ?? /* @__PURE__ */ new Map();
+					if (!out.has(id)) indegree.set(id, indegree.get(id) + 1);
+					out.set(id, Math.max(out.get(id) ?? -Infinity, a.right - a.left + gap));
+					edges.set(prev, out);
+				}
+				prev = id;
+			}
+		}
+		const left = new Map([...units].map(([id, u]) => [id, u.left]));
+		const queue = [...units.keys()].filter((id) => indegree.get(id) === 0);
+		while (queue.length > 0) {
+			const id = queue.shift();
+			for (const [to, dist] of edges.get(id) ?? []) {
+				left.set(to, Math.max(left.get(to), left.get(id) + dist));
+				indegree.set(to, indegree.get(to) - 1);
+				if (indegree.get(to) === 0) queue.push(to);
+			}
+		}
+		for (const [id, u] of units) {
+			const dx = left.get(id) - u.left;
+			if (dx === 0) continue;
+			if (u.cluster) for (const m of members.get(id) ?? []) m.x += dx;
+			else g.node(id).x += dx;
+		}
+	};
+	compact(null);
+}
+// src/layout/layered/rank.ts
+/**
+* Turns around the edges that close cycles, found by depth-first search in
+* insertion order — so the edge reversed is the one the author wrote last in
+* the loop, which is usually the "back" edge they meant.
+*/
+function removeCycles(g) {
+	const state = /* @__PURE__ */ new Map();
+	const reverse = [];
+	for (const start of g.nodes.keys()) {
+		if (state.get(start)) continue;
+		const stack = [{
+			id: start,
+			i: 0
+		}];
+		state.set(start, 1);
+		while (stack.length > 0) {
+			const top = stack[stack.length - 1];
+			const out = g.out(top.id);
+			if (top.i < out.length) {
+				const e = out[top.i++];
+				const s = state.get(e.w) ?? 0;
+				if (s === 1) reverse.push(e);
+				else if (s === 0) {
+					state.set(e.w, 1);
+					stack.push({
+						id: e.w,
+						i: 0
+					});
+				}
+			} else {
+				state.set(top.id, 2);
+				stack.pop();
+			}
+		}
+	}
+	for (const e of reverse) {
+		const v = e.v;
+		e.v = e.w;
+		e.w = v;
+		e.reversed = !e.reversed;
+	}
+	if (reverse.length > 0) g.reindex();
+}
+/** A simple graph for ranking: parallel edges merged, as network simplex expects. */
+function simplify$1(g, ids) {
+	const inside = new Set(ids);
+	const merged = /* @__PURE__ */ new Map();
+	for (const e of g.edges) {
+		if (!inside.has(e.v) || e.v === e.w) continue;
+		const key = `${e.v}\u0000${e.w}`;
+		const existing = merged.get(key);
+		if (existing) {
+			existing.weight += e.weight;
+			existing.minlen = Math.max(existing.minlen, e.minlen);
+		} else merged.set(key, {
+			v: e.v,
+			w: e.w,
+			minlen: e.minlen,
+			weight: e.weight
+		});
+	}
+	return {
+		nodes: [...ids],
+		edges: [...merged.values()]
+	};
+}
+/** Weakly connected components, each in insertion order. */
+function components(g) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const start of g.nodes.keys()) {
+		if (seen.has(start)) continue;
+		const comp = [];
+		const queue = [start];
+		seen.add(start);
+		while (queue.length > 0) {
+			const id = queue.shift();
+			comp.push(id);
+			for (const e of [...g.out(id), ...g.in(id)]) {
+				const other = e.v === id ? e.w : e.v;
+				if (!seen.has(other)) {
+					seen.add(other);
+					queue.push(other);
+				}
+			}
+		}
+		out.push(comp);
+	}
+	return out;
+}
+/**
+* Network simplex leaves ties: a node whose incoming weight equals its
+* outgoing weight costs the same anywhere between its neighbours, and the
+* initial ranking puts it as low as it can go — far from where it is drawn
+* from. Moving such a node up never makes the total longer (it shortens the
+* incoming edges at least as much as it lengthens the outgoing ones), so
+* every node with at least as much weight coming in as going out is pulled
+* up against its predecessors, in topological order.
+*/
+function pullUp(g, ids) {
+	const indegree = new Map(ids.map((id) => [id, g.in(id).length]));
+	const queue = ids.filter((id) => indegree.get(id) === 0);
+	while (queue.length > 0) {
+		const id = queue.shift();
+		const ins = g.in(id);
+		const outs = g.out(id);
+		if (ins.length > 0) {
+			if (ins.reduce((sum, e) => sum + e.weight, 0) >= outs.reduce((sum, e) => sum + e.weight, 0)) {
+				let target = -Infinity;
+				for (const e of ins) target = Math.max(target, g.node(e.v).rank + e.minlen);
+				const n = g.node(id);
+				if (target < n.rank) n.rank = target;
+			}
+		}
+		for (const e of outs) {
+			indegree.set(e.w, indegree.get(e.w) - 1);
+			if (indegree.get(e.w) === 0) queue.push(e.w);
+		}
+	}
+}
+/** Assigns `rank` to every node: 0 is the top, each component starts at 0. */
+function rank(g, maxIterations = 2e3) {
+	for (const comp of components(g)) {
+		const { nodes, edges } = simplify$1(g, comp);
+		const ranks = networkSimplex(nodes, edges, maxIterations);
+		let min = Infinity;
+		for (const r of ranks.values()) min = Math.min(min, r);
+		for (const [id, r] of ranks) g.node(id).rank = r - min;
+		pullUp(g, comp);
+		let low = Infinity;
+		for (const id of comp) low = Math.min(low, g.node(id).rank);
+		for (const id of comp) g.node(id).rank -= low;
+	}
+}
+/**
+* Network simplex over one connected component.
+* Returns ranks (not normalised).
+*/
+function networkSimplex(nodes, edges, maxIterations) {
+	const out = /* @__PURE__ */ new Map();
+	const inn = /* @__PURE__ */ new Map();
+	for (const n of nodes) {
+		out.set(n, []);
+		inn.set(n, []);
+	}
+	for (const e of edges) {
+		out.get(e.v).push(e);
+		inn.get(e.w).push(e);
+	}
+	const edgeKey = (v, w) => `${v}\u0000${w}`;
+	const byKey = new Map(edges.map((e) => [edgeKey(e.v, e.w), e]));
+	const graphEdge = (v, w) => byKey.get(edgeKey(v, w));
+	const ranks = /* @__PURE__ */ new Map();
+	const visit = (start) => {
+		const stack = [{
+			id: start,
+			i: 0
+		}];
+		const onStack = /* @__PURE__ */ new Set([start]);
+		while (stack.length > 0) {
+			const top = stack[stack.length - 1];
+			const list = out.get(top.id);
+			if (top.i < list.length) {
+				const e = list[top.i++];
+				if (!ranks.has(e.w) && !onStack.has(e.w)) {
+					onStack.add(e.w);
+					stack.push({
+						id: e.w,
+						i: 0
+					});
+				}
+			} else {
+				let r = Infinity;
+				for (const e of list) r = Math.min(r, ranks.get(e.w) - e.minlen);
+				ranks.set(top.id, r === Infinity ? 0 : r);
+				stack.pop();
+			}
+		}
+	};
+	for (const n of nodes) if (!ranks.has(n)) visit(n);
+	if (nodes.length <= 1 || edges.length === 0) return ranks;
+	const slack = (e) => ranks.get(e.w) - ranks.get(e.v) - e.minlen;
+	const treeAdj = /* @__PURE__ */ new Map();
+	const addTreeEdge = (v, w) => {
+		treeAdj.get(v).add(w);
+		treeAdj.get(w).add(v);
+	};
+	const growTight = () => {
+		const stack = [...treeAdj.keys()];
+		while (stack.length > 0) {
+			const v = stack.pop();
+			for (const e of [...out.get(v), ...inn.get(v)]) {
+				const w = e.v === v ? e.w : e.v;
+				if (!treeAdj.has(w) && slack(e) === 0) {
+					treeAdj.set(w, /* @__PURE__ */ new Set());
+					addTreeEdge(v, w);
+					stack.push(w);
+				}
+			}
+		}
+		return treeAdj.size;
+	};
+	treeAdj.set(nodes[0], /* @__PURE__ */ new Set());
+	while (growTight() < nodes.length) {
+		let best = null;
+		let bestSlack = Infinity;
+		for (const e of edges) if (treeAdj.has(e.v) !== treeAdj.has(e.w)) {
+			const s = slack(e);
+			if (s < bestSlack) {
+				bestSlack = s;
+				best = e;
+			}
+		}
+		if (!best) break;
+		const delta = treeAdj.has(best.v) ? bestSlack : -bestSlack;
+		for (const v of treeAdj.keys()) ranks.set(v, ranks.get(v) + delta);
+	}
+	const root = nodes[0];
+	const low = /* @__PURE__ */ new Map();
+	const lim = /* @__PURE__ */ new Map();
+	const parent = /* @__PURE__ */ new Map();
+	const cut = /* @__PURE__ */ new Map();
+	const treeKey = (a, b) => a < b ? edgeKey(a, b) : edgeKey(b, a);
+	const initLowLim = () => {
+		low.clear();
+		lim.clear();
+		parent.clear();
+		let next = 1;
+		const stack = [];
+		parent.set(root, void 0);
+		stack.push({
+			id: root,
+			it: treeAdj.get(root).values(),
+			low: next
+		});
+		const visited = /* @__PURE__ */ new Set([root]);
+		while (stack.length > 0) {
+			const top = stack[stack.length - 1];
+			const step = top.it.next();
+			if (!step.done) {
+				const w = step.value;
+				if (!visited.has(w)) {
+					visited.add(w);
+					parent.set(w, top.id);
+					stack.push({
+						id: w,
+						it: treeAdj.get(w).values(),
+						low: next
+					});
+				}
+			} else {
+				low.set(top.id, top.low);
+				lim.set(top.id, next++);
+				stack.pop();
+			}
+		}
+	};
+	const postorder = () => [...lim.entries()].sort((a, b) => a[1] - b[1]).map(([id]) => id);
+	const calcCut = (child) => {
+		const par = parent.get(child);
+		let childIsTail = true;
+		let ge = graphEdge(child, par);
+		if (!ge) {
+			childIsTail = false;
+			ge = graphEdge(par, child);
+		}
+		let value = ge.weight;
+		for (const e of [...out.get(child), ...inn.get(child)]) {
+			const isOut = e.v === child;
+			const other = isOut ? e.w : e.v;
+			if (other === par) continue;
+			const pointsToHead = isOut === childIsTail;
+			value += pointsToHead ? e.weight : -e.weight;
+			if (treeAdj.get(child).has(other)) {
+				const otherCut = cut.get(treeKey(child, other)) ?? 0;
+				value += pointsToHead ? -otherCut : otherCut;
+			}
+		}
+		return value;
+	};
+	const initCutValues = () => {
+		cut.clear();
+		for (const v of postorder()) {
+			const par = parent.get(v);
+			if (par === void 0) continue;
+			cut.set(treeKey(v, par), calcCut(v));
+		}
+	};
+	const updateRanks = () => {
+		const order = [...lim.entries()].sort((a, b) => b[1] - a[1]).map(([id]) => id);
+		for (const v of order) {
+			const par = parent.get(v);
+			if (par === void 0) continue;
+			const e = graphEdge(v, par);
+			if (e) ranks.set(v, ranks.get(par) - e.minlen);
+			else ranks.set(v, ranks.get(par) + graphEdge(par, v).minlen);
+		}
+	};
+	const isDescendant = (v, rootOf) => low.get(rootOf) <= lim.get(v) && lim.get(v) <= lim.get(rootOf);
+	initLowLim();
+	initCutValues();
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		let leave = null;
+		for (const [v, par] of parent) {
+			if (par === void 0) continue;
+			if ((cut.get(treeKey(v, par)) ?? 0) < 0) {
+				leave = graphEdge(v, par) ? {
+					v,
+					w: par
+				} : {
+					v: par,
+					w: v
+				};
+				break;
+			}
+		}
+		if (!leave) break;
+		let tail = leave.v;
+		let flip = false;
+		if (lim.get(leave.v) > lim.get(leave.w)) {
+			tail = leave.w;
+			flip = true;
+		}
+		let enter = null;
+		let best = Infinity;
+		for (const e of edges) if (flip === isDescendant(e.v, tail) && flip !== isDescendant(e.w, tail)) {
+			const s = slack(e);
+			if (s < best) {
+				best = s;
+				enter = e;
+			}
+		}
+		if (!enter) break;
+		treeAdj.get(leave.v).delete(leave.w);
+		treeAdj.get(leave.w).delete(leave.v);
+		addTreeEdge(enter.v, enter.w);
+		initLowLim();
+		initCutValues();
+		updateRanks();
+	}
+	return ranks;
+}
+// src/layout/layered/index.ts
+/**
+* Vendored from @dskripchenko/diagrams 1.1.0 (src/layout/layered), which does
+* not export it yet; see docs/internal/design.md. Keep in sync; do not edit
+* here beyond import paths.
+*
+* Layered ("Sugiyama") layout with clusters.
+*
+*   1. Clusters get invisible top and bottom border nodes, tied to their
+*      members, so a cluster occupies a contiguous band of ranks with room
+*      for its title.
+*   2. Cycles are broken by reversing edges.
+*   3. Ranks by network simplex. Every real edge's minimum length is doubled
+*      so that the middle rank of each edge is free for its label.
+*   4. Long edges are split into chains of dummy nodes, one per rank.
+*   5. Ranks are ordered to reduce crossings, keeping clusters contiguous.
+*   6. Coordinates: priority method, then clusters pushed apart as blocks.
+*   7. Everything is computed top-to-bottom and turned at the end for
+*      BT, LR and RL.
+*/
+var MAX_NODES = 500;
+var MAX_EDGES = 2e3;
+var SELF_LOOP = 22;
+function layoutCore(input) {
+	const direction = input.direction ?? "TB";
+	const horizontal = direction === "LR" || direction === "RL";
+	const spacing = {
+		nodeSep: input.nodeSep ?? 50,
+		rankSep: input.rankSep ?? 50,
+		edgeSep: input.edgeSep ?? 20,
+		clusterPadding: input.clusterPadding ?? 12
+	};
+	if (input.nodes.length > 500) throw tooLarge("nodes", input.nodes.length, 500);
+	if (input.edges.length > 2e3) throw tooLarge("edges", input.edges.length, MAX_EDGES);
+	const dims = (w, h) => horizontal ? {
+		width: h,
+		height: w
+	} : {
+		width: w,
+		height: h
+	};
+	const g = new Graph();
+	const clusters = new Map((input.clusters ?? []).map((c) => [c.id, c]));
+	const parents = /* @__PURE__ */ new Map();
+	for (const c of clusters.values()) {
+		if (c.parent !== void 0 && !clusters.has(c.parent)) throw new DiagramError(`Cluster "${c.id}" is inside an unknown cluster "${c.parent}"`);
+		parents.set(c.id, c.parent ?? null);
+	}
+	for (const c of clusters.keys()) {
+		let p = parents.get(c) ?? null;
+		let steps = 0;
+		while (p !== null) {
+			if (p === c || ++steps > clusters.size) throw new DiagramError(`Cluster "${c}" contains itself`);
+			p = parents.get(p) ?? null;
+		}
+	}
+	const selfLoops = input.edges.filter((e) => e.from === e.to && !clusters.has(e.from));
+	const loopRoom = /* @__PURE__ */ new Map();
+	for (const e of selfLoops) {
+		const labelRoom = e.label ? (horizontal ? e.label.height : e.label.width) + 6 : 0;
+		loopRoom.set(e.from, Math.max(loopRoom.get(e.from) ?? 0, SELF_LOOP + labelRoom));
+	}
+	for (const n of input.nodes) {
+		if (g.nodes.has(n.id)) continue;
+		const d = dims(n.width, n.height);
+		const room = loopRoom.get(n.id) ?? 0;
+		if (n.cluster !== void 0 && !clusters.has(n.cluster)) throw new DiagramError(`Node "${n.id}" is inside an unknown cluster "${n.cluster}"`);
+		g.addNode({
+			id: n.id,
+			width: d.width + room * 2,
+			height: d.height,
+			cluster: n.cluster ?? null
+		});
+	}
+	const top = (c) => `\u0000top:${c}`;
+	const bottom = (c) => `\u0000bottom:${c}`;
+	const titleRoom = /* @__PURE__ */ new Map();
+	const frameLeft = /* @__PURE__ */ new Map();
+	spacing.frameLeft = frameLeft;
+	for (const c of clusters.values()) {
+		const label = c.label ?? {
+			width: 0,
+			height: 0
+		};
+		const titleHeight = label.height > 0 ? label.height + 6 : 0;
+		titleRoom.set(c.id, titleHeight);
+		if (horizontal) frameLeft.set(c.id, titleHeight);
+		const titled = direction === "TB" ? "top" : direction === "BT" ? "bottom" : null;
+		g.addNode({
+			id: top(c.id),
+			width: titled === "top" ? label.width + 2 * spacing.clusterPadding : 0,
+			height: titled === "top" ? titleHeight : 0,
+			cluster: c.id,
+			dummy: "border-top"
+		});
+		g.addNode({
+			id: bottom(c.id),
+			width: titled === "bottom" ? label.width + 2 * spacing.clusterPadding : 0,
+			height: titled === "bottom" ? titleHeight : 0,
+			cluster: c.id,
+			dummy: "border-bottom"
+		});
+	}
+	let structuralId = 0;
+	const structural = (v, w) => g.addEdge({
+		id: `\u0000s${structuralId++}`,
+		v,
+		w,
+		minlen: 1,
+		weight: 1,
+		original: "",
+		reversed: false,
+		structural: true
+	});
+	for (const c of clusters.keys()) {
+		const directNodes = [...g.nodes.values()].filter((n) => n.cluster === c && !n.dummy);
+		const directClusters = [...clusters.values()].filter((k) => (k.parent ?? null) === c);
+		for (const n of directNodes) {
+			structural(top(c), n.id);
+			structural(n.id, bottom(c));
+		}
+		for (const k of directClusters) {
+			structural(top(c), top(k.id));
+			structural(bottom(k.id), bottom(c));
+		}
+		if (directNodes.length === 0 && directClusters.length === 0) structural(top(c), bottom(c));
+	}
+	const leaves = (c) => {
+		const out = [];
+		for (const n of input.nodes) if (n.cluster === c) out.push(n.id);
+		for (const k of clusters.values()) if ((k.parent ?? null) === c) out.push(...leaves(k.id));
+		return out;
+	};
+	const endpoint = (id, asSource) => {
+		if (clusters.has(id)) {
+			const inside = leaves(id);
+			if (inside.length === 0) return asSource ? bottom(id) : top(id);
+			return asSource ? inside[inside.length - 1] : inside[0];
+		}
+		if (!g.nodes.has(id)) throw new DiagramError(`Edge refers to an unknown node "${id}"`);
+		return id;
+	};
+	const labels = /* @__PURE__ */ new Map();
+	for (const e of input.edges) {
+		if (e.from === e.to && !clusters.has(e.from)) continue;
+		const v = endpoint(e.from, true);
+		const w = endpoint(e.to, false);
+		if (v === w) continue;
+		if (e.label) labels.set(e.id, dims(e.label.width, e.label.height));
+		g.addEdge({
+			id: e.id,
+			v,
+			w,
+			minlen: Math.max(1, e.minlen ?? 1) * 2,
+			weight: e.weight ?? 1,
+			original: e.id,
+			reversed: false
+		});
+	}
+	removeCycles(g);
+	rank(g);
+	pullBordersTight(g, clusters.keys(), top, bottom);
+	for (const e of g.edges.slice()) if (e.structural && g.node(e.w).rank - g.node(e.v).rank !== 1) g.removeEdge(e);
+	const chains = /* @__PURE__ */ new Map();
+	let dummyId = 0;
+	const clusterOfEnd = (id) => {
+		const n = g.node(id);
+		if (n.dummy === "border-top" || n.dummy === "border-bottom") return parents.get(n.cluster) ?? null;
+		return n.cluster;
+	};
+	for (const e of g.edges.slice()) {
+		if (e.structural) continue;
+		const v = g.node(e.v);
+		const w = g.node(e.w);
+		const owner = commonCluster(clusterOfEnd(v.id), clusterOfEnd(w.id), parents);
+		const chain = [v.id];
+		const span = w.rank - v.rank;
+		const label = labels.get(e.original);
+		const labelRank = v.rank + Math.floor(span / 2);
+		g.removeEdge(e);
+		let prev = v.id;
+		for (let r = v.rank + 1; r < w.rank; r++) {
+			const isLabel = !!label && r === labelRank;
+			const d = g.addNode({
+				id: `\u0000d${dummyId++}`,
+				width: isLabel ? label.width : 0,
+				height: isLabel ? label.height : 0,
+				cluster: owner,
+				dummy: isLabel ? "label" : "edge",
+				edge: e.original
+			});
+			d.rank = r;
+			g.addEdge({
+				id: `${e.id}#${r}`,
+				v: prev,
+				w: d.id,
+				minlen: 1,
+				weight: e.weight,
+				original: e.original,
+				reversed: e.reversed
+			});
+			chain.push(d.id);
+			prev = d.id;
+		}
+		g.addEdge({
+			id: `${e.id}#end`,
+			v: prev,
+			w: w.id,
+			minlen: 1,
+			weight: e.weight,
+			original: e.original,
+			reversed: e.reversed
+		});
+		chain.push(w.id);
+		chains.set(e.original, e.reversed ? chain.reverse() : chain);
+	}
+	addSpines(g, clusters.keys(), parents, top, bottom);
+	position(g, order(g, parents, 24, input.transpose ?? false), parents, spacing);
+	const frames = clusterFrames(g, parents, spacing.clusterPadding, spacing.frameLeft);
+	const clusterBoxes = /* @__PURE__ */ new Map();
+	const descendants = /* @__PURE__ */ new Map();
+	for (const n of g.nodes.values()) {
+		let c = n.cluster;
+		while (c !== null) {
+			const list = descendants.get(c) ?? [];
+			list.push(n);
+			descendants.set(c, list);
+			c = parents.get(c) ?? null;
+		}
+	}
+	const depth = (c) => {
+		let d = 0;
+		let p = parents.get(c) ?? null;
+		while (p !== null) {
+			d++;
+			p = parents.get(p) ?? null;
+		}
+		return d;
+	};
+	const byDepth = [...clusters.keys()].sort((a, b) => depth(b) - depth(a));
+	const vertical = /* @__PURE__ */ new Map();
+	for (const c of byDepth) {
+		let t = Infinity;
+		let b = -Infinity;
+		for (const n of descendants.get(c) ?? []) {
+			t = Math.min(t, n.y - n.height / 2);
+			b = Math.max(b, n.y + n.height / 2);
+		}
+		for (const k of clusters.values()) {
+			if ((k.parent ?? null) !== c) continue;
+			const inner = vertical.get(k.id);
+			if (inner) {
+				t = Math.min(t, inner.top);
+				b = Math.max(b, inner.bottom);
+			}
+		}
+		const pad = spacing.clusterPadding;
+		vertical.set(c, {
+			top: t - (direction === "TB" ? 0 : pad),
+			bottom: b + (direction === "BT" ? 0 : pad)
+		});
+	}
+	for (const c of clusters.keys()) {
+		const f = frames.get(c);
+		const v = vertical.get(c);
+		const left = f.left;
+		clusterBoxes.set(c, {
+			x: (left + f.right) / 2,
+			y: (v.top + v.bottom) / 2,
+			width: f.right - left,
+			height: v.bottom - v.top
+		});
+	}
+	let maxX = 0;
+	let maxY = 0;
+	let minX = 0;
+	let minY = 0;
+	for (const n of g.nodes.values()) {
+		maxX = Math.max(maxX, n.x + n.width / 2);
+		maxY = Math.max(maxY, n.y + n.height / 2);
+	}
+	for (const b of clusterBoxes.values()) {
+		minX = Math.min(minX, b.x - b.width / 2);
+		minY = Math.min(minY, b.y - b.height / 2);
+		maxX = Math.max(maxX, b.x + b.width / 2);
+		maxY = Math.max(maxY, b.y + b.height / 2);
+	}
+	const W = maxX - minX;
+	const H = maxY - minY;
+	const turn = (p) => {
+		const x = p.x - minX;
+		const y = p.y - minY;
+		switch (direction) {
+			case "BT": return {
+				x,
+				y: H - y
+			};
+			case "LR": return {
+				x: y,
+				y: x
+			};
+			case "RL": return {
+				x: H - y,
+				y: x
+			};
+			default: return {
+				x,
+				y
+			};
+		}
+	};
+	const turnBox = (b) => {
+		const c = turn(b);
+		return horizontal ? {
+			x: c.x,
+			y: c.y,
+			width: b.height,
+			height: b.width
+		} : {
+			...c,
+			width: b.width,
+			height: b.height
+		};
+	};
+	const nodes = /* @__PURE__ */ new Map();
+	for (const n of input.nodes) {
+		const c = turn(g.node(n.id));
+		nodes.set(n.id, {
+			x: c.x,
+			y: c.y,
+			width: n.width,
+			height: n.height
+		});
+	}
+	const clustersOut = /* @__PURE__ */ new Map();
+	for (const [id, b] of clusterBoxes) clustersOut.set(id, turnBox(b));
+	const edges = /* @__PURE__ */ new Map();
+	for (const e of input.edges) {
+		if (e.from === e.to && !clusters.has(e.from)) {
+			edges.set(e.id, selfLoopRoute(nodes.get(e.from), direction, e.label));
+			continue;
+		}
+		const chain = chains.get(e.id);
+		if (!chain) {
+			edges.set(e.id, { points: [] });
+			continue;
+		}
+		const inner = chain.slice(1, -1).map((id) => g.node(id));
+		const route = { points: inner.map((n) => turn(n)) };
+		const labelNode = inner.find((n) => n.dummy === "label");
+		if (labelNode) route.label = turn(labelNode);
+		if (clusters.has(e.from) || clusters.has(e.to)) clipAtClusters(route, turn(g.node(chain[0])), turn(g.node(chain[chain.length - 1])), {
+			from: clusters.has(e.from) ? clustersOut.get(e.from) : void 0,
+			to: clusters.has(e.to) ? clustersOut.get(e.to) : void 0
+		});
+		edges.set(e.id, route);
+	}
+	return {
+		width: horizontal ? H : W,
+		height: horizontal ? W : H,
+		nodes,
+		clusters: clustersOut,
+		edges
+	};
+}
+function inside(box, p) {
+	return Math.abs(p.x - box.x) <= box.width / 2 && Math.abs(p.y - box.y) <= box.height / 2;
+}
+/** Where the segment from `a` (outside) to `b` (inside) enters the box. */
+function entry(box, a, b) {
+	let lo = 0;
+	let hi = 1;
+	for (let i = 0; i < 30; i++) {
+		const mid = (lo + hi) / 2;
+		if (inside(box, {
+			x: a.x + (b.x - a.x) * mid,
+			y: a.y + (b.y - a.y) * mid
+		})) hi = mid;
+		else lo = mid;
+	}
+	return {
+		x: a.x + (b.x - a.x) * hi,
+		y: a.y + (b.y - a.y) * hi
+	};
+}
+/**
+* Cuts an edge laid out to a node inside a cluster at the cluster's frame,
+* and records the cut as the edge's explicit end.
+*/
+function clipAtClusters(route, start, end, frames) {
+	let line = [
+		start,
+		...route.points,
+		end
+	];
+	if (frames.to && !inside(frames.to, start)) {
+		for (let i = 1; i < line.length; i++) if (inside(frames.to, line[i])) {
+			const p = entry(frames.to, line[i - 1], line[i]);
+			line = [...line.slice(0, i), p];
+			break;
+		}
+		route.end = line[line.length - 1];
+	}
+	if (frames.from && !inside(frames.from, line[line.length - 1])) {
+		for (let i = line.length - 2; i >= 0; i--) if (inside(frames.from, line[i])) {
+			line = [entry(frames.from, line[i + 1], line[i]), ...line.slice(i + 1)];
+			break;
+		}
+		route.start = line[0];
+	}
+	route.points = line.slice(1, -1);
+}
+/**
+* Lays out a graph, first taking out every cluster that no node outside it
+* links into: such a cluster is laid out on its own — in its own direction,
+* if it has one — and placed in its parent as a single box. This is what
+* Mermaid does, and it is what makes `direction` inside a subgraph work.
+* A cluster with edges crossing its frame stays part of the whole layout.
+*/
+function layout(input) {
+	const clusters = input.clusters ?? [];
+	if (clusters.length === 0) return layoutCore(input);
+	const parent = new Map(clusters.map((c) => [c.id, c.parent ?? null]));
+	const within = (cluster, root) => {
+		let c = cluster ?? null;
+		let guard = 0;
+		while (c !== null && guard++ <= clusters.length) {
+			if (c === root) return true;
+			c = parent.get(c) ?? null;
+		}
+		return false;
+	};
+	const nodeCluster = new Map(input.nodes.map((n) => [n.id, n.cluster ?? null]));
+	const home = (id) => parent.has(id) ? {
+		cluster: id,
+		isCluster: true
+	} : {
+		cluster: nodeCluster.get(id) ?? null,
+		isCluster: false
+	};
+	const isolated = (c) => {
+		for (const e of input.edges) {
+			const a = home(e.from);
+			const b = home(e.to);
+			const aIn = a.isCluster ? within(a.cluster, c) && a.cluster !== c : within(a.cluster, c);
+			if (aIn !== (b.isCluster ? within(b.cluster, c) && b.cluster !== c : within(b.cluster, c))) {
+				const outsideEnd = aIn ? b : a;
+				if (!(outsideEnd.isCluster && outsideEnd.cluster === c)) return false;
+			}
+		}
+		return true;
+	};
+	const extracted = clusters.filter((c) => isolated(c.id) && !clusters.some((o) => o.id !== c.id && within(c.id, o.id) && isolated(o.id)));
+	if (extracted.length === 0) return layoutCore(input);
+	const pad = input.clusterPadding ?? 12;
+	const parentDirection = input.direction ?? "TB";
+	const inner = /* @__PURE__ */ new Map();
+	const removedNodes = /* @__PURE__ */ new Set();
+	const removedClusters = /* @__PURE__ */ new Set();
+	const removedEdges = /* @__PURE__ */ new Set();
+	for (const c of extracted) {
+		const sub = {
+			...input,
+			direction: c.direction ?? parentDirection,
+			nodes: input.nodes.filter((n) => within(n.cluster, c.id)).map((n) => ({
+				...n,
+				cluster: n.cluster === c.id ? void 0 : n.cluster
+			})),
+			clusters: clusters.filter((k) => k.id !== c.id && within(k.id, c.id)).map((k) => ({
+				...k,
+				parent: k.parent === c.id ? void 0 : k.parent
+			})),
+			edges: input.edges.filter((e) => {
+				const a = home(e.from);
+				const b = home(e.to);
+				const aIn = within(a.cluster, c.id) && !(a.isCluster && a.cluster === c.id);
+				const bIn = within(b.cluster, c.id) && !(b.isCluster && b.cluster === c.id);
+				return aIn && bIn;
+			})
+		};
+		for (const n of sub.nodes) removedNodes.add(n.id);
+		for (const k of sub.clusters ?? []) removedClusters.add(k.id);
+		removedClusters.add(c.id);
+		for (const e of sub.edges) removedEdges.add(e.id);
+		const result = layout(sub);
+		const title = c.label && c.label.height > 0 ? c.label.height + 6 : 0;
+		const width = Math.max(result.width, c.label?.width ?? 0) + pad * 2;
+		const height = result.height + pad * 2 + title;
+		inner.set(c.id, {
+			result,
+			title,
+			width,
+			height
+		});
+	}
+	const result = layout({
+		...input,
+		nodes: [...input.nodes.filter((n) => !removedNodes.has(n.id)), ...extracted.map((c) => ({
+			id: c.id,
+			width: inner.get(c.id).width,
+			height: inner.get(c.id).height,
+			cluster: c.parent
+		}))],
+		clusters: clusters.filter((k) => !removedClusters.has(k.id)),
+		edges: input.edges.filter((e) => !removedEdges.has(e.id))
+	});
+	for (const c of extracted) {
+		const box = result.nodes.get(c.id);
+		result.nodes.delete(c.id);
+		result.clusters.set(c.id, box);
+		const { result: r, title } = inner.get(c.id);
+		const dx = box.x - box.width / 2 + (box.width - r.width) / 2;
+		const dy = box.y - box.height / 2 + pad + title;
+		const move = (p) => ({
+			x: p.x + dx,
+			y: p.y + dy
+		});
+		for (const [id, b] of r.nodes) result.nodes.set(id, {
+			...b,
+			...move(b)
+		});
+		for (const [id, b] of r.clusters) result.clusters.set(id, {
+			...b,
+			...move(b)
+		});
+		for (const [id, route] of r.edges) result.edges.set(id, {
+			...route,
+			points: route.points.map(move),
+			label: route.label && move(route.label),
+			start: route.start && move(route.start),
+			end: route.end && move(route.end)
+		});
+	}
+	return result;
+}
+/** The innermost cluster containing both, or null. */
+function commonCluster(a, b, parents) {
+	const chainOf = (c) => {
+		const out = [];
+		while (c !== null) {
+			out.push(c);
+			c = parents.get(c) ?? null;
+		}
+		return out;
+	};
+	const ca = new Set(chainOf(a));
+	for (const c of chainOf(b)) if (ca.has(c)) return c;
+	return null;
+}
+/**
+* Network simplex leaves a border node anywhere its zero-cost slack allows;
+* pull each top border down to just above the cluster and each bottom one
+* up to just below it, so frames are no taller than their content.
+*/
+function pullBordersTight(g, clusterIds, top, bottom) {
+	const ids = [...clusterIds];
+	for (let pass = 0; pass < ids.length + 1; pass++) {
+		let changed = false;
+		for (const c of ids) {
+			const t = g.node(top(c));
+			const b = g.node(bottom(c));
+			const below = g.out(t.id).map((e) => g.node(e.w).rank);
+			const above = g.in(b.id).map((e) => g.node(e.v).rank);
+			const incoming = g.in(t.id).map((e) => g.node(e.v).rank + e.minlen);
+			const outgoing = g.out(b.id).map((e) => g.node(e.w).rank - e.minlen);
+			if (below.length > 0) {
+				const want = Math.min(...below) - 1;
+				const limit = incoming.length > 0 ? Math.max(...incoming) : -Infinity;
+				const r = Math.max(want, limit);
+				if (r !== t.rank && r <= Math.min(...below) - 1) {
+					t.rank = r;
+					changed = true;
+				}
+			}
+			if (above.length > 0) {
+				const want = Math.max(...above) + 1;
+				const limit = outgoing.length > 0 ? Math.min(...outgoing) : Infinity;
+				const r = Math.min(want, limit);
+				if (r !== b.rank && r >= Math.max(...above) + 1) {
+					b.rank = r;
+					changed = true;
+				}
+			}
+		}
+		if (!changed) break;
+	}
+}
+function addSpines(g, clusterIds, parents, top, bottom) {
+	const present = /* @__PURE__ */ new Map();
+	for (const n of g.nodes.values()) {
+		let c = n.cluster;
+		while (c !== null) {
+			let set = present.get(c);
+			if (!set) present.set(c, set = /* @__PURE__ */ new Set());
+			set.add(n.rank);
+			c = parents.get(c) ?? null;
+		}
+	}
+	let id = 0;
+	for (const c of clusterIds) {
+		const from = g.node(top(c)).rank;
+		const to = g.node(bottom(c)).rank;
+		const set = present.get(c) ?? /* @__PURE__ */ new Set();
+		for (let r = from + 1; r < to; r++) {
+			if (set.has(r)) continue;
+			const s = g.addNode({
+				id: `\u0000spine${id++}`,
+				width: 0,
+				height: 0,
+				cluster: c,
+				dummy: "spine"
+			});
+			s.rank = r;
+			let p = c;
+			while (p !== null) {
+				let ps = present.get(p);
+				if (!ps) present.set(p, ps = /* @__PURE__ */ new Set());
+				ps.add(r);
+				p = parents.get(p) ?? null;
+			}
+		}
+	}
+}
+/** A loop on the side of the node that faces away from the flow. */
+function selfLoopRoute(box, direction, label) {
+	const horizontal = direction === "LR" || direction === "RL";
+	const d = SELF_LOOP;
+	if (!horizontal) {
+		const xr = box.x + box.width / 2;
+		const y0 = box.y - box.height / 4;
+		const y1 = box.y + box.height / 4;
+		return {
+			selfLoop: true,
+			points: [
+				{
+					x: xr,
+					y: y0
+				},
+				{
+					x: xr + d,
+					y: y0 - 4
+				},
+				{
+					x: xr + d,
+					y: y1 + 4
+				},
+				{
+					x: xr,
+					y: y1
+				}
+			],
+			label: label ? {
+				x: xr + d + 4 + label.width / 2,
+				y: box.y
+			} : void 0
+		};
+	}
+	const yb = box.y + box.height / 2;
+	const x0 = box.x - box.width / 4;
+	const x1 = box.x + box.width / 4;
+	return {
+		selfLoop: true,
+		points: [
+			{
+				x: x0,
+				y: yb
+			},
+			{
+				x: x0 - 4,
+				y: yb + d
+			},
+			{
+				x: x1 + 4,
+				y: yb + d
+			},
+			{
+				x: x1,
+				y: yb
+			}
+		],
+		label: label ? {
+			x: box.x,
+			y: yb + d + 4 + label.height / 2
+		} : void 0
+	};
+}
+// src/layout/text.ts
+var NARROW = /* @__PURE__ */ new Set([...`il.,:;'|!()[]{}ftjrI1 `]);
+var WIDE = /* @__PURE__ */ new Set([..."mwMW@%ЖШЩЮжшщю—"]);
+/** Width in em of one character, by class; tuned on system sans fonts. */
+function glyph(ch) {
+	if (NARROW.has(ch)) return ch === " " ? .28 : .3;
+	if (WIDE.has(ch)) return .88;
+	const code = ch.codePointAt(0);
+	if (code >= 11904) return 1;
+	if (ch >= "0" && ch <= "9") return .57;
+	if (ch !== ch.toLowerCase()) return .68;
+	if (code >= 1024 && code <= 1279) return .58;
+	return .54;
+}
+var approximateMeasurer = (text, font) => {
+	let em = 0;
+	for (const ch of text) em += glyph(ch);
+	return em * font.size * ((font.weight ?? 400) >= 600 ? 1.06 : 1);
+};
+/**
+* Splits text into lines no wider than `max`, at spaces; a word longer than
+* a line is cut with an ellipsis. At most `maxLines` lines; the last one
+* ends with "…" when text is left over.
+*/
+function wrapText(text, max, font, measure, maxLines = 2) {
+	const words = text.trim().split(/\s+/).filter(Boolean);
+	if (words.length === 0) return [];
+	const lines = [];
+	let line = "";
+	let i = 0;
+	for (; i < words.length; i++) {
+		const w = words[i];
+		const next = line ? `${line} ${w}` : w;
+		if (measure(next, font) <= max) {
+			line = next;
+			continue;
+		}
+		if (line) {
+			lines.push(line);
+			if (lines.length === maxLines) break;
+		}
+		line = measure(w, font) <= max ? w : truncate(w, max, font, measure);
+	}
+	if (lines.length < maxLines && line) {
+		lines.push(line);
+		i = words.length;
+	}
+	if (i < words.length) {
+		const last = lines[lines.length - 1];
+		lines[lines.length - 1] = truncate(`${last}…`, max, font, measure, true);
+	}
+	return lines;
+}
+function truncate(text, max, font, measure, hasEllipsis = false) {
+	let t = hasEllipsis ? text.slice(0, -1) : text;
+	while (t.length > 1 && measure(`${t}…`, font) > max) t = t.slice(0, -1);
+	return measure(text, font) <= max && !hasEllipsis ? text : `${t.trimEnd()}…`;
+}
+// src/layout/route.ts
+var NORMAL = {
+	top: {
+		x: 0,
+		y: -1
+	},
+	right: {
+		x: 1,
+		y: 0
+	},
+	bottom: {
+		x: 0,
+		y: 1
+	},
+	left: {
+		x: -1,
+		y: 0
+	}
+};
+function sideNormal(side) {
+	return NORMAL[side];
+}
+/** A point on a box side, `offset` 0…1 along it (left→right, top→bottom). */
+function sidePoint(box, side, offset = .5) {
+	const left = box.x - box.width / 2;
+	const top = box.y - box.height / 2;
+	switch (side) {
+		case "top": return {
+			x: left + box.width * offset,
+			y: top
+		};
+		case "bottom": return {
+			x: left + box.width * offset,
+			y: top + box.height
+		};
+		case "left": return {
+			x: left,
+			y: top + box.height * offset
+		};
+		default: return {
+			x: left + box.width,
+			y: top + box.height * offset
+		};
+	}
+}
+/**
+* The side of `box` that faces `toward`. `prefer` biases ties to the flow's
+* axis: in a TB layout an edge leaves through top/bottom unless the other
+* end is clearly beside the node.
+*/
+function facingSide(box, toward, prefer) {
+	const dx = toward.x - box.x;
+	const dy = toward.y - box.y;
+	const nx = Math.abs(dx) / Math.max(1, box.width / 2);
+	const ny = Math.abs(dy) / Math.max(1, box.height / 2);
+	const bias = .6;
+	if (prefer === "vertical" ? ny >= nx * bias : ny > nx / bias) return dy < 0 ? "top" : "bottom";
+	return dx < 0 ? "left" : "right";
+}
+/** Whether anchors on this outline may be spread along a side. */
+function spreadable(shape) {
+	return shape === "rect" || shape === "rounded" || shape === "note" || shape === "pill";
+}
+var STUB = 18;
+var fmt = (n) => (Math.round(n * 10) / 10).toString();
+var P = (p) => `${fmt(p.x)} ${fmt(p.y)}`;
+var add = (a, b, k = 1) => ({
+	x: a.x + b.x * k,
+	y: a.y + b.y * k
+});
+var dist = (a, b) => Math.hypot(b.x - a.x, b.y - a.y);
+function route(input) {
+	return input.routing === "orthogonal" ? orthogonal(input) : spline(input);
+}
+function spline({ from, to, waypoints = [] }) {
+	const n0 = NORMAL[from.side];
+	const n1 = NORMAL[to.side];
+	const a = from.point;
+	const b = to.point;
+	if (waypoints.length === 0) {
+		const k = Math.max(28, Math.min(120, dist(a, b) * .45));
+		const c0 = add(a, n0, k);
+		const c1 = add(b, n1, k);
+		return {
+			d: `M ${P(a)} C ${P(c0)} ${P(c1)} ${P(b)}`,
+			points: [
+				a,
+				c0,
+				c1,
+				b
+			]
+		};
+	}
+	const pts = [
+		a,
+		...waypoints,
+		b
+	];
+	return {
+		d: basisPath(pts),
+		points: pts
+	};
+}
+/** d3's curveBasis written out: smooth, starts and ends exactly on the end points. */
+function basisPath(points) {
+	const pts = [];
+	for (const p of points) {
+		const last = pts[pts.length - 1];
+		if (!last || dist(last, p) > .5) pts.push(p);
+	}
+	if (pts.length === 0) return "";
+	if (pts.length === 2) return `M ${P(pts[0])} L ${P(pts[1])}`;
+	let d = "";
+	let x0 = 0;
+	let y0 = 0;
+	let x1 = 0;
+	let y1 = 0;
+	const bezier = (x, y) => {
+		d += ` C ${fmt((2 * x0 + x1) / 3)} ${fmt((2 * y0 + y1) / 3)} ${fmt((x0 + 2 * x1) / 3)} ${fmt((y0 + 2 * y1) / 3)} ${fmt((x0 + 4 * x1 + x) / 6)} ${fmt((y0 + 4 * y1 + y) / 6)}`;
+	};
+	let state = 0;
+	for (const p of pts) {
+		if (state === 0) {
+			state = 1;
+			d = `M ${P(p)}`;
+		} else if (state === 1) state = 2;
+		else if (state === 2) {
+			state = 3;
+			d += ` L ${fmt((5 * x0 + x1) / 6)} ${fmt((5 * y0 + y1) / 6)}`;
+			bezier(p.x, p.y);
+		} else bezier(p.x, p.y);
+		x0 = x1;
+		x1 = p.x;
+		y0 = y1;
+		y1 = p.y;
+	}
+	if (state === 3) bezier(x1, y1);
+	d += ` L ${P({
+		x: x1,
+		y: y1
+	})}`;
+	return d;
+}
+function orthogonal({ from, to, waypoints = [], radius = 8 }) {
+	const a = from.point;
+	const b = to.point;
+	const s0 = add(a, NORMAL[from.side], STUB);
+	const s1 = add(b, NORMAL[to.side], STUB);
+	const verticalStart = from.side === "top" || from.side === "bottom";
+	const ctrl = [
+		s0,
+		...waypoints,
+		s1
+	];
+	const pts = [a, s0];
+	let vertical = verticalStart;
+	for (let i = 1; i < ctrl.length; i++) {
+		const p = pts[pts.length - 1];
+		let q = ctrl[i];
+		const last = i === ctrl.length - 1;
+		if (!last) {
+			if (Math.abs(p.y - q.y) < 3) q = {
+				x: q.x,
+				y: p.y
+			};
+			else if (Math.abs(p.x - q.x) < 3) q = {
+				x: p.x,
+				y: q.y
+			};
+		}
+		if (Math.abs(p.x - q.x) < .5 || Math.abs(p.y - q.y) < .5) {
+			pts.push(q);
+			vertical = Math.abs(p.x - q.x) < .5;
+			continue;
+		}
+		const endVertical = to.side === "top" || to.side === "bottom";
+		if (last && vertical !== endVertical) pts.push(vertical ? {
+			x: p.x,
+			y: q.y
+		} : {
+			x: q.x,
+			y: p.y
+		});
+		else if (vertical) {
+			const my = (p.y + q.y) / 2;
+			pts.push({
+				x: p.x,
+				y: my
+			}, {
+				x: q.x,
+				y: my
+			});
+		} else {
+			const mx = (p.x + q.x) / 2;
+			pts.push({
+				x: mx,
+				y: p.y
+			}, {
+				x: mx,
+				y: q.y
+			});
+		}
+		pts.push(q);
+	}
+	pts.push(b);
+	const clean = simplify(pts);
+	return {
+		d: roundedPath(clean, radius),
+		points: clean
+	};
+}
+/** Drops repeated and collinear points. */
+function simplify(pts) {
+	const out = [];
+	for (const p of pts) {
+		const last = out[out.length - 1];
+		if (last && Math.abs(last.x - p.x) < .5 && Math.abs(last.y - p.y) < .5) continue;
+		const prev = out[out.length - 2];
+		if (prev && last) {
+			if (Math.abs(prev.x - last.x) < .5 && Math.abs(last.x - p.x) < .5 || Math.abs(prev.y - last.y) < .5 && Math.abs(last.y - p.y) < .5) out.pop();
+		}
+		out.push(p);
+	}
+	return out;
+}
+/** Straight segments with rounded corners. */
+function roundedPath(pts, radius) {
+	let d = `M ${P(pts[0])}`;
+	for (let i = 1; i < pts.length - 1; i++) {
+		const p = pts[i - 1];
+		const c = pts[i];
+		const n = pts[i + 1];
+		const r = Math.min(radius, dist(p, c) / 2, dist(c, n) / 2);
+		const inP = add(c, {
+			x: Math.sign(p.x - c.x),
+			y: Math.sign(p.y - c.y)
+		}, r);
+		const outP = add(c, {
+			x: Math.sign(n.x - c.x),
+			y: Math.sign(n.y - c.y)
+		}, r);
+		d += ` L ${P(inP)} Q ${P(c)} ${P(outP)}`;
+	}
+	d += ` L ${P(pts[pts.length - 1])}`;
+	return d;
+}
+/** The point halfway along a polyline: where a label goes without a layout hint. */
+function midpoint(points) {
+	if (points.length === 0) return {
+		x: 0,
+		y: 0
+	};
+	let total = 0;
+	for (let i = 1; i < points.length; i++) total += dist(points[i - 1], points[i]);
+	let left = total / 2;
+	for (let i = 1; i < points.length; i++) {
+		const l = dist(points[i - 1], points[i]);
+		if (left <= l && l > 0) {
+			const t = left / l;
+			return {
+				x: points[i - 1].x + (points[i].x - points[i - 1].x) * t,
+				y: points[i - 1].y + (points[i].y - points[i - 1].y) * t
+			};
+		}
+		left -= l;
+	}
+	return points[points.length - 1];
+}
+/** A cubic Bézier point, for the label of a direct spline. */
+function bezierPoint(p0, p1, p2, p3, t) {
+	const u = 1 - t;
+	return {
+		x: u * u * u * p0.x + 3 * u * u * t * p1.x + 3 * u * t * t * p2.x + t * t * t * p3.x,
+		y: u * u * u * p0.y + 3 * u * u * t * p1.y + 3 * u * t * t * p2.y + t * t * t * p3.y
+	};
+}
+/** Distance from a point to a polyline: hit testing edges in the editor. */
+function distanceToPolyline(p, points) {
+	let best = Infinity;
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const b = points[i];
+		const l2 = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
+		const t = l2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / l2));
+		best = Math.min(best, dist(p, {
+			x: a.x + t * (b.x - a.x),
+			y: a.y + t * (b.y - a.y)
+		}));
+	}
+	return best;
+}
+/**
+* Orthogonal routing through the layout's bends with as few corners as the
+* obstacles allow: the route keeps its lane while `clear` says the way along
+* the flow is free, and changes lane in the gap between two ranks (where no
+* node stands) only when the next bend would be blocked. `mainX` is true when
+* the flow runs along x (LR).
+*/
+function orthogonalThrough(from, to, waypoints, mainX, clear, radius = 10, through) {
+	const m = (p) => mainX ? p.x : p.y;
+	const c = (p) => mainX ? p.y : p.x;
+	const at = (mv, cv) => mainX ? {
+		x: mv,
+		y: cv
+	} : {
+		x: cv,
+		y: mv
+	};
+	const s0 = add(from.point, NORMAL[from.side], STUB);
+	const s1 = add(to.point, NORMAL[to.side], STUB);
+	const pts = [from.point, s0];
+	let cur = s0;
+	let prevM = m(from.point) + Math.sign(m(s0) - m(from.point) || 1) * 6;
+	/** Changes lane to `cv` somewhere between prevM and nextM, preferring the middle of the gap. */
+	const shift = (cv, nextM) => {
+		let bend = (prevM + nextM) / 2;
+		for (const t of [
+			.5,
+			.3,
+			.7,
+			.15,
+			.85,
+			.05,
+			.95
+		]) {
+			const b = prevM + (nextM - prevM) * t;
+			if (clear(at(b, c(cur)), at(b, cv)) && clear(at(m(cur), c(cur)), at(b, c(cur)))) {
+				bend = b;
+				break;
+			}
+		}
+		pts.push(at(bend, c(cur)), at(bend, cv));
+		cur = at(bend, cv);
+	};
+	for (const w of waypoints) {
+		const required = !!through && Math.abs(w.x - through.x) < .5 && Math.abs(w.y - through.y) < .5;
+		if (Math.abs(c(w) - c(cur)) < 1 || !required && clear(cur, at(m(w), c(cur)))) {
+			prevM = m(w);
+			continue;
+		}
+		shift(c(w), m(w));
+		prevM = m(w);
+	}
+	if (Math.abs(c(cur) - c(s1)) >= 1) shift(c(s1), m(s1));
+	pts.push(s1, to.point);
+	const clean = simplify(pts);
+	return {
+		d: roundedPath(clean, radius),
+		points: clean
+	};
+}
+/** Whether an axis-aligned segment passes through a box (grown by `pad`). */
+function segmentHitsBox(a, b, box, pad = 0) {
+	const x0 = Math.min(a.x, b.x);
+	const x1 = Math.max(a.x, b.x);
+	const y0 = Math.min(a.y, b.y);
+	const y1 = Math.max(a.y, b.y);
+	const bx0 = box.x - box.width / 2 - pad;
+	const bx1 = box.x + box.width / 2 + pad;
+	const by0 = box.y - box.height / 2 - pad;
+	const by1 = box.y + box.height / 2 + pad;
+	return x1 > bx0 && x0 < bx1 && y1 > by0 && y0 < by1;
+}
+/** The point of an orthogonal route at main-axis coordinate `mv` (for its label), if a segment along the flow covers it. */
+function pointAtMain(points, mv, mainX) {
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const b = points[i];
+		if (!(mainX ? Math.abs(a.y - b.y) < .5 : Math.abs(a.x - b.x) < .5)) continue;
+		const lo = Math.min(mainX ? a.x : a.y, mainX ? b.x : b.y);
+		const hi = Math.max(mainX ? a.x : a.y, mainX ? b.x : b.y);
+		if (mv >= lo && mv <= hi) return mainX ? {
+			x: mv,
+			y: a.y
+		} : {
+			x: a.x,
+			y: mv
+		};
+	}
+}
+// src/layout/channels.ts
+/**
+* Back edges — transitions against the flow (retry, resend, give up…) — are
+* routed through a channel beside the graph instead of across it: out of the
+* source's side facing the channel, along a lane of their own, and back into
+* the target from the same side. Lanes are assigned like intervals on a line,
+* so parallel back edges never share one; the shortest take the inner lanes.
+* The side (below/above in LR, right/left in TB) is picked per edge so its
+* drops do not cut through other nodes or foreign groups.
+*/
+var GAP = 30;
+var LANE = 16;
+var LANE_LABELLED = 30;
+/** Whether `target` lies wholly behind `source` along the flow. */
+function isBehind(source, target, direction) {
+	return direction === "LR" ? target.x + target.width / 2 <= source.x - source.width / 2 : target.y + target.height / 2 <= source.y - source.height / 2;
+}
+function routeChannels(edges, ctx) {
+	const out = /* @__PURE__ */ new Map();
+	if (edges.length === 0) return out;
+	const lr = ctx.direction === "LR";
+	const m = (p) => lr ? p.x : p.y;
+	const c = (p) => lr ? p.y : p.x;
+	const mHalf = (b) => (lr ? b.width : b.height) / 2;
+	const cHalf = (b) => (lr ? b.height : b.width) / 2;
+	const at = (mv, cv) => lr ? {
+		x: mv,
+		y: cv
+	} : {
+		x: cv,
+		y: mv
+	};
+	let cMin = Infinity;
+	let cMax = -Infinity;
+	for (const [id, b] of ctx.nodes) {
+		cMin = Math.min(cMin, c(b) - cHalf(b));
+		cMax = Math.max(cMax, c(b) + cHalf(b) + (ctx.extraBelow?.(id) ?? 0));
+	}
+	for (const g of ctx.groups.values()) {
+		cMin = Math.min(cMin, c(g) - cHalf(g));
+		cMax = Math.max(cMax, c(g) + cHalf(g));
+	}
+	/** Things a straight segment along the cross axis at `mv`, from `c0` to the graph's edge on side `s`, would cut through. */
+	const blockedFrom = (skip, mv, c0, s, own) => {
+		let n = 0;
+		const hit = (b) => Math.abs(m(b) - mv) < mHalf(b) + 6 && (s > 0 ? c(b) + cHalf(b) > c0 + 1 : c(b) - cHalf(b) < c0 - 1);
+		for (const [other, b] of ctx.nodes) if (other !== skip && hit(b)) n++;
+		for (const [gid, g] of ctx.groups) if (!own.has(gid) && hit(g)) n += 2;
+		return n;
+	};
+	const used = /* @__PURE__ */ new Map();
+	/**
+	* How one end reaches the channel on side `s`: straight out of the side
+	* facing the channel at the first clear offset, else out of the side facing
+	* along the flow into the gap between ranks, else straight (blocked).
+	*/
+	const endPlan = (id, box, own, s, isSource, spread, commit) => {
+		const facing = lr ? s > 0 ? "bottom" : "top" : s > 0 ? "right" : "left";
+		const key = `${id}\u0000${facing}`;
+		const taken = used.get(key) ?? [];
+		const offsets = spread ? [
+			.5,
+			.3,
+			.7,
+			.15,
+			.85
+		] : [.5];
+		const edgeC = c(box) + s * cHalf(box);
+		for (const o of offsets) {
+			if (taken.some((t) => Math.abs(t - o) < .1)) continue;
+			const p = sidePoint(box, facing, o);
+			if (blockedFrom(id, m(p), edgeC, s, own) === 0) {
+				if (commit) used.set(key, [...taken, o]);
+				return {
+					point: p,
+					side: facing,
+					dropM: m(p),
+					cost: 0
+				};
+			}
+		}
+		const gapSides = lr ? isSource ? ["left", "right"] : ["right", "left"] : isSource ? ["top", "bottom"] : ["bottom", "top"];
+		let best;
+		for (const gapSide of gapSides) {
+			const p = sidePoint(box, gapSide, .5);
+			const dir = gapSide === "left" || gapSide === "top" ? -1 : 1;
+			const dropM = m(p) + dir * 18;
+			const cost = blockedFrom(id, dropM, c(box), s, own);
+			const plan = {
+				point: p,
+				side: gapSide,
+				dropM,
+				stub: at(dropM, c(p)),
+				cost
+			};
+			if (cost === 0) return plan;
+			if (!best || cost < best.cost) best = plan;
+		}
+		const p0 = sidePoint(box, facing, .5);
+		const straight = {
+			point: p0,
+			side: facing,
+			dropM: m(p0),
+			cost: blockedFrom(id, m(p0), edgeC, s, own)
+		};
+		return best && best.cost < straight.cost ? best : straight;
+	};
+	const plans = edges.map((e) => {
+		const cost = (s) => endPlan(e.from, e.source, e.sourceGroups, s, true, e.spreadSource, false).cost + endPlan(e.to, e.target, e.targetGroups, s, false, e.spreadTarget, false).cost;
+		const side = cost(-1) < cost(1) ? -1 : 1;
+		const src = endPlan(e.from, e.source, e.sourceGroups, side, true, e.spreadSource, true);
+		const dst = endPlan(e.to, e.target, e.targetGroups, side, false, e.spreadTarget, true);
+		return {
+			e,
+			side,
+			lane: 0,
+			lo: Math.min(src.dropM, dst.dropM),
+			hi: Math.max(src.dropM, dst.dropM),
+			src,
+			dst
+		};
+	});
+	for (const s of [1, -1]) {
+		const side = plans.filter((p) => p.side === s).sort((a, b) => a.hi - a.lo - (b.hi - b.lo) || a.lo - b.lo);
+		const lanes = [];
+		for (const p of side) {
+			let i = lanes.findIndex((lane) => lane.every((r) => p.hi + 12 < r.lo || p.lo - 12 > r.hi));
+			if (i < 0) {
+				lanes.push([]);
+				i = lanes.length - 1;
+			}
+			lanes[i].push({
+				lo: p.lo,
+				hi: p.hi
+			});
+			p.lane = i;
+		}
+	}
+	const labelled = (s) => plans.some((p) => p.side === s && p.e.label);
+	const gap = (s) => lr && labelled(s) ? LANE_LABELLED : LANE;
+	const base = (s) => s > 0 ? cMax + GAP : cMin - GAP;
+	for (const p of plans) {
+		const s = p.side;
+		const laneC = base(s) + s * p.lane * gap(s);
+		const points = [p.src.point];
+		if (p.src.stub) points.push(p.src.stub);
+		points.push(at(p.src.dropM, laneC), at(p.dst.dropM, laneC));
+		if (p.dst.stub) points.push(p.dst.stub);
+		points.push(p.dst.point);
+		const route = {
+			d: roundedPath(points, 10),
+			points,
+			from: {
+				point: p.src.point,
+				side: p.src.side
+			},
+			to: {
+				point: p.dst.point,
+				side: p.dst.side
+			}
+		};
+		if (p.e.label) route.label = at((p.src.dropM + p.dst.dropM) / 2, laneC);
+		out.set(p.e.id, route);
+	}
+	return out;
+}
+// src/layout/labels.ts
+var hits = (a, b, pad) => Math.abs(a.x - b.x) < (a.width + b.width) / 2 + pad && Math.abs(a.y - b.y) < (a.height + b.height) / 2 + pad;
+/** Candidate centres along a polyline (longest segment first), then beside it. */
+function candidates(points, label) {
+	const segs = [];
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const b = points[i];
+		segs.push({
+			a,
+			b,
+			len: Math.hypot(b.x - a.x, b.y - a.y)
+		});
+	}
+	segs.sort((u, v) => v.len - u.len);
+	const out = [];
+	for (const s of segs) for (const t of [
+		.5,
+		.35,
+		.65,
+		.2,
+		.8,
+		.1,
+		.9
+	]) out.push({
+		x: s.a.x + (s.b.x - s.a.x) * t,
+		y: s.a.y + (s.b.y - s.a.y) * t
+	});
+	const beside = [];
+	for (const s of segs) {
+		const horizontal = Math.abs(s.a.y - s.b.y) < .5;
+		const dx = horizontal ? 0 : label.width / 2 + 3;
+		const dy = horizontal ? label.height / 2 + 3 : 0;
+		for (const t of [
+			.5,
+			.3,
+			.7
+		]) {
+			const p = {
+				x: s.a.x + (s.b.x - s.a.x) * t,
+				y: s.a.y + (s.b.y - s.a.y) * t
+			};
+			beside.push({
+				x: p.x - dx,
+				y: p.y - dy
+			}, {
+				x: p.x + dx,
+				y: p.y + dy
+			});
+		}
+	}
+	return [...out, ...beside];
+}
+/**
+* Moves labels off nodes and off each other, in the given order (earlier
+* labels keep their place). Mutates the labels' `x`/`y`.
+*/
+function placeLabels(items, nodes) {
+	const boxes = [...nodes];
+	const placed = [];
+	const free = (l) => !boxes.some((b) => hits(l, b, 4)) && !placed.some((p) => hits(l, p, 3));
+	for (const { label, points } of items) {
+		if (!free(label)) {
+			for (const c of candidates(points, label)) if (free({
+				...label,
+				x: c.x,
+				y: c.y
+			})) {
+				label.x = c.x;
+				label.y = c.y;
+				break;
+			}
+		}
+		placed.push(label);
+	}
+}
+// src/layout/index.ts
+/**
+* Graph layout: node sizes from types and labels, positions from the layered
+* layout (or the model's own positions), and routed edges with label boxes.
+* Deterministic: the same model and options give the same geometry.
+*/
+var LABEL_FONT = {
+	size: 14,
+	weight: 500
+};
+var DESCRIPTION_FONT = { size: 12 };
+var EDGE_FONT = {
+	size: 12,
+	weight: 500
+};
+/** The label beside a start/end circle. */
+var OUTSIDE_FONT = { size: 13 };
+var ICON_ROOM = 30;
+/** A node's size and wrapped label, before it is placed. */
+function measureNode(node, registry, measure) {
+	const def = typeOf(registry, node.type);
+	const label = node.label ?? "";
+	if (def.size) return {
+		id: node.id,
+		width: def.size.width,
+		height: def.size.height,
+		lines: label ? wrapText(label, 160, OUTSIDE_FONT, measure, 2) : [],
+		descriptionLines: []
+	};
+	const min = def.minWidth ?? 120;
+	const max = def.maxWidth ?? 220;
+	const icon = def.icon && def.shape !== "diamond" ? ICON_ROOM : 0;
+	const diamond = def.shape === "diamond";
+	const room = diamond ? max * .62 : max - 32 - icon - 10;
+	const lines = wrapText(label, room, LABEL_FONT, measure, diamond ? 2 : 3);
+	const descriptionLines = node.description && !diamond ? wrapText(node.description, room, DESCRIPTION_FONT, measure, 2) : [];
+	const textWidth = Math.max(0, ...lines.map((l) => measure(l, LABEL_FONT)), ...descriptionLines.map((l) => measure(l, DESCRIPTION_FONT)));
+	const width = diamond ? Math.min(max, Math.max(min, textWidth / .62 + 8)) : Math.min(max, Math.max(min, Math.ceil(textWidth + 32 + icon + 10)));
+	const textHeight = lines.length * 18 + descriptionLines.length * 15;
+	const height = Math.max(def.height ?? 44, diamond ? textHeight * 2 + 20 : textHeight + 24);
+	return {
+		id: node.id,
+		width: Math.round(width),
+		height: Math.round(height),
+		lines,
+		descriptionLines
+	};
+}
+function edgeLabelText(e) {
+	return e.label ?? e.condition ?? "";
+}
+function measureEdgeLabel(e, measure, extra = 0) {
+	const text = edgeLabelText(e);
+	if (!text) return void 0;
+	const lines = wrapText(text, 160, EDGE_FONT, measure, 2);
+	const width = Math.max(...lines.map((l) => measure(l, EDGE_FONT))) + 16 + extra;
+	return {
+		width: Math.ceil(width),
+		height: lines.length * 15 + 8,
+		lines
+	};
+}
+/** Lays out a graph. */
+function layoutGraph(graph, options = {}) {
+	const registry = options.registry ?? defaultRegistry;
+	const measure = options.measure ?? approximateMeasurer;
+	const direction = options.direction ?? graph.meta?.direction ?? "LR";
+	const routing = options.routing ?? "orthogonal";
+	const nodeIds = new Set(graph.nodes.map((n) => n.id));
+	const groupIds = new Set((graph.groups ?? []).map((g) => g.id));
+	const sized = new Map(graph.nodes.map((n) => [n.id, measureNode(n, registry, measure)]));
+	const edges = graph.edges.filter((e) => nodeIds.has(e.from) && nodeIds.has(e.to));
+	const labels = new Map(edges.map((e) => [e.id, measureEdgeLabel(e, measure, options.edgeLabelExtra ?? 0)]));
+	const fixed = options.ignorePositions ? [] : graph.nodes.filter((n) => n.position);
+	const centres = /* @__PURE__ */ new Map();
+	let waypoints = /* @__PURE__ */ new Map();
+	let labelAt = /* @__PURE__ */ new Map();
+	let groupBoxes = /* @__PURE__ */ new Map();
+	if (fixed.length < graph.nodes.length) {
+		let result = runLayered(graph, sized, edges, labels, direction, groupIds, options);
+		const back = new Set(edges.filter((e) => channelled(e, graph) && result.nodes.has(e.from) && result.nodes.has(e.to)).filter((e) => isBehind(result.nodes.get(e.from), result.nodes.get(e.to), direction)).map((e) => e.id));
+		if (back.size > 0) result = runLayered(graph, sized, edges.filter((e) => !back.has(e.id)), labels, direction, groupIds, options);
+		for (const [id, b] of result.nodes) centres.set(id, {
+			x: b.x,
+			y: b.y
+		});
+		for (const [id, r] of result.edges) {
+			waypoints.set(id, r.points);
+			if (r.label) labelAt.set(id, r.label);
+		}
+		groupBoxes = new Map([...result.clusters].map(([id, b]) => [id, b]));
+		if (fixed.length > 0) {
+			let dx = 0;
+			let dy = 0;
+			for (const n of fixed) {
+				const c = centres.get(n.id);
+				dx += n.position.x - c.x;
+				dy += n.position.y - c.y;
+			}
+			dx /= fixed.length;
+			dy /= fixed.length;
+			const placed = [];
+			for (const n of fixed) {
+				centres.set(n.id, { ...n.position });
+				placed.push({
+					...n.position,
+					width: sized.get(n.id).width,
+					height: sized.get(n.id).height
+				});
+			}
+			for (const n of graph.nodes) {
+				if (n.position) continue;
+				const c = centres.get(n.id);
+				const box = {
+					x: c.x + dx,
+					y: c.y + dy,
+					width: sized.get(n.id).width,
+					height: sized.get(n.id).height
+				};
+				let guard = 0;
+				while (placed.some((p) => overlaps(p, box, 16)) && guard++ < 400) if (direction === "LR") box.y += 12;
+				else box.x += 12;
+				centres.set(n.id, {
+					x: box.x,
+					y: box.y
+				});
+				placed.push(box);
+			}
+			waypoints = /* @__PURE__ */ new Map();
+			labelAt = /* @__PURE__ */ new Map();
+			groupBoxes = /* @__PURE__ */ new Map();
+		}
+	} else for (const n of graph.nodes) centres.set(n.id, { ...n.position });
+	const nodes = /* @__PURE__ */ new Map();
+	for (const n of graph.nodes) {
+		const s = sized.get(n.id);
+		const c = centres.get(n.id);
+		nodes.set(n.id, {
+			...s,
+			x: c.x,
+			y: c.y
+		});
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const g of graph.groups ?? []) {
+		const box = groupBoxes.get(g.id) ?? frameAround(g.id, graph, nodes);
+		if (box) groups.set(g.id, {
+			id: g.id,
+			label: g.label,
+			...box
+		});
+	}
+	const routed = routeEdges(graph, nodes, {
+		direction,
+		routing,
+		registry,
+		waypoints,
+		labelAt,
+		labels,
+		groups
+	});
+	return {
+		direction,
+		routing,
+		nodes,
+		edges: routed,
+		groups,
+		waypoints,
+		bounds: boundsOf(nodes, routed, groups)
+	};
+}
+function runLayered(graph, sized, edges, labels, direction, groupIds, options) {
+	const registry = options.registry ?? defaultRegistry;
+	const nodes = graph.nodes.map((n) => {
+		const s = sized.get(n.id);
+		const def = typeOf(registry, n.type);
+		let w = s.width;
+		let h = s.height;
+		if (def.labelOutside && s.lines.length) {
+			if (direction === "LR") h += (s.lines.length * 18 + 4) * 2;
+			else w += (Math.max(...s.lines.map((l) => (options.measure ?? approximateMeasurer)(l, OUTSIDE_FONT))) + 10) * 2;
+		}
+		const node = {
+			id: n.id,
+			width: w,
+			height: h
+		};
+		if (n.group && groupIds.has(n.group)) node.cluster = n.group;
+		return node;
+	});
+	const layoutEdges = edges.map((e) => {
+		const l = labels.get(e.id);
+		const le = {
+			id: e.id,
+			from: e.from,
+			to: e.to
+		};
+		if (l) le.label = {
+			width: l.width,
+			height: l.height
+		};
+		if (e.kind === "association") le.weight = .2;
+		return le;
+	});
+	const clusters = (graph.groups ?? []).map((g) => {
+		const c = { id: g.id };
+		if (g.parent && groupIds.has(g.parent)) c.parent = g.parent;
+		if (g.label) c.label = {
+			width: approximateMeasurer(g.label, {
+				size: 12,
+				weight: 600
+			}) + 8,
+			height: 18
+		};
+		return c;
+	});
+	try {
+		return layout({
+			direction,
+			nodes,
+			edges: layoutEdges,
+			clusters,
+			nodeSep: options.nodeSep ?? 36,
+			rankSep: options.rankSep ?? (direction === "LR" ? 26 : 22),
+			edgeSep: 16,
+			clusterPadding: 18,
+			transpose: true
+		});
+	} catch {
+		return layout({
+			direction,
+			nodes: nodes.map((n) => ({
+				id: n.id,
+				width: n.width,
+				height: n.height
+			})),
+			edges: layoutEdges,
+			nodeSep: 36,
+			rankSep: 24,
+			transpose: true
+		});
+	}
+}
+/**
+* Routes edges between placed nodes. Anchors on one side of a rectangular
+* node are spread along it so parallel edges do not merge.
+*/
+function routeEdges(graph, nodes, ctx, only) {
+	const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+	const prefer = ctx.direction === "TB" ? "vertical" : "horizontal";
+	const parentOf = new Map((graph.groups ?? []).map((g) => [g.id, g.parent]));
+	const groupsOf = (id) => {
+		const set = /* @__PURE__ */ new Set();
+		let g = byId.get(id)?.group;
+		while (g !== void 0 && !set.has(g)) {
+			set.add(g);
+			g = parentOf.get(g);
+		}
+		return set;
+	};
+	const clearOf = (e) => {
+		const own = /* @__PURE__ */ new Set([...groupsOf(e.from), ...groupsOf(e.to)]);
+		const boxes = [];
+		for (const [id, b] of nodes) if (id !== e.from && id !== e.to) boxes.push(b);
+		for (const [gid, g] of ctx.groups ?? []) if (!own.has(gid)) boxes.push(g);
+		return (u, v) => !boxes.some((b) => segmentHitsBox(u, v, b, 6));
+	};
+	const pending = [];
+	const backs = [];
+	const out = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const a = byId.get(e.from);
+		const b = byId.get(e.to);
+		const ab = nodes.get(e.from);
+		const bb = nodes.get(e.to);
+		if (!a || !b || !ab || !bb) continue;
+		if (e.from === e.to) {
+			if (only && !only.has(e.id)) continue;
+			out.set(e.id, selfLoop(e, ab, ctx));
+			continue;
+		}
+		if (channelled(e, graph) && isBehind(ab, bb, ctx.direction)) {
+			backs.push({
+				id: e.id,
+				from: e.from,
+				to: e.to,
+				source: ab,
+				target: bb,
+				sourceGroups: groupsOf(e.from),
+				targetGroups: groupsOf(e.to),
+				label: ctx.labels.get(e.id),
+				spreadSource: spreadable(typeOf(ctx.registry, a.type).shape),
+				spreadTarget: spreadable(typeOf(ctx.registry, b.type).shape)
+			});
+			continue;
+		}
+		const wps = ctx.waypoints.get(e.id) ?? [];
+		const end = (node, box, portId, toward) => {
+			const port = portId ? portsOf(ctx.registry, node).find((p) => p.id === portId) : void 0;
+			if (port) return {
+				node,
+				box,
+				side: port.side,
+				offset: port.offset ?? .5,
+				fixed: true,
+				toward
+			};
+			return {
+				node,
+				box,
+				side: facingSide(box, toward, prefer),
+				fixed: false,
+				toward
+			};
+		};
+		pending.push({
+			edge: e,
+			ends: [end(a, ab, e.fromPort, wps[0] ?? bb), end(b, bb, e.toPort, wps[wps.length - 1] ?? ab)],
+			wps
+		});
+	}
+	const slots = /* @__PURE__ */ new Map();
+	for (const p of pending) for (const i of [0, 1]) {
+		const end = p.ends[i];
+		if (end.fixed) continue;
+		const key = `${end.node.id}\u0000${end.side}`;
+		const list = slots.get(key) ?? [];
+		list.push({
+			p,
+			i
+		});
+		slots.set(key, list);
+	}
+	for (const list of slots.values()) {
+		const first = list[0].p.ends[list[0].i];
+		const shape = typeOf(ctx.registry, first.node.type).shape;
+		if (list.length === 1 || !spreadable(shape)) {
+			for (const { p, i } of list) p.ends[i].offset = .5;
+			continue;
+		}
+		const horizontalSide = first.side === "top" || first.side === "bottom";
+		list.sort((u, v) => {
+			const a = u.p.ends[u.i].toward;
+			const b = v.p.ends[v.i].toward;
+			return horizontalSide ? a.x - b.x || a.y - b.y : a.y - b.y || a.x - b.x;
+		});
+		const span = Math.min(.7, .18 * (list.length - 1));
+		list.forEach(({ p, i }, k) => p.ends[i].offset = .5 - span / 2 + span * k / (list.length - 1));
+	}
+	for (const p of pending) {
+		if (only && !only.has(p.edge.id)) continue;
+		const [s, t] = p.ends;
+		const from = {
+			point: anchorPoint(s.box, s.side, s.offset ?? .5, ctx, s.node),
+			side: s.side
+		};
+		const to = {
+			point: anchorPoint(t.box, t.side, t.offset ?? .5, ctx, t.node),
+			side: t.side
+		};
+		const r = p.wps.length > 0 ? orthogonalThrough(from, to, p.wps, ctx.direction === "LR", clearOf(p.edge), ctx.routing === "spline" ? 28 : 10, ctx.labelAt.get(p.edge.id)) : route({
+			from,
+			to,
+			waypoints: p.wps,
+			routing: ctx.routing
+		});
+		const geo = {
+			id: p.edge.id,
+			d: r.d,
+			points: r.points,
+			from,
+			to
+		};
+		const l = ctx.labels.get(p.edge.id);
+		if (l) {
+			let at = ctx.labelAt.get(p.edge.id);
+			if (at) at = pointAtMain(r.points, ctx.direction === "LR" ? at.x : at.y, ctx.direction === "LR") ?? midpoint(r.points);
+			if (!at) at = ctx.routing === "spline" && p.wps.length === 0 && r.points.length === 4 ? bezierPoint(r.points[0], r.points[1], r.points[2], r.points[3], .5) : midpoint(r.points);
+			geo.label = {
+				x: at.x,
+				y: at.y,
+				width: l.width,
+				height: l.height,
+				lines: l.lines
+			};
+		}
+		out.set(p.edge.id, geo);
+	}
+	const channels = routeChannels(backs, {
+		direction: ctx.direction,
+		nodes,
+		groups: ctx.groups ?? /* @__PURE__ */ new Map(),
+		extraBelow: (id) => {
+			const n = byId.get(id);
+			const def = n && typeOf(ctx.registry, n.type);
+			return ctx.direction === "LR" && def?.labelOutside && n?.label ? 42 : 0;
+		}
+	});
+	for (const b of backs) {
+		if (only && !only.has(b.id)) continue;
+		const r = channels.get(b.id);
+		const geo = {
+			id: b.id,
+			d: r.d,
+			points: r.points,
+			from: r.from,
+			to: r.to
+		};
+		const l = ctx.labels.get(b.id);
+		if (l && r.label) geo.label = {
+			x: r.label.x,
+			y: r.label.y,
+			width: l.width,
+			height: l.height,
+			lines: l.lines
+		};
+		out.set(b.id, geo);
+	}
+	if (!only) placeLabels([...out.values()].filter((g) => g.label).sort((a, b) => Number(backs.some((x) => x.id === a.id)) - Number(backs.some((x) => x.id === b.id))).map((g) => ({
+		label: g.label,
+		points: g.points
+	})), nodes.values());
+	return out;
+}
+/** Edges that go through the back-edge channel when they run against the flow. */
+function channelled(e, graph) {
+	return e.from !== e.to && e.kind !== "association" && !e.fromPort && !e.toPort;
+}
+function anchorPoint(box, side, offset, ctx, node) {
+	const shape = typeOf(ctx.registry, node.type).shape;
+	if (!spreadable(shape)) return sidePoint(box, side, .5);
+	return sidePoint(box, side, offset);
+}
+function selfLoop(e, box, ctx) {
+	const lr = ctx.direction === "LR";
+	const fromSide = lr ? "top" : "right";
+	const toSide = lr ? "top" : "right";
+	const a = sidePoint(box, fromSide, .7);
+	const b = sidePoint(box, toSide, .3);
+	const k = 34;
+	const d = lr ? `M ${a.x} ${a.y} C ${a.x} ${a.y - k} ${b.x} ${b.y - k} ${b.x} ${b.y}` : `M ${a.x} ${a.y} C ${a.x + k} ${a.y} ${b.x + k} ${b.y} ${b.x} ${b.y}`;
+	const apex = lr ? {
+		x: (a.x + b.x) / 2,
+		y: a.y - k * .75
+	} : {
+		x: a.x + k * .75,
+		y: (a.y + b.y) / 2
+	};
+	const geo = {
+		id: e.id,
+		d,
+		points: [
+			a,
+			apex,
+			b
+		],
+		from: {
+			point: a,
+			side: fromSide
+		},
+		to: {
+			point: b,
+			side: toSide
+		},
+		selfLoop: true
+	};
+	const l = ctx.labels.get(e.id);
+	if (l) geo.label = {
+		x: lr ? apex.x : apex.x + l.width / 2 + 4,
+		y: lr ? apex.y - l.height / 2 - 4 : apex.y,
+		width: l.width,
+		height: l.height,
+		lines: l.lines
+	};
+	return geo;
+}
+function overlaps(a, b, gap = 0) {
+	return Math.abs(a.x - b.x) < (a.width + b.width) / 2 + gap && Math.abs(a.y - b.y) < (a.height + b.height) / 2 + gap;
+}
+/** A group frame around its member nodes and nested groups. */
+function frameAround(groupId, graph, nodes, pad = 18, title = 24) {
+	const members = /* @__PURE__ */ new Set([groupId]);
+	let grew = true;
+	while (grew) {
+		grew = false;
+		for (const g of graph.groups ?? []) if (g.parent && members.has(g.parent) && !members.has(g.id)) {
+			members.add(g.id);
+			grew = true;
+		}
+	}
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const n of graph.nodes) {
+		if (!n.group || !members.has(n.group)) continue;
+		const b = nodes.get(n.id);
+		if (!b) continue;
+		x0 = Math.min(x0, b.x - b.width / 2);
+		y0 = Math.min(y0, b.y - b.height / 2);
+		x1 = Math.max(x1, b.x + b.width / 2);
+		y1 = Math.max(y1, b.y + b.height / 2);
+	}
+	if (!Number.isFinite(x0)) return void 0;
+	const nested = [...members].filter((m) => m !== groupId).length > 0 ? 10 : 0;
+	x0 -= pad + nested;
+	x1 += pad + nested;
+	y0 -= pad + title + nested;
+	y1 += pad + nested;
+	return {
+		x: (x0 + x1) / 2,
+		y: (y0 + y1) / 2,
+		width: x1 - x0,
+		height: y1 - y0
+	};
+}
+/** Everything drawn: nodes, edge bends and labels, frames. */
+function boundsOf(nodes, edges, groups, outsideLabels = 40) {
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	const box = (b, extraBottom = 0) => {
+		x0 = Math.min(x0, b.x - b.width / 2);
+		y0 = Math.min(y0, b.y - b.height / 2);
+		x1 = Math.max(x1, b.x + b.width / 2);
+		y1 = Math.max(y1, b.y + b.height / 2 + extraBottom);
+	};
+	for (const b of nodes.values()) {
+		box(b, b.width <= 40 ? outsideLabels : 0);
+		if (b.width <= 40 && "lines" in b && b.lines.length) {
+			box({
+				...b,
+				width: 110
+			});
+			box({
+				...b,
+				x: b.x + 60,
+				width: b.width + 120
+			});
+		}
+	}
+	for (const g of groups.values()) box(g);
+	for (const e of edges.values()) {
+		for (const p of e.points) box({
+			x: p.x,
+			y: p.y,
+			width: 0,
+			height: 0
+		});
+		if (e.label) box(e.label);
+	}
+	if (!Number.isFinite(x0)) return {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+	return {
+		x: x0,
+		y: y0,
+		width: x1 - x0,
+		height: y1 - y0
+	};
+}
+// src/monitor/state.ts
+function emptyMonitorState() {
+	return {
+		nodes: {},
+		edges: {},
+		failures: 0
+	};
+}
+function toEpoch(v) {
+	if (v === void 0) return void 0;
+	if (typeof v === "number") return Number.isFinite(v) ? v : void 0;
+	const t = Date.parse(v);
+	return Number.isNaN(t) ? void 0 : t;
+}
+function mergeRecord(prev, next) {
+	if (!next) return prev;
+	const out = { ...prev };
+	for (const [id, v] of Object.entries(next)) out[id] = {
+		...prev[id] ?? {},
+		...v
+	};
+	return out;
+}
+/** The pure reducer. Never mutates `state`. */
+function reduceMonitor(state, action) {
+	switch (action.type) {
+		case "reset": return emptyMonitorState();
+		case "error": return {
+			...state,
+			error: action.error,
+			failures: state.failures + 1
+		};
+		case "snapshot": {
+			const s = action.snapshot;
+			const next = {
+				...action.merge ? {
+					...state,
+					nodes: mergeRecord(state.nodes, s.nodes),
+					edges: mergeRecord(state.edges, s.edges)
+				} : {
+					nodes: { ...s.nodes ?? {} },
+					edges: { ...s.edges ?? {} },
+					failures: 0
+				},
+				failures: 0,
+				receivedAt: action.at
+			};
+			delete next.error;
+			const stamped = toEpoch(s.updatedAt);
+			if (stamped !== void 0) next.updatedAt = stamped;
+			else delete next.updatedAt;
+			if (s.path !== void 0 || !action.merge) {
+				if (s.path) next.path = [...s.path];
+				else delete next.path;
+			}
+			if (s.current !== void 0 || !action.merge) {
+				if (s.current) next.current = [...s.current];
+				else delete next.current;
+			}
+			return next;
+		}
+	}
+}
+/** Folds a snapshot into a state: the shorthand for the common case. */
+function mergeSnapshot(state, snapshot, at = Date.now(), merge = false) {
+	return reduceMonitor(state ?? emptyMonitorState(), {
+		type: "snapshot",
+		snapshot,
+		at,
+		merge
+	});
+}
+/**
+* Whether the state is too old to trust: nothing received for `staleAfterMs`.
+* A state that never received anything is not stale (it is loading).
+*/
+function isStale(state, now, staleAfterMs) {
+	if (!state?.receivedAt) return false;
+	return now - state.receivedAt > staleAfterMs;
+}
+/**
+* The edges of a path: for each consecutive pair of nodes, the first enabled
+* edge between them (then any edge). Pairs without an edge are skipped.
+*/
+function pathEdges(graph, path) {
+	if (!path || path.length < 2) return [];
+	const out = [];
+	for (let i = 1; i < path.length; i++) {
+		const from = path[i - 1];
+		const to = path[i];
+		const candidates = graph.edges.filter((e) => e.from === from && e.to === to);
+		const pick = candidates.find((e) => e.enabled !== false) ?? candidates[0];
+		if (pick) out.push(pick.id);
+	}
+	return out;
+}
+/** Built-in statuses and the kit tone each is drawn with. */
+var STATUS_TONES = Object.freeze({
+	active: "accent",
+	done: "success",
+	error: "danger",
+	waiting: "warning",
+	skipped: "neutral"
+});
+/** Counts of nodes by status: the summary line of a monitor. */
+function statusSummary(state) {
+	const out = {};
+	for (const n of Object.values(state?.nodes ?? {})) {
+		if (!n.status) continue;
+		out[n.status] = (out[n.status] ?? 0) + 1;
+	}
+	return out;
+}
+// src/monitor/poller.ts
+function documentVisibility() {
+	const doc = globalThis.document;
+	if (!doc || typeof doc.addEventListener !== "function") return void 0;
+	return {
+		hidden: () => doc.visibilityState === "hidden",
+		subscribe(listener) {
+			doc.addEventListener("visibilitychange", listener);
+			return () => doc.removeEventListener("visibilitychange", listener);
+		}
+	};
+}
+/** The delay after `failures` errors in a row. */
+function backoffDelay(intervalMs, failures, backoff = {}) {
+	if (backoff === false || failures === 0) return intervalMs;
+	const factor = backoff.factor ?? 2;
+	const max = backoff.maxMs ?? 6e4;
+	return Math.min(max, intervalMs * factor ** failures);
+}
+function createPoller(options) {
+	const visibility = options.visibilityPause === false ? void 0 : options.visibilityPause === true || options.visibilityPause === void 0 ? documentVisibility() : options.visibilityPause;
+	let status = "idle";
+	const current = () => status;
+	let timer;
+	let controller;
+	let failures = 0;
+	let unsubscribe;
+	let nextDelay = options.intervalMs;
+	/** Bumped on every stop/refresh, so a late response of an old run is ignored. */
+	let generation = 0;
+	const clear = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+	};
+	const abort = () => {
+		controller?.abort();
+		controller = void 0;
+	};
+	const schedule = (delay) => {
+		clear();
+		nextDelay = delay;
+		if (status !== "running") return;
+		timer = setTimeout(tick, delay);
+	};
+	const tick = async () => {
+		timer = void 0;
+		if (status !== "running") return;
+		const gen = ++generation;
+		abort();
+		const c = new AbortController();
+		controller = c;
+		try {
+			const data = await options.fetch(c.signal);
+			if (gen !== generation || current() === "idle") return;
+			failures = 0;
+			options.onData?.(data);
+		} catch (error) {
+			if (gen !== generation || current() === "idle" || c.signal.aborted) return;
+			failures++;
+			options.onError?.(error, failures);
+		} finally {
+			if (controller === c) controller = void 0;
+		}
+		if (gen === generation && status === "running") schedule(backoffDelay(options.intervalMs, failures, options.backoff));
+	};
+	const onVisibility = () => {
+		if (!visibility || status === "idle") return;
+		if (visibility.hidden()) {
+			if (status === "running") {
+				status = "paused";
+				generation++;
+				clear();
+				abort();
+			}
+		} else if (status === "paused") {
+			status = "running";
+			tick();
+		}
+	};
+	return {
+		start() {
+			if (status !== "idle") return;
+			unsubscribe = visibility?.subscribe(onVisibility);
+			if (visibility?.hidden()) {
+				status = "paused";
+				return;
+			}
+			status = "running";
+			if (options.immediate ?? true) tick();
+			else schedule(options.intervalMs);
+		},
+		stop() {
+			status = "idle";
+			generation++;
+			clear();
+			abort();
+			unsubscribe?.();
+			unsubscribe = void 0;
+		},
+		refresh() {
+			if (status !== "running") return;
+			clear();
+			tick();
+		},
+		get status() {
+			return status;
+		},
+		get failures() {
+			return failures;
+		},
+		get nextDelay() {
+			return nextDelay;
+		}
+	};
+}
+// src/edit/commands.ts
+/** Thrown when a command does not fit the graph (unknown id, duplicate id…). */
+var CommandError = class extends Error {
+	name = "CommandError";
+};
+function patched(obj, patch) {
+	const out = { ...obj };
+	for (const [k, v] of Object.entries(patch)) {
+		if (k === "id") continue;
+		if (v === null || v === void 0) delete out[k];
+		else out[k] = v;
+	}
+	return out;
+}
+function ids(graph) {
+	return /* @__PURE__ */ new Set([
+		...graph.nodes.map((n) => n.id),
+		...graph.edges.map((e) => e.id),
+		...(graph.groups ?? []).map((g) => g.id)
+	]);
+}
+/** Applies a command; returns a new graph and leaves the old one untouched. */
+function applyCommand(graph, command) {
+	switch (command.type) {
+		case "addNodes": {
+			const taken = ids(graph);
+			for (const el of [...command.nodes, ...command.edges ?? []]) {
+				if (taken.has(el.id)) throw new CommandError(`The id "${el.id}" is already used`);
+				taken.add(el.id);
+			}
+			return {
+				...graph,
+				nodes: [...graph.nodes, ...command.nodes],
+				edges: command.edges?.length ? [...graph.edges, ...command.edges] : graph.edges
+			};
+		}
+		case "removeElements": {
+			const gone = new Set(command.ids);
+			const nodes = graph.nodes.filter((n) => !gone.has(n.id));
+			const edges = graph.edges.filter((e) => !gone.has(e.id) && !gone.has(e.from) && !gone.has(e.to));
+			const next = {
+				...graph,
+				nodes,
+				edges
+			};
+			if (graph.groups) {
+				const parentOf = new Map(graph.groups.map((g) => [g.id, g.parent]));
+				const lift = (id) => {
+					let p = id;
+					let guard = 0;
+					while (p !== void 0 && gone.has(p) && guard++ < 100) p = parentOf.get(p);
+					return p;
+				};
+				next.groups = graph.groups.filter((g) => !gone.has(g.id)).map((g) => g.parent && gone.has(g.parent) ? patched(g, { parent: lift(g.parent) ?? null }) : g);
+				next.nodes = nodes.map((n) => n.group && gone.has(n.group) ? patched(n, { group: lift(n.group) ?? null }) : n);
+			}
+			return next;
+		}
+		case "updateNode": {
+			const i = graph.nodes.findIndex((n) => n.id === command.id);
+			if (i < 0) throw new CommandError(`No node "${command.id}"`);
+			const nodes = graph.nodes.slice();
+			nodes[i] = patched(nodes[i], command.patch);
+			return {
+				...graph,
+				nodes
+			};
+		}
+		case "moveNodes": {
+			const to = new Map(command.moves.map((m) => [m.id, m.position]));
+			return {
+				...graph,
+				nodes: graph.nodes.map((n) => to.has(n.id) ? {
+					...n,
+					position: { ...to.get(n.id) }
+				} : n)
+			};
+		}
+		case "addEdge":
+			if (ids(graph).has(command.edge.id)) throw new CommandError(`The id "${command.edge.id}" is already used`);
+			return {
+				...graph,
+				edges: [...graph.edges, command.edge]
+			};
+		case "updateEdge": {
+			const i = graph.edges.findIndex((e) => e.id === command.id);
+			if (i < 0) throw new CommandError(`No edge "${command.id}"`);
+			const edges = graph.edges.slice();
+			edges[i] = patched(edges[i], command.patch);
+			return {
+				...graph,
+				edges
+			};
+		}
+		case "setEnabled": {
+			const patch = { enabled: command.enabled ? null : false };
+			return command.kind === "node" ? applyCommand(graph, {
+				type: "updateNode",
+				id: command.id,
+				patch
+			}) : applyCommand(graph, {
+				type: "updateEdge",
+				id: command.id,
+				patch
+			});
+		}
+		case "addGroup":
+			if (ids(graph).has(command.group.id)) throw new CommandError(`The id "${command.group.id}" is already used`);
+			return {
+				...graph,
+				groups: [...graph.groups ?? [], command.group]
+			};
+		case "updateGroup": {
+			const groups = graph.groups ?? [];
+			const i = groups.findIndex((g) => g.id === command.id);
+			if (i < 0) throw new CommandError(`No group "${command.id}"`);
+			const next = groups.slice();
+			next[i] = patched(next[i], command.patch);
+			return {
+				...graph,
+				groups: next
+			};
+		}
+		case "updateMeta": return {
+			...graph,
+			meta: patched(graph.meta ?? {}, command.patch)
+		};
+		case "replace": return command.graph;
+		case "batch": return command.commands.reduce(applyCommand, graph);
+	}
+}
+/** A fresh id with a prefix: `state-3`. */
+function nextId(graph, prefix, taken = ids(graph)) {
+	const base = prefix.replace(/[^\p{L}\p{N}_-]+/gu, "-").replace(/^-+|-+$/g, "") || "n";
+	for (let i = 1;; i++) {
+		const id = `${base}-${i}`;
+		if (!taken.has(id)) return id;
+	}
+}
+/** Snaps a point to a grid. */
+function snap(p, grid) {
+	if (grid <= 0) return p;
+	return {
+		x: Math.round(p.x / grid) * grid,
+		y: Math.round(p.y / grid) * grid
+	};
+}
+/** A short human description of a command, for undo tooltips and logs. */
+function describeCommand(c) {
+	switch (c.type) {
+		case "addNodes": return c.nodes.length === 1 ? `add ${c.nodes[0].id}` : `add ${c.nodes.length} nodes`;
+		case "removeElements": return c.ids.length === 1 ? `delete ${c.ids[0]}` : `delete ${c.ids.length} elements`;
+		case "updateNode":
+		case "updateEdge":
+		case "updateGroup": return `edit ${c.id}`;
+		case "moveNodes": return c.moves.length === 1 ? `move ${c.moves[0].id}` : `move ${c.moves.length} nodes`;
+		case "addEdge": return `connect ${c.edge.from} → ${c.edge.to}`;
+		case "setEnabled": return `${c.enabled ? "enable" : "disable"} ${c.id}`;
+		case "addGroup": return `add group ${c.group.id}`;
+		case "updateMeta": return "edit settings";
+		case "replace": return "replace graph";
+		case "batch": return c.commands.length === 1 ? describeCommand(c.commands[0]) : `${c.commands.length} changes`;
+	}
+}
+// src/edit/history.ts
+/**
+* Undo/redo over commands. Each entry keeps the graph before and after the
+* command: graphs are immutable and share unchanged nodes, so this costs
+* little and undo never depends on computing an inverse correctly.
+*/
+var History = class {
+	current;
+	past = [];
+	future = [];
+	limit;
+	mergeWindow;
+	now;
+	constructor(current, options = {}) {
+		this.current = current;
+		this.limit = options.limit ?? 200;
+		this.mergeWindow = options.mergeWindowMs ?? 800;
+		this.now = options.now ?? Date.now;
+	}
+	get graph() {
+		return this.current;
+	}
+	get canUndo() {
+		return this.past.length > 0;
+	}
+	get canRedo() {
+		return this.future.length > 0;
+	}
+	/** The entry `undo` would revert. */
+	get last() {
+		return this.past[this.past.length - 1];
+	}
+	get next() {
+		return this.future[this.future.length - 1];
+	}
+	/** Applies a command and records it. Throws CommandError and records nothing when it does not apply. */
+	execute(command, mergeKey) {
+		const before = this.current;
+		const after = applyCommand(before, command);
+		const at = this.now();
+		const last = this.last;
+		if (mergeKey && last && last.mergeKey === mergeKey && at - last.at <= this.mergeWindow && this.future.length === 0) {
+			last.after = after;
+			last.command = last.command.type === "batch" ? {
+				type: "batch",
+				commands: [...last.command.commands, command]
+			} : {
+				type: "batch",
+				commands: [last.command, command]
+			};
+			last.at = at;
+		} else {
+			this.past.push({
+				command,
+				before,
+				after,
+				mergeKey,
+				at
+			});
+			if (this.past.length > this.limit) this.past.shift();
+		}
+		this.future = [];
+		this.current = after;
+		return after;
+	}
+	undo() {
+		const entry = this.past.pop();
+		if (!entry) return void 0;
+		this.future.push(entry);
+		this.current = entry.before;
+		return entry;
+	}
+	redo() {
+		const entry = this.future.pop();
+		if (!entry) return void 0;
+		this.past.push(entry);
+		this.current = entry.after;
+		return entry;
+	}
+	/**
+	* Takes a graph from outside (the host changed the model). When it is the
+	* one history already holds, nothing happens; otherwise history restarts.
+	*/
+	reset(graph) {
+		if (graph === this.current) return;
+		this.current = graph;
+		this.past = [];
+		this.future = [];
+	}
+	/** Ends merging: the next command starts a new entry even with the same key. */
+	seal() {
+		const last = this.last;
+		if (last) last.mergeKey = void 0;
+	}
+};
+// src/edit/selection.ts
+/**
+* Operations over a selection that produce commands: copy/paste/duplicate,
+* align, distribute, and applying an auto layout as one undoable move.
+*/
+function isFragment(v) {
+	return typeof v === "object" && v !== null && v.kind === "dskripchenko-flow/fragment" && Array.isArray(v.nodes);
+}
+/**
+* Copies the selected nodes, with positions from the layout, and the edges
+* whose both ends are selected (plus selected edges between them).
+*/
+function copyFragment(graph, selected, layout) {
+	const set = new Set(selected);
+	const nodes = graph.nodes.filter((n) => set.has(n.id)).map((n) => {
+		const box = layout?.nodes.get(n.id);
+		const copy = structuredClone(n);
+		if (box) copy.position = {
+			x: box.x,
+			y: box.y
+		};
+		return copy;
+	});
+	const inside = new Set(nodes.map((n) => n.id));
+	return {
+		kind: "dskripchenko-flow/fragment",
+		version: 1,
+		nodes,
+		edges: graph.edges.filter((e) => inside.has(e.from) && inside.has(e.to)).map((e) => structuredClone(e))
+	};
+}
+/**
+* The command that pastes a fragment with fresh ids, shifted by `offset`
+* (or centred on `at`). Returns the new node ids for the selection.
+*/
+function pasteFragment(graph, fragment, place = {}) {
+	const taken = /* @__PURE__ */ new Set([
+		...graph.nodes.map((n) => n.id),
+		...graph.edges.map((e) => e.id),
+		...(graph.groups ?? []).map((g) => g.id)
+	]);
+	const groups = new Set((graph.groups ?? []).map((g) => g.id));
+	const map = /* @__PURE__ */ new Map();
+	let shift = place.offset ?? {
+		x: 32,
+		y: 32
+	};
+	if (place.at) {
+		const ps = fragment.nodes.map((n) => n.position).filter((p) => !!p);
+		if (ps.length) {
+			const cx = (Math.min(...ps.map((p) => p.x)) + Math.max(...ps.map((p) => p.x))) / 2;
+			const cy = (Math.min(...ps.map((p) => p.y)) + Math.max(...ps.map((p) => p.y))) / 2;
+			shift = {
+				x: place.at.x - cx,
+				y: place.at.y - cy
+			};
+		}
+	}
+	const nodes = fragment.nodes.map((n) => {
+		const id = nextId(graph, n.type === "state" ? "state" : n.type, taken);
+		taken.add(id);
+		map.set(n.id, id);
+		const copy = {
+			...structuredClone(n),
+			id
+		};
+		if (n.position) copy.position = {
+			x: n.position.x + shift.x,
+			y: n.position.y + shift.y
+		};
+		if (copy.group && !groups.has(copy.group)) delete copy.group;
+		return copy;
+	});
+	return {
+		command: {
+			type: "addNodes",
+			nodes,
+			edges: fragment.edges.filter((e) => map.has(e.from) && map.has(e.to)).map((e) => {
+				const id = nextId(graph, "e", taken);
+				taken.add(id);
+				return {
+					...structuredClone(e),
+					id,
+					from: map.get(e.from),
+					to: map.get(e.to)
+				};
+			})
+		},
+		ids: nodes.map((n) => n.id)
+	};
+}
+/** Aligns the boxes' edges or centres; returns a move command (or null for < 2 nodes). */
+function alignNodes(boxes, ids, how) {
+	const list = ids.map((id) => [id, boxes.get(id)]).filter((x) => !!x[1]);
+	if (list.length < 2) return null;
+	const lefts = list.map(([, b]) => b.x - b.width / 2);
+	const rights = list.map(([, b]) => b.x + b.width / 2);
+	const tops = list.map(([, b]) => b.y - b.height / 2);
+	const bottoms = list.map(([, b]) => b.y + b.height / 2);
+	return {
+		type: "moveNodes",
+		moves: list.map(([id, b]) => {
+			let { x, y } = b;
+			switch (how) {
+				case "left":
+					x = Math.min(...lefts) + b.width / 2;
+					break;
+				case "right":
+					x = Math.max(...rights) - b.width / 2;
+					break;
+				case "center":
+					x = (Math.min(...lefts) + Math.max(...rights)) / 2;
+					break;
+				case "top":
+					y = Math.min(...tops) + b.height / 2;
+					break;
+				case "bottom":
+					y = Math.max(...bottoms) - b.height / 2;
+					break;
+				case "middle": y = (Math.min(...tops) + Math.max(...bottoms)) / 2;
+			}
+			return {
+				id,
+				position: {
+					x,
+					y
+				}
+			};
+		})
+	};
+}
+/** Spaces the boxes evenly between the outermost two (gaps, not centres). */
+function distributeNodes(boxes, ids, axis) {
+	const list = ids.map((id) => [id, boxes.get(id)]).filter((x) => !!x[1]);
+	if (list.length < 3) return null;
+	const h = axis === "horizontal";
+	const size = (b) => h ? b.width : b.height;
+	const pos = (b) => h ? b.x : b.y;
+	list.sort((a, b) => pos(a[1]) - pos(b[1]));
+	const first = list[0][1];
+	const last = list[list.length - 1][1];
+	const start = pos(first) - size(first) / 2;
+	const end = pos(last) + size(last) / 2;
+	const total = list.reduce((s, [, b]) => s + size(b), 0);
+	const gap = (end - start - total) / (list.length - 1);
+	let cursor = start;
+	return {
+		type: "moveNodes",
+		moves: list.map(([id, b]) => {
+			const c = cursor + size(b) / 2;
+			cursor += size(b) + gap;
+			return {
+				id,
+				position: h ? {
+					x: c,
+					y: b.y
+				} : {
+					x: b.x,
+					y: c
+				}
+			};
+		})
+	};
+}
+/** Fixes every node where a layout put it: auto layout as one undoable command. */
+function layoutCommand(layout) {
+	return {
+		type: "moveNodes",
+		moves: [...layout.nodes.values()].map((b) => ({
+			id: b.id,
+			position: {
+				x: Math.round(b.x),
+				y: Math.round(b.y)
+			}
+		}))
+	};
+}
+/**
+* The centre nearest to `near` where a box of `size` overlaps no box in
+* `boxes` (with `padding`), searching outward ring by ring on the grid.
+* Used to place nodes added from the palette.
+*/
+function findFreeSpot(boxes, size, near, options = {}) {
+	const grid = options.grid ?? 0;
+	const pad = options.padding ?? 24;
+	const list = [...boxes];
+	const snapTo = (v) => (grid > 0 ? Math.round(v / grid) * grid : Math.round(v)) + 0;
+	const free = (p) => list.every((b) => Math.abs(b.x - p.x) >= (b.width + size.width) / 2 + pad || Math.abs(b.y - p.y) >= (b.height + size.height) / 2 + pad);
+	const start = {
+		x: snapTo(near.x),
+		y: snapTo(near.y)
+	};
+	if (free(start)) return start;
+	const step = Math.max(grid, 20);
+	const rings = options.maxRings ?? 60;
+	for (let r = 1; r <= rings; r++) {
+		const ring = [];
+		for (let i = -r; i <= r; i++) {
+			ring.push({
+				x: start.x + i * step,
+				y: start.y - r * step
+			}, {
+				x: start.x + i * step,
+				y: start.y + r * step
+			});
+			if (i > -r && i < r) ring.push({
+				x: start.x - r * step,
+				y: start.y + i * step
+			}, {
+				x: start.x + r * step,
+				y: start.y + i * step
+			});
+		}
+		ring.sort((a, b) => Math.hypot(a.x - near.x, a.y - near.y) - Math.hypot(b.x - near.x, b.y - near.y));
+		const hit = ring.find(free);
+		if (hit) return {
+			x: snapTo(hit.x),
+			y: snapTo(hit.y)
+		};
+	}
+	return start;
+}
+// src/view/viewport.ts
+var DEFAULT_LIMITS = {
+	min: .2,
+	max: 2.5
+};
+function clampZoom(k, limits = DEFAULT_LIMITS) {
+	return Math.min(limits.max, Math.max(limits.min, k));
+}
+function toScreen(v, p) {
+	return {
+		x: p.x * v.k + v.x,
+		y: p.y * v.k + v.y
+	};
+}
+function toGraph(v, p) {
+	return {
+		x: (p.x - v.x) / v.k,
+		y: (p.y - v.y) / v.k
+	};
+}
+/** Zooms by `factor` keeping the graph point under `at` (screen) in place. */
+function zoomAt(v, factor, at, limits = DEFAULT_LIMITS) {
+	const k = clampZoom(v.k * factor, limits);
+	const g = toGraph(v, at);
+	return {
+		k,
+		x: at.x - g.x * k,
+		y: at.y - g.y * k
+	};
+}
+/**
+* The viewport that shows `bounds` whole and centred in a `width × height`
+* screen with `padding`; never zooms in beyond `maxFit` (small graphs stay
+* at a readable size instead of blowing up).
+*/
+function fitView(bounds, width, height, padding = 32, limits = DEFAULT_LIMITS, maxFit = 1) {
+	if (bounds.width <= 0 || bounds.height <= 0 || width <= 0 || height <= 0) return {
+		x: width / 2 - bounds.x,
+		y: height / 2 - bounds.y,
+		k: 1
+	};
+	const k = clampZoom(Math.min((width - padding * 2) / bounds.width, (height - padding * 2) / bounds.height, maxFit), limits);
+	return {
+		k,
+		x: width / 2 - (bounds.x + bounds.width / 2) * k,
+		y: height / 2 - (bounds.y + bounds.height / 2) * k
+	};
+}
+/** Pans so that a graph point sits in the screen centre, keeping the zoom. */
+function centreOn(v, p, width, height) {
+	return {
+		k: v.k,
+		x: width / 2 - p.x * v.k,
+		y: height / 2 - p.y * v.k
+	};
+}
+/** Whether a graph-space box is (mostly) inside the visible area. */
+function isVisible(v, box, width, height, margin = 24) {
+	const a = toScreen(v, {
+		x: box.x - box.width / 2,
+		y: box.y - box.height / 2
+	});
+	const b = toScreen(v, {
+		x: box.x + box.width / 2,
+		y: box.y + box.height / 2
+	});
+	return a.x >= margin && a.y >= margin && b.x <= width - margin && b.y <= height - margin;
+}
+/** The node nearest to `from` in a direction: arrow-key navigation. */
+function nearestInDirection(from, candidates, dir) {
+	let best;
+	let bestScore = Infinity;
+	for (const c of candidates) {
+		const dx = c.x - from.x;
+		const dy = c.y - from.y;
+		const along = dir === "right" ? dx : dir === "left" ? -dx : dir === "down" ? dy : -dy;
+		const across = dir === "left" || dir === "right" ? Math.abs(dy) : Math.abs(dx);
+		if (along <= 1) continue;
+		const score = along + across * 2;
+		if (score < bestScore) {
+			bestScore = score;
+			best = c.id;
+		}
+	}
+	return best;
+}
+export { DiagramError as $, reduceMonitor as A, measureNode as B, backoffDelay as C, isStale as D, emptyMonitorState as E, LABEL_FONT as F, midpoint as G, bezierPoint as H, boundsOf as I, sidePoint as J, route as K, frameAround as L, toEpoch as M, DESCRIPTION_FONT as N, mergeSnapshot as O, EDGE_FONT as P, MAX_NODES as Q, layoutGraph as R, snap as S, STATUS_TONES as T, distanceToPolyline as U, routeEdges as V, facingSide as W, wrapText as X, approximateMeasurer as Y, MAX_EDGES as Z, History as _, isVisible as a, isLocked as at, describeCommand as b, toScreen as c, GraphError as ct, copyFragment as d, stringifyGraph as dt, issuesByElement as et, distributeNodes as f, GRAPH_VERSION as ft, pasteFragment as g, layoutCommand as h, fitView as i, defaultRegistry as it, statusSummary as j, pathEdges as k, zoomAt as l, emptyGraph as lt, isFragment as m, centreOn as n, BUILTIN_TYPES as nt, nearestInDirection as o, portsOf as ot, findFreeSpot as p, isEnabled as pt, sideNormal as q, clampZoom as r, createRegistry as rt, toGraph as s, typeOf as st, DEFAULT_LIMITS as t, validateGraph as tt, alignNodes as u, parseGraph as ut, CommandError as v, createPoller as w, nextId as x, applyCommand as y, measureEdgeLabel as z };
+
+//# sourceMappingURL=core-DfJMfClV.js.map