@tangle-network/sandbox-ui 0.113.7 → 0.114.0

package/dist/model-I-NIxeM-.js

@@ -0,0 +1,1250 @@
+import { parse } from "yaml";
+//#region src/workflows/cron.ts
+/**
+* Cron → English for a schedule trigger's node label. A raw `0 9 * * 1-5` tells
+* a reader nothing at a glance; "Weekdays at 09:00" tells them everything.
+*
+* Deliberately partial: it recognizes the timetables people actually author and
+* returns the EXPRESSION VERBATIM for anything else (step ranges, multi-field
+* lists, `@yearly` macros, 6-field second-precision cron). A wrong-but-confident
+* translation of an exotic expression is worse than the expression itself, so
+* there is no best-effort guessing — the node just shows what was written.
+*/
+const WEEKDAY_NAMES = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+];
+/**
+* A step field (star-slash-N), but ONLY when N actually produces an even
+* cadence. Cron steps WITHIN a field's own range and then restarts at the top of
+* the next unit — so a minute step means "every N minutes" only when N divides
+* 60, and an hour step means "every N hours" only when N divides 24. A 90-minute
+* step (a classic authoring mistake) does NOT fire every 90 minutes: it matches
+* minute 0 alone, i.e. hourly. Translating it as "Every 90 minutes" would tell an
+* author their broken cron is exactly what they meant — the one thing this module
+* must never do.
+*/
+function evenStep(field, period) {
+	const m = /^\*\/(\d+)$/.exec(field);
+	if (!m) return null;
+	const n = Number.parseInt(m[1], 10);
+	if (n < 1 || n >= period || period % n !== 0) return null;
+	return n;
+}
+/** A single, plain integer field value (no list/range/step). */
+function plainInt(field) {
+	if (!/^\d+$/.test(field)) return null;
+	return Number.parseInt(field, 10);
+}
+/** `9` → "09:00". Returns null when either half isn't a plain in-range value. */
+function timeOfDay(minute, hour) {
+	const m = plainInt(minute);
+	const h = plainInt(hour);
+	if (m === null || h === null || m > 59 || h > 23) return null;
+	return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+}
+/** English for a day-of-week field: `1-5` → "Weekdays", `1` → "Mondays",
+*  `1,3,5` → "Mon, Wed, Fri". Null for anything else (a step, an out-of-range
+*  day), so the caller falls back to the raw expression. Cron allows both `0`
+*  and `7` for Sunday. */
+function weekdays(field) {
+	if (field === "1-5") return "Weekdays";
+	if (field === "0,6" || field === "6,0" || field === "6-7") return "Weekends";
+	const dayName = (value) => {
+		if (value < 0 || value > 7) return null;
+		return WEEKDAY_NAMES[value === 7 ? 0 : value];
+	};
+	const single = plainInt(field);
+	if (single !== null) {
+		const name = dayName(single);
+		return name ? `${name}s` : null;
+	}
+	if (/^\d+(,\d+)+$/.test(field)) {
+		const names = field.split(",").map((d) => dayName(Number.parseInt(d, 10)));
+		if (names.some((n) => n === null)) return null;
+		return [...new Set(names)].map((n) => n.slice(0, 3)).join(", ");
+	}
+	return null;
+}
+/** Ordinal for a day of the month: 1 → "1st", 22 → "22nd". */
+function ordinal(day) {
+	const tens = day % 100;
+	if (tens >= 11 && tens <= 13) return `${day}th`;
+	switch (day % 10) {
+		case 1: return `${day}st`;
+		case 2: return `${day}nd`;
+		case 3: return `${day}rd`;
+		default: return `${day}th`;
+	}
+}
+/**
+* English for a standard 5-field cron expression (`minute hour day-of-month
+* month day-of-week`), or the expression VERBATIM (trimmed) when it isn't one of
+* the recognized shapes — including when it is empty. Never throws, so it is
+* always safe to render whatever the definition happens to carry.
+*/
+function describeCron(expression) {
+	const raw = expression.trim();
+	const fields = raw.split(/\s+/);
+	if (fields.length !== 5) return raw;
+	const [minute, hour, dayOfMonth, month, dayOfWeek] = fields;
+	const anyDayOfMonth = dayOfMonth === "*";
+	const anyDayOfWeek = dayOfWeek === "*";
+	if (!(month === "*")) return raw;
+	if (!anyDayOfMonth && !anyDayOfWeek) return raw;
+	if (anyDayOfMonth && anyDayOfWeek) {
+		if (minute === "*" && hour === "*") return "Every minute";
+		const everyNMinutes = evenStep(minute, 60);
+		if (everyNMinutes !== null && hour === "*") return everyNMinutes === 1 ? "Every minute" : `Every ${everyNMinutes} minutes`;
+		const everyNHours = evenStep(hour, 24);
+		const atMinute = plainInt(minute);
+		const pastTheHour = atMinute !== null && atMinute <= 59 ? `:${String(atMinute).padStart(2, "0")}` : null;
+		if (everyNHours !== null && pastTheHour) return everyNHours === 1 ? `Hourly at ${pastTheHour}` : `Every ${everyNHours} hours at ${pastTheHour}`;
+		if (hour === "*" && pastTheHour) return `Hourly at ${pastTheHour}`;
+		const time = timeOfDay(minute, hour);
+		return time ? `Daily at ${time}` : raw;
+	}
+	const time = timeOfDay(minute, hour);
+	if (!time) return raw;
+	if (!anyDayOfWeek) {
+		const days = weekdays(dayOfWeek);
+		return days ? `${days} at ${time}` : raw;
+	}
+	const day = plainInt(dayOfMonth);
+	if (day !== null && day >= 1 && day <= 31) return `Monthly on the ${ordinal(day)} at ${time}`;
+	return raw;
+}
+//#endregion
+//#region src/workflows/format.ts
+/**
+* Display formatters for the workflow graph's live run-state chips. Pure and
+* dependency-free so they can be unit-tested without rendering the graph.
+*/
+/** Human-readable duration: `850ms`, `4.2s`, `1m30s`. Undefined for an absent,
+*  non-finite, or negative input (e.g. clock skew) so the caller renders no
+*  chip rather than a confusing `-5ms`. */
+function fmtDuration(ms) {
+	if (ms === void 0 || !Number.isFinite(ms) || ms < 0) return void 0;
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	const s = ms / 1e3;
+	if (s < 60) return `${s.toFixed(1)}s`;
+	const totalSeconds = Math.round(s);
+	return `${Math.floor(totalSeconds / 60)}m${totalSeconds % 60}s`;
+}
+/** Human-readable USD cost: `$0`, `$0.0032` (sub-cent, 4dp), `$1.20`. Undefined
+*  for an absent, non-finite, or negative input — a cost is a billing amount, so
+*  a negative value is bad data, not a refund to render. */
+function fmtCost(usd) {
+	if (usd === void 0 || !Number.isFinite(usd) || usd < 0) return void 0;
+	if (usd === 0) return "$0";
+	return usd < .01 ? `$${usd.toFixed(4)}` : `$${usd.toFixed(2)}`;
+}
+/** Bound host-supplied preview/error text to a fixed length (with an ellipsis)
+*  before it reaches the DOM, so an oversized payload can't bloat the node tree —
+*  the card only ever shows a short preview, and CSS clamping is visual only.
+*  Truncation is code-point aware: it never slices through a surrogate pair (which
+*  would leave a lone surrogate that renders as the replacement character). */
+function clampPreview(text, max = 200) {
+	if (text.length <= max) return text;
+	const lastCode = text.charCodeAt(max - 1);
+	const end = lastCode >= 55296 && lastCode <= 56319 ? max - 1 : max;
+	return `${text.slice(0, end)}…`;
+}
+/** Human-readable token usage: `1200/340 tok`. Undefined when neither side is a
+*  finite, non-negative count, so the caller renders no chip; an invalid side
+*  (negative / NaN / absent) shows as 0 rather than leaking `-5/NaN tok`. */
+function fmtTokens(input, output) {
+	const valid = (n) => n !== void 0 && Number.isFinite(n) && n >= 0 ? n : void 0;
+	const i = valid(input);
+	const o = valid(output);
+	if (i === void 0 && o === void 0) return void 0;
+	return `${i ?? 0}/${o ?? 0} tok`;
+}
+//#endregion
+//#region src/workflows/naming.ts
+/**
+* Human-facing naming for workflow nodes. A definition addresses things by
+* machine identifier — an action kind (`agent.run`), a hub action path
+* (`github.pulls.reviews.create`), a profile slug (`pr-reviewer`) — and showing
+* those verbatim on a node makes the graph read like a config file. These turn
+* an identifier into the label a person would say out loud.
+*
+* Pure and dependency-free so the naming rules are unit-testable without the
+* YAML parser or a render.
+*/
+/** Identifier fragments that read as an initialism, so they are upper-cased
+*  whole rather than sentence-cased into "Pr" / "Api". */
+const ACRONYMS = /* @__PURE__ */ new Set([
+	"ai",
+	"api",
+	"cd",
+	"ci",
+	"cli",
+	"cpu",
+	"css",
+	"csv",
+	"db",
+	"dns",
+	"gpu",
+	"html",
+	"http",
+	"https",
+	"id",
+	"io",
+	"ip",
+	"json",
+	"llm",
+	"mcp",
+	"ml",
+	"pr",
+	"qa",
+	"sdk",
+	"sla",
+	"sql",
+	"ssh",
+	"ui",
+	"url",
+	"uuid",
+	"vm",
+	"yaml"
+]);
+/** Split a machine identifier into its words, on separators and camelCase humps. */
+function words(id) {
+	return id.replace(/[._\-/]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").trim().split(/\s+/).filter(Boolean);
+}
+/**
+* Humanize a machine identifier: `pr-reviewer` → "PR reviewer", `sandbox.spawn`
+* → "Sandbox spawn", `postMessage` → "Post message". Known initialisms are
+* upper-cased wherever they appear; `lead` picks the case of the rest.
+*
+*  - `sentence` (default): "Create issue comment" — a label or a title.
+*  - `lower`: "create issue comment" — a fragment that sits INSIDE a phrase
+*    ("On pull request"), where a capital would read as a new sentence. An
+*    initialism still wins: `ci_run_completed` → "CI run completed", never
+*    "cI run completed".
+*  - `title`: "Google Sheets" — a brand/proper name.
+*
+* An identifier that carries no word characters is returned verbatim rather than
+* blanked.
+*/
+function humanizeIdentifier(id, lead = "sentence") {
+	const parts = words(id);
+	if (parts.length === 0) return id;
+	return parts.map((word, i) => {
+		const lower = word.toLowerCase();
+		if (ACRONYMS.has(lower)) return lower.toUpperCase();
+		const capitalized = lower.charAt(0).toUpperCase() + lower.slice(1);
+		if (lead === "title") return capitalized;
+		if (i > 0) return lower;
+		return lead === "lower" ? lower : capitalized;
+	}).join(" ");
+}
+/** A model slug without its provider prefix (`anthropic/claude-sonnet-5` →
+*  `claude-sonnet-5`) — the vendor is noise on a card whose width is the scarce
+*  resource, and the full slug stays in the node's config for the detail view. */
+function shortModel(model) {
+	const slash = model.lastIndexOf("/");
+	return slash === -1 ? model : model.slice(slash + 1);
+}
+/** The charset a hub action path is made of (mirrors the server's path schema:
+*  `<provider>.<action…>`, letters/digits/`_`/`-` per segment). A value that
+*  isn't one — most importantly a `${…}` mapping expression, which also contains
+*  dots — must not be split into a bogus provider (whose brand logo we'd then go
+*  and fetch). */
+const ACTION_PATH = /^[a-z0-9_-]+(\.[a-z0-9_-]+)+$/i;
+/** Split a hub action path into provider / resource / operation. Null when the
+*  value isn't a dotted path (a `${…}` expression, or a bare word), so callers
+*  fall back to showing it verbatim instead of inventing structure. */
+function parseActionPath(path) {
+	if (!ACTION_PATH.test(path.trim())) return null;
+	const [provider, ...rest] = path.trim().split(".");
+	return {
+		provider,
+		operation: rest[rest.length - 1],
+		resource: rest.length > 1 ? rest.slice(0, -1).join(".") : void 0
+	};
+}
+/**
+* The operation label for an action path, in n8n's `operation: resource` shape:
+* `github.pulls.reviews.create` → "create: pulls.reviews", `slack.postMessage`
+* → "post message". The provider names the node itself (its title + logo), so
+* it is deliberately absent here. A path we can't split is shown verbatim.
+*/
+function actionPathLabel(path) {
+	const parts = parseActionPath(path);
+	if (!parts) return path;
+	const operation = humanizeIdentifier(parts.operation, "lower");
+	return parts.resource ? `${operation}: ${parts.resource}` : operation;
+}
+//#endregion
+//#region src/workflows/provider-label.ts
+/**
+* Display label for a connector slug ("github" → "GitHub"). Separate from
+* `model.ts` so consumers that only need the label avoid pulling the `yaml`
+* parser (a `model.ts` dependency) into their bundle.
+*/
+const PROVIDER_LABELS = {
+	github: "GitHub",
+	gitlab: "GitLab",
+	slack: "Slack",
+	stripe: "Stripe",
+	notion: "Notion",
+	linear: "Linear",
+	discord: "Discord"
+};
+/**
+* The label above is a curated exception list (brands whose casing no rule
+* predicts: "GitHub", "GitLab"). Everything else is title-cased from its slug —
+* a connector id is multi-word far more often than not (`google-sheets`,
+* `microsoft-teams`), and merely capitalizing the first letter left the node
+* NAMED after the machine identifier: "Google-sheets".
+*/
+function providerLabel(provider) {
+	const key = provider.toLowerCase();
+	return PROVIDER_LABELS[key] ?? humanizeIdentifier(provider, "title");
+}
+//#endregion
+//#region src/workflows/model.ts
+/**
+* Turns a workflow YAML definition into a positioned node/edge graph for the
+* visualizer. Pure and React-Flow-agnostic so the parsing + layout is unit
+* testable on its own; the component maps these shapes onto React Flow nodes.
+*
+* The workflow model is a linear spine (trigger → action → action …) with
+* one-level fan-out: a `parallel` action has N leaf branches and a `foreach`
+* action has one leaf template. Branches dangle to the right of their structural
+* node on the spine; they never continue the chain (the schema forbids nesting),
+* so the spine stays a single readable column.
+*/
+/**
+* Node ids are PUBLIC contract, not an internal detail. A host keys its live
+* `nodeState` by them, points the graph's `selectedNodeId` at one, and — once it
+* supplies a declared topology — names its own edge endpoints with them. They
+* are bare strings, so a host that re-derives the format at the call site gets
+* no type error when the format changes here; the graph simply renders without
+* edges. The format is therefore written in exactly one place (these helpers)
+* and read everywhere else through them.
+*/
+/** The workflow's first (or only) trigger. */
+const TRIGGER_NODE_ID = "trigger";
+const TRIGGER_NODE_ID_PATTERN = new RegExp(`^${TRIGGER_NODE_ID}:(\\d+)$`);
+/** The node for the `index`th entry of a list-form `on:`. Entry 0 IS
+*  {@link TRIGGER_NODE_ID}, so a single-trigger graph — the overwhelmingly
+*  common one — keeps the plain id a host may already have persisted.
+*
+*  `index` is a position in the definition's `on:` list: a non-negative
+*  integer. Anything else formats an id no node bears, which a declared
+*  topology then rejects by name ("…names "trigger:NaN", which this definition
+*  has no step for") — reported there rather than thrown from here, because
+*  {@link buildWorkflowGraph} calls this and must never throw. */
+function triggerNodeId(index) {
+	return index === 0 ? TRIGGER_NODE_ID : `${TRIGGER_NODE_ID}:${index}`;
+}
+/** The `on:` entry a trigger node stands for, or null when the id names
+*  anything else — so a host can tell a trigger from an action without
+*  matching the id format itself. */
+function triggerNodeIndex(nodeId) {
+	if (nodeId === "trigger") return 0;
+	const match = TRIGGER_NODE_ID_PATTERN.exec(nodeId);
+	return match ? Number(match[1]) : null;
+}
+/** The node for the `do` entry at `index`. */
+function actionNodeId(index) {
+	return `a${index}`;
+}
+/** The node for the `branchIndex`th fan-out leaf of the `do` entry at
+*  `actionIndex` — a `parallel` branch or a `foreach` template. */
+function branchNodeId(actionIndex, branchIndex) {
+	return `${actionNodeId(actionIndex)}-b${branchIndex}`;
+}
+/** An edge's id, from its endpoints. Written in ONE place so the graph, the
+*  styling pass and a problem anchored to a pair all name the same edge. */
+function wfEdgeId(source, target) {
+	return `${source}->${target}`;
+}
+/** The loudest severity in a set — one error among warnings makes the whole
+*  anchor read as an error. Null for an empty set, so a caller can skip. */
+function worstSeverity(problems) {
+	if (!problems || problems.length === 0) return null;
+	return problems.every((p) => p.severity === "warning") ? "warning" : "error";
+}
+/** Fixed card width — uniform so every layer is evenly pitched and the cards read
+*  as one system. */
+const NODE_W = 292;
+/** Gap between successive layers along the main axis. */
+const RANK_SEP = 72;
+/** Gap between two nodes stacked in the same layer (branch leaves) along the
+*  cross axis. */
+const CROSS_SEP = 24;
+/**
+* The layer gap a graph uses once its edges carry labels (a guard summary, a
+* cycle badge). An edge label sits in the corridor BETWEEN two layers, so the
+* corridor has to be wide enough to hold one — at the ordinary separations (72
+* expanded, 20 compact) a chip is several times the gap it sits in and spills
+* across the nodes either side.
+*
+* Reserved for the same reason node heights are: the layout renders the label,
+* so the layout owes it room. Sized to the chip's own max width (`max-w-40`,
+* 160px — the chips stack rather than sit side by side, so the widest possible
+* group is one chip) plus breathing space. Applied only to graphs that actually
+* have labelled edges, so nothing else spreads out.
+*/
+const EDGE_LABEL_LANE = 180;
+/** The corridor an edge needs when the canvas draws an INSERT control at its
+*  midpoint: the button plus clearance from the cards either side, so the "+"
+*  never sits on a node. Only widens a gap — a labelled graph's lane is already
+*  bigger. */
+const EDGE_INSERT_LANE = 44;
+/** The two-line, clamped description (agent prompt, notify URL, trigger events). */
+const DESCRIPTION_ROW = 40;
+const WELL_PROSE_LINE = 15.125;
+const WELL_JSON_LINE = 14.4375;
+const WELL_JSON_GAP = 2;
+/** Caption + `mb-1`, `py-1.5`, the border, and the `mt-2` above the well. */
+const WELL_CHROME = 39.5;
+/**
+* Reservation for a well holding `rows` lines, with ~3px of headroom — the same
+* the neighbouring text bands carry against a fractional rendered line.
+*
+* Sized to the TALLER of the two bodies rather than to prose alone. JSON wins
+* from three rows up despite its smaller type, because its gaps accumulate where
+* prose has none (3 rows: 47.3px json vs 45.4px prose) — so sizing off the prose
+* case, which is the one that comes to mind, under-reserves exactly where the
+* card is most crowded.
+*/
+function wellRow(rows) {
+	const body = Math.max(rows * WELL_PROSE_LINE, rows * WELL_JSON_LINE + (rows - 1) * WELL_JSON_GAP);
+	return Math.ceil(WELL_CHROME + body) + 3;
+}
+/**
+* Kinds that route the run rather than do work. `decision` is deliberately NOT
+* here: it carries the same `structural` tone, but it is the one node that stops
+* the run to ask the reader something, and its card has to hold the question.
+*/
+const STRUCTURAL_KINDS = /* @__PURE__ */ new Set(["parallel", "foreach"]);
+function isStructuralKind(kind) {
+	return kind !== void 0 && STRUCTURAL_KINDS.has(kind);
+}
+/** The run status FOOTER pinned to the card's bottom: a top border (1px), the
+*  progress bar (`h-1`, 4px), and a `py-1` caption row whose line box is pinned
+*  (so a node with no rounds/elapsed to report keeps the same footer as one that
+*  has both — otherwise the band's height would drift with its content). */
+const FOOTER_ROW = 28;
+/** LR: the tile, the gap, and a two-line name block (title + subtitle) beneath it
+*  — plus one more line of run metrics once a run is in play, reserved up front so
+*  the merge never reflows. */
+const COMPACT_NODE_SIZE = {
+	width: 168,
+	height: 118
+};
+const COMPACT_NODE_SIZE_RUN = {
+	width: 168,
+	height: 133
+};
+/** TB: the name sits beside the tile, so the box is the tile's height — the name
+*  block (2-3 short lines) is shorter than the tile it sits next to, run state or
+*  not, which is why TB needs no separate run-reserved size. */
+const COMPACT_NODE_SIZE_TB = {
+	width: 236,
+	height: 76
+};
+/**
+* The card's box height. The React Flow node is PINNED to this height (the card
+* fills it via `h-full` inside a node sized to it) and clips overflow, so cards
+* can never overlap regardless of the consumer's fonts — this height IS the
+* layout, not an estimate of the DOM. The row constants are tuned for the
+* library's default token/font config; a consumer whose fonts render a row
+* taller just sees that content clamped within the fixed box, never a reflow.
+* `withRunState` reserves the rows live run state adds (the metrics line, the
+* output block, and the bottom status footer) so the layout — computed ONCE,
+* before any run state is merged in — already leaves room for a node that later
+* runs, and the merge never reflows. A trigger only ever shows a status (no
+* metrics/output/progress), so it's spaced by its static height (`withRunState`
+* false) and the node component skips its footer to match.
+*/
+function nodeHeight(data, withRunState) {
+	if (!withRunState || data.tone === "trigger") return 54 + (data.description ? DESCRIPTION_ROW : 0);
+	if (data.kind === "decision") return 133;
+	if (isStructuralKind(data.kind)) return 104;
+	if (data.kind === "agent.run") return 154;
+	return 54 + wellRow(3) + FOOTER_ROW;
+}
+/**
+* The node box + the layer/lane separators for one density, resolved ONCE per
+* graph. The two travel together: a compact box is much wider than the tile it
+* draws (the name underneath it is), so the separator is only part of the gap a
+* reader actually sees — the box's own margin supplies the rest. Its layers
+* therefore pitch much tighter than the expanded cards', to land at a comparable
+* VISUAL gap rather than a comparable numeric one.
+*
+* `runMode` is the GRAPH's — not the individual node's. Every compact tile is
+* the same box even though a trigger shows no metrics line, because the tile sits
+* at the top of its box: a shorter trigger box would ride its tile up out of line
+* with the row it belongs to. (An expanded card, whose content starts at the top
+* edge either way, is free to be exactly as tall as it needs — see nodeHeight.)
+*/
+function geometry(compact, runMode, direction) {
+	if (compact) {
+		if (direction === "TB") return {
+			size: COMPACT_NODE_SIZE_TB,
+			rankSep: 34,
+			crossSep: 24
+		};
+		return {
+			size: runMode ? COMPACT_NODE_SIZE_RUN : COMPACT_NODE_SIZE,
+			rankSep: 20,
+			crossSep: 20
+		};
+	}
+	return {
+		size: void 0,
+		rankSep: RANK_SEP,
+		crossSep: CROSS_SEP
+	};
+}
+function asRecord(v) {
+	return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function str(v) {
+	return typeof v === "string" && v.trim() !== "" ? v : void 0;
+}
+/** A free-text field as a node DESCRIPTION: bounded, because the card clamps it
+*  to two lines and hangs it in a tooltip — an 8k prompt has no business in
+*  either. The untruncated value stays on `config` for the detail view. */
+function describeText(v) {
+	const text = str(v);
+	return text ? clampPreview(text.trim(), 220) : void 0;
+}
+/** Host of an https URL for a compact `notify` subtitle; the raw value if it
+*  isn't a parseable URL (e.g. a `${...}` expression). */
+function urlHost(url) {
+	try {
+		return new URL(url).host;
+	} catch {
+		return url;
+	}
+}
+/**
+* The keys a `do` entry may carry ALONGSIDE its one action key: the guard, the
+* retry policy, and the failure policy. They are not actions and never name a
+* node.
+*/
+const CONTROL_FLOW_KEYS = [
+	"if",
+	"retry",
+	"onError"
+];
+const CONTROL_FLOW = new Set(CONTROL_FLOW_KEYS);
+/**
+* The action kind a `do` entry declares. A `do` entry is a one-key action map
+* that may also carry the control-flow siblings above, and YAML preserves the
+* author's key order — so `- if: … / agent.run: …` puts `if` first. The kind can
+* therefore never be "the first key": that names a guarded step after its guard.
+*
+* It is whatever is NOT control flow — chosen by EXCLUSION, not by matching a list
+* of kinds we happen to know. An allowlist would silently start naming steps after
+* their guard again the moment the API adds a kind (`agent.review`), since an
+* unknown kind would fall out of the list and the guard would win by position.
+*/
+function actionKind(rec) {
+	return Object.keys(rec).find((k) => !CONTROL_FLOW.has(k));
+}
+/** The SHAPE of an id the platform minted for a stored profile: `ap_` followed by 16
+*  base64url characters (what 12 random bytes encode to). Shape only — it says
+*  nothing about the bytes behind it, and nothing about whether such a profile
+*  exists; the host holds the catalog that could answer either.
+*
+*  What it buys is a title. A minted id names the profile to a DATABASE, not to a
+*  reader — humanising it yields noise ("ap_NROQux-n7dC7Ll30" → "Ap nro qux n7d c7
+*  ll30") — so a node named by one is titled generically instead.
+*
+*  The length is pinned rather than open-ended: `{8,}` would also swallow a slug a
+*  person wrote that happens to start with `ap_` ("ap_code_review"), replacing their
+*  name with a generic one. */
+const MINTED_PROFILE_ID = /^ap_[A-Za-z0-9_-]{16}$/;
+/** The agent's name: a profile named by a readable slug reads as the role it plays
+*  ("pr-reviewer" → "PR reviewer"). An inline profile object, or one named only by
+*  a minted catalog id, has no readable name here — the node is the generic agent
+*  rather than a mangled identifier. */
+function agentTitle(profile) {
+	const named = str(profile);
+	if (!named || MINTED_PROFILE_ID.test(named)) return "AI Agent";
+	return humanizeIdentifier(named);
+}
+/** Build the card-facing node data for a single `do` leaf or top-level action.
+*  The action object is a single-key map (`{ "integration.invoke": {...} }`),
+*  mirroring the YAML schema, optionally alongside control-flow siblings.
+*  Returns the base data WITHOUT the raw `config`. */
+function describeActionBase(action) {
+	const rec = asRecord(action);
+	const kind = actionKind(rec);
+	const cfg = asRecord(kind ? rec[kind] : void 0);
+	switch (kind) {
+		case "sandbox.spawn": return {
+			title: "Sandbox",
+			kind,
+			subtitle: str(cfg.template) ?? "Provision",
+			description: describeText(cfg.prompt),
+			isRoot: false,
+			tone: "action"
+		};
+		case "integration.invoke": {
+			const path = str(cfg.path);
+			const parts = path ? parseActionPath(path) : null;
+			return {
+				title: parts ? providerLabel(parts.provider) : "Integration",
+				kind,
+				subtitle: path ? actionPathLabel(path) : void 0,
+				path,
+				provider: parts?.provider,
+				isRoot: false,
+				tone: "action"
+			};
+		}
+		case "notify": {
+			const url = str(cfg.url);
+			return {
+				title: "Notify",
+				kind,
+				subtitle: url ? urlHost(url) : void 0,
+				description: describeText(url),
+				isRoot: false,
+				tone: "action"
+			};
+		}
+		case "agent.run": {
+			const model = str(cfg.model);
+			return {
+				title: agentTitle(cfg.profile),
+				kind,
+				subtitle: model ? shortModel(model) : "Agent",
+				description: describeText(cfg.prompt),
+				model,
+				isRoot: false,
+				tone: "action"
+			};
+		}
+		case "parallel": {
+			const branches = Array.isArray(cfg.branches) ? cfg.branches : [];
+			return {
+				title: "Parallel",
+				kind,
+				subtitle: `${branches.length} branch${branches.length === 1 ? "" : "es"}`,
+				badge: branches.length > 0 ? `×${branches.length}` : void 0,
+				isRoot: false,
+				tone: "structural"
+			};
+		}
+		case "foreach": return {
+			title: "For each",
+			kind,
+			subtitle: "Repeat per item",
+			description: typeof cfg.items === "string" ? cfg.items : "Literal list",
+			isRoot: false,
+			tone: "structural"
+		};
+		case "decision": {
+			const options = Array.isArray(cfg.options) ? cfg.options.filter((o) => typeof o === "string") : [];
+			return {
+				title: str(cfg.title) ?? "Decision",
+				kind,
+				subtitle: options.length > 0 ? describeText(options.join(" / ")) : "Waits for a human",
+				description: describeText(cfg.prompt),
+				isRoot: false,
+				tone: "structural"
+			};
+		}
+		case "script.run": {
+			const connections = Array.isArray(cfg.connections) ? cfg.connections.filter((c) => typeof c === "string") : [];
+			return {
+				title: "Script",
+				kind,
+				subtitle: connections.length > 0 ? `TypeScript · ${connections.length} connection${connections.length === 1 ? "" : "s"}` : "TypeScript",
+				description: describeText(cfg.source),
+				isRoot: false,
+				tone: "action"
+			};
+		}
+		case "sandbox.snapshot": return {
+			title: "Snapshot",
+			kind,
+			subtitle: str(cfg.sandbox) ?? "Capture a sandbox",
+			isRoot: false,
+			tone: "action"
+		};
+		case "trace.analyze": {
+			const kinds = Array.isArray(cfg.kinds) ? cfg.kinds.filter((k) => typeof k === "string") : [];
+			return {
+				title: "Trace analysis",
+				kind,
+				subtitle: kinds.length > 0 ? describeText(kinds.map((k) => humanizeIdentifier(k, "lower")).join(", ")) : "Default analysts",
+				description: describeText(cfg.trace),
+				isRoot: false,
+				tone: "action"
+			};
+		}
+		default: return {
+			title: kind ? humanizeIdentifier(kind) : "Action",
+			kind: kind ?? "action",
+			isRoot: false,
+			tone: "action"
+		};
+	}
+}
+/** Max nesting depth {@link toJsonSafe} descends before returning a marker. A
+*  real workflow config is a handful of levels deep; this bounds the recursion
+*  far below the JS stack limit so a pathologically deep config yields a marker
+*  instead of a `RangeError`, keeping {@link buildWorkflowGraph}'s no-throw
+*  contract intact (node-building runs outside the parse try/catch). */
+const MAX_CONFIG_DEPTH = 100;
+/** Deep-copy a parsed-config value into a JSON-safe tree for the public `config`
+*  surface. The result is owned by the caller (no references back into the parsed
+*  definition) and is always serializable: cycles — reachable via recursive YAML
+*  anchors — collapse to `"[Circular]"`, nesting beyond {@link MAX_CONFIG_DEPTH}
+*  collapses to `"[Max depth exceeded]"`, and non-JSON values (undefined,
+*  functions, symbols, bigints) are dropped, so a consumer can `JSON.stringify`,
+*  diff, or recursively render the config without throwing. Total by
+*  construction — it never throws, preserving {@link buildWorkflowGraph}'s
+*  no-throw contract. */
+function toJsonSafe(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+	if (value === null) return null;
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value !== "object") return void 0;
+	if (value instanceof Date) return value.toISOString();
+	if (seen.has(value)) return "[Circular]";
+	if (depth >= MAX_CONFIG_DEPTH) return "[Max depth exceeded]";
+	seen.add(value);
+	let out;
+	if (Array.isArray(value)) out = value.map((v) => {
+		const s = toJsonSafe(v, seen, depth + 1);
+		return s === void 0 ? null : s;
+	});
+	else {
+		const obj = {};
+		for (const [k, v] of Object.entries(value)) {
+			const s = toJsonSafe(v, seen, depth + 1);
+			if (s !== void 0) obj[k] = s;
+		}
+		out = obj;
+	}
+	seen.delete(value);
+	return out;
+}
+/** Attach the raw, untruncated `config` to node data for the full-detail view,
+*  but only when non-empty — an empty config is omitted (never `config: {}`), so
+*  action and trigger nodes honor the same "omitted when no config" contract.
+*  The config is normalized to a JSON-safe deep copy ({@link toJsonSafe}) so the
+*  node owns it outright and a consumer can always serialize/render it. */
+function withConfig(base, cfg) {
+	return Object.keys(cfg).length > 0 ? {
+		...base,
+		config: toJsonSafe(cfg)
+	} : base;
+}
+/**
+* Describe one action as node data, attaching the raw, untruncated `config` for a
+* full-detail view on top of the card-facing summary from
+* {@link describeActionBase}.
+*
+* The config carries the action's own fields PLUS any control-flow the entry
+* declares (`if`/`retry`/`onError`), under those names. A step that may be skipped
+* by a guard, or that retries three times, is not the same step as one that does
+* neither — dropping the envelope would leave the two indistinguishable in the
+* detail view, which is the one place that promises every field.
+*/
+function describeAction(action) {
+	const rec = asRecord(action);
+	const kind = actionKind(rec);
+	const base = describeActionBase(action);
+	const config = toJsonSafe(asRecord(kind ? rec[kind] : {}));
+	for (const key of CONTROL_FLOW_KEYS) if (rec[key] !== void 0) config[key] = toJsonSafe(rec[key]);
+	return Object.keys(config).length > 0 ? {
+		...base,
+		config
+	} : base;
+}
+/**
+* A trigger's `scope` in a phrase: which of the provider's things it fires on.
+*
+* The dimension key is the only name available here (the human label lives in
+* the provider catalog, server-side), so it is used as written — `repository`,
+* `channel`. Both directions read as what they mean: a denylist is "all but",
+* an allowlist names its members when there are few enough to be worth naming.
+*
+* Dimensions are read in key order, not in the order the author happened to
+* write them: `Object.entries` follows insertion order, so the same logical
+* scope would otherwise label the node differently depending on how its YAML
+* was typed. Sorted here for the same reason the platform sorts keys when it
+* canonicalises a scope — one scope, one rendering.
+*
+* Compared by code unit rather than `localeCompare`: a dimension id is a
+* machine identifier (`repository`, `channel`), not prose to collate for a
+* reader, and locale-aware ordering would make the rendering depend on the
+* runtime's locale — reintroducing, per viewer, exactly the instability the
+* sort exists to remove.
+*/
+function describeScope(scope) {
+	const rec = asRecord(scope);
+	const parts = [];
+	for (const [dimension, raw] of Object.entries(rec).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+		const selection = asRecord(raw);
+		const except = Array.isArray(selection.except) ? [...new Set(selection.except.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry !== ""))] : [];
+		if (except.length === 0) {
+			if (selection.default === "exclude") parts.push(`${dimension}: none`);
+			continue;
+		}
+		const named = except.length <= 2 ? except.join(", ") : `${except.length} selected`;
+		parts.push(selection.default === "exclude" ? `${dimension}: ${named}` : `${dimension}: all but ${named}`);
+	}
+	return parts.length > 0 ? parts.join(" · ") : void 0;
+}
+/** Describe the `on:` trigger as the spine's root node. */
+function describeTrigger(on) {
+	const rec = asRecord(on);
+	if (rec.provider_event) {
+		const ev = asRecord(rec.provider_event);
+		const connection = str(ev.connection);
+		const event = str(ev.event);
+		const actions = Array.isArray(ev.actions) ? ev.actions.filter((a) => typeof a === "string") : [];
+		const repo = str(ev.repo);
+		const description = describeText([
+			actions.length > 0 ? actions.join(", ") : void 0,
+			repo,
+			describeScope(ev.scope)
+		].filter(Boolean).join(" · "));
+		return withConfig({
+			title: connection ? providerLabel(connection) : "Trigger",
+			kind: "provider_event",
+			subtitle: event ? `On ${humanizeIdentifier(event, "lower")}` : "On an event",
+			description,
+			provider: connection,
+			isRoot: true,
+			tone: "trigger"
+		}, ev);
+	}
+	if (rec.schedule) {
+		const sch = asRecord(rec.schedule);
+		const cron = str(sch.cron);
+		const tz = str(sch.timezone);
+		return withConfig({
+			title: "Schedule",
+			kind: "schedule",
+			subtitle: cron ? describeCron(cron) : "On a timetable",
+			description: cron ? tz ? `${cron} · ${tz}` : cron : void 0,
+			isRoot: true,
+			tone: "trigger"
+		}, sch);
+	}
+	if (rec.webhook !== void 0) return withConfig({
+		title: "Webhook",
+		kind: "webhook",
+		subtitle: "On an inbound POST",
+		isRoot: true,
+		tone: "trigger"
+	}, asRecord(rec.webhook));
+	const [kind] = Object.keys(rec);
+	return withConfig({
+		title: "Trigger",
+		kind: "trigger",
+		subtitle: kind ? humanizeIdentifier(kind) : void 0,
+		isRoot: true,
+		tone: "trigger"
+	}, asRecord(kind ? rec[kind] : void 0));
+}
+/**
+* The shape a folded layout aims for: roughly the proportions of the panels
+* these graphs are shown in (a wide, half-height card). Folding to a target
+* SHAPE rather than a target width is what keeps the layouter free of the
+* canvas — it never measures anything, so a resize can never trigger a
+* relayout, and the framing math still does the fitting.
+*/
+const WRAP_TARGET_ASPECT = 742 / 480;
+/**
+* How many times wider than {@link WRAP_TARGET_ASPECT} a single row must get
+* before it is worth folding. A short pipeline reads best as what it is — one
+* line, left to right — and folding three steps into an L buys legibility
+* nobody needed while making the order something you have to work out. Past
+* this the line is several panels wide and the trade reverses: at four nodes a
+* row still frames at a readable size, at five it does not.
+*
+* The value has to clear a WINDOW, not just land on the right side of one case:
+* a compact node is 118px tall as a definition and 133px once run rows are
+* reserved, which moves a four-node row's aspect between 6.20 and 5.50 and a
+* five-node row's between 7.80 and 6.92. Anything in (6.20, 6.92) — i.e. a
+* multiplier in (4.01, 4.48) — folds the same graph the same way whether or not
+* a run is in play. Sitting at 4.0 does not, and a graph that re-folds the
+* moment a run starts is worse than one that never folds.
+*/
+const WRAP_ASPECT_TRIGGER = 4.2;
+/** The corridor a row change needs. A layer separator is sized for two nodes
+*  standing side by side; stacked rows need enough air that the return bracket
+*  reads as a turn rather than a collision. */
+const WRAP_ROW_GAP = 28;
+/** How many columns fold `count` equal cells closest to {@link
+*  WRAP_TARGET_ASPECT}. Compared in LOG space so being twice too wide and half
+*  too wide are penalised the same — a linear error would always prefer the
+*  wide side. */
+function foldColumns(count, cellW, cellH, colSep, rowSep) {
+	let best = count;
+	let bestError = Number.POSITIVE_INFINITY;
+	for (let cols = 1; cols <= count; cols++) {
+		const rows = Math.ceil(count / cols);
+		const width = cols * cellW + (cols - 1) * colSep;
+		const height = rows * cellH + (rows - 1) * rowSep;
+		const error = Math.abs(Math.log(width / height / WRAP_TARGET_ASPECT));
+		if (error < bestError) {
+			bestError = error;
+			best = cols;
+		}
+	}
+	return best;
+}
+/**
+* Fold a single-file pipeline into ROWS that read boustrophedon — left to
+* right, then right to left on the row below — so consecutive steps stay
+* adjacent and no edge ever travels back across the canvas.
+*
+* One unbounded row is why a long workflow cannot fit its panel: it grows along
+* a single axis while the other sits empty, so framing it whole means zooming
+* until the nodes are specks, and refusing to zoom that far means clipping it.
+* Folding spends the idle axis instead — the eleven steps that need a 2048px
+* row occupy a 732x439 block, which a 742x480 panel frames nearly full size.
+*
+* Returns null unless the graph is a plain LINE, on two counts. Any layer
+* holding more than one node is a fan-out, whose branches already occupy the
+* cross axis the fold needs. And every edge must join one layer to the next: a
+* declared topology may name a shortcut past a step, and mirroring only keeps
+* CONSECUTIVE steps adjacent — a skip that reads as one hop in a straight line
+* becomes a stroke across the middle of a grid. Re-ranking either shape is a
+* different problem from folding a line.
+*/
+function layoutSerpentine(nodes, edges, colSep, laneSep) {
+	const rowSep = Math.max(laneSep, WRAP_ROW_GAP);
+	const byRank = /* @__PURE__ */ new Map();
+	for (const n of nodes) {
+		const arr = byRank.get(n.rank);
+		if (arr) arr.push(n);
+		else byRank.set(n.rank, [n]);
+	}
+	const ranks = [...byRank.keys()].sort((a, b) => a - b);
+	if (ranks.some((r) => byRank.get(r).length !== 1)) return null;
+	const rankOf = new Map(nodes.map((n) => [n.id, n.rank]));
+	const joinsNextLayer = (e) => {
+		const from = rankOf.get(e.source);
+		const to = rankOf.get(e.target);
+		return from !== void 0 && to !== void 0 && to === from + 1;
+	};
+	if (!edges.every(joinsNextLayer)) return null;
+	const ordered = ranks.map((r) => byRank.get(r)[0]);
+	const count = ordered.length;
+	const cellW = Math.max(...ordered.map((n) => n.width));
+	const cellH = Math.max(...ordered.map((n) => n.height));
+	if ((count * cellW + (count - 1) * colSep) / cellH <= WRAP_TARGET_ASPECT * WRAP_ASPECT_TRIGGER) return null;
+	const cols = foldColumns(count, cellW, cellH, colSep, rowSep);
+	if (cols >= count) return null;
+	return ordered.map((node, i) => {
+		const row = Math.floor(i / cols);
+		const indexInRow = i % cols;
+		const leftToRight = row % 2 === 0;
+		const col = leftToRight ? indexInRow : cols - 1 - indexInRow;
+		return {
+			id: node.id,
+			position: {
+				x: col * (cellW + colSep) + (cellW - node.width) / 2,
+				y: row * (cellH + rowSep) + (cellH - node.height) / 2
+			},
+			width: node.width,
+			height: node.height,
+			data: node.data,
+			targetSide: leftToRight ? "left" : "right",
+			sourceSide: leftToRight ? "right" : "left"
+		};
+	});
+}
+/**
+* Position the logical nodes as a layered flow: advance layers along the MAIN
+* axis (x for "LR", y for "TB") and stack each layer's nodes along the CROSS
+* axis, centered on the spine (cross = 0) so a fan-out fans symmetrically and
+* reconverges cleanly. Because dims are authoritative and each layer is pitched
+* by its widest/tallest node plus a separator, layers can never overlap.
+*/
+function layoutLayers(nodes, direction, rankSep, crossSep) {
+	const isLR = direction === "LR";
+	const mainSize = (n) => isLR ? n.width : n.height;
+	const crossSize = (n) => isLR ? n.height : n.width;
+	const byRank = /* @__PURE__ */ new Map();
+	for (const n of nodes) {
+		const arr = byRank.get(n.rank);
+		if (arr) arr.push(n);
+		else byRank.set(n.rank, [n]);
+	}
+	const ranks = [...byRank.keys()].sort((a, b) => a - b);
+	const mainStart = /* @__PURE__ */ new Map();
+	let cursor = 0;
+	for (const r of ranks) {
+		mainStart.set(r, cursor);
+		cursor += Math.max(...byRank.get(r).map(mainSize)) + rankSep;
+	}
+	const out = [];
+	for (const r of ranks) {
+		const layer = byRank.get(r);
+		const extent = Math.max(...layer.map(mainSize));
+		let cross = -(layer.reduce((s, n) => s + crossSize(n), 0) + crossSep * (layer.length - 1)) / 2;
+		for (const n of layer) {
+			const main = mainStart.get(r) + (extent - mainSize(n)) / 2;
+			out.push({
+				id: n.id,
+				position: isLR ? {
+					x: main,
+					y: cross
+				} : {
+					x: cross,
+					y: main
+				},
+				width: n.width,
+				height: n.height,
+				data: n.data
+			});
+			cross += crossSize(n) + crossSep;
+		}
+	}
+	const minX = Math.min(...out.map((n) => n.position.x));
+	const minY = Math.min(...out.map((n) => n.position.y));
+	for (const n of out) n.position = {
+		x: n.position.x - minX,
+		y: n.position.y - minY
+	};
+	return out;
+}
+/**
+* The edges that close a cycle, by edge id — an edge whose target is already on
+* the path that reached it, which is the one edge in a loop that can make a node
+* run twice.
+*
+* The walk starts at the graph's ENTRY POINTS and only then at whatever they
+* miss. Both orders find a correct back edge for every cycle (any DFS does), but
+* only this one picks the edge a reader would point at: entering `a→b→c→a` from
+* its entry marks `c→a`, while starting mid-cycle would just as validly mark
+* `a→b`. Nodes no entry point reaches — a loop closed entirely on itself — are
+* walked afterwards, so every edge is classified either way.
+*/
+function classifyBackEdges(orderedIds, edges) {
+	const outgoing = /* @__PURE__ */ new Map();
+	const hasIncoming = /* @__PURE__ */ new Set();
+	for (const e of edges) {
+		const list = outgoing.get(e.source);
+		if (list) list.push(e);
+		else outgoing.set(e.source, [e]);
+		hasIncoming.add(e.target);
+	}
+	const walkOrder = [...orderedIds.filter((id) => !hasIncoming.has(id)), ...orderedIds.filter((id) => hasIncoming.has(id))];
+	const back = /* @__PURE__ */ new Set();
+	const color = new Map(orderedIds.map((id) => [id, 0]));
+	for (const start of walkOrder) {
+		if (color.get(start) !== 0) continue;
+		color.set(start, 1);
+		const stack = [{
+			id: start,
+			next: 0
+		}];
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			const out = outgoing.get(frame.id);
+			if (!out || frame.next >= out.length) {
+				color.set(frame.id, 2);
+				stack.pop();
+				continue;
+			}
+			const edge = out[frame.next];
+			frame.next += 1;
+			const target = color.get(edge.target);
+			if (target === 1) back.add(edge.id);
+			else if (target === 0) {
+				color.set(edge.target, 1);
+				stack.push({
+					id: edge.target,
+					next: 0
+				});
+			}
+		}
+	}
+	return back;
+}
+/**
+* Layer each node by its LONGEST path from an entry point. Longest, not
+* shortest, is what makes a diamond's two arms meet again in one column: the
+* node both arms lead to sits past the later of them, instead of a layer short
+* with an edge reaching forward over its neighbour.
+*
+* Back edges are excluded — they are what makes the graph cyclic, and layering
+* is defined only on an acyclic one. Removing every DFS back edge always leaves
+* a DAG, so the sweep below drains completely and no node is left unranked.
+*/
+function rankByTopology(orderedIds, edges, backEdgeIds) {
+	const outgoing = /* @__PURE__ */ new Map();
+	const indegree = new Map(orderedIds.map((id) => [id, 0]));
+	for (const e of edges) {
+		if (backEdgeIds.has(e.id)) continue;
+		const list = outgoing.get(e.source);
+		if (list) list.push(e);
+		else outgoing.set(e.source, [e]);
+		indegree.set(e.target, (indegree.get(e.target) ?? 0) + 1);
+	}
+	const rank = new Map(orderedIds.map((id) => [id, 0]));
+	const queue = orderedIds.filter((id) => indegree.get(id) === 0);
+	for (let head = 0; head < queue.length; head += 1) {
+		const id = queue[head];
+		for (const e of outgoing.get(id) ?? []) {
+			rank.set(e.target, Math.max(rank.get(e.target) ?? 0, (rank.get(id) ?? 0) + 1));
+			const remaining = (indegree.get(e.target) ?? 0) - 1;
+			indegree.set(e.target, remaining);
+			if (remaining === 0) queue.push(e.target);
+		}
+	}
+	return rank;
+}
+/** Build a positioned graph from a workflow YAML string. Never throws —
+*  malformed YAML or an empty definition returns an `error` the UI can fall
+*  back on (e.g. show the raw YAML while authoring). `reserveRunState` leaves
+*  room for the rows live run state adds (see {@link nodeHeight}); `direction`
+*  picks the flow axis (default "LR"); `compact` collapses nodes to icon tiles;
+*  `edges` replaces the inferred positional spine with a declared topology. */
+function buildWorkflowGraph(yaml, options) {
+	const reserveRunState = options?.reserveRunState ?? false;
+	const direction = options?.direction ?? "LR";
+	const compact = options?.compact ?? false;
+	const declared = options?.edges;
+	if (!yaml || yaml.trim() === "") return {
+		nodes: [],
+		edges: [],
+		error: "No definition"
+	};
+	let parsed;
+	try {
+		parsed = parse(yaml);
+	} catch {
+		return {
+			nodes: [],
+			edges: [],
+			error: "Invalid YAML"
+		};
+	}
+	const def = asRecord(parsed);
+	const actions = Array.isArray(def.do) ? def.do : [];
+	const triggers = !def.on ? [] : Array.isArray(def.on) ? def.on : [def.on];
+	if (triggers.length === 0 && actions.length === 0) return {
+		nodes: [],
+		edges: [],
+		error: "Empty workflow"
+	};
+	const logical = [];
+	const edges = [];
+	const geo = geometry(compact, reserveRunState, direction);
+	const addNode = (id, data, rank, withRunState) => {
+		const dims = geo.size ?? {
+			width: NODE_W,
+			height: nodeHeight(data, withRunState)
+		};
+		logical.push({
+			id,
+			data,
+			width: dims.width,
+			height: dims.height,
+			rank
+		});
+	};
+	const edgeIds = /* @__PURE__ */ new Set();
+	const addEdge = (source, target, kind, whenLabel) => {
+		const id = wfEdgeId(source, target);
+		if (edgeIds.has(id)) return;
+		edgeIds.add(id);
+		edges.push({
+			id,
+			source,
+			target,
+			kind,
+			...whenLabel ? { whenLabel } : {}
+		});
+	};
+	let rank = 0;
+	let prevExits = [];
+	const branchLeafIds = /* @__PURE__ */ new Set();
+	const triggerIds = triggers.map((_, i) => triggerNodeId(i));
+	triggers.forEach((trigger, i) => {
+		addNode(triggerNodeId(i), describeTrigger(trigger), rank, false);
+	});
+	if (triggers.length > 0) {
+		prevExits = [...triggerIds];
+		rank += 1;
+	}
+	actions.forEach((action, i) => {
+		const id = actionNodeId(i);
+		const data = describeAction(action);
+		if (i === 0 && triggers.length === 0) data.isRoot = true;
+		addNode(id, data, rank, reserveRunState);
+		if (!declared) for (const from of prevExits) addEdge(from, id, branchLeafIds.has(from) ? "join" : "spine");
+		const rec = asRecord(action);
+		const children = "parallel" in rec ? Array.isArray(asRecord(rec.parallel).branches) ? asRecord(rec.parallel).branches : [] : "foreach" in rec ? [asRecord(rec.foreach).do].filter(Boolean) : [];
+		if (children.length > 0) {
+			const branchRank = rank + 1;
+			const branchIds = [];
+			children.forEach((child, j) => {
+				const cid = branchNodeId(i, j);
+				addNode(cid, describeAction(child), branchRank, reserveRunState);
+				addEdge(id, cid, "fork");
+				branchIds.push(cid);
+				branchLeafIds.add(cid);
+			});
+			prevExits = branchIds;
+			rank = branchRank + 1;
+		} else {
+			prevExits = [id];
+			rank += 1;
+		}
+	});
+	if (declared) {
+		const known = new Set(logical.map((n) => n.id));
+		for (const spec of declared) {
+			const missing = !known.has(spec.from) ? spec.from : !known.has(spec.to) ? spec.to : null;
+			if (missing !== null) return {
+				nodes: [],
+				edges: [],
+				error: `Declared topology names "${missing}", which this definition has no step for`
+			};
+			addEdge(spec.from, spec.to, "spine", spec.whenLabel);
+		}
+		const rootward = new Set(edges.map((e) => e.target));
+		for (const n of logical) {
+			if (triggerNodeIndex(n.id) !== null) continue;
+			if (rootward.has(n.id)) continue;
+			for (const triggerId of triggerIds) addEdge(triggerId, n.id, "spine");
+		}
+		const orderedIds = logical.map((n) => n.id);
+		const backEdgeIds = classifyBackEdges(orderedIds, edges);
+		for (const e of edges) if (backEdgeIds.has(e.id)) e.backEdge = true;
+		const rankById = rankByTopology(orderedIds, edges, backEdgeIds);
+		const incoming = new Set(edges.map((e) => e.target));
+		for (const n of logical) {
+			n.rank = rankById.get(n.id) ?? 0;
+			n.data = {
+				...n.data,
+				isRoot: !incoming.has(n.id)
+			};
+		}
+	}
+	const labelled = edges.some((e) => e.whenLabel !== void 0 || e.backEdge === true);
+	const rankSep = labelled ? Math.max(geo.rankSep, EDGE_LABEL_LANE) : options?.reserveEdgeInsert ? Math.max(geo.rankSep, EDGE_INSERT_LANE) : geo.rankSep;
+	return {
+		nodes: (options?.wrap && direction === "LR" && !labelled ? layoutSerpentine(logical, edges, rankSep, geo.crossSep) : null) ?? layoutLayers(logical, direction, rankSep, geo.crossSep),
+		edges,
+		error: null
+	};
+}
+//#endregion
+export { buildWorkflowGraph as a, triggerNodeIndex as c, providerLabel as d, shortModel as f, fmtTokens as g, fmtDuration as h, branchNodeId as i, wfEdgeId as l, fmtCost as m, TRIGGER_NODE_ID as n, isStructuralKind as o, clampPreview as p, actionNodeId as r, triggerNodeId as s, COMPACT_NODE_SIZE as t, worstSeverity as u };