@kekonic/diagrams-core 1.0.0-rc.4

package/dist/index.mjs

@@ -0,0 +1,4966 @@
+//#region src/types/branch.ts
+/**
+* Classify an edge label into a yes/no/neutral branch cue.
+* Only clear affirmative/negative tokens — use `branch: yes|no` for outcome wording.
+*/
+function classifyBranch(label) {
+	if (!label) return "neutral";
+	const normalized = label.trim().toLowerCase();
+	if (/^(yes|y|true|ok)\b/.test(normalized) || normalized === "yes") return "yes";
+	if (/^(no|n|false)\b/.test(normalized) || normalized === "no") return "no";
+	if (/\byes\b/.test(normalized) && !/\bno\b/.test(normalized)) return "yes";
+	if (/\bno\b/.test(normalized) && !/\byes\b/.test(normalized)) return "no";
+	return "neutral";
+}
+function normalizeBranch(value) {
+	if (value === "yes" || value === "no" || value === "neutral") return value;
+}
+//#endregion
+//#region src/animation/infer-auto-animation.ts
+const DEFAULT_FLOW_MS$1 = 500;
+const DEFAULT_PULSE_MS$1 = 650;
+/** Dwell pulse for ordinary nodes between hops. */
+const DEFAULT_NODE_PULSE_MS = 450;
+const DEFAULT_WAIT_MS = 600;
+const DEFAULT_CHAPTER_MS = 350;
+/** Soft cap so dense exclusive-branch DAGs stay watchable. */
+const MAX_AUTO_CHAPTERS = 12;
+/**
+* Infer Automatic animation.
+*
+* - **Exclusive** fan-out (choice nodes / yes·no branches) → one chapter per alternative.
+* - **Parallel** fan-out (everything else) → `parallel` flow cues in a single story.
+*/
+function inferAutoAnimation(graph) {
+	if (graph.diagramKind === "sequence" && graph.sequence) return inferSequenceAutoAnimation(graph);
+	const steps = planAutoWalk(graph);
+	if (steps.length === 0) return null;
+	const cues = [];
+	const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+	let chapterIndex = -1;
+	const pulseFor = (nodeId) => {
+		const node = nodeById.get(nodeId);
+		return {
+			op: "pulse",
+			targets: [{
+				type: "node",
+				id: nodeId
+			}],
+			durationMs: node?.kind === "choice" ? DEFAULT_PULSE_MS$1 : DEFAULT_NODE_PULSE_MS
+		};
+	};
+	for (const step of steps) {
+		if (step.kind === "chapter") {
+			chapterIndex += 1;
+			cues.push({
+				op: "dim",
+				targets: [{ type: "all" }]
+			});
+			if (chapterIndex > 0) cues.push({
+				op: "wait",
+				durationMs: DEFAULT_CHAPTER_MS
+			});
+			continue;
+		}
+		if (step.kind === "enter") {
+			cues.push({
+				op: "activate",
+				targets: [{
+					type: "node",
+					id: step.nodeId
+				}]
+			});
+			cues.push(pulseFor(step.nodeId));
+			continue;
+		}
+		if (step.kind === "enter-many") {
+			const targets = step.nodeIds.map((id) => ({
+				type: "node",
+				id
+			}));
+			cues.push({
+				op: "activate",
+				targets
+			});
+			cues.push({
+				op: "parallel",
+				cues: step.nodeIds.map((id) => pulseFor(id))
+			});
+			continue;
+		}
+		if (step.kind === "edge") {
+			cues.push({
+				op: "flow",
+				path: [step.from, step.to],
+				durationMs: DEFAULT_FLOW_MS$1
+			});
+			continue;
+		}
+		if (step.edges.length === 1) {
+			const e = step.edges[0];
+			cues.push({
+				op: "flow",
+				path: [e.from, e.to],
+				durationMs: DEFAULT_FLOW_MS$1
+			});
+		} else cues.push({
+			op: "parallel",
+			cues: step.edges.map((e) => ({
+				op: "flow",
+				path: [e.from, e.to],
+				durationMs: DEFAULT_FLOW_MS$1
+			}))
+		});
+	}
+	cues.push({
+		op: "wait",
+		durationMs: DEFAULT_WAIT_MS
+	});
+	return {
+		id: "auto",
+		name: "Automatic",
+		loop: false,
+		cues,
+		source: "auto"
+	};
+}
+/**
+* Chaptered walk: exclusive alternatives restart as chapters; concurrent
+* fan-out becomes parallel edge steps within a chapter.
+*/
+function planAutoWalk(graph) {
+	const chapters = enumerateChapterEdgeSets(graph);
+	if (chapters.length === 0) return [];
+	const steps = [];
+	for (const chapter of chapters) {
+		steps.push({ kind: "chapter" });
+		steps.push(...wavefrontSteps(chapter.startId, chapter.edges));
+	}
+	return steps;
+}
+/**
+* Exclusive alternatives as node sequences (parallel siblings linearized in
+* wavefront order). Prefer {@link planAutoWalk} for playback structure.
+*/
+function enumerateAutoPaths(graph) {
+	return enumerateChapterEdgeSets(graph).map((ch) => linearizeChapter(ch.startId, ch.edges));
+}
+/** First-visit node order across Automatic chapters. */
+function traceDeclarationPath(graph) {
+	const seen = /* @__PURE__ */ new Set();
+	const path = [];
+	for (const step of planAutoWalk(graph)) if (step.kind === "enter") {
+		if (seen.has(step.nodeId)) continue;
+		seen.add(step.nodeId);
+		path.push(step.nodeId);
+	} else if (step.kind === "enter-many") for (const id of step.nodeIds) {
+		if (seen.has(id)) continue;
+		seen.add(id);
+		path.push(id);
+	}
+	return path;
+}
+function enumerateChapterEdgeSets(graph) {
+	if (graph.nodes.length === 0) return [];
+	const nodeIds = new Set(graph.nodes.map((n) => n.id));
+	const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+	const outs = buildOuts(graph, nodeIds);
+	const indegree = buildIndegree(graph, nodeIds);
+	const sources = graph.nodes.filter((n) => (indegree.get(n.id) ?? 0) === 0);
+	const startIds = sources.length > 0 ? sources.map((n) => n.id) : [graph.nodes[0].id];
+	const primary = startIds[0];
+	const chapters = [];
+	const pushChapter = (startId, edges) => {
+		if (chapters.length >= MAX_AUTO_CHAPTERS) return;
+		const key = `${startId}|${edges.map((e) => `${e.from}>${e.to}`).join(";")}`;
+		if (chapters.some((c) => `${c.startId}|${c.edges.map((e) => `${e.from}>${e.to}`).join(";")}` === key)) return;
+		chapters.push({
+			startId,
+			edges: dedupeEdges(edges)
+		});
+	};
+	for (const edgeSet of edgeSetsFrom(primary, /* @__PURE__ */ new Set(), nodeById, outs)) {
+		pushChapter(primary, edgeSet);
+		if (chapters.length >= MAX_AUTO_CHAPTERS) break;
+	}
+	const covered = /* @__PURE__ */ new Set();
+	for (const ch of chapters) {
+		covered.add(ch.startId);
+		for (const e of ch.edges) {
+			covered.add(e.from);
+			covered.add(e.to);
+		}
+	}
+	for (const sourceId of startIds.slice(1)) {
+		if (chapters.length >= MAX_AUTO_CHAPTERS) break;
+		const side = [];
+		const seen = /* @__PURE__ */ new Set();
+		let nodeId = sourceId;
+		while (nodeId && !seen.has(nodeId)) {
+			seen.add(nodeId);
+			if (seen.size > 1 && covered.has(nodeId)) break;
+			const nexts = outs.get(nodeId) ?? [];
+			if (nexts.length === 0) break;
+			const out = nexts[0];
+			side.push({
+				from: nodeId,
+				to: out.to
+			});
+			nodeId = out.to;
+		}
+		pushChapter(sourceId, side);
+	}
+	for (const node of graph.nodes) {
+		if (covered.has(node.id)) continue;
+		if (chapters.some((ch) => ch.startId === node.id || ch.edges.some((e) => e.from === node.id || e.to === node.id))) continue;
+		if (chapters.length >= MAX_AUTO_CHAPTERS) break;
+		const sets = edgeSetsFrom(node.id, /* @__PURE__ */ new Set(), nodeById, outs);
+		if (sets.length === 0) pushChapter(node.id, []);
+		else for (const edgeSet of sets) pushChapter(node.id, edgeSet);
+	}
+	return chapters;
+}
+/**
+* Edge-set alternatives from `nodeId`.
+* Exclusive fan-out → multiple sets; parallel fan-out → one set (cartesian if
+* parallel arms themselves contain exclusive forks).
+*/
+function edgeSetsFrom(nodeId, trail, nodeById, outs) {
+	if (trail.has(nodeId)) return [[]];
+	const nextTrail = new Set(trail);
+	nextTrail.add(nodeId);
+	const nexts = outs.get(nodeId) ?? [];
+	if (nexts.length === 0) return [[]];
+	if (isExclusiveFanOut(nodeById.get(nodeId), nexts)) {
+		const result = [];
+		for (const out of nexts) {
+			const hop = {
+				from: nodeId,
+				to: out.to
+			};
+			for (const suffix of edgeSetsFrom(out.to, nextTrail, nodeById, outs)) result.push([hop, ...suffix]);
+		}
+		return result.length > 0 ? result : [[]];
+	}
+	return cartesianConcat(nexts.map((out) => {
+		const hop = {
+			from: nodeId,
+			to: out.to
+		};
+		return edgeSetsFrom(out.to, nextTrail, nodeById, outs).map((suffix) => [hop, ...suffix]);
+	}));
+}
+function cartesianConcat(branches) {
+	if (branches.length === 0) return [[]];
+	let acc = [[]];
+	for (const alts of branches) {
+		const next = [];
+		for (const prefix of acc) for (const alt of alts) next.push([...prefix, ...alt]);
+		acc = next;
+		if (acc.length >= MAX_AUTO_CHAPTERS) break;
+	}
+	return acc;
+}
+function wavefrontSteps(startId, edges) {
+	const steps = [];
+	const remaining = new Set(edges.map((e) => keyOf(e)));
+	const edgeByKey = new Map(edges.map((e) => [keyOf(e), e]));
+	const reached = /* @__PURE__ */ new Set([startId]);
+	steps.push({
+		kind: "enter",
+		nodeId: startId
+	});
+	let guard = edges.length + 2;
+	while (remaining.size > 0 && guard-- > 0) {
+		const ready = [];
+		for (const key of remaining) {
+			const e = edgeByKey.get(key);
+			if (reached.has(e.from)) ready.push(e);
+		}
+		if (ready.length === 0) break;
+		if (ready.length === 1) {
+			const e = ready[0];
+			steps.push({
+				kind: "edge",
+				from: e.from,
+				to: e.to
+			});
+		} else steps.push({
+			kind: "parallel-edges",
+			edges: ready
+		});
+		const newly = [];
+		for (const e of ready) {
+			remaining.delete(keyOf(e));
+			if (!reached.has(e.to)) {
+				reached.add(e.to);
+				newly.push(e.to);
+			}
+		}
+		const uniqueNew = [...new Set(newly)];
+		if (uniqueNew.length === 1) steps.push({
+			kind: "enter",
+			nodeId: uniqueNew[0]
+		});
+		else if (uniqueNew.length > 1) steps.push({
+			kind: "enter-many",
+			nodeIds: uniqueNew
+		});
+	}
+	return steps;
+}
+function linearizeChapter(startId, edges) {
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const step of wavefrontSteps(startId, edges)) if (step.kind === "enter") {
+		if (!seen.has(step.nodeId)) {
+			seen.add(step.nodeId);
+			ids.push(step.nodeId);
+		}
+	} else if (step.kind === "enter-many") for (const id of step.nodeIds) {
+		if (seen.has(id)) continue;
+		seen.add(id);
+		ids.push(id);
+	}
+	return ids;
+}
+/** Choice diamonds / yes·no forks are mutually exclusive stories. */
+function isExclusiveFanOut(node, outs) {
+	if (outs.length < 2) return false;
+	if (node?.kind === "choice") return true;
+	const branches = new Set(outs.map((o) => o.edge.branch ?? classifyBranch(o.edge.label)));
+	return branches.has("yes") && branches.has("no");
+}
+function buildOuts(graph, nodeIds) {
+	const outs = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		if (!nodeIds.has(edge.from) || !nodeIds.has(edge.to)) continue;
+		const list = outs.get(edge.from);
+		if (list) list.push({
+			to: edge.to,
+			edge
+		});
+		else outs.set(edge.from, [{
+			to: edge.to,
+			edge
+		}]);
+	}
+	return outs;
+}
+function buildIndegree(graph, nodeIds) {
+	const indegree = /* @__PURE__ */ new Map();
+	for (const id of nodeIds) indegree.set(id, 0);
+	for (const edge of graph.edges) {
+		if (!nodeIds.has(edge.to)) continue;
+		indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+	}
+	return indegree;
+}
+function dedupeEdges(edges) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const e of edges) {
+		const k = keyOf(e);
+		if (seen.has(k)) continue;
+		seen.add(k);
+		out.push(e);
+	}
+	return out;
+}
+function keyOf(e) {
+	return `${e.from}\0${e.to}`;
+}
+/** Participants with an open activation bar covering this message order. */
+function liveParticipantsAt(activations, order) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const a of activations) if (a.startOrder <= order && order <= a.endOrder) ids.add(a.participantId);
+	return [...ids];
+}
+/**
+* Walk sequence messages in order.
+* Emphasis follows SequenceIR activation spans: when a participant deactivates,
+* we dim and re-activate only the still-live set (plus the hop endpoints).
+*/
+function inferSequenceAutoAnimation(graph) {
+	const seq = graph.sequence;
+	if (!seq || seq.messages.length === 0) return null;
+	const cues = [];
+	let prevEmphasisKey = "";
+	for (const msg of seq.messages) {
+		if (!msg.from || !msg.to || msg.kind === "destroy") continue;
+		const live = liveParticipantsAt(seq.activations, msg.order);
+		const emphasis = new Set(live);
+		emphasis.add(msg.from);
+		emphasis.add(msg.to);
+		const emphasisKey = [...emphasis].sort().join("\0");
+		if (emphasisKey !== prevEmphasisKey) {
+			cues.push({
+				op: "dim",
+				targets: [{ type: "all" }]
+			});
+			cues.push({
+				op: "activate",
+				targets: [...emphasis].map((id) => ({
+					type: "node",
+					id
+				}))
+			});
+			prevEmphasisKey = emphasisKey;
+		}
+		cues.push({
+			op: "flow",
+			path: [msg.from, msg.to],
+			durationMs: DEFAULT_FLOW_MS$1,
+			edgeId: msg.id,
+			edgeIds: [msg.id]
+		});
+		cues.push({
+			op: "pulse",
+			targets: [{
+				type: "node",
+				id: msg.to
+			}],
+			durationMs: DEFAULT_NODE_PULSE_MS
+		});
+	}
+	cues.push({
+		op: "wait",
+		durationMs: DEFAULT_WAIT_MS
+	});
+	return {
+		id: "auto",
+		name: "Automatic",
+		loop: false,
+		cues,
+		source: "auto"
+	};
+}
+//#endregion
+//#region src/animation/bind-sequence-flow-edge-ids.ts
+/**
+* Resolve the concrete edge/message id for hop `i` of a flow cue.
+* `edgeIds` is authoritative and index-aligned with hops; lone `edgeId` only
+* covers hop 0 (single-hop convenience / auto-anim).
+*/
+function flowHopEdgeId(hopIndex, refs) {
+	if (refs.edgeIds && hopIndex < refs.edgeIds.length) return refs.edgeIds[hopIndex];
+	if (hopIndex === 0) return refs.edgeId;
+}
+/** Attach concrete sequence message ids to authored `flow` cues (in place-safe copy). */
+function bindSequenceFlowEdgeIds(graph, cues) {
+	const seq = graph.sequence;
+	if (!seq) return cues;
+	const messages = seq.messages.filter((m) => m.from && m.to && m.kind !== "destroy").slice().sort((a, b) => a.order - b.order);
+	const used = /* @__PURE__ */ new Set();
+	const take = (from, to) => {
+		for (const m of messages) {
+			if (used.has(m.id) || m.from !== from || m.to !== to) continue;
+			used.add(m.id);
+			return m.id;
+		}
+	};
+	const mapCue = (cue) => {
+		if (cue.op === "parallel") return {
+			...cue,
+			cues: cue.cues.map(mapCue)
+		};
+		if (cue.op !== "flow") return cue;
+		if (cue.edgeId || cue.edgeIds && cue.edgeIds.length > 0) return cue;
+		if (cue.path.length < 2) return cue;
+		const hops = cue.path.length - 1;
+		const edgeIds = [];
+		for (let i = 0; i < hops; i++) {
+			const id = take(cue.path[i], cue.path[i + 1]);
+			if (!id) return cue;
+			edgeIds.push(id);
+		}
+		return {
+			...cue,
+			edgeId: edgeIds[0],
+			edgeIds
+		};
+	};
+	return cues.map(mapCue);
+}
+//#endregion
+//#region src/animation/index.ts
+/** Slugify an authored animation name into a stable id. */
+function animationIdFromName(name) {
+	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "animation";
+}
+//#endregion
+//#region src/types/cardinality.ts
+const ALIASES = {
+	"1": "one",
+	one: "one",
+	exactlyone: "one",
+	"0..1": "zeroOrOne",
+	"0:1": "zeroOrOne",
+	"01": "zeroOrOne",
+	zeroorone: "zeroOrOne",
+	optional: "zeroOrOne",
+	"1..n": "oneOrMany",
+	"1..*": "oneOrMany",
+	"1:n": "oneOrMany",
+	"1:*": "oneOrMany",
+	n: "oneOrMany",
+	many: "oneOrMany",
+	"+": "oneOrMany",
+	oneormany: "oneOrMany",
+	"0..n": "zeroOrMany",
+	"0..*": "zeroOrMany",
+	"0:n": "zeroOrMany",
+	"0:*": "zeroOrMany",
+	"*": "zeroOrMany",
+	zeroormany: "zeroOrMany"
+};
+function normalizeToken(raw) {
+	const key = raw.trim().toLowerCase().replace(/\s+/g, "");
+	return ALIASES[key];
+}
+/**
+* Parse cardinality from a property or label.
+*
+* Forms:
+* - `"1:N"` / `"1:0..N"` / `"0..1:N"` (from:to)
+* - Mermaid-ish `"||--o{"` / `"}o--||"`
+* - Single side `"N"` (applied to target; source defaults to `one`)
+*/
+function parseCardinality(raw) {
+	if (raw == null || raw === "") return void 0;
+	if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "boolean") return;
+	const text = String(raw).trim();
+	if (!text) return void 0;
+	const mermaid = parseMermaidCardinality(text);
+	if (mermaid) return mermaid;
+	const parts = text.split(/[:|]/).map((p) => p.trim()).filter(Boolean);
+	if (parts.length >= 2) {
+		const from = normalizeToken(parts[0]);
+		const to = normalizeToken(parts[1]);
+		if (from && to) return {
+			from,
+			to
+		};
+	}
+	const single = normalizeToken(text);
+	if (single) return {
+		from: "one",
+		to: single
+	};
+}
+/**
+* True when a label only encodes cardinality (crow's-foot already conveys it).
+* Shared by finalize (label placement) and SVG (hide duplicate text).
+*/
+function isPureCardinalityLabel(label) {
+	if (!label) return true;
+	const t = label.trim();
+	if (!t) return true;
+	if (parseMermaidCardinality(t)) return true;
+	if (/^(?:1|0\.\.1|1\.\.N|0\.\.N|N|\*):\s*(?:1|0\.\.1|1\.\.N|0\.\.N|N|\*)$/i.test(t)) return true;
+	if (/^(?:\d+\.\.[Nn*]|\d+:[Nn*]|\*|[Nn]|0\.\.[Nn*])$/i.test(t)) return true;
+	if (!parseCardinality(t)) return false;
+	return !/[a-z]/i.test(t.replace(/n/gi, ""));
+}
+function cardinalityLabel(c) {
+	return `${formatSide(c.from)}:${formatSide(c.to)}`;
+}
+function parseMermaidCardinality(text) {
+	const match = text.replace(/\s+/g, "").match(/^([|}{o]+)--([|}{o]+)$/);
+	if (!match) return void 0;
+	const from = mermaidEnd(match[1]);
+	const to = mermaidEnd(match[2]);
+	if (!from || !to) return void 0;
+	return {
+		from,
+		to
+	};
+}
+function mermaidEnd(token) {
+	if (token === "}o" || token === "o{") return "zeroOrMany";
+	if (token === "}|" || token === "|{") return "oneOrMany";
+	if (token === "||") return "one";
+	if (token === "o|" || token === "|o") return "zeroOrOne";
+	if (token === "|") return "one";
+	if (token === "o") return "zeroOrOne";
+}
+function formatSide(c) {
+	switch (c) {
+		case "one": return "1";
+		case "zeroOrOne": return "0..1";
+		case "oneOrMany": return "1..N";
+		case "zeroOrMany": return "0..N";
+	}
+}
+/** Default IE cardinality for a FK from parent → child. */
+function fkCardinality(fkNotNull) {
+	return {
+		from: fkNotNull ? "one" : "zeroOrOne",
+		to: "zeroOrMany"
+	};
+}
+//#endregion
+//#region src/types/table.ts
+const FLAG_TOKENS = /* @__PURE__ */ new Set([
+	"PK",
+	"PRIMARY",
+	"FK",
+	"FOREIGN",
+	"UK",
+	"UNIQUE",
+	"NN",
+	"NOTNULL",
+	"NOT_NULL"
+]);
+/**
+* Parse a compact column spec string into a structured column.
+*
+* Accepted forms (whitespace-separated):
+* - `"id PK uuid"`
+* - `"email text UK NN"`
+* - `"customer_id : uuid FK"`
+* - `"customer_id FK uuid -> customers.id"`
+* - `"status text NN // order lifecycle"` (note after //)
+*
+* Flags: PK, FK, UK/UNIQUE, NN/NOT NULL/NOTNULL (case-insensitive).
+*/
+function parseTableColumnSpec(raw) {
+	let trimmed = raw.trim();
+	if (!trimmed) return null;
+	let note;
+	const noteSplit = trimmed.split(/\s+\/\/\s+/);
+	if (noteSplit.length > 1) {
+		trimmed = noteSplit[0].trim();
+		note = noteSplit.slice(1).join(" // ").trim() || void 0;
+	}
+	let references;
+	const refMatch = trimmed.match(/^(.*?)\s*->\s*([A-Za-z_][\w-]*)\.([A-Za-z_][\w-]*)\s*$/);
+	if (refMatch) {
+		trimmed = refMatch[1].trim();
+		references = {
+			table: refMatch[2],
+			column: refMatch[3]
+		};
+	} else {
+		const refWord = trimmed.match(/^(.*?)\s+(?:ref|references)\s+([A-Za-z_][\w-]*)\.([A-Za-z_][\w-]*)\s*$/i);
+		if (refWord) {
+			trimmed = refWord[1].trim();
+			references = {
+				table: refWord[2],
+				column: refWord[3]
+			};
+		}
+	}
+	const parts = trimmed.replace(/\s*:\s*/g, " ").split(/\s+/).filter(Boolean);
+	if (parts.length === 0) return null;
+	const name = parts[0];
+	const keys = [];
+	let notNull = false;
+	const typeParts = [];
+	for (let i = 1; i < parts.length; i++) {
+		const token = parts[i];
+		const upper = token.toUpperCase();
+		if (upper === "NOT" && parts[i + 1]?.toUpperCase() === "NULL") {
+			notNull = true;
+			i++;
+			continue;
+		}
+		switch (upper) {
+			case "PK":
+			case "PRIMARY":
+				if (!keys.includes("pk")) keys.push("pk");
+				break;
+			case "FK":
+			case "FOREIGN":
+				if (!keys.includes("fk")) keys.push("fk");
+				break;
+			case "UK":
+			case "UNIQUE":
+				if (!keys.includes("uk")) keys.push("uk");
+				break;
+			case "NN":
+			case "NOTNULL":
+			case "NOT_NULL":
+				notNull = true;
+				break;
+			default:
+				if (!FLAG_TOKENS.has(upper)) typeParts.push(token);
+				break;
+		}
+	}
+	if (references && !keys.includes("fk")) keys.push("fk");
+	return {
+		name,
+		type: typeParts.length ? typeParts.join(" ") : void 0,
+		keys,
+		notNull: notNull || void 0,
+		references,
+		note
+	};
+}
+function parseTableColumns(raw) {
+	if (!Array.isArray(raw)) return [];
+	const columns = [];
+	for (const item of raw) {
+		const col = parseTableColumnSpec(String(item));
+		if (col) columns.push(col);
+	}
+	return columns;
+}
+function findColumnIndex(columns, name) {
+	if (!columns) return -1;
+	return columns.findIndex((c) => c.name === name);
+}
+/**
+* Format a structured column as a highlightable line:
+* `customer_id: uuid FK NN -> customers.id // buyer`
+*/
+function formatTableColumnLine(col) {
+	const flags = [];
+	for (const key of col.keys) flags.push(key.toUpperCase());
+	if (col.notNull) flags.push("NN");
+	const rhs = [];
+	if (col.type) rhs.push(col.type);
+	rhs.push(...flags);
+	if (col.references) rhs.push(`-> ${col.references.table}.${col.references.column}`);
+	let line = col.name;
+	if (rhs.length) line += `: ${rhs.join(" ")}`;
+	if (col.note) line += ` // ${col.note}`;
+	return line;
+}
+//#endregion
+//#region src/types/sequence.ts
+/** Map authored keyword (including aliases) → canonical operator. */
+const SEQUENCE_FRAGMENT_ALIASES = {
+	alt: "alternate",
+	alternate: "alternate",
+	opt: "optional",
+	optional: "optional",
+	loop: "loop",
+	par: "parallel",
+	parallel: "parallel",
+	critical: "critical",
+	break: "break",
+	group: "section",
+	section: "section",
+	box: "section"
+};
+/** Title-case label painted on the fragment frame (newcomer-friendly). */
+function sequenceFragmentDisplayName(operator) {
+	switch (operator) {
+		case "alternate": return "Alternate";
+		case "optional": return "Optional";
+		case "loop": return "Loop";
+		case "parallel": return "Parallel";
+		case "critical": return "Critical";
+		case "break": return "Break";
+		case "section": return "Section";
+	}
+}
+function normalizeSequenceFragmentOperator(word) {
+	return SEQUENCE_FRAGMENT_ALIASES[word.toLowerCase()];
+}
+//#endregion
+//#region src/parser/edge-ops.ts
+/** Edge operators — longest first so `<->` / `<..` / `<~` / `-->` win over shorter prefixes. */
+const EDGE_OPS = [
+	"<->",
+	"<..",
+	"<~",
+	"<=",
+	"<-",
+	"x-",
+	"=>",
+	"~>",
+	"..>",
+	"-->",
+	"-x",
+	"->",
+	"--"
+];
+/** Escape for TextMate / Shiki character classes (e.g. `.` in `..>`). */
+function edgeOpsPattern() {
+	return EDGE_OPS.map((op) => op.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+}
+//#endregion
+//#region src/parser/lexer.ts
+/** Soft keywords — statement intros; lexer emits them as identifiers. */
+const STATEMENT_KEYWORDS = /* @__PURE__ */ new Set([
+	"diagram",
+	"state",
+	"sequence",
+	"kdiagram",
+	"group",
+	"boundary",
+	"zone",
+	"swimlane",
+	"direction",
+	"density",
+	"layout",
+	"edges",
+	"render",
+	"presentation",
+	"animation",
+	"style",
+	"is",
+	"for",
+	"edge",
+	"svg",
+	"activate",
+	"deactivate",
+	"create",
+	"destroy",
+	"note",
+	"autonumber",
+	"alt",
+	"alternate",
+	"else",
+	"otherwise",
+	"opt",
+	"optional",
+	"loop",
+	"par",
+	"parallel",
+	"and",
+	"also",
+	"critical",
+	"break",
+	"section",
+	"box",
+	"divider"
+]);
+function tokenize(source, diagnostics = []) {
+	const tokens = [];
+	let i = 0;
+	let line = 1;
+	let column = 1;
+	const makeRange = (start, end) => {
+		const startLine = source.slice(0, start).split("\n").length;
+		const startCol = start - (source.lastIndexOf("\n", start - 1) + 1) + 1;
+		const endLine = source.slice(0, end).split("\n").length;
+		const endCol = end - (source.lastIndexOf("\n", end - 1) + 1) + 1;
+		return {
+			start: {
+				line: startLine,
+				column: startCol,
+				offset: start
+			},
+			end: {
+				line: endLine,
+				column: endCol,
+				offset: end
+			}
+		};
+	};
+	while (i < source.length) {
+		const start = i;
+		if (source[i] === "\n") {
+			tokens.push({
+				type: "newline",
+				value: "\n",
+				range: makeRange(start, ++i)
+			});
+			line++;
+			column = 1;
+			continue;
+		}
+		if (source[i] === " " || source[i] === "	" || source[i] === "\r" || source[i] === ";") {
+			i++;
+			column++;
+			continue;
+		}
+		if (source.slice(i, i + 2) === "//") {
+			i += 2;
+			const commentStart = i;
+			while (i < source.length && source[i] !== "\n") i++;
+			tokens.push({
+				type: "comment",
+				value: source.slice(commentStart, i).trim(),
+				range: makeRange(start, i)
+			});
+			continue;
+		}
+		if (source.slice(i, i + 2) === "/*") {
+			i += 2;
+			while (i < source.length && source.slice(i, i + 2) !== "*/") i++;
+			if (i < source.length) i += 2;
+			continue;
+		}
+		if (source[i] === "[") {
+			tokens.push({
+				type: "lbracket",
+				value: "[",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === "]") {
+			tokens.push({
+				type: "rbracket",
+				value: "]",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === "(") {
+			tokens.push({
+				type: "lparen",
+				value: "(",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === ")") {
+			tokens.push({
+				type: "rparen",
+				value: ")",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === "{") {
+			tokens.push({
+				type: "lbrace",
+				value: "{",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === "}") {
+			tokens.push({
+				type: "rbrace",
+				value: "}",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === ":") {
+			tokens.push({
+				type: "colon",
+				value: ":",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === ",") {
+			tokens.push({
+				type: "comma",
+				value: ",",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === "*") {
+			tokens.push({
+				type: "star",
+				value: "*",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === "#") {
+			let j = i + 1;
+			while (j < source.length && /[0-9a-fA-F]/.test(source[j])) j++;
+			const hexLen = j - i - 1;
+			if (hexLen === 3 || hexLen === 4 || hexLen === 6 || hexLen === 8) {
+				tokens.push({
+					type: "identifier",
+					value: source.slice(i, j),
+					range: makeRange(start, j)
+				});
+				column += j - i;
+				i = j;
+				continue;
+			}
+			diagnostics.push({
+				severity: "error",
+				code: "FM006",
+				message: `Unexpected character "#"`,
+				range: makeRange(start, start + 1),
+				hint: "Use a valid hex color (#rgb, #rrggbb, #rgba, or #rrggbbaa)"
+			});
+			i++;
+			column++;
+			continue;
+		}
+		let matchedEdge = false;
+		for (const op of EDGE_OPS) {
+			if (source.slice(i, i + op.length) !== op) continue;
+			if (op === "--") {
+				const next = source[i + 2];
+				if (next && /[A-Za-z0-9_-]/.test(next)) continue;
+			}
+			tokens.push({
+				type: "edgeOp",
+				value: op,
+				range: makeRange(start, i + op.length)
+			});
+			i += op.length;
+			column += op.length;
+			matchedEdge = true;
+			break;
+		}
+		if (matchedEdge) continue;
+		if (source[i] === ".") {
+			tokens.push({
+				type: "dot",
+				value: ".",
+				range: makeRange(start, ++i)
+			});
+			column++;
+			continue;
+		}
+		if (source[i] === "\"") {
+			i++;
+			let value = "";
+			while (i < source.length && source[i] !== "\"") {
+				if (source[i] === "\\" && i + 1 < source.length) value += source[++i];
+				else value += source[i];
+				i++;
+			}
+			if (i >= source.length || source[i] !== "\"") diagnostics.push({
+				severity: "error",
+				code: "FM007",
+				message: "Unclosed string literal",
+				range: makeRange(start, i)
+			});
+			else i++;
+			tokens.push({
+				type: "string",
+				value,
+				range: makeRange(start, i)
+			});
+			continue;
+		}
+		if (/[0-9]/.test(source[i])) {
+			let value = "";
+			while (i < source.length && /[0-9]/.test(source[i])) value += source[i++];
+			if (source[i] === "." && /[0-9]/.test(source[i + 1] ?? "")) {
+				value += source[i++];
+				while (i < source.length && /[0-9]/.test(source[i])) value += source[i++];
+			}
+			tokens.push({
+				type: "number",
+				value,
+				range: makeRange(start, i)
+			});
+			continue;
+		}
+		if (source[i] === "-" && source[i + 1] === "-" && /[a-zA-Z_]/.test(source[i + 2] ?? "")) {
+			let value = "--";
+			i += 2;
+			while (i < source.length && /[a-zA-Z0-9_-]/.test(source[i])) value += source[i++];
+			tokens.push({
+				type: "identifier",
+				value,
+				range: makeRange(start, i)
+			});
+			continue;
+		}
+		if (/[a-zA-Z_]/.test(source[i])) {
+			let value = "";
+			while (i < source.length && /[a-zA-Z0-9_-]/.test(source[i])) value += source[i++];
+			tokens.push({
+				type: "identifier",
+				value,
+				range: makeRange(start, i)
+			});
+			continue;
+		}
+		diagnostics.push({
+			severity: "error",
+			code: "FM006",
+			message: `Unexpected character "${source[i]}"`,
+			range: makeRange(start, start + 1)
+		});
+		i++;
+		column++;
+	}
+	tokens.push({
+		type: "eof",
+		value: "",
+		range: makeRange(source.length, source.length)
+	});
+	return tokens;
+}
+//#endregion
+//#region src/parser/parser.ts
+function parse(source) {
+	const diagnostics = [];
+	return new Parser(tokenize(source, diagnostics), diagnostics, source).parseDocument();
+}
+var Parser = class {
+	constructor(tokens, diagnostics, source) {
+		this.tokens = tokens;
+		this.diagnostics = diagnostics;
+		this.source = source;
+		this.pos = 0;
+	}
+	peek(offset = 0) {
+		return this.tokens[this.pos + offset] ?? this.tokens[this.tokens.length - 1];
+	}
+	advance() {
+		return this.tokens[this.pos++] ?? this.tokens[this.tokens.length - 1];
+	}
+	at(type, value) {
+		const t = this.peek();
+		return t.type === type && (value === void 0 || t.value === value);
+	}
+	/** Soft keyword / identifier word match. */
+	atWord(value) {
+		const t = this.peek();
+		return t.type === "identifier" && t.value === value;
+	}
+	skipNewlines() {
+		this.skipTrivia();
+	}
+	/** Skip newlines and line comments (trivia). */
+	skipTrivia() {
+		while (this.at("newline") || this.at("comment")) this.advance();
+	}
+	error(code, message, range, hint) {
+		this.diagnostics.push({
+			severity: "error",
+			code,
+			message,
+			range,
+			hint
+		});
+	}
+	parseDocument() {
+		this.skipNewlines();
+		let version;
+		if (this.atWord("kdiagram")) {
+			this.advance();
+			const num = this.advance();
+			if (num.type === "number") version = Number(num.value);
+			this.skipNewlines();
+		}
+		const body = [];
+		while (!this.at("eof")) {
+			this.skipNewlines();
+			if (this.at("eof")) break;
+			if (this.atWord("diagram")) body.push(this.parseDiagram("flow"));
+			else if (this.atWord("state")) body.push(this.parseDiagram("state"));
+			else if (this.atWord("sequence")) body.push(this.parseSequence());
+			else {
+				this.error("FM001", `Unexpected token "${this.peek().value}"`, this.peek().range);
+				this.advance();
+			}
+			this.skipNewlines();
+		}
+		return {
+			type: "Document",
+			version,
+			body,
+			diagnostics: this.diagnostics
+		};
+	}
+	parseSequence() {
+		const start = this.peek().range.start;
+		this.advance();
+		this.skipTrivia();
+		let name;
+		if (this.at("string")) {
+			name = this.advance().value;
+			this.skipTrivia();
+		}
+		if (!this.at("lbrace")) this.error("FM002", "Expected \"{\" to open sequence", this.peek().range);
+		else this.advance();
+		const statements = [];
+		while (!this.at("rbrace") && !this.at("eof")) {
+			this.skipNewlines();
+			if (this.at("rbrace") || this.at("eof")) break;
+			const stmt = this.parseSequenceStatement();
+			if (!stmt) continue;
+			if (Array.isArray(stmt)) statements.push(...stmt);
+			else statements.push(stmt);
+		}
+		if (!this.at("rbrace")) this.error("FM002", "Expected \"}\" to close sequence", this.peek().range);
+		else this.advance();
+		const end = this.tokens[Math.min(this.pos, this.tokens.length - 1)].range.end;
+		return {
+			type: "Sequence",
+			name,
+			statements,
+			range: {
+				start,
+				end
+			}
+		};
+	}
+	parseSequenceStatement() {
+		if (this.at("identifier") && this.peek(1).type === "colon") {
+			const id = this.advance();
+			this.advance();
+			return this.parseNode(id.value, id.range);
+		}
+		if (this.atWord("activate")) return this.parseSequenceActivate();
+		if (this.atWord("deactivate")) return this.parseSequenceDeactivate();
+		if (this.atWord("create")) return this.parseSequenceCreate();
+		if (this.atWord("destroy")) return this.parseSequenceDestroy();
+		if (this.atWord("note")) return this.parseSequenceNote();
+		if (this.atWord("autonumber")) return {
+			type: "SequenceAutonumber",
+			range: this.advance().range
+		};
+		if (this.atWord("divider")) return this.parseSequenceDivider();
+		if (this.atWord("alt") || this.atWord("alternate") || this.atWord("opt") || this.atWord("optional") || this.atWord("loop") || this.atWord("par") || this.atWord("parallel") || this.atWord("critical") || this.atWord("break") || this.atWord("group") || this.atWord("section") || this.atWord("box")) return this.parseSequenceFragment();
+		if (this.atWord("style")) return this.parseStyle();
+		if (this.atWord("direction") || this.atWord("density")) return this.parseDirective();
+		if (this.atWord("layout")) return this.parseLayoutBlock();
+		if (this.atWord("edges")) return this.parseEdgePolicyBlock();
+		if (this.atWord("render")) return this.parseRenderBlock();
+		if (this.atWord("presentation")) return this.parsePresentationBlock();
+		if (this.atWord("animation")) return this.parseAnimationBlock();
+		if (this.at("star") && this.peek(1).type === "edgeOp") {
+			const star = this.advance();
+			return this.parseEdgeChain("*", void 0, star.range);
+		}
+		if (this.at("identifier")) {
+			if (this.looksLikeStyleRef()) return this.parseStyleRefStatement();
+			const id = this.advance();
+			if (this.at("dot") || this.at("edgeOp")) {
+				const from = this.parseQualifiedName(id.value, id.range);
+				return this.parseEdgeChain(from.nodeId, from.column, id.range);
+			}
+			this.error("FM003", `Unexpected identifier "${id.value}"`, id.range);
+			return null;
+		}
+		this.error("FM004", `Unexpected token "${this.peek().value}"`, this.peek().range);
+		this.advance();
+		return null;
+	}
+	parseSequenceActivate() {
+		const startTok = this.advance();
+		const idTok = this.advance();
+		if (idTok.type !== "identifier") {
+			this.error("FM140", "Expected participant id after activate", idTok.range);
+			return {
+				type: "SequenceActivate",
+				participantId: "",
+				range: startTok.range
+			};
+		}
+		return {
+			type: "SequenceActivate",
+			participantId: idTok.value,
+			range: {
+				start: startTok.range.start,
+				end: idTok.range.end
+			}
+		};
+	}
+	parseSequenceDeactivate() {
+		const startTok = this.advance();
+		const idTok = this.advance();
+		if (idTok.type !== "identifier") {
+			this.error("FM141", "Expected participant id after deactivate", idTok.range);
+			return {
+				type: "SequenceDeactivate",
+				participantId: "",
+				range: startTok.range
+			};
+		}
+		return {
+			type: "SequenceDeactivate",
+			participantId: idTok.value,
+			range: {
+				start: startTok.range.start,
+				end: idTok.range.end
+			}
+		};
+	}
+	parseSequenceCreate() {
+		const startTok = this.advance();
+		this.skipTrivia();
+		if (!(this.at("identifier") && this.peek(1).type === "colon")) {
+			this.error("FM142", "Expected `create id: kind \"Label\"`", this.peek().range);
+			return {
+				type: "SequenceCreate",
+				node: {
+					type: "Node",
+					id: "",
+					kind: "participant",
+					properties: {},
+					styleRefs: [],
+					range: startTok.range
+				},
+				range: startTok.range
+			};
+		}
+		const id = this.advance();
+		this.advance();
+		const node = this.parseNode(id.value, id.range);
+		return {
+			type: "SequenceCreate",
+			node,
+			range: {
+				start: startTok.range.start,
+				end: node.range.end
+			}
+		};
+	}
+	parseSequenceDestroy() {
+		const startTok = this.advance();
+		const idTok = this.advance();
+		if (idTok.type !== "identifier") {
+			this.error("FM143", "Expected participant id after destroy", idTok.range);
+			return {
+				type: "SequenceDestroy",
+				participantId: "",
+				range: startTok.range
+			};
+		}
+		return {
+			type: "SequenceDestroy",
+			participantId: idTok.value,
+			range: {
+				start: startTok.range.start,
+				end: idTok.range.end
+			}
+		};
+	}
+	parseSequenceNote() {
+		const startTok = this.advance();
+		this.skipTrivia();
+		let placement = "over";
+		if (this.atWord("over")) {
+			this.advance();
+			placement = "over";
+		} else if (this.atWord("left")) {
+			this.advance();
+			this.skipTrivia();
+			if (this.atWord("of")) this.advance();
+			placement = "left";
+		} else if (this.atWord("right")) {
+			this.advance();
+			this.skipTrivia();
+			if (this.atWord("of")) this.advance();
+			placement = "right";
+		} else this.error("FM144", "Expected note placement (over | left of | right of)", this.peek().range);
+		this.skipTrivia();
+		const participantIds = [];
+		while (this.at("identifier")) {
+			participantIds.push(this.advance().value);
+			this.skipTrivia();
+			if (this.at("comma")) {
+				this.advance();
+				this.skipTrivia();
+				continue;
+			}
+			break;
+		}
+		let text = "";
+		if (this.at("string")) text = this.advance().value;
+		else this.error("FM145", "Expected note text string", this.peek().range);
+		return {
+			type: "SequenceNote",
+			placement,
+			participantIds,
+			text,
+			range: {
+				start: startTok.range.start,
+				end: this.peek(-1)?.range.end ?? startTok.range.end
+			}
+		};
+	}
+	parseSequenceDivider() {
+		const startTok = this.advance();
+		this.skipTrivia();
+		let label;
+		if (this.at("string")) label = this.advance().value;
+		return {
+			type: "SequenceDivider",
+			label,
+			range: {
+				start: startTok.range.start,
+				end: this.peek(-1)?.range.end ?? startTok.range.end
+			}
+		};
+	}
+	parseSequenceFragment() {
+		const startTok = this.peek();
+		const operator = normalizeSequenceFragmentOperator(startTok.value) ?? "section";
+		this.advance();
+		this.skipTrivia();
+		let label;
+		if (this.at("string")) {
+			label = this.advance().value;
+			this.skipTrivia();
+		}
+		const styleRefs = this.parseOptionalIsStyleRefs();
+		this.skipTrivia();
+		const operands = [];
+		const first = this.parseSequenceFragmentBody(label, styleRefs);
+		operands.push(first);
+		while (operator === "alternate" && (this.atWord("else") || this.atWord("otherwise")) || operator === "parallel" && (this.atWord("and") || this.atWord("also"))) {
+			this.advance();
+			this.skipTrivia();
+			let opLabel;
+			if (this.at("string")) {
+				opLabel = this.advance().value;
+				this.skipTrivia();
+			}
+			const opStyleRefs = this.parseOptionalIsStyleRefs();
+			this.skipTrivia();
+			operands.push(this.parseSequenceFragmentBody(opLabel, opStyleRefs));
+		}
+		return {
+			type: "SequenceFragment",
+			operator,
+			label,
+			styleRefs,
+			operands,
+			range: {
+				start: startTok.range.start,
+				end: this.peek(-1)?.range.end ?? startTok.range.end
+			}
+		};
+	}
+	parseSequenceFragmentBody(label, styleRefs = []) {
+		const start = this.peek().range.start;
+		if (!this.at("lbrace")) {
+			this.error("FM146", "Expected \"{\" to open fragment body", this.peek().range);
+			return {
+				label,
+				styleRefs,
+				statements: [],
+				range: this.peek().range
+			};
+		}
+		this.advance();
+		const statements = [];
+		while (!this.at("rbrace") && !this.at("eof")) {
+			this.skipNewlines();
+			if (this.at("rbrace") || this.at("eof")) break;
+			const stmt = this.parseSequenceStatement();
+			if (!stmt) continue;
+			if (Array.isArray(stmt)) statements.push(...stmt);
+			else statements.push(stmt);
+		}
+		if (!this.at("rbrace")) this.error("FM146", "Expected \"}\" to close fragment body", this.peek().range);
+		else this.advance();
+		return {
+			label,
+			styleRefs,
+			statements,
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? start
+			}
+		};
+	}
+	parseDiagram(diagramKind) {
+		const start = this.peek().range.start;
+		this.advance();
+		this.skipTrivia();
+		let name;
+		if (this.at("string")) {
+			name = this.advance().value;
+			this.skipTrivia();
+		}
+		if (!this.at("lbrace")) this.error("FM002", `Expected "{" to open ${diagramKind} diagram`, this.peek().range);
+		else this.advance();
+		const statements = [];
+		while (!this.at("rbrace") && !this.at("eof")) {
+			this.skipNewlines();
+			if (this.at("rbrace") || this.at("eof")) break;
+			const stmt = this.parseStatement(true);
+			if (!stmt) continue;
+			if (Array.isArray(stmt)) statements.push(...stmt);
+			else statements.push(stmt);
+		}
+		if (!this.at("rbrace")) this.error("FM002", "Expected \"}\" to close diagram", this.peek().range);
+		else this.advance();
+		const end = this.tokens[Math.min(this.pos, this.tokens.length - 1)].range.end;
+		return {
+			type: "Diagram",
+			diagramKind,
+			name,
+			statements,
+			range: {
+				start,
+				end
+			}
+		};
+	}
+	parseStatement(inGroup = false) {
+		if (this.at("identifier") && this.peek(1).type === "colon") {
+			if (inGroup && isGroupLayoutHint(this.peek().value)) return this.parseDirective();
+			const id = this.advance();
+			this.advance();
+			return this.parseNode(id.value, id.range);
+		}
+		if (this.atWord("group") || this.atWord("boundary") || this.atWord("zone") || this.atWord("swimlane")) return this.parseGroup();
+		if (this.atWord("style")) return this.parseStyle();
+		if (this.atWord("direction") || this.atWord("density")) return this.parseDirective();
+		if (this.atWord("layout")) return this.parseLayoutBlock();
+		if (this.atWord("edges")) return this.parseEdgePolicyBlock();
+		if (this.atWord("render")) return this.parseRenderBlock();
+		if (this.atWord("presentation")) return this.parsePresentationBlock();
+		if (this.atWord("animation")) return this.parseAnimationBlock();
+		if (this.at("identifier")) {
+			if (this.looksLikeStyleRef()) return this.parseStyleRefStatement();
+			if (inGroup && this.looksLikeGroupMember()) return this.parseGroupMemberList();
+			const id = this.advance();
+			if (this.at("dot") || this.at("edgeOp")) {
+				const from = this.parseQualifiedName(id.value, id.range);
+				return this.parseEdgeChain(from.nodeId, from.column, id.range);
+			}
+			this.error("FM003", `Unexpected identifier "${id.value}"`, id.range);
+			return null;
+		}
+		this.error("FM004", `Unexpected token "${this.peek().value}"`, this.peek().range);
+		this.advance();
+		return null;
+	}
+	parseNode(id, idRange) {
+		const start = idRange.start;
+		const kindTok = this.advance();
+		const kind = kindTok.value;
+		let label;
+		if (this.at("string")) label = this.advance().value;
+		const styleRefs = this.parseOptionalIsStyleRefs();
+		const properties = this.parseOptionalProperties();
+		styleRefs.push(...this.parseOptionalIsStyleRefs());
+		const end = this.peek(-1)?.range.end ?? kindTok.range.end;
+		return {
+			type: "Node",
+			id,
+			kind,
+			label,
+			properties,
+			styleRefs,
+			range: {
+				start,
+				end
+			}
+		};
+	}
+	parseOptionalIsStyleRefs() {
+		const refs = [];
+		while (this.atWord("is")) {
+			this.advance();
+			const styleTok = this.advance();
+			if (styleTok.type !== "identifier") {
+				this.error("FM008", "Expected style name after \"is\"", styleTok.range);
+				break;
+			}
+			refs.push(styleTok.value);
+		}
+		return refs;
+	}
+	parseQualifiedName(firstId, _firstRange) {
+		if (!this.at("dot")) return { nodeId: firstId };
+		this.advance();
+		const colTok = this.advance();
+		if (colTok.type !== "identifier") {
+			this.error("FM007", "Expected column name after '.'", colTok.range);
+			return { nodeId: firstId };
+		}
+		return {
+			nodeId: firstId,
+			column: colTok.value
+		};
+	}
+	parseEdgeChain(from, fromColumn, fromRange) {
+		const edges = [];
+		let currentFrom = from;
+		let currentFromColumn = fromColumn;
+		let chainStart = fromRange.start;
+		while (this.at("edgeOp")) {
+			const opTok = this.advance();
+			let toNodeId;
+			let toColumn;
+			let toRange;
+			if (this.at("star")) {
+				const star = this.advance();
+				toNodeId = "*";
+				toRange = star.range;
+			} else {
+				const toTok = this.advance();
+				if (toTok.type !== "identifier") {
+					this.error("FM005", "Expected target node id after edge operator", toTok.range, "Add a target node id after the edge operator.");
+					break;
+				}
+				const to = this.parseQualifiedName(toTok.value, toTok.range);
+				toNodeId = to.nodeId;
+				toColumn = to.column;
+				toRange = toTok.range;
+			}
+			let label;
+			if (this.at("string")) label = this.advance().value;
+			const properties = this.parseOptionalProperties();
+			const end = this.peek(-1)?.range.end ?? toRange.end;
+			edges.push({
+				type: "Edge",
+				from: currentFrom,
+				to: toNodeId,
+				fromColumn: currentFromColumn,
+				toColumn,
+				op: opTok.value,
+				label,
+				properties,
+				styleRefs: [],
+				range: {
+					start: chainStart,
+					end
+				}
+			});
+			currentFrom = toNodeId;
+			currentFromColumn = toColumn;
+			chainStart = toRange.start;
+			if (this.atWord("is")) {
+				this.advance();
+				const styleTok = this.advance();
+				edges[edges.length - 1].styleRefs.push(styleTok.value);
+			}
+		}
+		return edges;
+	}
+	looksLikeStyleRef() {
+		let p = this.pos;
+		while (this.tokens[p]?.type === "identifier") {
+			p++;
+			if (this.tokens[p]?.type === "comma") {
+				p++;
+				continue;
+			}
+			break;
+		}
+		const t = this.tokens[p];
+		return t?.type === "identifier" && t.value === "is";
+	}
+	looksLikeGroupMember() {
+		if (!this.at("identifier")) return false;
+		const next = this.peek(1);
+		if (next.type === "colon" || next.type === "edgeOp" || next.type === "dot") return false;
+		if (next.type === "identifier" && next.value === "is") return false;
+		return true;
+	}
+	parseStyleRefStatement() {
+		const start = this.peek().range.start;
+		const targetIds = [this.advance().value];
+		while (this.at("comma")) {
+			this.advance();
+			targetIds.push(this.advance().value);
+		}
+		this.advance();
+		return {
+			type: "StyleRef",
+			targetIds,
+			styleName: this.advance().value,
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? start
+			}
+		};
+	}
+	parseGroupMemberList() {
+		const start = this.peek().range.start;
+		const nodeIds = [this.advance().value];
+		while (this.at("comma")) {
+			this.advance();
+			nodeIds.push(this.advance().value);
+		}
+		return {
+			type: "GroupMember",
+			nodeIds,
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? start
+			}
+		};
+	}
+	parseGroup() {
+		const start = this.peek().range.start;
+		const kindTok = this.advance();
+		const groupKind = kindTok.value;
+		let id;
+		let label;
+		if (this.at("identifier")) id = this.advance().value;
+		if (this.at("string")) label = this.advance().value;
+		const properties = {};
+		if (this.at("lbrace")) {
+			this.advance();
+			const statements = [];
+			while (!this.at("rbrace") && !this.at("eof")) {
+				this.skipNewlines();
+				if (this.at("rbrace") || this.at("eof")) break;
+				const stmt = this.parseStatement(true);
+				if (!stmt) continue;
+				if (Array.isArray(stmt)) statements.push(...stmt);
+				else statements.push(stmt);
+			}
+			if (this.at("rbrace")) this.advance();
+			const end = this.peek(-1)?.range.end ?? kindTok.range.end;
+			return {
+				type: "Group",
+				id,
+				label,
+				groupKind,
+				statements,
+				properties,
+				range: {
+					start,
+					end
+				}
+			};
+		}
+		this.error("FM006", "Expected { after group declaration", this.peek().range);
+		return {
+			type: "Group",
+			id,
+			label,
+			groupKind,
+			statements: [],
+			properties,
+			range: {
+				start,
+				end: kindTok.range.end
+			}
+		};
+	}
+	parseStyle() {
+		const start = this.advance().range.start;
+		const nameTok = this.advance();
+		const name = nameTok.value;
+		let target = "node";
+		if (this.atWord("for")) {
+			this.advance();
+			if (this.atWord("edge")) {
+				this.advance();
+				target = "edge";
+			} else if (this.atWord("fragment")) {
+				this.advance();
+				target = "fragment";
+			}
+		}
+		const properties = this.parseBlockProperties();
+		return {
+			type: "Style",
+			name,
+			target,
+			properties,
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? nameTok.range.end
+			}
+		};
+	}
+	parseDirective() {
+		const keywordTok = this.advance();
+		const start = keywordTok.range.start;
+		const name = keywordTok.value;
+		let value;
+		if (this.at("colon")) this.advance();
+		if (this.at("lbracket")) value = this.parseIdentifierList();
+		else if (!this.at("newline") && !this.at("comment") && !this.at("rbrace") && !this.at("eof")) value = this.parsePropertyValue();
+		return {
+			type: "Directive",
+			name,
+			value,
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? keywordTok.range.end
+			}
+		};
+	}
+	parseLayoutBlock() {
+		const start = this.advance().range.start;
+		return {
+			type: "LayoutBlock",
+			properties: this.parseBlockProperties(),
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? {
+					line: 1,
+					column: 1,
+					offset: 0
+				}
+			}
+		};
+	}
+	parseEdgePolicyBlock() {
+		const start = this.advance().range.start;
+		return {
+			type: "EdgePolicyBlock",
+			properties: this.parseBlockProperties(),
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? {
+					line: 1,
+					column: 1,
+					offset: 0
+				}
+			}
+		};
+	}
+	parseRenderBlock() {
+		const start = this.advance().range.start;
+		return {
+			type: "RenderBlock",
+			properties: this.at("lbrace") ? this.parseBlockProperties() : {},
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? {
+					line: 1,
+					column: 1,
+					offset: 0
+				}
+			}
+		};
+	}
+	parsePresentationBlock() {
+		const start = this.advance().range.start;
+		return {
+			type: "PresentationBlock",
+			properties: this.at("lbrace") ? this.parseBlockProperties() : {},
+			range: {
+				start,
+				end: this.peek(-1)?.range.end ?? {
+					line: 1,
+					column: 1,
+					offset: 0
+				}
+			}
+		};
+	}
+	parseAnimationBlock() {
+		const startTok = this.advance();
+		this.skipTrivia();
+		let name = "Animation";
+		if (this.at("string")) {
+			name = this.advance().value;
+			this.skipTrivia();
+		} else this.error("FM120", "Expected quoted animation name after `animation`", this.peek().range);
+		if (!this.at("lbrace")) {
+			this.error("FM121", "Expected \"{\" to open animation block", this.peek().range);
+			return {
+				type: "AnimationBlock",
+				name,
+				cues: [],
+				range: {
+					start: startTok.range.start,
+					end: startTok.range.end
+				}
+			};
+		}
+		this.advance();
+		const cues = [];
+		while (!this.at("rbrace") && !this.at("eof")) {
+			this.skipTrivia();
+			if (this.at("rbrace") || this.at("eof")) break;
+			const cue = this.parseAnimationCue();
+			if (cue) cues.push(cue);
+		}
+		if (this.at("rbrace")) this.advance();
+		else this.error("FM121", "Expected \"}\" to close animation block", this.peek().range);
+		return {
+			type: "AnimationBlock",
+			name,
+			cues,
+			range: {
+				start: startTok.range.start,
+				end: this.peek(-1)?.range.end ?? startTok.range.end
+			}
+		};
+	}
+	parseAnimationCue() {
+		const start = this.peek().range;
+		if (this.atWord("loop")) {
+			this.advance();
+			return {
+				type: "loop",
+				range: start
+			};
+		}
+		if (this.atWord("wait")) {
+			this.advance();
+			return {
+				type: "wait",
+				durationMs: this.parseDurationMs() ?? 400,
+				range: {
+					start: start.start,
+					end: this.peek(-1)?.range.end ?? start.end
+				}
+			};
+		}
+		if (this.atWord("parallel")) {
+			this.advance();
+			this.skipTrivia();
+			if (!this.at("lbrace")) {
+				this.error("FM121", "Expected \"{\" to open parallel animation group", this.peek().range);
+				return null;
+			}
+			this.advance();
+			const cues = [];
+			while (!this.at("rbrace") && !this.at("eof")) {
+				this.skipTrivia();
+				if (this.at("rbrace") || this.at("eof")) break;
+				if (this.atWord("parallel")) {
+					this.error("FM130", "Nested parallel groups are not supported", this.peek().range, "Keep parallel groups one level deep");
+					this.advance();
+					continue;
+				}
+				if (this.atWord("loop")) {
+					this.error("FM129", "`loop` belongs on the animation block, not inside parallel", this.peek().range);
+					this.advance();
+					continue;
+				}
+				const cue = this.parseAnimationCue();
+				if (cue) cues.push(cue);
+			}
+			if (this.at("rbrace")) this.advance();
+			else this.error("FM121", "Expected \"}\" to close parallel group", this.peek().range);
+			return {
+				type: "parallel",
+				cues,
+				range: {
+					start: start.start,
+					end: this.peek(-1)?.range.end ?? start.end
+				}
+			};
+		}
+		if (this.atWord("dim") || this.atWord("activate") || this.atWord("pulse")) {
+			const op = this.advance().value;
+			const targets = this.parseAnimationTargets();
+			let durationMs;
+			if (op === "pulse" && this.atWord("for")) {
+				this.advance();
+				durationMs = this.parseDurationMs();
+			}
+			const range = {
+				start: start.start,
+				end: this.peek(-1)?.range.end ?? start.end
+			};
+			if (op === "pulse") return {
+				type: "pulse",
+				targets,
+				durationMs,
+				range
+			};
+			return {
+				type: op,
+				targets,
+				range
+			};
+		}
+		if (this.atWord("flow")) {
+			this.advance();
+			const path = this.parseAnimationPath();
+			let durationMs;
+			if (this.atWord("for")) {
+				this.advance();
+				durationMs = this.parseDurationMs();
+			}
+			return {
+				type: "flow",
+				path,
+				durationMs,
+				range: {
+					start: start.start,
+					end: this.peek(-1)?.range.end ?? start.end
+				}
+			};
+		}
+		this.error("FM122", `Unexpected animation cue "${this.peek().value}"`, this.peek().range, "Expected dim, activate, pulse, flow, wait, parallel, or loop");
+		this.advance();
+		return null;
+	}
+	parseAnimationTargets() {
+		const targets = [];
+		for (;;) {
+			this.skipTrivia();
+			if (this.at("star")) {
+				this.advance();
+				targets.push({ type: "all" });
+			} else if (this.at("identifier")) {
+				const from = this.advance().value;
+				if (this.at("edgeOp") && this.peek().value === "->") {
+					this.advance();
+					if (!this.at("identifier")) {
+						this.error("FM123", "Expected node id after `->` in animation target", this.peek().range);
+						break;
+					}
+					const to = this.advance().value;
+					targets.push({
+						type: "edge",
+						from,
+						to
+					});
+				} else targets.push({
+					type: "node",
+					id: from
+				});
+			} else break;
+			this.skipTrivia();
+			if (this.at("comma")) {
+				this.advance();
+				continue;
+			}
+			break;
+		}
+		if (targets.length === 0) this.error("FM124", "Expected animation target (* or node id)", this.peek().range);
+		return targets;
+	}
+	parseAnimationPath() {
+		const path = [];
+		if (!this.at("identifier")) {
+			this.error("FM125", "Expected node id to start flow path", this.peek().range);
+			return path;
+		}
+		path.push(this.advance().value);
+		while (this.at("edgeOp") && this.peek().value === "->") {
+			this.advance();
+			if (!this.at("identifier")) {
+				this.error("FM125", "Expected node id after `->` in flow path", this.peek().range);
+				break;
+			}
+			path.push(this.advance().value);
+		}
+		if (path.length < 2) this.error("FM126", "flow path needs at least two node ids (a -> b)", this.peek().range);
+		return path;
+	}
+	/** Parse `800ms`, `1.5s`, or bare number (milliseconds). */
+	parseDurationMs() {
+		if (!this.at("number")) {
+			this.error("FM127", "Expected duration (e.g. 800ms or 1.5s)", this.peek().range);
+			return;
+		}
+		const n = Number(this.advance().value);
+		if (!Number.isFinite(n)) return void 0;
+		if (this.at("identifier") && (this.peek().value === "ms" || this.peek().value === "s")) return this.advance().value === "s" ? Math.round(n * 1e3) : Math.round(n);
+		return Math.round(n);
+	}
+	parseBlockProperties() {
+		const props = {};
+		if (!this.at("lbrace")) return props;
+		this.advance();
+		while (!this.at("rbrace") && !this.at("eof")) {
+			this.skipTrivia();
+			if (this.at("identifier")) {
+				const key = this.advance().value;
+				if (this.at("colon")) this.advance();
+				if (key === "columns" && this.at("lbrace")) {
+					props[key] = this.parseColumnsBlock();
+					continue;
+				}
+				if (this.at("lbracket")) {
+					props[key] = this.parseIdentifierList();
+					continue;
+				}
+				if (this.at("newline") || this.at("comment") || this.at("rbrace") || this.at("eof")) continue;
+				props[key] = key.startsWith("--") || key === "iconColor" ? this.parseCssValue() : this.parsePropertyValue();
+			} else if (!this.at("rbrace")) this.advance();
+		}
+		if (this.at("rbrace")) this.advance();
+		return props;
+	}
+	/**
+	* Property values: numbers, booleans, strings, identifiers,
+	* and qualified ids like `lucide:user` / `logos:aws`.
+	*/
+	parsePropertyValue() {
+		const val = this.advance();
+		if (val.type === "number") return Number(val.value);
+		if (val.value === "true" || val.value === "false") return val.value === "true";
+		if (val.type === "string") return val.value;
+		let text = val.value;
+		while (this.at("colon") && this.peek(1).type === "identifier") {
+			this.advance();
+			text += `:${this.advance().value}`;
+		}
+		return text;
+	}
+	/**
+	* CSS custom-property values on a style/node — slice source through end of line so
+	* `#hex`, `var(...)`, and `color-mix(...)` keep spaces and punctuation.
+	*/
+	parseCssValue() {
+		if (this.at("string")) return this.advance().value;
+		if (this.at("newline") || this.at("comment") || this.at("rbrace") || this.at("eof")) return "";
+		const start = this.peek().range.start.offset;
+		let end = start;
+		while (!this.at("newline") && !this.at("comment") && !this.at("rbrace") && !this.at("eof")) end = this.advance().range.end.offset;
+		return this.source.slice(start, end).trim();
+	}
+	/**
+	* Parse `columns { name: type FLAGS … }` into compact column specs
+	* (same strings `parseTableColumnSpec` already understands).
+	*/
+	parseColumnsBlock() {
+		const cols = [];
+		if (!this.at("lbrace")) return cols;
+		this.advance();
+		while (!this.at("rbrace") && !this.at("eof")) {
+			this.skipTrivia();
+			if (this.at("rbrace") || this.at("eof")) break;
+			if (this.peek().type !== "identifier") {
+				this.error("FM113", "Expected column name in columns block", this.peek().range);
+				this.advance();
+				continue;
+			}
+			const nameTok = this.advance();
+			if (this.at("colon")) this.advance();
+			const parts = [];
+			while (!this.at("newline") && !this.at("comment") && !this.at("rbrace") && !this.at("eof") && !this.at("comma")) {
+				const t = this.advance();
+				parts.push(t.value);
+			}
+			let note;
+			if (this.at("comment")) note = this.advance().value || void 0;
+			if (this.at("comma")) this.advance();
+			const body = joinColumnParts(parts);
+			const spec = note ? `${nameTok.value}: ${body} // ${note}` : `${nameTok.value}: ${body}`;
+			cols.push(spec.trim());
+		}
+		if (this.at("rbrace")) this.advance();
+		return cols;
+	}
+	parseOptionalProperties() {
+		if (!this.at("lbrace")) return {};
+		return this.parseBlockProperties();
+	}
+	parseIdentifierList() {
+		const items = [];
+		if (!this.at("lbracket")) return items;
+		this.advance();
+		while (!this.at("rbracket") && !this.at("eof")) {
+			this.skipTrivia();
+			if (this.at("rbracket")) break;
+			items.push(this.advance().value);
+			if (this.at("comma")) this.advance();
+		}
+		if (this.at("rbracket")) this.advance();
+		return items;
+	}
+};
+/** Join column RHS tokens so `customers . id` becomes `customers.id`. */
+function joinColumnParts(parts) {
+	if (parts.length === 0) return "";
+	let out = "";
+	for (const part of parts) {
+		if (part === ".") {
+			out = out.trimEnd() + ".";
+			continue;
+		}
+		if (out.endsWith(".")) {
+			out += part;
+			continue;
+		}
+		out += out ? ` ${part}` : part;
+	}
+	return out.trim();
+}
+const GROUP_LAYOUT_HINTS = /* @__PURE__ */ new Set([
+	"padding",
+	"arrange",
+	"align",
+	"gap",
+	"columns",
+	"rows",
+	"column",
+	"row",
+	"span",
+	"colSpan",
+	"rowSpan",
+	"chrome",
+	"icon",
+	"iconPaint",
+	"iconColor"
+]);
+function isGroupLayoutHint(name) {
+	return GROUP_LAYOUT_HINTS.has(name);
+}
+//#endregion
+//#region src/types/presentation.ts
+/** Props removed from the presentation DSL — emit a diagnostic instead of ignoring. */
+const REMOVED_PRESENTATION_PROPS = [
+	"preset",
+	"background",
+	"grid",
+	"frame",
+	"legend",
+	"nodeGradient",
+	"groupHeaders"
+];
+function normalizePadding(spec, fallback = 0) {
+	if (spec == null) return {
+		top: fallback,
+		right: fallback,
+		bottom: fallback,
+		left: fallback
+	};
+	if (typeof spec === "number") return {
+		top: spec,
+		right: spec,
+		bottom: spec,
+		left: spec
+	};
+	return {
+		top: spec.top ?? fallback,
+		right: spec.right ?? fallback,
+		bottom: spec.bottom ?? fallback,
+		left: spec.left ?? fallback
+	};
+}
+const BASE_DEFAULTS = {
+	title: false,
+	labelCase: "as-authored",
+	showKindSubtitles: false,
+	showEndpoints: false,
+	groupAccent: false,
+	clampLabels: true
+};
+function resolveTitle(title, graphTitle) {
+	if (title === false || title == null) return false;
+	if (title === true || title === "auto") {
+		if (!graphTitle) return false;
+		return {
+			text: graphTitle,
+			align: "start"
+		};
+	}
+	if (typeof title === "object") {
+		const text = title.text ?? graphTitle;
+		if (!text) return false;
+		return {
+			text,
+			subtitle: title.subtitle,
+			align: title.align ?? "start"
+		};
+	}
+	return false;
+}
+/** Merge explicit options onto chromeless defaults. */
+function resolvePresentation(options, graphTitle) {
+	const merged = {
+		...BASE_DEFAULTS,
+		...options
+	};
+	return {
+		title: resolveTitle(merged.title, graphTitle),
+		padding: normalizePadding(merged.padding, 0),
+		contentPadding: normalizePadding(merged.contentPadding, 0),
+		labelCase: "as-authored",
+		showKindSubtitles: merged.showKindSubtitles === true,
+		showEndpoints: merged.showEndpoints === true,
+		groupAccent: merged.groupAccent === true,
+		clampLabels: merged.clampLabels !== false
+	};
+}
+/** Parse a DSL property map into PresentationOptions. */
+function presentationFromProperties(props) {
+	const out = {};
+	const str = (key) => {
+		const v = props[key];
+		return typeof v === "string" ? v : void 0;
+	};
+	const bool = (key) => {
+		const v = props[key];
+		if (typeof v === "boolean") return v;
+		if (v === "true") return true;
+		if (v === "false") return false;
+	};
+	const num = (key) => {
+		const v = props[key];
+		return typeof v === "number" ? v : void 0;
+	};
+	const titleVal = props.title;
+	const titleSubtitle = str("titleSubtitle");
+	const titleAlign = str("titleAlign");
+	if (titleVal === false || titleVal === "false" || titleVal === "none") out.title = false;
+	else if (titleVal === true || titleVal === "true" || titleVal === "auto") if (titleSubtitle || titleAlign) out.title = {
+		subtitle: titleSubtitle,
+		align: titleAlign
+	};
+	else out.title = titleVal === "auto" ? "auto" : true;
+	else if (typeof titleVal === "string") out.title = {
+		text: titleVal,
+		subtitle: titleSubtitle,
+		align: titleAlign
+	};
+	else if (titleSubtitle || titleAlign) out.title = {
+		subtitle: titleSubtitle,
+		align: titleAlign
+	};
+	const padding = num("padding");
+	if (padding != null) out.padding = padding;
+	const contentPadding = num("contentPadding");
+	if (contentPadding != null) out.contentPadding = contentPadding;
+	out.labelCase = "as-authored";
+	const showKindSubtitles = bool("showKindSubtitles");
+	if (showKindSubtitles != null) out.showKindSubtitles = showKindSubtitles;
+	const showEndpoints = bool("showEndpoints");
+	if (showEndpoints != null) out.showEndpoints = showEndpoints;
+	if (props.groupAccent === "auto") out.groupAccent = true;
+	else {
+		const b = bool("groupAccent");
+		if (b != null) out.groupAccent = b;
+	}
+	const clampLabels = bool("clampLabels");
+	if (clampLabels != null) out.clampLabels = clampLabels;
+	return out;
+}
+/**
+* Pick the case policy for a concrete label.
+* Quoted / authored labels are never rewritten.
+*/
+function displayLabelCase(_labelAuthored, _policy) {
+	return "as-authored";
+}
+function formatLabelText(text, _policy) {
+	return text;
+}
+/** Shallow-merge presentation layers (later wins). */
+function mergePresentationOptions(...layers) {
+	let result;
+	for (const layer of layers) {
+		if (!layer) continue;
+		result = {
+			...result,
+			...layer
+		};
+	}
+	return result;
+}
+//#endregion
+//#region src/types/shapes.ts
+/**
+* Shared shape id vocabulary — leaf types used by kinds, compile, and geometry.
+* Geometry implementations live in @kekonic/diagrams-geometry; this module
+* only names the ids so core can validate without depending on renderers.
+*/
+const BUILTIN_SHAPE_IDS = [
+	"rectangle",
+	"rounded",
+	"pill",
+	"circle",
+	"ellipse",
+	"diamond",
+	"hexagon",
+	"triangle",
+	"parallelogram",
+	"trapezoid",
+	"document",
+	"folded-document",
+	"cylinder",
+	"cloud",
+	"person",
+	"queue",
+	"stream",
+	"table",
+	"boundary"
+];
+const SHAPE_ALIASES = {
+	note: "folded-document",
+	card: "rounded",
+	round: "rounded",
+	roundedbox: "rounded",
+	rect: "rectangle",
+	box: "rectangle",
+	cyl: "cylinder",
+	hex: "hexagon",
+	diam: "diamond",
+	capsule: "pill",
+	stadium: "pill",
+	pipe: "queue",
+	log: "stream"
+};
+function normalizeShapeId(shape) {
+	if (!shape) return "rounded";
+	const key = String(shape).trim().toLowerCase();
+	if (!key) return "rounded";
+	return SHAPE_ALIASES[key] ?? key;
+}
+function isKnownShapeId(shape) {
+	if (!shape) return false;
+	const id = normalizeShapeId(shape);
+	return BUILTIN_SHAPE_IDS.includes(id);
+}
+function listBuiltinShapeIds() {
+	return BUILTIN_SHAPE_IDS;
+}
+//#endregion
+//#region src/compiler/kinds.ts
+function defineKind(id, spec) {
+	const caps = new Set(spec.capabilities ?? []);
+	if (spec.shape === "rounded" || spec.shape === "rectangle" || spec.shape === "table" || spec.shape === "boundary") caps.add("card");
+	const shapeId = normalizeShapeId(spec.shape);
+	const classNames = [
+		`flow-node-${id}`,
+		`flow-shape-${shapeId}`,
+		...spec.extraClasses ?? []
+	];
+	return {
+		shape: shapeId,
+		icon: spec.icon,
+		subtitle: spec.subtitle,
+		classNames: [...new Set(classNames)],
+		cssVars: spec.cssVars ?? {},
+		defaultMinWidth: spec.min ?? 120,
+		defaultMaxWidth: spec.max ?? 240,
+		defaultDepth: spec.depth ?? 1,
+		category: spec.category,
+		capabilities: [...caps]
+	};
+}
+function titleCaseKind(kind) {
+	const words = kind.replace(/[_-]+/g, " ").trim();
+	if (!words) return "Node";
+	return words.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function sanitizeKindClass(kind) {
+	return kind.replace(/[^a-z0-9-]/gi, "") || "generic";
+}
+/**
+* Built-in semantic node kinds.
+* Geometry is selected via `shape`; meaning via kind + theme (+ optional authored `icon`).
+* Do not invent a unique SVG engine per kind — map onto the shared geometry library.
+*/
+const BUILTIN_KINDS = {
+	note: defineKind("note", {
+		shape: "folded-document",
+		subtitle: "Note",
+		category: "general",
+		min: 120,
+		max: 280,
+		capabilities: ["annotation"]
+	}),
+	label: defineKind("label", {
+		shape: "rounded",
+		subtitle: "Label",
+		category: "general",
+		min: 64,
+		max: 200,
+		capabilities: ["annotation", "symbolic"]
+	}),
+	group: defineKind("group", {
+		shape: "boundary",
+		subtitle: "Group",
+		category: "general",
+		min: 160,
+		max: 400,
+		capabilities: ["boundary"]
+	}),
+	image: defineKind("image", {
+		shape: "rectangle",
+		subtitle: "Image",
+		category: "general",
+		min: 80,
+		max: 320
+	}),
+	icon: defineKind("icon", {
+		shape: "rounded",
+		subtitle: "Icon",
+		category: "general",
+		min: 56,
+		max: 96,
+		capabilities: ["symbolic", "icon-only"]
+	}),
+	start: defineKind("start", {
+		shape: "pill",
+		subtitle: "Start",
+		category: "flowchart",
+		min: 88,
+		max: 160,
+		capabilities: ["symbolic"]
+	}),
+	end: defineKind("end", {
+		shape: "pill",
+		subtitle: "End",
+		category: "flowchart",
+		min: 88,
+		max: 160,
+		capabilities: ["symbolic"]
+	}),
+	process: defineKind("process", {
+		shape: "rounded",
+		subtitle: "Process",
+		category: "flowchart",
+		min: 128,
+		max: 260
+	}),
+	task: defineKind("task", {
+		shape: "rounded",
+		subtitle: "Task",
+		category: "flowchart",
+		min: 120,
+		max: 240
+	}),
+	subprocess: defineKind("subprocess", {
+		shape: "rounded",
+		subtitle: "Subprocess",
+		category: "flowchart",
+		min: 140,
+		max: 280
+	}),
+	choice: defineKind("choice", {
+		shape: "diamond",
+		subtitle: "Decision",
+		category: "flowchart",
+		min: 180,
+		max: 360
+	}),
+	decision: defineKind("decision", {
+		shape: "diamond",
+		subtitle: "Decision",
+		category: "flowchart",
+		min: 180,
+		max: 360,
+		extraClasses: ["flow-node-choice"]
+	}),
+	io: defineKind("io", {
+		shape: "parallelogram",
+		subtitle: "Input / Output",
+		category: "flowchart",
+		min: 120,
+		max: 240
+	}),
+	document: defineKind("document", {
+		shape: "document",
+		subtitle: "Document",
+		category: "flowchart",
+		min: 120,
+		max: 240
+	}),
+	preparation: defineKind("preparation", {
+		shape: "hexagon",
+		subtitle: "Preparation",
+		category: "flowchart",
+		min: 120,
+		max: 220
+	}),
+	manual: defineKind("manual", {
+		shape: "trapezoid",
+		subtitle: "Manual",
+		category: "flowchart",
+		min: 120,
+		max: 240
+	}),
+	connector: defineKind("connector", {
+		shape: "circle",
+		subtitle: "Connector",
+		category: "flowchart",
+		min: 36,
+		max: 56,
+		capabilities: ["symbolic"]
+	}),
+	user: defineKind("user", {
+		shape: "person",
+		subtitle: "User",
+		category: "architecture",
+		icon: "user",
+		min: 100,
+		max: 220,
+		extraClasses: ["flow-node-user"]
+	}),
+	person: defineKind("person", {
+		shape: "person",
+		subtitle: "Person",
+		category: "architecture",
+		icon: "user",
+		min: 100,
+		max: 220,
+		extraClasses: ["flow-node-user"]
+	}),
+	actor: defineKind("actor", {
+		shape: "rounded",
+		subtitle: "Actor",
+		category: "architecture",
+		icon: "user",
+		min: 120,
+		max: 240,
+		extraClasses: ["flow-node-actor"],
+		capabilities: ["sequence-lifeline"]
+	}),
+	participant: defineKind("participant", {
+		shape: "rounded",
+		subtitle: "Participant",
+		category: "architecture",
+		min: 120,
+		max: 240,
+		extraClasses: ["flow-node-participant"],
+		capabilities: ["sequence-lifeline"]
+	}),
+	system: defineKind("system", {
+		shape: "rounded",
+		subtitle: "System",
+		category: "architecture",
+		min: 176,
+		max: 340
+	}),
+	external: defineKind("external", {
+		shape: "rectangle",
+		subtitle: "External",
+		category: "architecture",
+		min: 120,
+		max: 260
+	}),
+	container: defineKind("container", {
+		shape: "rounded",
+		subtitle: "Container",
+		category: "architecture",
+		min: 148,
+		max: 300
+	}),
+	component: defineKind("component", {
+		shape: "rounded",
+		subtitle: "Component",
+		category: "architecture",
+		min: 120,
+		max: 240
+	}),
+	service: defineKind("service", {
+		shape: "rounded",
+		subtitle: "Service",
+		category: "architecture",
+		min: 128,
+		max: 280
+	}),
+	application: defineKind("application", {
+		shape: "rounded",
+		subtitle: "Application",
+		category: "architecture",
+		min: 140,
+		max: 280,
+		extraClasses: ["flow-node-service"]
+	}),
+	module: defineKind("module", {
+		shape: "rounded",
+		subtitle: "Module",
+		category: "architecture",
+		min: 120,
+		max: 240,
+		extraClasses: ["flow-node-service"]
+	}),
+	package: defineKind("package", {
+		shape: "folded-document",
+		subtitle: "Package",
+		category: "architecture",
+		min: 120,
+		max: 240
+	}),
+	deployment: defineKind("deployment", {
+		shape: "rectangle",
+		subtitle: "Deployment",
+		category: "architecture",
+		min: 140,
+		max: 280,
+		extraClasses: ["flow-node-service"]
+	}),
+	server: defineKind("server", {
+		shape: "rectangle",
+		subtitle: "Server",
+		category: "infrastructure",
+		min: 120,
+		max: 240,
+		extraClasses: ["flow-node-service"]
+	}),
+	database: defineKind("database", {
+		shape: "cylinder",
+		subtitle: "Database",
+		category: "infrastructure",
+		min: 100,
+		max: 200,
+		capabilities: ["datastore"]
+	}),
+	cache: defineKind("cache", {
+		shape: "cylinder",
+		subtitle: "Cache",
+		category: "infrastructure",
+		min: 100,
+		max: 200,
+		capabilities: ["datastore"],
+		extraClasses: ["flow-node-database"]
+	}),
+	store: defineKind("store", {
+		shape: "cylinder",
+		subtitle: "Data store",
+		category: "infrastructure",
+		min: 100,
+		max: 220,
+		capabilities: ["datastore"],
+		extraClasses: ["flow-node-database"]
+	}),
+	bucket: defineKind("bucket", {
+		shape: "cylinder",
+		subtitle: "Object store",
+		category: "infrastructure",
+		min: 100,
+		max: 220,
+		capabilities: ["datastore"],
+		extraClasses: ["flow-node-database"]
+	}),
+	queue: defineKind("queue", {
+		shape: "queue",
+		subtitle: "Queue",
+		category: "infrastructure",
+		min: 100,
+		max: 180,
+		capabilities: ["messaging"]
+	}),
+	topic: defineKind("topic", {
+		shape: "stream",
+		subtitle: "Topic",
+		category: "infrastructure",
+		min: 100,
+		max: 220,
+		capabilities: ["messaging"],
+		extraClasses: ["flow-node-stream"]
+	}),
+	stream: defineKind("stream", {
+		shape: "stream",
+		subtitle: "Stream",
+		category: "infrastructure",
+		min: 120,
+		max: 260,
+		capabilities: ["messaging"]
+	}),
+	gateway: defineKind("gateway", {
+		shape: "hexagon",
+		subtitle: "Gateway",
+		category: "infrastructure",
+		min: 110,
+		max: 200
+	}),
+	loadbalancer: defineKind("loadbalancer", {
+		shape: "hexagon",
+		subtitle: "Load balancer",
+		category: "infrastructure",
+		min: 120,
+		max: 220,
+		extraClasses: ["flow-node-gateway"]
+	}),
+	cloud: defineKind("cloud", {
+		shape: "cloud",
+		subtitle: "Cloud",
+		category: "infrastructure",
+		min: 140,
+		max: 260
+	}),
+	firewall: defineKind("firewall", {
+		shape: "rectangle",
+		subtitle: "Firewall",
+		category: "infrastructure",
+		min: 100,
+		max: 200,
+		extraClasses: ["flow-node-gateway"]
+	}),
+	zone: defineKind("zone", {
+		shape: "boundary",
+		subtitle: "Zone",
+		category: "infrastructure",
+		min: 180,
+		max: 400,
+		capabilities: ["boundary"]
+	}),
+	broker: defineKind("broker", {
+		shape: "hexagon",
+		subtitle: "Broker",
+		category: "messaging",
+		min: 110,
+		max: 200,
+		capabilities: ["messaging"]
+	}),
+	event: defineKind("event", {
+		shape: "pill",
+		subtitle: "Event",
+		category: "messaging",
+		min: 90,
+		max: 180,
+		capabilities: ["messaging", "symbolic"]
+	}),
+	command: defineKind("command", {
+		shape: "rounded",
+		subtitle: "Command",
+		category: "messaging",
+		min: 110,
+		max: 220,
+		capabilities: ["messaging"],
+		extraClasses: ["flow-node-service"]
+	}),
+	message: defineKind("message", {
+		shape: "document",
+		subtitle: "Message",
+		category: "messaging",
+		min: 100,
+		max: 200,
+		capabilities: ["messaging"]
+	}),
+	worker: defineKind("worker", {
+		shape: "rounded",
+		subtitle: "Worker",
+		category: "messaging",
+		min: 110,
+		max: 200,
+		extraClasses: ["flow-node-service"]
+	}),
+	producer: defineKind("producer", {
+		shape: "rounded",
+		subtitle: "Producer",
+		category: "messaging",
+		min: 110,
+		max: 200,
+		capabilities: ["messaging"],
+		extraClasses: ["flow-node-service"]
+	}),
+	consumer: defineKind("consumer", {
+		shape: "rounded",
+		subtitle: "Consumer",
+		category: "messaging",
+		min: 110,
+		max: 200,
+		capabilities: ["messaging"],
+		extraClasses: ["flow-node-service"]
+	}),
+	dlq: defineKind("dlq", {
+		shape: "queue",
+		subtitle: "Dead-letter queue",
+		category: "messaging",
+		min: 110,
+		max: 200,
+		capabilities: ["messaging"],
+		extraClasses: ["flow-node-queue", "flow-node-warning"]
+	}),
+	job: defineKind("job", {
+		shape: "rounded",
+		subtitle: "Job",
+		category: "messaging",
+		min: 110,
+		max: 200,
+		extraClasses: ["flow-node-worker"]
+	}),
+	table: defineKind("table", {
+		shape: "cylinder",
+		subtitle: "Table",
+		category: "modeling",
+		min: 160,
+		max: 320,
+		capabilities: ["datastore", "erd-table"]
+	}),
+	entity: defineKind("entity", {
+		shape: "cylinder",
+		subtitle: "Entity",
+		category: "modeling",
+		min: 160,
+		max: 320,
+		capabilities: ["datastore", "erd-table"],
+		extraClasses: ["flow-node-table"]
+	}),
+	class: defineKind("class", {
+		shape: "table",
+		subtitle: "Class",
+		category: "modeling",
+		min: 160,
+		max: 320,
+		capabilities: ["erd-table"],
+		extraClasses: ["flow-node-table"]
+	}),
+	interface: defineKind("interface", {
+		shape: "rounded",
+		subtitle: "Interface",
+		category: "modeling",
+		min: 120,
+		max: 240,
+		extraClasses: ["flow-node-service"]
+	}),
+	aggregate: defineKind("aggregate", {
+		shape: "rounded",
+		subtitle: "Aggregate",
+		category: "modeling",
+		min: 140,
+		max: 280,
+		extraClasses: ["flow-node-service"]
+	}),
+	projection: defineKind("projection", {
+		shape: "rounded",
+		subtitle: "Projection",
+		category: "modeling",
+		min: 140,
+		max: 280,
+		extraClasses: ["flow-node-service"]
+	}),
+	policy: defineKind("policy", {
+		shape: "hexagon",
+		subtitle: "Policy",
+		category: "modeling",
+		min: 120,
+		max: 220,
+		extraClasses: ["flow-node-gateway"]
+	}),
+	state: defineKind("state", {
+		shape: "rounded",
+		subtitle: "State",
+		category: "state",
+		min: 100,
+		max: 200
+	}),
+	initial: defineKind("initial", {
+		shape: "circle",
+		subtitle: "Initial",
+		category: "state",
+		min: 28,
+		max: 40,
+		capabilities: ["symbolic"]
+	}),
+	final: defineKind("final", {
+		shape: "circle",
+		subtitle: "Final",
+		category: "state",
+		min: 32,
+		max: 48,
+		capabilities: ["symbolic"]
+	}),
+	junction: defineKind("junction", {
+		shape: "circle",
+		subtitle: "Junction",
+		category: "state",
+		min: 24,
+		max: 36,
+		capabilities: ["symbolic"]
+	}),
+	fork: defineKind("fork", {
+		shape: "rectangle",
+		subtitle: "Fork",
+		category: "state",
+		min: 80,
+		max: 160,
+		capabilities: ["symbolic"]
+	}),
+	join: defineKind("join", {
+		shape: "rectangle",
+		subtitle: "Join",
+		category: "state",
+		min: 80,
+		max: 160,
+		capabilities: ["symbolic"]
+	}),
+	success: defineKind("success", {
+		shape: "rounded",
+		subtitle: "Success",
+		category: "flowchart",
+		min: 128,
+		max: 260
+	}),
+	warning: defineKind("warning", {
+		shape: "rounded",
+		subtitle: "Manual review",
+		category: "flowchart",
+		min: 128,
+		max: 260
+	}),
+	failure: defineKind("failure", {
+		shape: "rounded",
+		subtitle: "Failure",
+		category: "flowchart",
+		min: 120,
+		max: 240,
+		extraClasses: ["flow-node-warning"]
+	}),
+	commit: defineKind("commit", {
+		shape: "circle",
+		subtitle: "Commit",
+		category: "git",
+		min: 28,
+		max: 44,
+		capabilities: ["symbolic"]
+	}),
+	branch: defineKind("branch", {
+		shape: "pill",
+		subtitle: "Branch",
+		category: "git",
+		min: 72,
+		max: 160,
+		capabilities: ["symbolic"]
+	}),
+	tag: defineKind("tag", {
+		shape: "pill",
+		subtitle: "Tag",
+		category: "git",
+		min: 64,
+		max: 140,
+		capabilities: ["symbolic"]
+	})
+};
+for (const [id, spec] of Object.entries({
+	rectangle: {
+		shape: "rectangle",
+		subtitle: "Rectangle",
+		category: "shape",
+		min: 100,
+		max: 240
+	},
+	rounded: {
+		shape: "rounded",
+		subtitle: "Rounded",
+		category: "shape",
+		min: 100,
+		max: 240
+	},
+	pill: {
+		shape: "pill",
+		subtitle: "Pill",
+		category: "shape",
+		min: 88,
+		max: 180,
+		capabilities: ["symbolic"]
+	},
+	circle: {
+		shape: "circle",
+		subtitle: "Circle",
+		category: "shape",
+		min: 36,
+		max: 72,
+		capabilities: ["symbolic"]
+	},
+	ellipse: {
+		shape: "ellipse",
+		subtitle: "Ellipse",
+		category: "shape",
+		min: 100,
+		max: 200
+	},
+	diamond: {
+		shape: "diamond",
+		subtitle: "Diamond",
+		category: "shape",
+		min: 120,
+		max: 280
+	},
+	hexagon: {
+		shape: "hexagon",
+		subtitle: "Hexagon",
+		category: "shape",
+		min: 110,
+		max: 220
+	},
+	triangle: {
+		shape: "triangle",
+		subtitle: "Triangle",
+		category: "shape",
+		min: 64,
+		max: 140,
+		capabilities: ["symbolic"]
+	},
+	parallelogram: {
+		shape: "parallelogram",
+		subtitle: "Parallelogram",
+		category: "shape",
+		min: 120,
+		max: 240
+	},
+	trapezoid: {
+		shape: "trapezoid",
+		subtitle: "Trapezoid",
+		category: "shape",
+		min: 120,
+		max: 240
+	},
+	"folded-document": {
+		shape: "folded-document",
+		subtitle: "Folded document",
+		category: "shape",
+		min: 120,
+		max: 240,
+		capabilities: ["annotation"]
+	},
+	cylinder: {
+		shape: "cylinder",
+		subtitle: "Cylinder",
+		category: "shape",
+		min: 100,
+		max: 200,
+		capabilities: ["datastore"]
+	},
+	boundary: {
+		shape: "boundary",
+		subtitle: "Boundary",
+		category: "shape",
+		min: 160,
+		max: 400,
+		capabilities: ["boundary"]
+	}
+})) if (!(id in BUILTIN_KINDS)) BUILTIN_KINDS[id] = defineKind(id, spec);
+const GENERIC_DEFAULTS = {
+	shape: "rounded",
+	subtitle: "Node",
+	classNames: ["flow-node-generic"],
+	cssVars: {},
+	defaultMinWidth: 100,
+	defaultMaxWidth: 200,
+	defaultDepth: 1,
+	category: "general",
+	capabilities: ["card"]
+};
+function geometryDefaultsFor(shapeId) {
+	const existing = BUILTIN_KINDS[shapeId];
+	if (existing) return existing;
+	return defineKind(shapeId, {
+		shape: shapeId,
+		subtitle: titleCaseKind(shapeId),
+		category: "shape"
+	});
+}
+function getKindDefaults(kind) {
+	const defaults = BUILTIN_KINDS[kind];
+	if (defaults) return {
+		defaults,
+		isBuiltin: true
+	};
+	const shapeId = normalizeShapeId(kind);
+	if (shapeId !== kind && isKnownShapeId(shapeId)) return {
+		defaults: geometryDefaultsFor(shapeId),
+		isBuiltin: true
+	};
+	if (BUILTIN_SHAPE_IDS.includes(kind)) return {
+		defaults: geometryDefaultsFor(kind),
+		isBuiltin: true
+	};
+	return {
+		defaults: {
+			...GENERIC_DEFAULTS,
+			subtitle: titleCaseKind(kind),
+			classNames: [`flow-node-${sanitizeKindClass(kind)}`, "flow-node-generic"]
+		},
+		isBuiltin: false
+	};
+}
+function isBuiltinKind(kind) {
+	return getKindDefaults(kind).isBuiltin;
+}
+/**
+* True when `kind` names a built-in shape (or alias): `diamond`, `hex`, `cloud`, …
+* Semantic kinds that share a shape id (`cloud`, `document`, `person`, `queue`) count —
+* they are usable as both meaning and geometry. ERD `table` is excluded.
+*/
+function isGeometryKind(kind) {
+	const shapeId = normalizeShapeId(kind);
+	if (!isKnownShapeId(shapeId) || shapeId === "table") return false;
+	if (shapeId !== kind) return true;
+	return kind === shapeId && BUILTIN_SHAPE_IDS.includes(kind);
+}
+function kindHasCapability(kind, capability) {
+	return getKindDefaults(kind).defaults.capabilities.includes(capability);
+}
+/** Human-readable kind subtitle for presentation chrome. */
+function kindSubtitle(kind) {
+	return getKindDefaults(kind).defaults.subtitle;
+}
+function listKindsByCategory(category) {
+	return Object.entries(BUILTIN_KINDS).filter(([, d]) => d.category === category).map(([id]) => id).sort();
+}
+/**
+* Shape ids usable directly as kinds (excludes ERD `table`, which stays semantic-only).
+* Includes semantic synonyms that share a shape id (`cloud`, `document`, `person`, `queue`).
+*/
+function listGeometryKinds() {
+	return BUILTIN_SHAPE_IDS.filter((id) => id !== "table" && id in BUILTIN_KINDS).sort();
+}
+const BUILTIN_KIND_LIST = Object.keys(BUILTIN_KINDS).sort();
+const BUILTIN_KIND_CATALOG = BUILTIN_KINDS;
+//#endregion
+//#region src/compiler/direction.ts
+/** Normalize DSL direction aliases to canonical values (§6.5). */
+function normalizeDirection(value) {
+	switch (value.toLowerCase()) {
+		case "lr":
+		case "right": return "LR";
+		case "rl": return "RL";
+		case "td":
+		case "tb":
+		case "down": return "TD";
+		case "bt": return "BT";
+		default: return value.toUpperCase();
+	}
+}
+//#endregion
+//#region src/compiler/compile-animations.ts
+const DEFAULT_PULSE_MS = 400;
+const DEFAULT_FLOW_MS = 600;
+function compileAnimationBlocks(blocks, nodes, diagnostics) {
+	const usedIds = /* @__PURE__ */ new Set();
+	const animations = [];
+	for (const block of blocks) {
+		let id = animationIdFromName(block.name);
+		if (usedIds.has(id)) {
+			let n = 2;
+			while (usedIds.has(`${id}-${n}`)) n++;
+			id = `${id}-${n}`;
+		}
+		usedIds.add(id);
+		let loop = false;
+		const cues = [];
+		for (const cueAst of block.cues) {
+			if (cueAst.type === "loop") {
+				loop = true;
+				continue;
+			}
+			const cue = compileCue(cueAst, nodes, diagnostics);
+			if (cue) cues.push(cue);
+		}
+		const source = cues.length === 0 ? "auto" : "authored";
+		animations.push({
+			id,
+			name: block.name,
+			loop,
+			cues,
+			source
+		});
+	}
+	return animations;
+}
+function compileCue(cue, nodes, diagnostics) {
+	switch (cue.type) {
+		case "dim":
+		case "activate": return {
+			op: cue.type,
+			targets: resolveTargets(cue.targets, nodes, diagnostics, cue.range)
+		};
+		case "pulse": return {
+			op: "pulse",
+			targets: resolveTargets(cue.targets, nodes, diagnostics, cue.range),
+			durationMs: cue.durationMs ?? DEFAULT_PULSE_MS
+		};
+		case "flow":
+			for (const id of cue.path) if (!nodes.has(id)) diagnostics.push({
+				severity: "error",
+				code: "FM128",
+				message: `Unknown node "${id}" in animation flow path`,
+				range: cue.range
+			});
+			return {
+				op: "flow",
+				path: cue.path,
+				durationMs: cue.durationMs ?? DEFAULT_FLOW_MS
+			};
+		case "wait": return {
+			op: "wait",
+			durationMs: cue.durationMs
+		};
+		case "parallel": {
+			const children = [];
+			for (const child of cue.cues) {
+				if (child.type === "loop") {
+					diagnostics.push({
+						severity: "warning",
+						code: "FM129",
+						message: "`loop` inside parallel is ignored — place it on the animation block",
+						range: child.range
+					});
+					continue;
+				}
+				if (child.type === "parallel") {
+					diagnostics.push({
+						severity: "error",
+						code: "FM130",
+						message: "Nested parallel groups are not supported",
+						range: child.range
+					});
+					continue;
+				}
+				const compiled = compileCue(child, nodes, diagnostics);
+				if (compiled) children.push(compiled);
+			}
+			return {
+				op: "parallel",
+				cues: children
+			};
+		}
+		case "loop": return null;
+	}
+}
+function resolveTargets(targets, nodes, diagnostics, range) {
+	const out = [];
+	for (const t of targets) {
+		if (t.type === "all") {
+			out.push({ type: "all" });
+			continue;
+		}
+		if (t.type === "node") {
+			if (!nodes.has(t.id)) diagnostics.push({
+				severity: "error",
+				code: "FM128",
+				message: `Unknown node "${t.id}" in animation`,
+				range
+			});
+			out.push({
+				type: "node",
+				id: t.id
+			});
+			continue;
+		}
+		if (!nodes.has(t.from) || !nodes.has(t.to)) diagnostics.push({
+			severity: "error",
+			code: "FM128",
+			message: `Unknown edge endpoints "${t.from} -> ${t.to}" in animation`,
+			range
+		});
+		out.push({
+			type: "edge",
+			from: t.from,
+			to: t.to
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/compiler/compile-sequence.ts
+function edgeOpToSequenceKind(op, from, to) {
+	if (from === "*") return "found";
+	if (to === "*") return "lost";
+	switch (op) {
+		case "-->": return "return";
+		case "~>":
+		case "<~":
+		case "=>":
+		case "<=": return "async";
+		case "-x":
+		case "x-": return "failure";
+		default: return "sync";
+	}
+}
+function collectStyleRefsFromProperties$1(properties) {
+	const raw = properties.styles ?? properties.style;
+	if (Array.isArray(raw)) return raw.map(String);
+	if (typeof raw === "string") return [raw];
+	return [];
+}
+function collectUnresolvedVars$1(properties) {
+	const vars = {};
+	for (const [key, value] of Object.entries(properties)) {
+		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") continue;
+		if (key.startsWith("--") || key === "iconColor") {
+			if (key === "iconColor") vars["--icon-color"] = String(value);
+			else if (key.startsWith("--")) vars[key] = String(value);
+		}
+	}
+	return vars;
+}
+function materializeNode(stmt, nodes, diagnostics) {
+	if (nodes.has(stmt.id)) {
+		diagnostics.push({
+			severity: "error",
+			code: "FM101",
+			message: `Duplicate participant id "${stmt.id}"`,
+			range: stmt.range
+		});
+		return nodes.get(stmt.id) ?? null;
+	}
+	const { defaults, isBuiltin } = getKindDefaults(stmt.kind);
+	if (!isBuiltin) diagnostics.push({
+		severity: "warning",
+		code: "FM102",
+		message: `Unknown node kind "${stmt.kind}" — using generic defaults`,
+		range: stmt.range,
+		hint: "Any kind can be a sequence lifeline; prefer participant, actor, or architecture kinds."
+	});
+	const rawShape = stmt.properties.shape != null ? String(stmt.properties.shape) : void 0;
+	const shapeOverride = rawShape ? normalizeShapeId(rawShape) : void 0;
+	if (rawShape && !isKnownShapeId(shapeOverride)) diagnostics.push({
+		severity: "warning",
+		code: "FM111",
+		message: `Unknown shape "${rawShape}"`,
+		range: stmt.range
+	});
+	const styleRefs = [...collectStyleRefsFromProperties$1(stmt.properties), ...stmt.styleRefs];
+	const unresolvedVars = {
+		...defaults.cssVars,
+		...collectUnresolvedVars$1(stmt.properties)
+	};
+	const rawIcon = stmt.properties.icon != null ? String(stmt.properties.icon) : void 0;
+	const icon = rawIcon === "none" ? void 0 : rawIcon !== void 0 ? rawIcon : defaults.shape === "person" ? void 0 : defaults.icon;
+	const authoredPaint = stmt.properties.iconPaint != null ? String(stmt.properties.iconPaint).toLowerCase() : void 0;
+	const iconPaint = authoredPaint === "theme" || authoredPaint === "brand" ? authoredPaint : void 0;
+	const iconColor = stmt.properties.iconColor != null && String(stmt.properties.iconColor).length > 0 ? String(stmt.properties.iconColor) : void 0;
+	const nodeVars = {
+		...unresolvedVars,
+		...iconColor ? { "--icon-color": iconColor } : {}
+	};
+	const node = {
+		id: stmt.id,
+		label: stmt.label ?? stmt.id,
+		labelAuthored: stmt.label != null,
+		kind: stmt.kind,
+		shape: shapeOverride ?? defaults.shape,
+		icon,
+		iconPaint,
+		iconColor,
+		minWidth: defaults.defaultMinWidth,
+		maxWidth: defaults.defaultMaxWidth,
+		depth: defaults.defaultDepth,
+		styleRefs,
+		unresolvedVars: Object.keys(nodeVars).length ? nodeVars : void 0,
+		sourceRange: stmt.range
+	};
+	nodes.set(stmt.id, node);
+	return node;
+}
+function nextOrder(ctx) {
+	const o = ctx.order;
+	ctx.order += 1;
+	return o;
+}
+function ensureParticipant(ctx, id, range) {
+	if (id === "*" || !id) return;
+	if (!ctx.nodes.has(id)) ctx.diagnostics.push({
+		severity: "error",
+		code: "FM147",
+		message: `Unknown participant "${id}" — declare with \`id: kind "Label"\` before use`,
+		range: range ?? {
+			start: {
+				line: 1,
+				column: 1,
+				offset: 0
+			},
+			end: {
+				line: 1,
+				column: 1,
+				offset: 0
+			}
+		}
+	});
+	else if (!ctx.participantOrder.includes(id)) ctx.participantOrder.push(id);
+}
+function pushMessage(ctx, partial, edgeMeta) {
+	const order = nextOrder(ctx);
+	const id = partial.id ?? `msg${ctx.edgeCounter++}`;
+	const msg = {
+		...partial,
+		id,
+		order
+	};
+	ctx.messages.push(msg);
+	const styleRefs = edgeMeta?.styleRefs ?? [];
+	const branch = edgeMeta?.branch ?? (msg.label != null ? classifyBranch(msg.label) : void 0);
+	if (msg.from && msg.to && msg.from !== "*" && msg.to !== "*") ctx.edges.push({
+		id,
+		from: msg.from,
+		to: msg.to,
+		label: msg.label,
+		labelAuthored: msg.labelAuthored,
+		kind: msg.kind === "async" ? "eventual" : msg.kind === "failure" ? "failure" : msg.kind === "return" ? "dependency" : msg.kind === "destroy" ? "failure" : "sync",
+		arrows: "end",
+		styleRefs,
+		branch: branch === "neutral" ? void 0 : branch,
+		sequenceOrder: order,
+		sequenceKind: msg.kind,
+		sourceRange: msg.sourceRange
+	});
+	return msg;
+}
+function closeActivation(ctx, participantId, endOrder) {
+	const stack = ctx.openActivations.get(participantId);
+	if (!stack || stack.length === 0) return;
+	const open = stack.pop();
+	ctx.activations.push({
+		id: open.id,
+		participantId,
+		startOrder: open.startOrder,
+		endOrder,
+		sourceRange: open.range
+	});
+}
+function openActivation(ctx, participantId, startOrder, range) {
+	const stack = ctx.openActivations.get(participantId) ?? [];
+	stack.push({
+		id: `act${ctx.nextActId++}`,
+		startOrder,
+		range
+	});
+	ctx.openActivations.set(participantId, stack);
+}
+function collectSequenceStatements(statements, ctx) {
+	for (const stmt of statements) switch (stmt.type) {
+		case "Node":
+			materializeNode(stmt, ctx.nodes, ctx.diagnostics);
+			if (!ctx.participantOrder.includes(stmt.id)) ctx.participantOrder.push(stmt.id);
+			break;
+		case "Edge": {
+			const from = stmt.from;
+			const to = stmt.to;
+			ensureParticipant(ctx, from, stmt.range);
+			ensureParticipant(ctx, to, stmt.range);
+			const kind = edgeOpToSequenceKind(stmt.op, from, to);
+			const styleRefs = [...collectStyleRefsFromProperties$1(stmt.properties), ...stmt.styleRefs];
+			const branch = normalizeBranch(stmt.properties.branch) ?? (stmt.label != null ? classifyBranch(stmt.label) : void 0);
+			const msg = pushMessage(ctx, {
+				from: from === "*" ? null : from,
+				to: to === "*" ? null : to,
+				kind,
+				label: stmt.label,
+				labelAuthored: stmt.label != null,
+				sourceRange: stmt.range
+			}, {
+				styleRefs,
+				branch
+			});
+			if (kind === "sync" && msg.to) {
+				openActivation(ctx, msg.to, msg.order, stmt.range);
+				if (msg.from) ctx.callStack.push({
+					messageId: msg.id,
+					to: msg.to,
+					from: msg.from
+				});
+			} else if (kind === "return" && msg.from) {
+				const idx = [...ctx.callStack].reverse().findIndex((c) => c.to === msg.from);
+				if (idx >= 0) {
+					const real = ctx.callStack.length - 1 - idx;
+					msg.replyTo = ctx.callStack[real].messageId;
+					ctx.callStack.splice(real, 1);
+				}
+				closeActivation(ctx, msg.from, msg.order);
+			}
+			break;
+		}
+		case "SequenceActivate":
+			ensureParticipant(ctx, stmt.participantId, stmt.range);
+			openActivation(ctx, stmt.participantId, ctx.order, stmt.range);
+			break;
+		case "SequenceDeactivate":
+			ensureParticipant(ctx, stmt.participantId, stmt.range);
+			closeActivation(ctx, stmt.participantId, Math.max(0, ctx.order - 1));
+			break;
+		case "SequenceCreate": {
+			materializeNode(stmt.node, ctx.nodes, ctx.diagnostics);
+			if (!ctx.participantOrder.includes(stmt.node.id)) ctx.participantOrder.push(stmt.node.id);
+			const prev = ctx.messages.at(-1);
+			pushMessage(ctx, {
+				from: prev?.to ?? prev?.from ?? null,
+				to: stmt.node.id,
+				kind: "create",
+				label: stmt.node.label,
+				labelAuthored: stmt.node.label != null,
+				sourceRange: stmt.range
+			});
+			break;
+		}
+		case "SequenceDestroy":
+			ensureParticipant(ctx, stmt.participantId, stmt.range);
+			pushMessage(ctx, {
+				from: stmt.participantId,
+				to: stmt.participantId,
+				kind: "destroy",
+				sourceRange: stmt.range
+			});
+			closeActivation(ctx, stmt.participantId, ctx.order - 1);
+			break;
+		case "SequenceNote": {
+			for (const id of stmt.participantIds) ensureParticipant(ctx, id, stmt.range);
+			const order = nextOrder(ctx);
+			ctx.notes.push({
+				id: `note${ctx.nextNoteId++}`,
+				order,
+				placement: stmt.placement,
+				participantIds: stmt.participantIds,
+				text: stmt.text,
+				sourceRange: stmt.range
+			});
+			break;
+		}
+		case "SequenceDivider": {
+			const order = nextOrder(ctx);
+			ctx.dividers.push({
+				id: `div${ctx.nextDivId++}`,
+				order,
+				label: stmt.label,
+				sourceRange: stmt.range
+			});
+			break;
+		}
+		case "SequenceAutonumber":
+			ctx.autonumber = true;
+			break;
+		case "SequenceFragment":
+			collectFragment(stmt, ctx);
+			break;
+		case "Style":
+			ctx.styles.push({
+				name: stmt.name,
+				target: stmt.target,
+				properties: Object.fromEntries(Object.entries(stmt.properties).map(([k, v]) => [k, String(v)]))
+			});
+			break;
+		case "StyleRef":
+			for (const id of stmt.targetIds) {
+				const node = ctx.nodes.get(id);
+				if (node && !node.styleRefs.includes(stmt.styleName)) node.styleRefs.push(stmt.styleName);
+			}
+			break;
+		case "Directive":
+		case "LayoutBlock":
+		case "EdgePolicyBlock":
+		case "RenderBlock":
+		case "PresentationBlock":
+		case "AnimationBlock": break;
+		default: break;
+	}
+}
+function collectFragment(stmt, ctx) {
+	const fragId = `frag${ctx.nextFragId++}`;
+	const startOrder = ctx.order;
+	const operands = [];
+	for (const op of stmt.operands) {
+		const opStart = ctx.order;
+		const childFragsStart = ctx.fragments.length;
+		collectSequenceStatements(op.statements, ctx);
+		const nested = ctx.fragments.splice(childFragsStart);
+		const opEnd = Math.max(opStart, ctx.order - 1);
+		operands.push({
+			label: op.label,
+			styleRefs: [...op.styleRefs],
+			startOrder: opStart,
+			endOrder: opEnd,
+			children: nested
+		});
+	}
+	const endOrder = Math.max(startOrder, ctx.order - 1);
+	ctx.fragments.push({
+		id: fragId,
+		operator: stmt.operator,
+		label: stmt.label,
+		styleRefs: [...stmt.styleRefs],
+		unresolvedVars: {},
+		startOrder,
+		endOrder,
+		operands,
+		sourceRange: stmt.range
+	});
+}
+function collectAnimationBlocks$1(statements) {
+	const blocks = [];
+	for (const stmt of statements) {
+		if (stmt.type === "AnimationBlock") blocks.push(stmt);
+		if (stmt.type === "SequenceFragment") for (const op of stmt.operands) blocks.push(...collectAnimationBlocks$1(op.statements));
+	}
+	return blocks;
+}
+function finalizeOpenActivations(ctx) {
+	const lastOrder = Math.max(0, ctx.order - 1);
+	for (const [participantId, stack] of ctx.openActivations) while (stack.length) {
+		const open = stack.pop();
+		ctx.activations.push({
+			id: open.id,
+			participantId,
+			startOrder: open.startOrder,
+			endOrder: lastOrder,
+			sourceRange: open.range
+		});
+	}
+}
+/** Compile a `sequence { … }` document body into GraphModel + SequenceIR. */
+function compileSequence(ast, diagramIndex = 0) {
+	const diagnostics = [...ast.diagnostics];
+	const top = ast.body[diagramIndex];
+	if (!top || top.type !== "Sequence") {
+		diagnostics.push({
+			severity: "error",
+			code: "FM100",
+			message: "No sequence diagram found at index",
+			range: {
+				start: {
+					line: 1,
+					column: 1,
+					offset: 0
+				},
+				end: {
+					line: 1,
+					column: 1,
+					offset: 0
+				}
+			}
+		});
+		return {
+			graph: {
+				id: "empty",
+				diagramKind: "sequence",
+				nodes: [],
+				edges: [],
+				groups: [],
+				styles: [],
+				animations: [],
+				diagnostics
+			},
+			layoutHints: {},
+			routingHints: {},
+			renderHints: {},
+			diagnostics
+		};
+	}
+	const seq = top;
+	const ctx = {
+		nodes: /* @__PURE__ */ new Map(),
+		edges: [],
+		styles: [],
+		diagnostics,
+		participantOrder: [],
+		messages: [],
+		activations: [],
+		fragments: [],
+		notes: [],
+		dividers: [],
+		autonumber: false,
+		order: 0,
+		edgeCounter: 0,
+		openActivations: /* @__PURE__ */ new Map(),
+		callStack: [],
+		nextActId: 0,
+		nextFragId: 0,
+		nextNoteId: 0,
+		nextDivId: 0
+	};
+	collectSequenceStatements(seq.statements, ctx);
+	finalizeOpenActivations(ctx);
+	const sequence = {
+		autonumber: ctx.autonumber,
+		messages: ctx.messages,
+		activations: ctx.activations,
+		fragments: ctx.fragments,
+		notes: ctx.notes,
+		dividers: ctx.dividers,
+		participantOrder: ctx.participantOrder
+	};
+	const graph = {
+		id: seq.name ? seq.name.toLowerCase().replace(/\s+/g, "-") : "sequence",
+		title: seq.name,
+		diagramKind: "sequence",
+		sequence,
+		nodes: ctx.participantOrder.map((id) => ctx.nodes.get(id)).filter(Boolean),
+		edges: ctx.edges,
+		groups: [],
+		styles: ctx.styles,
+		animations: compileAnimationBlocks(collectAnimationBlocks$1(seq.statements), ctx.nodes, diagnostics),
+		diagnostics
+	};
+	const hints = extractSequenceHints(seq);
+	diagnostics.push(...hints.diagnostics);
+	const { diagnostics: _d, ...hintFields } = hints;
+	hintFields.layoutHints = {
+		...hintFields.layoutHints,
+		direction: hintFields.layoutHints.direction ?? "TD"
+	};
+	return {
+		graph,
+		...hintFields,
+		diagnostics
+	};
+}
+function extractSequenceHints(seq) {
+	const layoutHints = {};
+	const routingHints = {};
+	const renderHints = {};
+	const diagnostics = [];
+	let presentationLayers = [];
+	for (const stmt of seq.statements) {
+		if (stmt.type === "Directive") {
+			if (stmt.name === "direction" && stmt.value) layoutHints.direction = normalizeDirection(String(stmt.value));
+			if (stmt.name === "density" && stmt.value) {
+				const d = String(stmt.value);
+				if (d === "compact" || d === "normal" || d === "spacious") layoutHints.density = d;
+			}
+		}
+		if (stmt.type === "LayoutBlock") {
+			if (stmt.properties.direction) layoutHints.direction = normalizeDirection(String(stmt.properties.direction));
+			if (stmt.properties.density) {
+				const d = String(stmt.properties.density);
+				if (d === "compact" || d === "normal" || d === "spacious") layoutHints.density = d;
+			}
+		}
+		if (stmt.type === "EdgePolicyBlock") {
+			if (stmt.properties.route) routingHints.route = String(stmt.properties.route);
+		}
+		if (stmt.type === "RenderBlock") {
+			if (stmt.properties.theme) renderHints.theme = String(stmt.properties.theme);
+		}
+		if (stmt.type === "PresentationBlock") {
+			const layer = presentationFromProperties(stmt.properties);
+			if (layer) presentationLayers.push(layer);
+		}
+	}
+	const merged = mergePresentationOptions(...presentationLayers);
+	if (merged) renderHints.presentation = merged;
+	return {
+		layoutHints,
+		routingHints,
+		renderHints,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/compiler/compile.ts
+function suggestKindName(kind) {
+	const target = kind.toLowerCase();
+	let best;
+	let bestDist = 3;
+	for (const candidate of BUILTIN_KIND_LIST) {
+		const d = levenshtein(target, candidate.toLowerCase());
+		if (d < bestDist) {
+			bestDist = d;
+			best = candidate;
+		}
+	}
+	return best;
+}
+function levenshtein(a, b) {
+	const m = a.length;
+	const n = b.length;
+	const dp = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
+	for (let i = 0; i <= m; i++) dp[i][0] = i;
+	for (let j = 0; j <= n; j++) dp[0][j] = j;
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) {
+		const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+		dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+	}
+	return dp[m][n];
+}
+function collectStyleRefsFromProperties(properties) {
+	const refs = [];
+	const styles = properties.styles;
+	if (Array.isArray(styles)) for (const s of styles) refs.push(String(s));
+	return refs;
+}
+function collectUnresolvedVars(properties) {
+	const vars = {};
+	for (const [k, v] of Object.entries(properties)) if (k.startsWith("--")) vars[k] = String(v);
+	return Object.keys(vars).length ? vars : void 0;
+}
+function edgeOpToKind(op) {
+	switch (op) {
+		case "=>":
+		case "<=": return "async";
+		case "~>":
+		case "<~": return "eventual";
+		case "..>":
+		case "<..":
+		case "-->": return "dependency";
+		case "-x":
+		case "x-": return "failure";
+		case "--": return "association";
+		default: return "sync";
+	}
+}
+/** Reverse ops are authored target-first; compile swaps endpoints so routing stays from→to. */
+function edgeOpIsReverse(op) {
+	return op === "<-" || op === "<=" || op === "<.." || op === "x-" || op === "<~";
+}
+function edgeOpArrows(op) {
+	if (op === "<->") return "both";
+	if (op === "--") return "none";
+	return "end";
+}
+function normalizePriority(value) {
+	if (value === "low" || value === "normal" || value === "high") return value;
+}
+/** Along-path label bias — `labelPosition` or alias `labelAt`. */
+function normalizeLabelPosition(value) {
+	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") return;
+	const raw = String(value).trim().toLowerCase();
+	if (raw === "start" || raw === "begin" || raw === "source") return "start";
+	if (raw === "middle" || raw === "mid" || raw === "center") return "middle";
+	if (raw === "end" || raw === "target") return "end";
+}
+function normalizeGroupLayout(value) {
+	if (value === "auto" || value === "flat" || value === "compound" || value === "swimlane") return value;
+}
+/** Normalize DSL nodePlacement to public values (no obscure ELK nicknames). */
+function normalizeNodePlacement(value) {
+	switch (value) {
+		case "straight":
+		case "balanced":
+		case "basic": return value;
+		default: return;
+	}
+}
+function normalizeDensity(value) {
+	if (value === "compact" || value === "normal" || value === "spacious") return value;
+}
+function isRemovedDensityAlias(value) {
+	return value === "mid" || value === "comfortable" || value === "roomy";
+}
+/** Prefer `gaps`; accept singular `gap`. */
+function normalizeCrossings(value) {
+	if (value === "none" || value === "gaps" || value === "jumps" || value === "smart") return value;
+	if (value === "gap") return "gaps";
+}
+function normalizeBool(value) {
+	if (value === true || value === false) return value;
+	if (value === "true") return true;
+	if (value === "false") return false;
+}
+function optionalNumber(value) {
+	if (value == null || value === "") return void 0;
+	const n = Number(value);
+	return Number.isFinite(n) ? n : void 0;
+}
+/** Presentation scale — clamp so layout stays sane. */
+function normalizeScale(value) {
+	const n = optionalNumber(value);
+	if (n == null || n <= 0) return void 0;
+	return Math.min(2, Math.max(.75, n));
+}
+function collectStatements(statements, ctx) {
+	for (const stmt of statements) switch (stmt.type) {
+		case "Node": {
+			if (ctx.nodes.has(stmt.id)) {
+				ctx.diagnostics.push({
+					severity: "error",
+					code: "FM101",
+					message: `Duplicate node id "${stmt.id}"`,
+					range: stmt.range
+				});
+				break;
+			}
+			const { defaults, isBuiltin } = getKindDefaults(stmt.kind);
+			if (!isBuiltin) {
+				const suggestion = suggestKindName(stmt.kind);
+				ctx.diagnostics.push({
+					severity: "warning",
+					code: "FM102",
+					message: `Unknown node kind "${stmt.kind}" — using generic defaults`,
+					range: stmt.range,
+					hint: suggestion ? `Did you mean "${suggestion}"?` : "See built-in kinds (service, database, event, process, …) or keep an open kind."
+				});
+			}
+			const columns = parseTableColumns(stmt.properties.columns);
+			const hasErdColumns = columns.length > 0;
+			const rawShape = stmt.properties.shape != null ? String(stmt.properties.shape) : void 0;
+			const shapeOverride = rawShape ? normalizeShapeId(rawShape) : void 0;
+			if (rawShape && !isKnownShapeId(shapeOverride)) ctx.diagnostics.push({
+				severity: "warning",
+				code: "FM111",
+				message: `Unknown shape "${rawShape}" — rendering falls back to rounded unless a custom shape is registered`,
+				range: stmt.range,
+				hint: `Known shapes: rectangle, rounded, pill, diamond, hexagon, cylinder, queue, cloud, document, …`
+			});
+			const erdKind = defaults.capabilities.includes("erd-table") || stmt.kind === "table" || stmt.kind === "entity";
+			const shape = shapeOverride ?? (hasErdColumns && erdKind ? "table" : defaults.shape);
+			const styleRefs = [...collectStyleRefsFromProperties(stmt.properties), ...stmt.styleRefs];
+			const unresolvedVars = {
+				...defaults.cssVars,
+				...collectUnresolvedVars(stmt.properties)
+			};
+			const erdMinWidth = hasErdColumns ? Math.max(defaults.defaultMinWidth, 200) : defaults.defaultMinWidth;
+			const erdMaxWidth = hasErdColumns ? Math.max(defaults.defaultMaxWidth, 360) : defaults.defaultMaxWidth;
+			const rawIcon = stmt.properties.icon != null ? String(stmt.properties.icon) : void 0;
+			const icon = rawIcon === "none" ? void 0 : rawIcon !== void 0 ? rawIcon : shape === "person" ? void 0 : defaults.icon;
+			const authoredPaint = stmt.properties.iconPaint != null ? String(stmt.properties.iconPaint).toLowerCase() : void 0;
+			const iconPaint = authoredPaint === "theme" || authoredPaint === "brand" ? authoredPaint : void 0;
+			const iconColor = stmt.properties.iconColor != null && String(stmt.properties.iconColor).length > 0 ? String(stmt.properties.iconColor) : void 0;
+			const nodeVars = {
+				...unresolvedVars,
+				...iconColor ? { "--icon-color": iconColor } : {}
+			};
+			const parentGroupId = ctx.groupStack.at(-1);
+			ctx.nodes.set(stmt.id, {
+				id: stmt.id,
+				label: stmt.label ?? stmt.id,
+				labelAuthored: stmt.label != null,
+				kind: stmt.kind,
+				shape,
+				icon,
+				iconPaint,
+				iconColor,
+				groupId: parentGroupId,
+				styleRefs,
+				unresolvedVars: Object.keys(nodeVars).length ? nodeVars : void 0,
+				note: stmt.properties.note != null ? String(stmt.properties.note) : void 0,
+				showSubtitle: stmt.properties.subtitle === true,
+				subtitle: typeof stmt.properties.subtitle === "string" && stmt.properties.subtitle.length > 0 ? String(stmt.properties.subtitle) : void 0,
+				technology: stmt.properties.technology != null && String(stmt.properties.technology).length > 0 ? String(stmt.properties.technology) : void 0,
+				description: stmt.properties.description != null && String(stmt.properties.description).length > 0 ? String(stmt.properties.description) : void 0,
+				columns: hasErdColumns ? columns : void 0,
+				minWidth: stmt.properties.minWidth ?? erdMinWidth,
+				maxWidth: stmt.properties.maxWidth ?? erdMaxWidth,
+				depth: stmt.properties.depth ?? defaults.defaultDepth,
+				scale: normalizeScale(stmt.properties.scale),
+				sourceRange: stmt.range
+			});
+			if (parentGroupId) ctx.groups.find((g) => g.id === parentGroupId)?.members?.push({
+				kind: "node",
+				id: stmt.id
+			});
+			break;
+		}
+		case "Edge": {
+			ctx.edgeCounter++;
+			const fromColumn = stmt.fromColumn ?? (stmt.properties.fromColumn != null ? String(stmt.properties.fromColumn) : stmt.properties.fromCol != null ? String(stmt.properties.fromCol) : void 0);
+			const toColumn = stmt.toColumn ?? (stmt.properties.toColumn != null ? String(stmt.properties.toColumn) : stmt.properties.toCol != null ? String(stmt.properties.toCol) : void 0);
+			const cardinality = parseCardinality(stmt.properties.cardinality ?? stmt.properties.rel) ?? parseCardinality(stmt.label) ?? (fromColumn || toColumn ? {
+				from: "one",
+				to: "zeroOrMany"
+			} : void 0);
+			const branch = normalizeBranch(stmt.properties.branch) ?? (cardinality && isPureCardinalityLabel(stmt.label) ? void 0 : classifyBranch(stmt.label));
+			const identifying = normalizeBool(stmt.properties.identifying);
+			const rawIcon = stmt.properties.icon != null ? String(stmt.properties.icon) : void 0;
+			const icon = rawIcon && rawIcon !== "none" ? rawIcon : void 0;
+			const authoredPaint = stmt.properties.iconPaint != null ? String(stmt.properties.iconPaint).toLowerCase() : void 0;
+			const iconPaint = authoredPaint === "theme" || authoredPaint === "brand" ? authoredPaint : void 0;
+			const iconColor = stmt.properties.iconColor != null && String(stmt.properties.iconColor).length > 0 ? String(stmt.properties.iconColor) : void 0;
+			const reverse = edgeOpIsReverse(stmt.op);
+			const arrowsProp = String(stmt.properties.arrows ?? "").toLowerCase();
+			const arrows = arrowsProp === "both" || arrowsProp === "start" || arrowsProp === "end" || arrowsProp === "none" ? arrowsProp : edgeOpArrows(stmt.op);
+			ctx.edges.push({
+				id: `e${ctx.edgeCounter}`,
+				from: reverse ? stmt.to : stmt.from,
+				to: reverse ? stmt.from : stmt.to,
+				fromColumn: reverse ? toColumn : fromColumn,
+				toColumn: reverse ? fromColumn : toColumn,
+				label: stmt.label,
+				labelAuthored: stmt.label != null,
+				kind: edgeOpToKind(stmt.op),
+				arrows,
+				styleRefs: [...collectStyleRefsFromProperties(stmt.properties), ...stmt.styleRefs],
+				icon,
+				iconPaint,
+				iconColor,
+				priority: normalizePriority(stmt.properties.priority),
+				labelPosition: normalizeLabelPosition(stmt.properties.labelPosition ?? stmt.properties.labelAt),
+				branch,
+				cardinality,
+				identifying: identifying ?? void 0,
+				sourceRange: stmt.range
+			});
+			break;
+		}
+		case "Group": {
+			const groupId = stmt.id ?? `group_${ctx.groups.length + 1}`;
+			const hints = extractGroupArrangeHints(stmt.statements);
+			const rawIcon = hints.icon;
+			const icon = rawIcon && rawIcon !== "none" ? rawIcon : void 0;
+			const group = {
+				id: groupId,
+				label: stmt.label ?? groupId,
+				labelAuthored: stmt.label != null,
+				kind: stmt.groupKind,
+				parentId: ctx.groupStack.at(-1),
+				nodeIds: [],
+				childGroupIds: [],
+				members: [],
+				styleRefs: [],
+				paddingHint: hints.paddingHint,
+				chrome: hints.chrome,
+				icon,
+				iconPaint: hints.iconPaint,
+				iconColor: hints.iconColor,
+				arrange: hints.arrange,
+				align: hints.align,
+				gap: hints.gap,
+				columns: hints.columns,
+				rows: hints.rows,
+				column: hints.column,
+				row: hints.row,
+				span: hints.span,
+				colSpan: hints.colSpan,
+				rowSpan: hints.rowSpan,
+				cellArrange: hints.cellArrange
+			};
+			if (ctx.groupStack.length > 0) {
+				const parent = ctx.groups.find((g) => g.id === ctx.groupStack.at(-1));
+				parent?.childGroupIds.push(groupId);
+				parent?.members?.push({
+					kind: "group",
+					id: groupId
+				});
+			}
+			ctx.groups.push(group);
+			ctx.groupStack.push(groupId);
+			collectStatements(stmt.statements, ctx);
+			for (const n of ctx.nodes.values()) if (n.groupId === groupId && !group.nodeIds.includes(n.id)) group.nodeIds.push(n.id);
+			if (group.arrange === "stack" && group.childGroupIds.length === 0 && group.cellArrange == null) {
+				group.cellArrange = "stack";
+				group.arrange = void 0;
+			}
+			ctx.groupStack.pop();
+			break;
+		}
+		case "Style": {
+			const props = {};
+			for (const [k, v] of Object.entries(stmt.properties)) props[k] = String(v);
+			ctx.styles.push({
+				name: stmt.name,
+				target: stmt.target,
+				properties: props
+			});
+			break;
+		}
+		case "StyleRef": {
+			const styleDef = ctx.styles.find((s) => s.name === stmt.styleName);
+			for (const id of stmt.targetIds) {
+				const node = ctx.nodes.get(id);
+				if (node) {
+					if (!node.styleRefs.includes(stmt.styleName)) node.styleRefs.push(stmt.styleName);
+				} else ctx.diagnostics.push({
+					severity: "warning",
+					code: "FM105",
+					message: styleDef?.target === "edge" ? `Style "${stmt.styleName}" targets edges — use \`a -> b is ${stmt.styleName}\` or styles: […] on the edge` : `Style ref "${stmt.styleName}" references unknown node "${id}"`,
+					range: stmt.range
+				});
+			}
+			break;
+		}
+		case "GroupMember": {
+			const groupId = ctx.groupStack.at(-1);
+			if (!groupId) break;
+			const group = ctx.groups.find((g) => g.id === groupId);
+			for (const nodeId of stmt.nodeIds) {
+				const node = ctx.nodes.get(nodeId);
+				if (node) {
+					node.groupId = groupId;
+					if (group && !group.nodeIds.includes(nodeId)) group.nodeIds.push(nodeId);
+					if (group && !group.members?.some((m) => m.kind === "node" && m.id === nodeId)) group.members?.push({
+						kind: "node",
+						id: nodeId
+					});
+				} else ctx.pendingGroupMembers.push({
+					nodeId,
+					groupId,
+					range: stmt.range
+				});
+			}
+			break;
+		}
+		default: break;
+	}
+}
+function extractGroupPaddingHint(statements) {
+	for (const stmt of statements) if (stmt.type === "Directive" && stmt.name === "padding" && stmt.value != null) return String(stmt.value);
+}
+function normalizeGroupChrome(value) {
+	if (value === true || value === "true" || value === "on") return true;
+	if (value === false || value === "false" || value === "none" || value === "off") return false;
+}
+function normalizeRegionArrange(value) {
+	if (value === "stack" || value === "row" || value === "grid") return value;
+}
+function normalizeRegionAlign(value) {
+	if (value === "stretch" || value === "start" || value === "center" || value === "end") return value;
+}
+function normalizeCellArrange(value) {
+	if (value === "flow" || value === "pack" || value === "stack") return value;
+}
+function normalizeTrackSpec(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value >= 1) return Math.floor(value);
+	if (typeof value === "string") {
+		const n = Number(value);
+		if (Number.isFinite(n) && n >= 1) return Math.floor(n);
+		return;
+	}
+	if (Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === "string")) return value.map(String);
+}
+function normalizeTrackRef(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value >= 1) return Math.floor(value);
+	if (typeof value === "string") {
+		const n = Number(value);
+		if (Number.isFinite(n) && n >= 1 && String(n) === value.trim()) return Math.floor(n);
+		if (value.trim()) return value.trim();
+	}
+}
+function normalizePositiveInt(value) {
+	const n = typeof value === "number" ? value : Number(value);
+	if (!Number.isFinite(n) || n < 1) return void 0;
+	return Math.floor(n);
+}
+function normalizeGap(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim()) {
+		const n = Number(value);
+		if (Number.isFinite(n)) return n;
+		const named = value.trim();
+		if (named === "compact" || named === "normal" || named === "spacious") return named;
+		return;
+	}
+}
+function extractGroupArrangeHints(statements) {
+	const hints = { paddingHint: extractGroupPaddingHint(statements) };
+	for (const stmt of statements) {
+		if (stmt.type !== "Directive" || stmt.value == null) continue;
+		switch (stmt.name) {
+			case "chrome": {
+				const chrome = normalizeGroupChrome(stmt.value);
+				if (chrome != null) hints.chrome = chrome;
+				break;
+			}
+			case "icon":
+				hints.icon = String(stmt.value);
+				break;
+			case "iconPaint": {
+				const paint = String(stmt.value).toLowerCase();
+				if (paint === "theme" || paint === "brand") hints.iconPaint = paint;
+				break;
+			}
+			case "iconColor": {
+				const color = String(stmt.value).trim();
+				if (color.length > 0) hints.iconColor = color;
+				break;
+			}
+			case "arrange": {
+				const region = normalizeRegionArrange(stmt.value);
+				const cell = normalizeCellArrange(stmt.value);
+				if (region) hints.arrange = region;
+				else if (cell) hints.cellArrange = cell;
+				break;
+			}
+			case "align": {
+				const align = normalizeRegionAlign(stmt.value);
+				if (align) hints.align = align;
+				break;
+			}
+			case "gap": {
+				const gap = normalizeGap(stmt.value);
+				if (gap != null) hints.gap = gap;
+				break;
+			}
+			case "columns": {
+				const tracks = normalizeTrackSpec(stmt.value);
+				if (tracks != null) hints.columns = tracks;
+				break;
+			}
+			case "rows": {
+				const tracks = normalizeTrackSpec(stmt.value);
+				if (tracks != null) hints.rows = tracks;
+				break;
+			}
+			case "column": {
+				const ref = normalizeTrackRef(stmt.value);
+				if (ref != null) hints.column = ref;
+				break;
+			}
+			case "row": {
+				const ref = normalizeTrackRef(stmt.value);
+				if (ref != null) hints.row = ref;
+				break;
+			}
+			case "span": {
+				const n = normalizePositiveInt(stmt.value);
+				if (n != null) hints.span = n;
+				break;
+			}
+			case "colSpan": {
+				const n = normalizePositiveInt(stmt.value);
+				if (n != null) hints.colSpan = n;
+				break;
+			}
+			case "rowSpan": {
+				const n = normalizePositiveInt(stmt.value);
+				if (n != null) hints.rowSpan = n;
+				break;
+			}
+			default: break;
+		}
+	}
+	return hints;
+}
+function removedPresentationDiagnostics(props, range) {
+	const out = [];
+	for (const key of REMOVED_PRESENTATION_PROPS) {
+		if (!(key in props)) continue;
+		out.push({
+			severity: "warning",
+			code: "FM210",
+			message: `presentation.${key} was removed — SVG is chromeless by default; set title, legend, padding, groupAccent, etc. explicitly`,
+			range,
+			hint: key === "preset" ? "Presets (document/slide/print/embed) no longer exist." : `Drop ${key}; backgrounds, grids, and frames are not part of the SVG embed model.`
+		});
+	}
+	return out;
+}
+function extractHints(diagram) {
+	const layoutHints = {};
+	const routingHints = {};
+	const renderHints = {};
+	const diagnostics = [];
+	let presentationLayers = [];
+	for (const stmt of diagram.statements) {
+		if (stmt.type === "Directive") {
+			if (stmt.name === "direction" && stmt.value) layoutHints.direction = normalizeDirection(String(stmt.value));
+			if (stmt.name === "density" && stmt.value) {
+				if (isRemovedDensityAlias(stmt.value)) diagnostics.push({
+					severity: "error",
+					code: "FM112",
+					message: `density "${String(stmt.value)}" is not supported`,
+					range: stmt.range,
+					hint: "Use density compact, normal, or spacious"
+				});
+				const density = normalizeDensity(stmt.value);
+				if (density) layoutHints.density = density;
+			}
+		}
+		if (stmt.type === "LayoutBlock") {
+			if (stmt.properties.direction) layoutHints.direction = normalizeDirection(String(stmt.properties.direction));
+			if (stmt.properties.density) {
+				if (isRemovedDensityAlias(stmt.properties.density)) diagnostics.push({
+					severity: "error",
+					code: "FM112",
+					message: `density "${String(stmt.properties.density)}" is not supported`,
+					range: stmt.range,
+					hint: "Use density compact, normal, or spacious"
+				});
+				const density = normalizeDensity(stmt.properties.density);
+				if (density) layoutHints.density = density;
+			}
+			if (stmt.properties.spacingScale != null) {
+				const spacingScale = optionalNumber(stmt.properties.spacingScale);
+				if (spacingScale != null) layoutHints.spacingScale = spacingScale;
+			}
+			const groupLayout = normalizeGroupLayout(stmt.properties.groupLayout);
+			if (groupLayout) layoutHints.groupLayout = groupLayout;
+			const nodePlacement = normalizeNodePlacement(stmt.properties.nodePlacement);
+			if (nodePlacement) layoutHints.nodePlacement = nodePlacement;
+			const considerModelOrder = normalizeBool(stmt.properties.considerModelOrder);
+			if (considerModelOrder != null) layoutHints.considerModelOrder = considerModelOrder;
+			const groupGap = optionalNumber(stmt.properties.groupGap);
+			if (groupGap != null) layoutHints.groupGap = groupGap;
+			const edgeNodeSpacing = optionalNumber(stmt.properties.edgeNodeSpacing);
+			if (edgeNodeSpacing != null) layoutHints.edgeNodeSpacing = edgeNodeSpacing;
+			const edgeEdgeSpacing = optionalNumber(stmt.properties.edgeEdgeSpacing);
+			if (edgeEdgeSpacing != null) layoutHints.edgeEdgeSpacing = edgeEdgeSpacing;
+			const edgeLabelSpacing = optionalNumber(stmt.properties.edgeLabelSpacing);
+			if (edgeLabelSpacing != null) layoutHints.edgeLabelSpacing = edgeLabelSpacing;
+			const arrange = normalizeRegionArrange(stmt.properties.arrange);
+			if (arrange) layoutHints.arrange = arrange;
+			const align = normalizeRegionAlign(stmt.properties.align);
+			if (align) layoutHints.align = align;
+			const gap = normalizeGap(stmt.properties.gap);
+			if (gap != null) layoutHints.gap = gap;
+			const columns = normalizeTrackSpec(stmt.properties.columns);
+			if (columns != null) layoutHints.columns = columns;
+			const rows = normalizeTrackSpec(stmt.properties.rows);
+			if (rows != null) layoutHints.rows = rows;
+			const edgeGap = stmt.properties.edgeGap != null ? String(stmt.properties.edgeGap) : "";
+			if (edgeGap === "tight" || edgeGap === "normal" || edgeGap === "wide") {
+				const p = {
+					tight: {
+						edgeNodeSpacing: 28,
+						edgeEdgeSpacing: 14,
+						edgeLabelSpacing: 10
+					},
+					normal: {
+						edgeNodeSpacing: 36,
+						edgeEdgeSpacing: 28,
+						edgeLabelSpacing: 16
+					},
+					wide: {
+						edgeNodeSpacing: 72,
+						edgeEdgeSpacing: 56,
+						edgeLabelSpacing: 28
+					}
+				}[edgeGap];
+				if (layoutHints.edgeNodeSpacing == null) layoutHints.edgeNodeSpacing = p.edgeNodeSpacing;
+				if (layoutHints.edgeEdgeSpacing == null) layoutHints.edgeEdgeSpacing = p.edgeEdgeSpacing;
+				if (layoutHints.edgeLabelSpacing == null) layoutHints.edgeLabelSpacing = p.edgeLabelSpacing;
+			}
+		}
+		if (stmt.type === "EdgePolicyBlock") {
+			if (stmt.properties.route) routingHints.route = String(stmt.properties.route);
+			if (stmt.properties.crossings) {
+				const crossings = normalizeCrossings(stmt.properties.crossings);
+				if (crossings) routingHints.crossings = crossings;
+			}
+			if (stmt.properties.cornerRadius != null) routingHints.cornerRadius = Number(stmt.properties.cornerRadius);
+			if (stmt.properties.parallel) routingHints.parallel = String(stmt.properties.parallel);
+			if (stmt.properties.arrowheads != null) routingHints.arrowheads = stmt.properties.arrowheads !== false;
+		}
+		if (stmt.type === "PresentationBlock") {
+			diagnostics.push(...removedPresentationDiagnostics(stmt.properties, stmt.range));
+			presentationLayers.push(presentationFromProperties(stmt.properties));
+		}
+		if (stmt.type === "RenderBlock") {
+			if (stmt.properties.theme) renderHints.theme = String(stmt.properties.theme);
+			if (stmt.properties.shadows != null) renderHints.shadows = stmt.properties.shadows !== false;
+			if (stmt.properties.roundedCorners != null) renderHints.roundedCorners = stmt.properties.roundedCorners !== false;
+			const presentationPreset = stmt.properties.presentation;
+			if (typeof presentationPreset === "string") diagnostics.push({
+				severity: "warning",
+				code: "FM210",
+				message: `render.presentation: "${presentationPreset}" presets were removed — SVG is chromeless by default`,
+				range: stmt.range,
+				hint: "Use presentation { title, padding, groupAccent, … } for opt-in chrome."
+			});
+			else {
+				diagnostics.push(...removedPresentationDiagnostics(stmt.properties, stmt.range));
+				presentationLayers.push(presentationFromProperties(stmt.properties));
+			}
+		}
+	}
+	const mergedPresentation = mergePresentationOptions(...presentationLayers);
+	if (mergedPresentation) renderHints.presentation = mergedPresentation;
+	return {
+		layoutHints,
+		routingHints,
+		renderHints,
+		diagnostics
+	};
+}
+function compile(ast, diagramIndex = 0) {
+	const top = ast.body[diagramIndex];
+	if (top?.type === "Sequence") return compileSequence(ast, diagramIndex);
+	const diagnostics = [...ast.diagnostics];
+	const diagram = top;
+	if (!diagram || diagram.type !== "Diagram") {
+		diagnostics.push({
+			severity: "error",
+			code: "FM100",
+			message: "No diagram found in document",
+			range: {
+				start: {
+					line: 1,
+					column: 1,
+					offset: 0
+				},
+				end: {
+					line: 1,
+					column: 1,
+					offset: 0
+				}
+			}
+		});
+		return {
+			graph: {
+				id: "empty",
+				nodes: [],
+				edges: [],
+				groups: [],
+				styles: [],
+				animations: [],
+				diagnostics
+			},
+			layoutHints: {},
+			routingHints: {},
+			renderHints: {},
+			diagnostics
+		};
+	}
+	const nodes = /* @__PURE__ */ new Map();
+	const edges = [];
+	const groups = [];
+	const styles = [];
+	const pendingGroupMembers = [];
+	collectStatements(diagram.statements, {
+		nodes,
+		edges,
+		groups,
+		styles,
+		diagnostics,
+		groupStack: [],
+		edgeCounter: 0,
+		pendingGroupMembers
+	});
+	for (const pending of pendingGroupMembers) {
+		const node = nodes.get(pending.nodeId);
+		const group = groups.find((g) => g.id === pending.groupId);
+		if (node && group) {
+			node.groupId = pending.groupId;
+			if (!group.nodeIds.includes(pending.nodeId)) group.nodeIds.push(pending.nodeId);
+			if (!group.members?.some((m) => m.kind === "node" && m.id === pending.nodeId)) group.members?.push({
+				kind: "node",
+				id: pending.nodeId
+			});
+		} else diagnostics.push({
+			severity: "warning",
+			code: "FM106",
+			message: `Group membership references unknown node "${pending.nodeId}"`,
+			range: pending.range
+		});
+	}
+	for (const edge of edges) {
+		if (!nodes.has(edge.from)) diagnostics.push({
+			severity: "error",
+			code: "FM103",
+			message: `Edge references unknown node "${edge.from}"`,
+			range: edge.sourceRange ?? diagram.range
+		});
+		if (!nodes.has(edge.to)) diagnostics.push({
+			severity: "error",
+			code: "FM104",
+			message: `Edge references unknown node "${edge.to}"`,
+			range: edge.sourceRange ?? diagram.range
+		});
+	}
+	let edgeCounter = edges.length;
+	for (const node of nodes.values()) {
+		if (!node.columns) continue;
+		for (const col of node.columns) {
+			const ref = col.references;
+			if (!ref) continue;
+			const target = nodes.get(ref.table);
+			if (!target) {
+				diagnostics.push({
+					severity: "error",
+					code: "FM107",
+					message: `FK "${node.id}.${col.name}" references unknown table "${ref.table}"`,
+					range: node.sourceRange ?? diagram.range
+				});
+				continue;
+			}
+			if (findColumnIndex(target.columns, ref.column) < 0 && target.columns?.length) diagnostics.push({
+				severity: "warning",
+				code: "FM108",
+				message: `FK "${node.id}.${col.name}" references unknown column "${ref.table}.${ref.column}"`,
+				range: node.sourceRange ?? diagram.range
+			});
+			const card = fkCardinality(col.notNull);
+			const existing = edges.find((e) => e.from === ref.table && e.to === node.id && (e.fromColumn == null || e.fromColumn === ref.column) && (e.toColumn == null || e.toColumn === col.name));
+			if (existing) {
+				existing.fromColumn ??= ref.column;
+				existing.toColumn ??= col.name;
+				existing.cardinality ??= card;
+				if (existing.identifying == null) existing.identifying = false;
+				continue;
+			}
+			const reverse = edges.find((e) => e.from === node.id && e.to === ref.table && (e.fromColumn == null || e.fromColumn === col.name) && (e.toColumn == null || e.toColumn === ref.column));
+			if (reverse) {
+				reverse.fromColumn ??= col.name;
+				reverse.toColumn ??= ref.column;
+				reverse.cardinality ??= {
+					from: card.to,
+					to: card.from
+				};
+				if (reverse.identifying == null) reverse.identifying = false;
+				continue;
+			}
+			edgeCounter++;
+			edges.push({
+				id: `e${edgeCounter}`,
+				from: ref.table,
+				to: node.id,
+				fromColumn: ref.column,
+				toColumn: col.name,
+				kind: "sync",
+				styleRefs: [],
+				cardinality: card,
+				identifying: false,
+				sourceRange: node.sourceRange
+			});
+		}
+	}
+	for (const edge of edges) {
+		const fromNode = nodes.get(edge.from);
+		const toNode = nodes.get(edge.to);
+		if (edge.fromColumn && fromNode) {
+			if (findColumnIndex(fromNode.columns, edge.fromColumn) < 0) diagnostics.push({
+				severity: "warning",
+				code: "FM109",
+				message: `Edge column "${edge.from}.${edge.fromColumn}" not found on table`,
+				range: edge.sourceRange ?? diagram.range
+			});
+		}
+		if (edge.toColumn && toNode) {
+			if (findColumnIndex(toNode.columns, edge.toColumn) < 0) diagnostics.push({
+				severity: "warning",
+				code: "FM110",
+				message: `Edge column "${edge.to}.${edge.toColumn}" not found on table`,
+				range: edge.sourceRange ?? diagram.range
+			});
+		}
+		if (edge.fromColumn && edge.toColumn && !parseCardinality(edge.label)) {
+			const toFk = toNode?.columns?.find((c) => c.name === edge.toColumn && c.keys.includes("fk"));
+			const fromFk = fromNode?.columns?.find((c) => c.name === edge.fromColumn && c.keys.includes("fk"));
+			const refined = toFk ? fkCardinality(toFk.notNull) : fromFk ? (() => {
+				const c = fkCardinality(fromFk.notNull);
+				return {
+					from: c.to,
+					to: c.from
+				};
+			})() : void 0;
+			if (refined) {
+				const looksLikeGenericDefault = edge.cardinality?.from === "one" && edge.cardinality?.to === "zeroOrMany";
+				if (!edge.cardinality || looksLikeGenericDefault) edge.cardinality = refined;
+			}
+		}
+		if (edge.identifying == null && (edge.fromColumn || edge.toColumn) && fromNode?.shape === "table" && toNode?.shape === "table") edge.identifying = false;
+	}
+	if (diagram.diagramKind === "state") {
+		const initialNodes = [...nodes.values()].filter((node) => node.kind === "initial");
+		const finalNodes = [...nodes.values()].filter((node) => node.kind === "final");
+		if (initialNodes.length !== 1) diagnostics.push({
+			severity: initialNodes.length === 0 ? "warning" : "error",
+			code: "FM150",
+			message: initialNodes.length === 0 ? "State diagram has no initial pseudostate" : "State diagram must have exactly one initial pseudostate",
+			range: initialNodes[1]?.sourceRange ?? diagram.range,
+			hint: "Declare one symbolic entry node, for example `entry: initial \"Start\"`."
+		});
+		if (finalNodes.length === 0) diagnostics.push({
+			severity: "warning",
+			code: "FM151",
+			message: "State diagram has no final state",
+			range: diagram.range,
+			hint: "Declare at least one terminal node, for example `done: final \"Completed\"`."
+		});
+		for (const node of initialNodes) {
+			const incoming = edges.filter((edge) => edge.to === node.id);
+			const outgoing = edges.filter((edge) => edge.from === node.id);
+			if (incoming.length > 0) diagnostics.push({
+				severity: "error",
+				code: "FM152",
+				message: `Initial pseudostate "${node.id}" cannot have incoming transitions`,
+				range: incoming[0]?.sourceRange ?? node.sourceRange ?? diagram.range
+			});
+			if (outgoing.length !== 1) diagnostics.push({
+				severity: "warning",
+				code: "FM153",
+				message: `Initial pseudostate "${node.id}" should have exactly one outgoing transition`,
+				range: node.sourceRange ?? diagram.range
+			});
+		}
+		for (const node of finalNodes) {
+			const outgoing = edges.find((edge) => edge.from === node.id);
+			if (outgoing) diagnostics.push({
+				severity: "error",
+				code: "FM154",
+				message: `Final state "${node.id}" cannot have outgoing transitions`,
+				range: outgoing.sourceRange ?? node.sourceRange ?? diagram.range
+			});
+		}
+	}
+	const graph = {
+		id: diagram.name ? diagram.name.toLowerCase().replace(/\s+/g, "-") : "diagram",
+		title: diagram.name,
+		diagramKind: diagram.diagramKind,
+		nodes: [...nodes.values()],
+		edges,
+		groups,
+		styles,
+		animations: compileAnimationBlocks(collectAnimationBlocks(diagram.statements), nodes, diagnostics),
+		diagnostics
+	};
+	const hints = extractHints(diagram);
+	diagnostics.push(...hints.diagnostics);
+	const { diagnostics: _hintDiags, ...hintFields } = hints;
+	if (diagram.diagramKind === "state") hintFields.layoutHints = {
+		...hintFields.layoutHints,
+		direction: hintFields.layoutHints.direction ?? "TD"
+	};
+	return {
+		graph,
+		...hintFields,
+		diagnostics
+	};
+}
+function collectAnimationBlocks(statements) {
+	const blocks = [];
+	for (const stmt of statements) {
+		if (stmt.type === "AnimationBlock") blocks.push(stmt);
+		if (stmt.type === "Group") blocks.push(...collectAnimationBlocks(stmt.statements));
+	}
+	return blocks;
+}
+//#endregion
+//#region src/format/print.ts
+const INDENT = "  ";
+function formatSource(source) {
+	const ast = parse(source);
+	if (ast.diagnostics.some((d) => d.severity === "error")) return source.trimEnd() + "\n";
+	return printDocument(ast);
+}
+function printDocument(ast) {
+	const parts = [];
+	if (ast.version != null) parts.push(`kdiagram ${ast.version}`);
+	parts.push(...ast.body.map(printTopLevel));
+	return parts.join("\n\n") + "\n";
+}
+function printTopLevel(node) {
+	if (node.type === "Sequence") return printSequence(node);
+	return printDiagram(node);
+}
+function printDiagram(diagram) {
+	const keyword = diagram.diagramKind === "state" ? "state" : "diagram";
+	const lines = [diagram.name != null ? `${keyword} "${diagram.name}" {` : `${keyword} {`];
+	const policy = diagram.statements.filter(isDiagramPolicyStatement);
+	const content = diagram.statements.filter((statement) => !isDiagramPolicyStatement(statement));
+	for (const statement of policy) printStatement(statement, 1, lines);
+	if (policy.length > 0 && content.length > 0) lines.push("");
+	let previousContent;
+	for (const statement of content) {
+		const adjacentInSource = previousContent != null && diagram.statements.indexOf(statement) === diagram.statements.indexOf(previousContent) + 1;
+		if (previousContent && adjacentInSource && hasBlankLineBetween(previousContent, statement)) lines.push("");
+		printStatement(statement, 1, lines);
+		previousContent = statement;
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+function isDiagramPolicyStatement(statement) {
+	return diagramPolicyRank(statement) < Number.POSITIVE_INFINITY;
+}
+function diagramPolicyRank(statement) {
+	if (statement.type === "Directive" && statement.name === "direction") return 0;
+	if (statement.type === "Directive" && statement.name === "density") return 1;
+	if (statement.type === "LayoutBlock") return 2;
+	if (statement.type === "EdgePolicyBlock") return 3;
+	if (statement.type === "RenderBlock") return 4;
+	if (statement.type === "PresentationBlock") return 5;
+	return Number.POSITIVE_INFINITY;
+}
+function printSequence(seq) {
+	const lines = [seq.name != null ? `sequence "${seq.name}" {` : "sequence {"];
+	printSeparated(seq.statements, lines, (stmt) => printSequenceStatement(stmt, 1, lines));
+	lines.push("}");
+	return lines.join("\n");
+}
+function printSequenceStatement(stmt, depth, lines) {
+	const pad = INDENT.repeat(depth);
+	switch (stmt.type) {
+		case "SequenceActivate":
+			lines.push(`${pad}activate ${stmt.participantId}`);
+			break;
+		case "SequenceDeactivate":
+			lines.push(`${pad}deactivate ${stmt.participantId}`);
+			break;
+		case "SequenceCreate": {
+			const n = stmt.node;
+			const isSuffix = n.styleRefs.map((s) => ` is ${s}`).join("");
+			printPropsBlock(`${pad}create ${n.id}: ${n.kind}${n.label ? ` "${n.label}"` : ""}${isSuffix}`, n.properties, depth, lines);
+			break;
+		}
+		case "SequenceDestroy":
+			lines.push(`${pad}destroy ${stmt.participantId}`);
+			break;
+		case "SequenceNote": {
+			const ids = stmt.participantIds.join(", ");
+			const place = stmt.placement === "over" ? `over ${ids}` : stmt.placement === "left" ? `left of ${ids}` : `right of ${ids}`;
+			lines.push(`${pad}note ${place} "${stmt.text}"`);
+			break;
+		}
+		case "SequenceDivider":
+			lines.push(stmt.label ? `${pad}divider "${stmt.label}"` : `${pad}divider`);
+			break;
+		case "SequenceAutonumber":
+			lines.push(`${pad}autonumber`);
+			break;
+		case "SequenceFragment": {
+			const label = stmt.label ? ` "${stmt.label}"` : "";
+			for (let i = 0; i < stmt.operands.length; i++) {
+				const op = stmt.operands[i];
+				const keyword = i === 0 ? stmt.operator : stmt.operator === "parallel" ? "and" : "else";
+				const opLabel = i === 0 ? label : op.label ? ` "${op.label}"` : "";
+				const styleSuffix = op.styleRefs.map((s) => ` is ${s}`).join("");
+				lines.push(`${pad}${keyword}${opLabel}${styleSuffix} {`);
+				printSeparated(op.statements, lines, (inner) => printSequenceStatement(inner, depth + 1, lines));
+				lines.push(`${pad}}`);
+			}
+			break;
+		}
+		default:
+			printStatement(stmt, depth, lines);
+			break;
+	}
+}
+function printStatement(stmt, depth, lines) {
+	const pad = INDENT.repeat(depth);
+	switch (stmt.type) {
+		case "Directive":
+			lines.push(`${pad}${printDirective(stmt)}`);
+			break;
+		case "Node": {
+			const isSuffix = stmt.styleRefs.map((s) => ` is ${s}`).join("");
+			printPropsBlock(`${pad}${stmt.id}: ${stmt.kind}${stmt.label ? ` "${stmt.label}"` : ""}${isSuffix}`, stmt.properties, depth, lines);
+			break;
+		}
+		case "Edge": {
+			const from = stmt.fromColumn ? `${stmt.from}.${stmt.fromColumn}` : stmt.from;
+			const to = stmt.toColumn ? `${stmt.to}.${stmt.toColumn}` : stmt.to;
+			const label = stmt.label ? ` "${stmt.label}"` : "";
+			const isSuffix = stmt.styleRefs.map((s) => ` is ${s}`).join("");
+			printPropsBlock(`${pad}${from} ${stmt.op} ${to}${label}`, stmt.properties, depth, lines, isSuffix);
+			break;
+		}
+		case "Group":
+			printGroup(stmt, depth, lines);
+			break;
+		case "Style": {
+			const forTarget = stmt.target === "edge" ? " for edge" : stmt.target === "fragment" ? " for fragment" : "";
+			printPropertyBlock(`${pad}style ${stmt.name}${forTarget}`, stmt.properties, depth, lines);
+			break;
+		}
+		case "StyleRef":
+			lines.push(`${pad}${stmt.targetIds.join(", ")} is ${stmt.styleName}`);
+			break;
+		case "GroupMember":
+			lines.push(`${pad}${stmt.nodeIds.join(", ")}`);
+			break;
+		case "LayoutBlock":
+			printPropertyBlock(`${pad}layout`, stmt.properties, depth, lines);
+			break;
+		case "EdgePolicyBlock":
+			printPropertyBlock(`${pad}edges`, stmt.properties, depth, lines);
+			break;
+		case "RenderBlock":
+			printPropertyBlock(`${pad}render`, stmt.properties, depth, lines);
+			break;
+		case "PresentationBlock":
+			printPropertyBlock(`${pad}presentation`, stmt.properties, depth, lines);
+			break;
+		case "AnimationBlock":
+			lines.push(`${pad}animation "${stmt.name}" {`);
+			printSeparated(stmt.cues, lines, (cue) => {
+				for (const line of formatAnimationCueLines(cue)) lines.push(line ? `${pad}${INDENT}${line}` : "");
+			});
+			lines.push(`${pad}}`);
+			break;
+	}
+}
+function printDirective(stmt) {
+	const value = Array.isArray(stmt.value) ? stmt.value.join(", ") : stmt.value ?? "";
+	return stmt.name === "direction" || stmt.name === "density" ? `${stmt.name} ${value}` : `${stmt.name}: ${value}`;
+}
+function formatAnimationCueLines(cue) {
+	if (cue.type === "parallel") {
+		const lines = ["parallel {"];
+		let previous;
+		for (const child of cue.cues) {
+			if (previous && hasBlankLineBetween(previous, child)) lines.push("");
+			for (const line of formatAnimationCueLines(child)) lines.push(line ? `${INDENT}${line}` : "");
+			previous = child;
+		}
+		lines.push("}");
+		return lines;
+	}
+	return [formatAnimationCue(cue)];
+}
+function formatAnimationCue(cue) {
+	switch (cue.type) {
+		case "loop": return "loop";
+		case "wait": return `wait ${formatDuration(cue.durationMs)}`;
+		case "dim":
+		case "activate": return `${cue.type} ${cue.targets.map(formatAnimationTarget).join(", ")}`;
+		case "pulse": {
+			const dur = cue.durationMs != null ? ` for ${formatDuration(cue.durationMs)}` : "";
+			return `pulse ${cue.targets.map(formatAnimationTarget).join(", ")}${dur}`;
+		}
+		case "flow": {
+			const dur = cue.durationMs != null ? ` for ${formatDuration(cue.durationMs)}` : "";
+			return `flow ${cue.path.join(" -> ")}${dur}`;
+		}
+		case "parallel": return "parallel { … }";
+	}
+}
+function formatAnimationTarget(t) {
+	if (t.type === "all") return "*";
+	if (t.type === "node") return t.id;
+	return `${t.from} -> ${t.to}`;
+}
+function formatDuration(ms) {
+	if (ms >= 1e3 && ms % 100 === 0) return `${ms / 1e3}s`;
+	return `${ms}ms`;
+}
+function printPropsBlock(head, properties, depth, lines, tail = "") {
+	const pad = INDENT.repeat(depth);
+	const entries = Object.entries(properties);
+	if (entries.length === 0) {
+		lines.push(`${head}${tail}`);
+		return;
+	}
+	if (entries.length === 1 && entries[0][0] !== "columns") {
+		const [key, value] = entries[0];
+		lines.push(`${head} { ${key}: ${formatValue(value)} }${tail}`);
+		return;
+	}
+	lines.push(`${head} {`);
+	for (const [k, v] of entries) {
+		if (k === "columns" && Array.isArray(v)) {
+			lines.push(`${pad}${INDENT}columns {`);
+			for (const raw of v) {
+				const col = parseTableColumnSpec(String(raw));
+				const line = col ? formatTableColumnLine(col) : String(raw);
+				lines.push(`${pad}${INDENT}${INDENT}${line}`);
+			}
+			lines.push(`${pad}${INDENT}}`);
+			continue;
+		}
+		lines.push(`${pad}${INDENT}${k}: ${formatValue(v)}`);
+	}
+	lines.push(`${pad}}${tail}`);
+}
+function printGroup(group, depth, lines) {
+	const pad = INDENT.repeat(depth);
+	const id = group.id ? `${group.id} ` : "";
+	const label = group.label != null ? `"${group.label}" ` : "";
+	lines.push(`${pad}${group.groupKind} ${id}${label}{`);
+	printSeparated(group.statements, lines, (stmt) => printStatement(stmt, depth + 1, lines));
+	lines.push(`${pad}}`);
+}
+function printPropertyBlock(head, properties, depth, lines) {
+	const entries = Object.entries(properties);
+	if (entries.length === 0) {
+		lines.push(`${head} {}`);
+		return;
+	}
+	if (entries.length === 1) {
+		const [key, value] = entries[0];
+		lines.push(`${head} { ${key}: ${formatValue(value)} }`);
+		return;
+	}
+	const pad = INDENT.repeat(depth);
+	lines.push(`${head} {`);
+	for (const [key, value] of entries) lines.push(`${pad}${INDENT}${key}: ${formatValue(value)}`);
+	lines.push(`${pad}}`);
+}
+function printSeparated(items, lines, print) {
+	let previous;
+	for (const item of items) {
+		if (previous && hasBlankLineBetween(previous, item)) lines.push("");
+		print(item);
+		previous = item;
+	}
+}
+function hasBlankLineBetween(previous, next) {
+	return next.range.start.line > previous.range.end.line + 1;
+}
+function formatValue(v) {
+	if (Array.isArray(v)) return `[${v.map((x) => `"${x}"`).join(", ")}]`;
+	if (typeof v === "string") return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(v) ? v : JSON.stringify(v);
+	return String(v);
+}
+//#endregion
+//#region src/types/graph.ts
+function mergeOptions(defaults, ...layers) {
+	const result = { ...defaults };
+	for (const layer of layers) {
+		if (!layer) continue;
+		for (const [k, v] of Object.entries(layer)) if (v !== void 0) result[k] = v;
+	}
+	return result;
+}
+//#endregion
+//#region src/types/geometry.ts
+function rectCenter(r) {
+	return {
+		x: r.x + r.width / 2,
+		y: r.y + r.height / 2
+	};
+}
+function rectRight(r) {
+	return r.x + r.width;
+}
+function rectBottom(r) {
+	return r.y + r.height;
+}
+function rectsOverlap(a, b, gap = 0) {
+	return !(a.x + a.width + gap <= b.x || b.x + b.width + gap <= a.x || a.y + a.height + gap <= b.y || b.y + b.height + gap <= a.y);
+}
+function expandRect(r, pad) {
+	return {
+		x: r.x - pad,
+		y: r.y - pad,
+		width: r.width + pad * 2,
+		height: r.height + pad * 2
+	};
+}
+function manhattan(a, b) {
+	return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+}
+//#endregion
+export { BUILTIN_KIND_CATALOG, BUILTIN_KIND_LIST, BUILTIN_SHAPE_IDS, EDGE_OPS, REMOVED_PRESENTATION_PROPS, SEQUENCE_FRAGMENT_ALIASES, STATEMENT_KEYWORDS, animationIdFromName, bindSequenceFlowEdgeIds, cardinalityLabel, classifyBranch, compile, displayLabelCase, edgeOpsPattern, enumerateAutoPaths, expandRect, findColumnIndex, fkCardinality, flowHopEdgeId, formatLabelText, formatSource, formatTableColumnLine, getKindDefaults, inferAutoAnimation, isBuiltinKind, isGeometryKind, isKnownShapeId, isPureCardinalityLabel, kindHasCapability, kindSubtitle, listBuiltinShapeIds, listGeometryKinds, listKindsByCategory, manhattan, mergeOptions, mergePresentationOptions, normalizeBranch, normalizeSequenceFragmentOperator, normalizeShapeId, parse, parseCardinality, parseTableColumnSpec, parseTableColumns, planAutoWalk, presentationFromProperties, rectBottom, rectCenter, rectRight, rectsOverlap, resolvePresentation, sequenceFragmentDisplayName, traceDeclarationPath };
+
+//# sourceMappingURL=index.mjs.map