@dxos/diagram 0.11.1

package/dist/lib/index.mjs

@@ -0,0 +1,3975 @@
+import { invariant } from "@dxos/invariant";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import ELK from "elkjs/lib/elk.bundled.js";
+import * as SchemaAST from "effect/SchemaAST";
+import { graphlib, layout } from "@dagrejs/dagre";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/content.ts
+var __dxlog_file$3 = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/infinite-canvas-depth-7e0949/packages/common/diagram/src/content.ts";
+/** Apply a batch of edit commands to the canvas content (mutates `content`). */
+var applyCommands = (content, commands, handler) => {
+	handler.scaffold?.(content);
+	const upserted = /* @__PURE__ */ new Set();
+	let removed = 0;
+	const find = (objectId) => handler.read(content).scene.objects.find((object) => object.id === objectId);
+	const merge = (object, placement) => {
+		const records = handler.render(object, placement, content);
+		if (handler.merge) handler.merge(content, records);
+		else Object.assign(content, records);
+	};
+	const remove = (predicate) => {
+		let count = 0;
+		for (const [key, record] of Object.entries(content)) {
+			const identity = handler.identify(record);
+			if (identity && predicate(identity)) {
+				const isPart = identity.part !== void 0;
+				delete content[key];
+				if (!isPart) count++;
+			}
+		}
+		handler.prune?.(content);
+		return count;
+	};
+	for (const command of commands) switch (command.op) {
+		case "upsert-object": {
+			const previous = find(command.object.id);
+			removed += remove((identity) => identity.object === command.object.id);
+			merge(command.object, {
+				origin: command.object.origin ?? previous?.origin ?? {
+					x: 0,
+					y: 0
+				},
+				scale: command.object.scale ?? previous?.scale ?? 1
+			});
+			upserted.add(command.object.id);
+			break;
+		}
+		case "upsert-elements": {
+			const previous = find(command.objectId);
+			invariant(previous, `unknown object: ${command.objectId} (use upsert-object to create it)`, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 128,
+				S: void 0,
+				A: ["previous", "`unknown object: ${command.objectId} (use upsert-object to create it)`"]
+			});
+			const ids = new Set(command.elements.map((element) => element.id));
+			removed += remove((identity) => identity.object === command.objectId && ids.has(identity.element));
+			merge({
+				id: command.objectId,
+				elements: command.elements
+			}, previous);
+			upserted.add(command.objectId);
+			break;
+		}
+		case "remove-elements": {
+			const ids = new Set(command.elementIds);
+			removed += remove((identity) => identity.object === command.objectId && ids.has(identity.element));
+			break;
+		}
+		case "remove-object":
+			removed += remove((identity) => identity.object === command.objectId);
+			break;
+		case "move-object": {
+			const previous = find(command.objectId);
+			invariant(previous, `unknown object: ${command.objectId}`, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 149,
+				S: void 0,
+				A: ["previous", "`unknown object: ${command.objectId}`"]
+			});
+			const delta = {
+				x: command.origin.x - previous.origin.x,
+				y: command.origin.y - previous.origin.y
+			};
+			for (const record of Object.values(content)) if (handler.identify(record)?.object === command.objectId) handler.translate(record, delta);
+			upserted.add(command.objectId);
+			break;
+		}
+	}
+	return {
+		upserted: [...upserted],
+		removed
+	};
+};
+/** Seed a fractional-index counter past any existing `a<n>` indexes. */
+var nextIndex = (content, isCounted = () => true) => {
+	let max = 0;
+	let count = 0;
+	for (const record of Object.values(content)) {
+		if (!record || !isCounted(record)) continue;
+		count++;
+		const match = /^a(\d+)$/.exec(record.index ?? "");
+		if (match) max = Math.max(max, Number(match[1]));
+	}
+	return Math.max(max, count);
+};
+//#endregion
+//#region src/scene.ts
+var scene_exports = /* @__PURE__ */ __exportAll({
+	Arc: () => Arc,
+	Arrow: () => Arrow,
+	ArrowHead: () => ArrowHead,
+	ArrowTail: () => ArrowTail,
+	Box: () => Box,
+	Circle: () => Circle,
+	Color: () => Color,
+	Command: () => Command,
+	Curve: () => Curve,
+	Element: () => Element,
+	Fill: () => Fill,
+	MoveObject: () => MoveObject,
+	Point: () => Point,
+	Polyline: () => Polyline,
+	Portal: () => Portal,
+	RemoveElements: () => RemoveElements,
+	RemoveObject: () => RemoveObject,
+	Scene: () => Scene,
+	Stroke: () => Stroke,
+	Text: () => Text,
+	UpsertElements: () => UpsertElements,
+	UpsertObject: () => UpsertObject,
+	Weight: () => Weight,
+	WorldObject: () => WorldObject,
+	formatRef: () => formatRef,
+	parseRef: () => parseRef,
+	resolveRef: () => resolveRef
+});
+var Color = Schema.Literals([
+	"black",
+	"grey",
+	"light-violet",
+	"violet",
+	"blue",
+	"light-blue",
+	"yellow",
+	"orange",
+	"green",
+	"light-green",
+	"light-red",
+	"red",
+	"white"
+]);
+var Fill = Schema.Literals([
+	"none",
+	"solid",
+	"pattern"
+]);
+var Stroke = Schema.Literals([
+	"sketchy",
+	"solid",
+	"dashed",
+	"dotted"
+]);
+var Weight = Schema.Literals([
+	"s",
+	"m",
+	"l",
+	"xl"
+]);
+var Point = Schema.Struct({
+	x: Schema.Number,
+	y: Schema.Number
+});
+/** Style props shared by all elements; every field is optional with sensible defaults. */
+var styleFields = {
+	color: Schema.optional(Color).annotate({ description: "Stroke/text color." }),
+	fill: Schema.optional(Fill).annotate({ description: "Interior fill of closed shapes." }),
+	stroke: Schema.optional(Stroke).annotate({ description: "Stroke rendering; sketchy is hand-drawn." }),
+	weight: Schema.optional(Weight).annotate({ description: "Stroke weight / text size." })
+};
+var id = Schema.String.annotate({ description: "Stable element id, unique within the object (e.g. \"left-eye\"). Used to edit or delete the element." });
+/** Closed shape drawn inside a local bounding box. */
+var Box = Schema.Struct({
+	kind: Schema.Literals([
+		"rect",
+		"ellipse",
+		"diamond",
+		"triangle"
+	]),
+	id,
+	x: Schema.Number.annotate({ description: "Left edge (object-local units)." }),
+	y: Schema.Number.annotate({ description: "Top edge (object-local units)." }),
+	w: Schema.Number,
+	h: Schema.Number,
+	rotation: Schema.optional(Schema.Number).annotate({ description: "Clockwise rotation in degrees." }),
+	text: Schema.optional(Schema.String).annotate({ description: "Centered label." }),
+	corners: Schema.optional(Schema.Literals([
+		"top",
+		"bottom",
+		"none"
+	])).annotate({ description: "Rects only: round just these corners (default all); backends without corner control ignore it." }),
+	...styleFields
+});
+/** Circle sugar; reads back as an ellipse. */
+var Circle = Schema.Struct({
+	kind: Schema.Literal("circle"),
+	id,
+	cx: Schema.Number.annotate({ description: "Center x (object-local units)." }),
+	cy: Schema.Number.annotate({ description: "Center y (object-local units)." }),
+	r: Schema.Number,
+	text: Schema.optional(Schema.String),
+	...styleFields
+});
+/** Straight segment or open polyline through the given points. */
+var Polyline = Schema.Struct({
+	kind: Schema.Literal("line"),
+	id,
+	points: Schema.Array(Point).annotate({ description: "Two or more points (object-local units)." }),
+	closed: Schema.optional(Schema.Boolean).annotate({ description: "Close the path back to the first point." }),
+	...styleFields
+});
+/** Smooth curve through the given points (spline). */
+var Curve = Schema.Struct({
+	kind: Schema.Literal("curve"),
+	id,
+	points: Schema.Array(Point).annotate({ description: "Control points the curve passes through." }),
+	...styleFields
+});
+/**
+* Circular arc sugar; reads back as a curve. Angles are degrees, measured clockwise from
+* the positive x-axis in screen coordinates (y grows downward): 0–180 is the lower half
+* (a smile), 180–360 the upper half (a frown).
+*/
+var Arc = Schema.Struct({
+	kind: Schema.Literal("arc"),
+	id,
+	cx: Schema.Number,
+	cy: Schema.Number,
+	r: Schema.Number,
+	startAngle: Schema.Number,
+	endAngle: Schema.Number,
+	...styleFields
+});
+/** Free-standing text. */
+var Text = Schema.Struct({
+	kind: Schema.Literal("text"),
+	id,
+	x: Schema.Number,
+	y: Schema.Number,
+	w: Schema.optional(Schema.Number).annotate({ description: "Wrap width; omit for auto-size." }),
+	text: Schema.String,
+	...styleFields
+});
+/** UML-style end markers: the head sits at the target, the tail at the source. */
+var ArrowHead = Schema.Literals([
+	"arrow",
+	"triangle",
+	"crowsfoot",
+	"none"
+]);
+var ArrowTail = Schema.Literals(["none", "circle"]);
+/**
+* Connector. Endpoints are element refs — `"<elementId>"` within the same object or
+* `"<objectId>/<elementId>"` across objects, either with an optional `#<port>` naming an
+* attachment point on the element — or explicit local points. Bound endpoints track their
+* target when it moves; without a port the renderer picks the attachment point.
+*/
+var Arrow = Schema.Struct({
+	kind: Schema.Literal("arrow"),
+	id,
+	from: Schema.optional(Schema.String).annotate({ description: "Source element ref, optionally `#port`." }),
+	to: Schema.optional(Schema.String).annotate({ description: "Target element ref, optionally `#port`." }),
+	start: Schema.optional(Point).annotate({ description: "Explicit start (used when `from` is omitted)." }),
+	end: Schema.optional(Point).annotate({ description: "Explicit end (used when `to` is omitted)." }),
+	text: Schema.optional(Schema.String).annotate({ description: "Label at the arrow midpoint." }),
+	head: Schema.optional(ArrowHead).annotate({ description: "Marker at the target end (default arrow): triangle for inheritance, crowsfoot for has-many." }),
+	tail: Schema.optional(ArrowTail).annotate({ description: "Marker at the source end (default none): circle for containment." }),
+	...styleFields
+});
+/** Parse `"[object/]element[#port]"`; element ids may not contain `/` or `#`. */
+var parseRef = (ref) => {
+	const hash = ref.indexOf("#");
+	const target = hash === -1 ? ref : ref.slice(0, hash);
+	const port = hash === -1 ? void 0 : ref.slice(hash + 1);
+	const slash = target.indexOf("/");
+	return {
+		...slash === -1 ? {} : { object: target.slice(0, slash) },
+		element: slash === -1 ? target : target.slice(slash + 1),
+		...port ? { port } : {}
+	};
+};
+/** Inverse of {@link parseRef}. */
+var formatRef = ({ object, element, port }) => `${object === void 0 ? "" : `${object}/`}${element}${port === void 0 ? "" : `#${port}`}`;
+/**
+* Canonical `object/element` handle of a ref, resolving a bare element id against the owning
+* object and dropping the port, so renderers without ports bind to the element itself.
+*/
+var resolveRef = (ref, objectId) => {
+	const { object = objectId, element } = parseRef(ref);
+	return `${object}/${element}`;
+};
+/**
+* Window onto another drawing: the referenced scene is rendered inside the box as a nested level
+* of detail. Renderers without nesting ignore it.
+*/
+var Portal = Schema.Struct({
+	kind: Schema.Literal("portal"),
+	id,
+	x: Schema.Number.annotate({ description: "Left edge (object-local units)." }),
+	y: Schema.Number.annotate({ description: "Top edge (object-local units)." }),
+	w: Schema.Number,
+	h: Schema.Number,
+	ref: Schema.String.annotate({ description: "The drawing shown inside the box: an ECHO object reference (DXN)." }),
+	text: Schema.optional(Schema.String).annotate({ description: "Title shown on the frame." }),
+	...styleFields
+});
+var Element = Schema.Union([
+	Box,
+	Circle,
+	Polyline,
+	Curve,
+	Arc,
+	Text,
+	Arrow,
+	Portal
+]);
+/**
+* A semantic group of elements ("face", "hat") authored in its own local unit space.
+* `origin` (canvas px) and `scale` (px per unit) place it on the canvas:
+* `canvas = origin + local * scale`. On read, `origin` is derived as the top-left of the
+* object's bounding box, so the model survives users dragging shapes around.
+*/
+var WorldObject = Schema.Struct({
+	id: Schema.String.annotate({ description: "Stable object id naming the thing depicted (e.g. \"face\", \"hat\")." }),
+	origin: Schema.optional(Point).annotate({ description: "Canvas position (px). Omit on upsert to keep the current position." }),
+	scale: Schema.optional(Schema.Number).annotate({ description: "Canvas px per local unit (default 1)." }),
+	index: Schema.optional(Schema.String).annotate({ description: "Fractional z-order index (e.g. \"a1\"); objects with one paint above those without, in index order." }),
+	ref: Schema.optional(Schema.String).annotate({ description: "What the object depicts: an ECHO object reference (activating the node opens it) or any other URI or path, carried for tooling." }),
+	elements: Schema.Array(Element)
+});
+var Scene = Schema.Struct({ objects: Schema.Array(WorldObject) });
+var UpsertObject = Schema.Struct({
+	op: Schema.Literal("upsert-object"),
+	object: WorldObject
+}).annotate({ description: "Create an object, or replace an existing one wholesale (same id)." });
+var UpsertElements = Schema.Struct({
+	op: Schema.Literal("upsert-elements"),
+	objectId: Schema.String,
+	elements: Schema.Array(Element)
+}).annotate({ description: "Add elements to an existing object, replacing any with matching ids." });
+var RemoveElements = Schema.Struct({
+	op: Schema.Literal("remove-elements"),
+	objectId: Schema.String,
+	elementIds: Schema.Array(Schema.String)
+});
+var RemoveObject = Schema.Struct({
+	op: Schema.Literal("remove-object"),
+	objectId: Schema.String
+});
+var MoveObject = Schema.Struct({
+	op: Schema.Literal("move-object"),
+	objectId: Schema.String,
+	origin: Point.annotate({ description: "New canvas position (px) for the object top-left." })
+});
+var Command = Schema.Union([
+	UpsertObject,
+	UpsertElements,
+	RemoveElements,
+	RemoveObject,
+	MoveObject
+]);
+//#endregion
+//#region src/dialect.ts
+var __dxlog_file$2 = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/infinite-canvas-depth-7e0949/packages/common/diagram/src/dialect.ts";
+/** The core dialect: input is already scene edit commands (identity compile). */
+var sceneDialect = {
+	id: "scene",
+	description: "Positioned world objects and elements; the agent does the layout.",
+	input: Schema.Array(Command),
+	compile: Effect.succeed
+};
+var DialectRegistry = class {
+	#dialects = /* @__PURE__ */ new Map();
+	constructor(dialects = [sceneDialect]) {
+		dialects.forEach((dialect) => this.register(dialect));
+	}
+	register(dialect) {
+		invariant(!this.#dialects.has(dialect.id), `duplicate dialect: ${dialect.id}`, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 42,
+			S: this,
+			A: ["!this.#dialects.has(dialect.id)", "`duplicate dialect: ${dialect.id}`"]
+		});
+		this.#dialects.set(dialect.id, dialect);
+	}
+	get(id) {
+		return this.#dialects.get(id);
+	}
+	list() {
+		return [...this.#dialects.values()];
+	}
+};
+//#endregion
+//#region src/layout.ts
+var layout_exports = /* @__PURE__ */ __exportAll({
+	FONT_METRICS: () => FONT_METRICS,
+	backEdges: () => backEdges,
+	rank: () => rank$1
+});
+/**
+* Empirical text metrics per scene weight, calibrated to tldraw's draw font (`size` s/m/l/xl runs
+* ~18/25/38/48 px): charW ≈ 0.6–0.67 em, lineH ≈ 1.35 em. Dialects size boxes from these so text
+* fits without the renderer growing shapes over their neighbours.
+*/
+var FONT_METRICS = {
+	s: {
+		charW: 12,
+		lineH: 26
+	},
+	m: {
+		charW: 15,
+		lineH: 34
+	},
+	l: {
+		charW: 23,
+		lineH: 51
+	},
+	xl: {
+		charW: 29,
+		lineH: 65
+	}
+};
+/**
+* Edges that close a cycle, found by DFS: an edge into a node still on the stack points backwards.
+* Ranking ignores them, so `C --> Y --> C` ranks C by its forward predecessors alone instead of
+* chasing the loop.
+*/
+var backEdges = (nodeIds, edges) => {
+	const outgoing = /* @__PURE__ */ new Map();
+	for (const edge of edges) outgoing.set(edge.from, [...outgoing.get(edge.from) ?? [], edge]);
+	const back = /* @__PURE__ */ new Set();
+	const done = /* @__PURE__ */ new Set();
+	const onStack = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		onStack.add(id);
+		for (const edge of outgoing.get(id) ?? []) if (onStack.has(edge.to)) back.add(edge);
+		else if (!done.has(edge.to)) visit(edge.to);
+		onStack.delete(id);
+		done.add(id);
+	};
+	const targets = new Set(edges.map((edge) => edge.to));
+	for (const id of nodeIds) if (!targets.has(id) && !done.has(id)) visit(id);
+	for (const id of nodeIds) if (!done.has(id)) visit(id);
+	return back;
+};
+/** Assign each node a rank one past its deepest forward predecessor. */
+var rank$1 = (nodeIds, edges) => {
+	const back = backEdges(nodeIds, edges);
+	const forward = edges.filter((edge) => !back.has(edge));
+	const ranks = new Map(nodeIds.map((id) => [id, 0]));
+	for (let pass = 0; pass < nodeIds.length; pass++) {
+		let changed = false;
+		for (const edge of forward) {
+			const next = (ranks.get(edge.from) ?? 0) + 1;
+			if (next > (ranks.get(edge.to) ?? 0)) {
+				ranks.set(edge.to, next);
+				changed = true;
+			}
+		}
+		if (!changed) break;
+	}
+	return ranks;
+};
+//#endregion
+//#region src/diagnostics.ts
+var diagnostics_exports = /* @__PURE__ */ __exportAll({
+	Code: () => Code,
+	Diagnostic: () => Diagnostic,
+	SEVERITY: () => SEVERITY,
+	Severity: () => Severity,
+	analyze: () => analyze,
+	errors: () => errors
+});
+var Severity = Schema.Literals(["error", "warning"]);
+/**
+* `error` codes are objective defects — the picture is wrong, not merely busy — and gate CI.
+* `warning` codes are quality metrics that trend rather than pass/fail; they are golden-filed so
+* a layout change reads as a reviewable diff instead of a threshold argument.
+*/
+var Code = Schema.Literals([
+	"node-overlap",
+	"route-through-node",
+	"label-overflow",
+	"edge-crossing",
+	"excessive-bends"
+]);
+var SEVERITY = {
+	"node-overlap": "error",
+	"route-through-node": "error",
+	"label-overflow": "error",
+	"edge-crossing": "warning",
+	"excessive-bends": "warning"
+};
+/** A schema so operations can return diagnostics to the agent — the repair loop. */
+var Diagnostic = Schema.Struct({
+	code: Code,
+	severity: Severity,
+	message: Schema.String,
+	refs: Schema.Array(Schema.String).annotate({ description: "Scene refs implicated: `objectId` or `objectId/elementId`, as `Arrow.from`/`to` spell them." })
+});
+/** Tolerance in scene units; ports land on a half-grid, so this only absorbs float error. */
+var EPSILON = .5;
+var place$1 = (object, point) => {
+	const { x = 0, y = 0 } = object.origin ?? {};
+	const scale = object.scale ?? 1;
+	return {
+		x: x + point.x * scale,
+		y: y + point.y * scale
+	};
+};
+var isBox = (element) => element.kind === "rect" || element.kind === "ellipse" || element.kind === "diamond" || element.kind === "triangle";
+/** Absolute rects for every closed shape, keyed by scene ref. */
+var nodes = (objects) => objects.flatMap((object) => object.elements.filter(isBox).map((element) => {
+	const origin = place$1(object, {
+		x: element.x,
+		y: element.y
+	});
+	const scale = object.scale ?? 1;
+	return {
+		ref: `${object.id}/${element.id}`,
+		rect: {
+			x: origin.x,
+			y: origin.y,
+			w: element.w * scale,
+			h: element.h * scale
+		},
+		text: element.text,
+		weight: element.weight ?? "m"
+	};
+}));
+/**
+* Connector paths, rejoining the `line` prefix and `arrow` head the emitters split a routed edge
+* into (`<id>-path` + `<id>`); a plain arrow is a one-segment path.
+*/
+var connectors = (objects) => {
+	const paths = /* @__PURE__ */ new Map();
+	for (const object of objects) {
+		for (const element of object.elements) if (element.kind === "line") {
+			const id = element.id.replace(/-path$/, "");
+			const ref = `${object.id}/${id}`;
+			paths.set(ref, {
+				ref,
+				points: element.points.map((point) => place$1(object, point))
+			});
+		}
+		for (const element of object.elements) if (element.kind === "arrow" && element.start && element.end) {
+			const ref = `${object.id}/${element.id}`;
+			const head = [place$1(object, element.start), place$1(object, element.end)];
+			const existing = paths.get(ref);
+			paths.set(ref, {
+				ref,
+				points: existing ? [...existing.points.slice(0, -1), ...head] : head
+			});
+		}
+	}
+	return [...paths.values()];
+};
+var segmentsOf$1 = ({ points }) => points.slice(0, -1).map((point, index) => [point, points[index + 1]]);
+var orientation = (origin, a, b) => (a.x - origin.x) * (b.y - origin.y) - (a.y - origin.y) * (b.x - origin.x);
+var coincident = (a, b) => Math.abs(a.x - b.x) < EPSILON && Math.abs(a.y - b.y) < EPSILON;
+/** Proper crossing: the segments intersect away from all four endpoints (shared ports do not count). */
+var properlyCrosses = ([a1, a2], [b1, b2]) => {
+	if ([a1, a2].some((a) => [b1, b2].some((b) => coincident(a, b)))) return false;
+	const d1 = orientation(a1, a2, b1);
+	const d2 = orientation(a1, a2, b2);
+	const d3 = orientation(b1, b2, a1);
+	const d4 = orientation(b1, b2, a2);
+	return d1 > 0 !== d2 > 0 && d3 > 0 !== d4 > 0;
+};
+/** Overlap area of two rects; 0 when they merely touch. */
+var overlapArea = (a, b) => {
+	const w = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);
+	const h = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);
+	return w > EPSILON && h > EPSILON ? w * h : 0;
+};
+/**
+* Strict enclosure: the inner rect fits inside AND is smaller. Two identical rects are stacked
+* nodes — the strongest overlap — not a container and its member.
+*/
+var contains = (outer, inner) => outer.x - EPSILON <= inner.x && outer.y - EPSILON <= inner.y && outer.x + outer.w + EPSILON >= inner.x + inner.w && outer.y + outer.h + EPSILON >= inner.y + inner.h && (inner.w < outer.w - EPSILON || inner.h < outer.h - EPSILON);
+/**
+* Length of the segment's run through the rect's INTERIOR (Liang-Barsky). A connector legitimately
+* terminating at a node only touches its border, so an interior run identifies a route drawn
+* across a node it does not belong to — no knowledge of the edge's terminals required.
+*/
+var interiorRun = ([start, end], rect) => {
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	const box = {
+		x: rect.x + EPSILON,
+		y: rect.y + EPSILON,
+		w: rect.w - EPSILON * 2,
+		h: rect.h - EPSILON * 2
+	};
+	if (box.w <= 0 || box.h <= 0) return 0;
+	let enter = 0;
+	let exit = 1;
+	for (const [p, q] of [
+		[-dx, start.x - box.x],
+		[dx, box.x + box.w - start.x],
+		[-dy, start.y - box.y],
+		[dy, box.y + box.h - start.y]
+	]) {
+		if (p === 0) {
+			if (q < 0) return 0;
+			continue;
+		}
+		const r = q / p;
+		if (p < 0) enter = Math.max(enter, r);
+		else exit = Math.min(exit, r);
+	}
+	return enter >= exit ? 0 : Math.hypot(dx, dy) * (exit - enter);
+};
+/** Bends in an orthogonal path: waypoints where the run changes axis. */
+var bendCount = ({ points }) => {
+	let bends = 0;
+	for (let index = 1; index < points.length - 1; index++) {
+		const [previous, point, next] = [
+			points[index - 1],
+			points[index],
+			points[index + 1]
+		];
+		if (!(Math.abs(previous.x - point.x) < EPSILON && Math.abs(point.x - next.x) < EPSILON || Math.abs(previous.y - point.y) < EPSILON && Math.abs(point.y - next.y) < EPSILON)) bends++;
+	}
+	return bends;
+};
+/**
+* Estimated bounds of a wrapped label, using the shared font metrics the dialects size boxes by.
+* The last line carries no trailing leading: `lineH ≈ 1.35em` (see `FONT_METRICS`), so the glyph
+* block is `(lines − 1) · lineH + em`.
+*/
+var labelFits = ({ rect, text, weight }) => {
+	if (!text) return true;
+	const font = FONT_METRICS[weight];
+	const perLine = Math.max(1, Math.floor(rect.w / font.charW));
+	return (text.split("\n").reduce((total, line) => total + Math.max(1, Math.ceil(line.length / perLine)), 0) - 1) * font.lineH + font.lineH / 1.35 <= rect.h + EPSILON;
+};
+/**
+* Analyzes an emitted scene for layout defects and quality metrics. Pure: the same scene always
+* yields the same report, so the soft metrics can be golden-filed and the hard codes asserted.
+*/
+var analyze = (objects, { maxBends = 3 } = {}) => {
+	const diagnostics = [];
+	const allNodes = nodes(objects);
+	const allConnectors = connectors(objects);
+	const ownerOf = (ref) => ref.slice(0, ref.indexOf("/"));
+	const containers = new Set(allNodes.filter((outer) => allNodes.some((inner) => ownerOf(inner.ref) !== ownerOf(outer.ref) && contains(outer.rect, inner.rect))).map(({ ref }) => ref));
+	for (let i = 0; i < allNodes.length; i++) for (let j = i + 1; j < allNodes.length; j++) {
+		const [left, right] = [allNodes[i], allNodes[j]];
+		if (ownerOf(left.ref) === ownerOf(right.ref)) continue;
+		if (contains(left.rect, right.rect) || contains(right.rect, left.rect)) continue;
+		if (overlapArea(left.rect, right.rect) > 0) diagnostics.push({
+			code: "node-overlap",
+			severity: SEVERITY["node-overlap"],
+			message: `Nodes "${left.ref}" and "${right.ref}" overlap.`,
+			refs: [left.ref, right.ref]
+		});
+	}
+	for (const connector of allConnectors) for (const node of allNodes) {
+		if (ownerOf(node.ref) === ownerOf(connector.ref) || containers.has(node.ref)) continue;
+		if (segmentsOf$1(connector).reduce((total, segment) => total + interiorRun(segment, node.rect), 0) > EPSILON) diagnostics.push({
+			code: "route-through-node",
+			severity: SEVERITY["route-through-node"],
+			message: `Connector "${connector.ref}" is drawn across node "${node.ref}".`,
+			refs: [connector.ref, node.ref]
+		});
+	}
+	for (const node of allNodes) if (!labelFits(node)) diagnostics.push({
+		code: "label-overflow",
+		severity: SEVERITY["label-overflow"],
+		message: `Label of "${node.ref}" does not fit its shape.`,
+		refs: [node.ref]
+	});
+	let crossings = 0;
+	for (let i = 0; i < allConnectors.length; i++) for (let j = i + 1; j < allConnectors.length; j++) {
+		const [left, right] = [allConnectors[i], allConnectors[j]];
+		if (segmentsOf$1(left).some((a) => segmentsOf$1(right).some((b) => properlyCrosses(a, b)))) {
+			crossings++;
+			diagnostics.push({
+				code: "edge-crossing",
+				severity: SEVERITY["edge-crossing"],
+				message: `Connectors "${left.ref}" and "${right.ref}" cross.`,
+				refs: [left.ref, right.ref]
+			});
+		}
+	}
+	let bends = 0;
+	let length = 0;
+	for (const connector of allConnectors) {
+		length += segmentsOf$1(connector).reduce((total, [a, b]) => total + Math.hypot(b.x - a.x, b.y - a.y), 0);
+		const count = bendCount(connector);
+		bends += count;
+		if (count > maxBends) diagnostics.push({
+			code: "excessive-bends",
+			severity: SEVERITY["excessive-bends"],
+			message: `Connector "${connector.ref}" takes ${count} bends.`,
+			refs: [connector.ref]
+		});
+	}
+	const xs = allNodes.flatMap(({ rect }) => [rect.x, rect.x + rect.w]);
+	const ys = allNodes.flatMap(({ rect }) => [rect.y, rect.y + rect.h]);
+	const frameRects = allNodes.filter(({ ref }) => containers.has(ref)).map(({ rect }) => rect);
+	const gapBetween = (a, b) => Math.max(a.x - (b.x + b.w), b.x - (a.x + a.w), a.y - (b.y + b.h), b.y - (a.y + a.h));
+	const nearestGaps = frameRects.flatMap((frame, index) => {
+		const gaps = frameRects.filter((_, other) => other !== index).map((other) => gapBetween(frame, other)).filter((gap) => gap >= 0);
+		return gaps.length ? [Math.min(...gaps)] : [];
+	});
+	return {
+		diagnostics,
+		metrics: {
+			nodes: allNodes.length,
+			connectors: allConnectors.length,
+			overlaps: diagnostics.filter(({ code }) => code === "node-overlap").length,
+			routesThroughNodes: diagnostics.filter(({ code }) => code === "route-through-node").length,
+			labelOverflows: diagnostics.filter(({ code }) => code === "label-overflow").length,
+			crossings,
+			bends,
+			length,
+			width: xs.length ? Math.max(...xs) - Math.min(...xs) : 0,
+			height: ys.length ? Math.max(...ys) - Math.min(...ys) : 0,
+			containers: frameRects.length,
+			frameGapMin: nearestGaps.length ? Math.min(...nearestGaps) : Infinity,
+			frameGapSpread: nearestGaps.length >= 2 ? Math.max(...nearestGaps) - Math.min(...nearestGaps) : 0
+		}
+	};
+};
+/** Errors only — the set that gates CI and that an agent must fix before the diagram is usable. */
+var errors = (report) => report.diagnostics.filter(({ severity }) => severity === "error");
+//#endregion
+//#region src/mermaid.ts
+var mermaid_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$7,
+	markers: () => markers,
+	parse: () => parse$1,
+	toStandard: () => toStandard
+});
+/**
+* Edge tokens: mermaid's own arrows read as references; the classDiagram-style `--|>` (hollow
+* triangle) and ER-style `--{` (crow's foot) and `o-->` (circle at the source) extend the flowchart
+* grammar with the UML kinds, at the cost of mermaid.js rejecting those lines.
+*/
+var EDGE_KINDS = {
+	"-->": "reference",
+	"---": "reference",
+	"-.->": "reference",
+	"==>": "reference",
+	"--|>": "inheritance",
+	"--{": "hasMany",
+	"o-->": "contains"
+};
+/** Reference-render labels for the UML kinds, used when the edge carries none of its own. */
+var UML_LABELS = {
+	"--|>": "extends",
+	"--{": "has many",
+	"o-->": "contains"
+};
+var UML_EDGE = /^(\s*\S+)\s*(o-->|--\|>|--\{)\s*(?:\|(.*?)\|\s*)?(\S+)\s*$/;
+/**
+* Rewrite the UML edge tokens into mermaid-legal labelled arrows, for rendering the source with
+* mermaid.js itself (as a reference beside our layout). Lossy by design: mermaid flowcharts have no
+* triangle or crow's foot, so the kind becomes the label unless the edge already has one; `%% ref`
+* lines are already comments.
+*/
+var toStandard = (source) => source.split("\n").map((line) => {
+	const match = UML_EDGE.exec(line);
+	return match ? `${match[1]} -->|${match[3] ?? UML_LABELS[match[2]]}| ${match[4]}` : line;
+}).join("\n");
+/** Scene arrow markers for a relationship kind. */
+var markers = (kind) => {
+	switch (kind) {
+		case "inheritance": return { head: "triangle" };
+		case "hasMany": return { head: "crowsfoot" };
+		case "contains": return { tail: "circle" };
+		default: return {};
+	}
+};
+var DIRECTIONS$1 = [
+	"TB",
+	"BT",
+	"LR",
+	"RL"
+];
+var NODE = /^([A-Za-z0-9_-]+)(?:\[(.*?)\]|\((.*?)\)|\{(.*?)\})?$/;
+var EDGE = /^(.+?)\s*(o-->|--\|>|--\{|-->|---|-\.->|==>)\s*(?:\|(.*?)\|\s*)?(.+)$/;
+var SUBGRAPH = /^subgraph\s+([A-Za-z0-9_-]+)(?:\s*\[(.*?)\])?\s*$/;
+var REF = /^%%\s*ref\s+([A-Za-z0-9_-]+)\s+(\S+)\s*$/;
+var unquote = (value) => value.trim().replace(/^"(.*)"$/, "$1");
+/** Parse a mermaid flowchart into a neutral graph. Unrecognised lines are ignored. */
+var parse$1 = (source) => {
+	const nodes = /* @__PURE__ */ new Map();
+	const groups = [];
+	const edges = [];
+	let direction = "TB";
+	const stack = [];
+	const declare = (token) => {
+		const match = NODE.exec(token.trim());
+		if (!match) return;
+		const [, id, square, round, curly] = match;
+		const label = unquote(square ?? round ?? curly ?? id);
+		const group = stack[stack.length - 1];
+		const existing = nodes.get(id);
+		if (existing) {
+			if (square ?? round ?? curly) existing.label = label;
+			return id;
+		}
+		nodes.set(id, {
+			id,
+			label,
+			...group ? { group } : {}
+		});
+		if (group) groups.find((entry) => entry.id === group)?.children.push(id);
+		return id;
+	};
+	const refs = /* @__PURE__ */ new Map();
+	for (const raw of source.split("\n")) {
+		const line = raw.trim();
+		const ref = REF.exec(line);
+		if (ref) {
+			refs.set(ref[1], ref[2]);
+			continue;
+		}
+		if (!line || line.startsWith("%%")) continue;
+		const header = /^(?:flowchart|graph)\s+([A-Za-z]{2})$/.exec(line);
+		if (header) {
+			const value = header[1].toUpperCase();
+			direction = DIRECTIONS$1.includes(value) ? value : "TB";
+			continue;
+		}
+		const subgraph = SUBGRAPH.exec(line);
+		if (subgraph) {
+			const [, id, label] = subgraph;
+			groups.push({
+				id,
+				label: unquote(label ?? id),
+				children: []
+			});
+			stack.push(id);
+			continue;
+		}
+		if (line === "end") {
+			stack.pop();
+			continue;
+		}
+		const edge = EDGE.exec(line);
+		if (edge) {
+			const [, from, token, label, to] = edge;
+			const fromId = declare(from);
+			const toId = declare(to);
+			if (fromId && toId) edges.push({
+				from: fromId,
+				to: toId,
+				kind: EDGE_KINDS[token] ?? "reference",
+				...label ? { label: unquote(label) } : {}
+			});
+			continue;
+		}
+		declare(line);
+	}
+	return {
+		direction,
+		nodes: [...nodes.values()].map((node) => refs.has(node.id) ? {
+			...node,
+			ref: refs.get(node.id)
+		} : node),
+		groups,
+		edges
+	};
+};
+/** Layout constants in scene units. */
+var NODE_W = 100;
+var NODE_H = 50;
+var GAP_MAIN$3 = 60;
+var GAP_CROSS$3 = 40;
+var GROUP_PAD = 24;
+/** Assign each node a rank one past its deepest forward predecessor. */
+var rank = (graph) => rank$1(graph.nodes.map((node) => node.id), graph.edges);
+/**
+* Compile a mermaid flowchart into scene commands: one world object per node (element `box`),
+* one per subgraph frame, and an `edges` object holding the connectors as bound arrows.
+*/
+var compile$7 = (source, options = {}) => {
+	const graph = parse$1(source);
+	const { origin = {
+		x: 0,
+		y: 0
+	}, scale = 1, gapMain = GAP_MAIN$3, gapCross = GAP_CROSS$3 } = options;
+	const ranks = rank(graph);
+	const horizontal = graph.direction === "LR" || graph.direction === "RL";
+	const lanes = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const value = ranks.get(node.id) ?? 0;
+		lanes.set(value, [...lanes.get(value) ?? [], node]);
+	}
+	const widest = Math.max(...[...lanes.values()].map((lane) => lane.length), 1);
+	const mainSize = horizontal ? NODE_W : NODE_H;
+	const crossSize = horizontal ? NODE_H : NODE_W;
+	const positions = /* @__PURE__ */ new Map();
+	for (const [lane, members] of lanes) {
+		const span = members.length * crossSize + (members.length - 1) * gapCross;
+		const offset = (widest * crossSize + (widest - 1) * gapCross - span) / 2;
+		members.forEach((node, index) => {
+			const cross = offset + index * (crossSize + gapCross);
+			const main = lane * (mainSize + gapMain);
+			positions.set(node.id, horizontal ? {
+				x: main,
+				y: cross
+			} : {
+				x: cross,
+				y: main
+			});
+		});
+	}
+	const commands = [];
+	for (const group of graph.groups) {
+		const members = group.children.map((id) => positions.get(id)).filter((point) => !!point);
+		if (members.length === 0) continue;
+		const minX = Math.min(...members.map((point) => point.x)) - GROUP_PAD;
+		const minY = Math.min(...members.map((point) => point.y)) - GROUP_PAD;
+		const maxX = Math.max(...members.map((point) => point.x)) + NODE_W + GROUP_PAD;
+		const maxY = Math.max(...members.map((point) => point.y)) + NODE_H + GROUP_PAD;
+		commands.push({
+			op: "upsert-object",
+			object: {
+				id: group.id,
+				origin: {
+					x: origin.x + minX * scale,
+					y: origin.y + minY * scale
+				},
+				scale,
+				elements: [{
+					kind: "rect",
+					id: "frame",
+					x: 0,
+					y: 0,
+					w: maxX - minX,
+					h: maxY - minY,
+					stroke: "dashed",
+					color: "grey",
+					...group.label.trim() ? { text: group.label } : {}
+				}]
+			}
+		});
+	}
+	for (const node of graph.nodes) {
+		const point = positions.get(node.id);
+		commands.push({
+			op: "upsert-object",
+			object: {
+				id: node.id,
+				origin: {
+					x: origin.x + point.x * scale,
+					y: origin.y + point.y * scale
+				},
+				scale,
+				...node.ref ? { ref: node.ref } : {},
+				elements: [{
+					kind: "rect",
+					id: "box",
+					x: 0,
+					y: 0,
+					w: NODE_W,
+					h: NODE_H,
+					text: node.label
+				}]
+			}
+		});
+	}
+	if (graph.edges.length > 0) commands.push({
+		op: "upsert-object",
+		object: {
+			id: "edges",
+			origin,
+			scale,
+			elements: graph.edges.map((edge) => ({
+				kind: "arrow",
+				id: `${edge.from}-${edge.to}`,
+				from: `${edge.from}/box`,
+				to: `${edge.to}/box`,
+				...markers(edge.kind),
+				...edge.label ? { text: edge.label } : {}
+			}))
+		}
+	});
+	return commands;
+};
+//#endregion
+//#region src/ortho-router.ts
+/** Clearance kept between a route and any node border, in steps. */
+var CLEARANCE = 1;
+/** One bend costs as much as this many steps — turns dominate, distance breaks ties. */
+var TURN_COST = 1e3;
+/** Traversing a cell another edge already used costs this many extra steps. */
+var USED_COST = 24;
+/** Margin around the diagram bounds the search may roam into, in steps. */
+var MARGIN = 8;
+/** Directions: right, down, left, up. */
+var DX = [
+	1,
+	0,
+	-1,
+	0
+];
+var DY = [
+	0,
+	1,
+	0,
+	-1
+];
+/**
+* Creates a router that avoids the given node rects. Stateful across edges: earlier routes
+* penalize (not block) the cells they occupy, spreading parallel runs apart. `fallback` handles
+* the (fenced-in) edges the search cannot reach. The step is passed in rather than derived from
+* `uml-grid`'s `GRID`, which keeps this module free of a value import cycle with the dialects.
+*/
+var makeAvoidingRouter = (obstacles, fallback, { step: STEP }) => {
+	const xs = obstacles.flatMap((rect) => [rect.x, rect.x + rect.w]);
+	const ys = obstacles.flatMap((rect) => [rect.y, rect.y + rect.h]);
+	const bounds = {
+		x0: Math.floor(Math.min(...xs) / STEP) - MARGIN,
+		y0: Math.floor(Math.min(...ys) / STEP) - MARGIN,
+		x1: Math.ceil(Math.max(...xs) / STEP) + MARGIN,
+		y1: Math.ceil(Math.max(...ys) / STEP) + MARGIN
+	};
+	const width = bounds.x1 - bounds.x0 + 1;
+	const height = bounds.y1 - bounds.y0 + 1;
+	const inBounds = (x, y) => x >= bounds.x0 && x <= bounds.x1 && y >= bounds.y0 && y <= bounds.y1;
+	const cellIndex = (x, y) => (y - bounds.y0) * width + (x - bounds.x0);
+	const blockedGrid = new Uint8Array(width * height);
+	for (const rect of obstacles) {
+		const x0 = Math.floor(rect.x / STEP) - CLEARANCE;
+		const y0 = Math.floor(rect.y / STEP) - CLEARANCE;
+		const x1 = Math.ceil((rect.x + rect.w) / STEP) + CLEARANCE;
+		const y1 = Math.ceil((rect.y + rect.h) / STEP) + CLEARANCE;
+		for (let y = Math.max(bounds.y0, y0 + 1); y < Math.min(bounds.y1 + 1, y1); y++) for (let x = Math.max(bounds.x0, x0 + 1); x < Math.min(bounds.x1 + 1, x1); x++) blockedGrid[cellIndex(x, y)] = 1;
+	}
+	const blocked = (x, y) => inBounds(x, y) && blockedGrid[cellIndex(x, y)] !== 0;
+	const usedGrid = new Uint8Array(width * height);
+	const isUsed = (x, y) => inBounds(x, y) && usedGrid[cellIndex(x, y)] !== 0;
+	const markUsed = (x, y) => {
+		if (inBounds(x, y)) usedGrid[cellIndex(x, y)] = 1;
+	};
+	const settledCost = new Float64Array(width * height * 4);
+	const settledGen = new Int32Array(width * height * 4);
+	let generation = 0;
+	/** Binary min-heap on cost + estimate, so each pop is O(log n) instead of a frontier scan. */
+	const heapPush = (heap, state) => {
+		heap.push(state);
+		let index = heap.length - 1;
+		while (index > 0) {
+			const parent = index - 1 >> 1;
+			if (heap[parent].f <= heap[index].f) break;
+			[heap[parent], heap[index]] = [heap[index], heap[parent]];
+			index = parent;
+		}
+	};
+	const heapPop = (heap) => {
+		const top = heap[0];
+		const last = heap.pop();
+		if (heap.length > 0) {
+			heap[0] = last;
+			let index = 0;
+			for (;;) {
+				const left = index * 2 + 1;
+				const right = left + 1;
+				let smallest = index;
+				if (left < heap.length && heap[left].f < heap[smallest].f) smallest = left;
+				if (right < heap.length && heap[right].f < heap[smallest].f) smallest = right;
+				if (smallest === index) break;
+				[heap[smallest], heap[index]] = [heap[index], heap[smallest]];
+				index = smallest;
+			}
+		}
+		return top;
+	};
+	/**
+	* Fewest turns any path from (x, y) heading `dir` needs to reach the target: none while aligned
+	* and heading at it, two when heading away along its axis, otherwise one. Admissible, and since
+	* a turn costs as much as a thousand steps it is what makes the search converge on a diagram
+	* hundreds of cells across — distance alone leaves it exploring almost uniformly.
+	*/
+	const turnsNeeded = (x, y, dir, target) => {
+		const dx = target.x - x;
+		const dy = target.y - y;
+		if (dx !== 0 && dy !== 0) return 1;
+		if (dx === 0 && dy === 0) return 0;
+		const towards = dx !== 0 ? dx > 0 ? 0 : 2 : dy > 0 ? 1 : 3;
+		return dir === towards ? 0 : (dir + 2) % 4 === towards ? 2 : 1;
+	};
+	const estimateFrom = (x, y, dir, target) => Math.abs(target.x - x) + Math.abs(target.y - y) + turnsNeeded(x, y, dir, target) * TURN_COST;
+	const budget = Math.max(5e4, (bounds.x1 - bounds.x0) * (bounds.y1 - bounds.y0) * 4);
+	/**
+	* Bounded A* between two stub ends (grid coordinates). Successors already dominated by a
+	* settled state are pruned before pushing; undefined when the target is unreachable.
+	*/
+	const search = (source, startDir, target, endDir) => {
+		const open = [{
+			x: source.x,
+			y: source.y,
+			dir: startDir,
+			cost: 0,
+			f: estimateFrom(source.x, source.y, startDir, target)
+		}];
+		generation++;
+		const settledAt = (index) => settledGen[index] === generation ? settledCost[index] : void 0;
+		let found;
+		for (let iterations = 0; open.length > 0 && iterations < budget; iterations++) {
+			const current = heapPop(open);
+			if (current.x === target.x && current.y === target.y) {
+				found = current;
+				break;
+			}
+			const stateIndex = cellIndex(current.x, current.y) * 4 + current.dir;
+			const seen = settledAt(stateIndex);
+			if (seen !== void 0 && seen <= current.cost) continue;
+			settledGen[stateIndex] = generation;
+			settledCost[stateIndex] = current.cost;
+			for (let dir = 0; dir < 4; dir++) {
+				if ((dir + 2) % 4 === current.dir) continue;
+				const x = current.x + DX[dir];
+				const y = current.y + DY[dir];
+				if (!inBounds(x, y)) continue;
+				const cell = cellIndex(x, y);
+				if (blockedGrid[cell] !== 0) continue;
+				const cost = current.cost + 1 + (dir === current.dir ? 0 : TURN_COST) + (usedGrid[cell] !== 0 ? USED_COST : 0) + (x === target.x && y === target.y && dir !== endDir ? TURN_COST : 0);
+				const dominated = settledAt(cell * 4 + dir);
+				if (dominated !== void 0 && dominated <= cost) continue;
+				heapPush(open, {
+					x,
+					y,
+					dir,
+					cost,
+					f: cost + estimateFrom(x, y, dir, target),
+					prev: current
+				});
+			}
+		}
+		if (!found) return;
+		const cells = [];
+		for (let state = found; state; state = state.prev) cells.unshift({
+			x: state.x,
+			y: state.y
+		});
+		return {
+			cost: found.cost,
+			cells
+		};
+	};
+	return (edge) => {
+		const { from, to, horizontal, ports } = edge;
+		const sameLane = horizontal ? from.x === to.x : from.y === to.y;
+		const alongY = horizontal ? sameLane : !sameLane;
+		const down = to.y >= from.y;
+		const right = to.x >= from.x;
+		const flowStart = alongY ? {
+			point: {
+				x: ports?.start ?? from.x + from.w / 2,
+				y: down ? from.y + from.h : from.y
+			},
+			dir: down ? 1 : 3
+		} : {
+			point: {
+				x: right ? from.x + from.w : from.x,
+				y: ports?.start ?? from.y + from.h / 2
+			},
+			dir: right ? 0 : 2
+		};
+		const flowEnd = alongY ? {
+			point: {
+				x: ports?.end ?? to.x + to.w / 2,
+				y: down ? to.y : to.y + to.h
+			},
+			dir: down ? 1 : 3
+		} : {
+			point: {
+				x: right ? to.x : to.x + to.w,
+				y: ports?.end ?? to.y + to.h / 2
+			},
+			dir: right ? 0 : 2
+		};
+		const crossStart = alongY ? {
+			point: {
+				x: right ? from.x + from.w : from.x,
+				y: from.y + from.h / 2
+			},
+			dir: right ? 0 : 2
+		} : {
+			point: {
+				x: from.x + from.w / 2,
+				y: down ? from.y + from.h : from.y
+			},
+			dir: down ? 1 : 3
+		};
+		const crossEnd = alongY ? {
+			point: {
+				x: right ? to.x : to.x + to.w,
+				y: to.y + to.h / 2
+			},
+			dir: right ? 0 : 2
+		} : {
+			point: {
+				x: to.x + to.w / 2,
+				y: down ? to.y : to.y + to.h
+			},
+			dir: down ? 1 : 3
+		};
+		const configurations = (alongY ? flowStart.point.x !== flowEnd.point.x : flowStart.point.y !== flowEnd.point.y) ? [
+			[flowStart, flowEnd],
+			[crossStart, flowEnd],
+			[flowStart, crossEnd]
+		] : [[flowStart, flowEnd]];
+		const stub = (point, dir, out) => {
+			const sign = out ? 1 : -1;
+			return {
+				x: Math.round(point.x / STEP) + DX[dir] * 2 * sign,
+				y: Math.round(point.y / STEP) + DY[dir] * 2 * sign
+			};
+		};
+		let start;
+		let end;
+		let best;
+		for (const [startTerminal, endTerminal] of configurations) {
+			const result = search(stub(startTerminal.point, startTerminal.dir, true), startTerminal.dir, stub(endTerminal.point, endTerminal.dir, false), endTerminal.dir);
+			if (result && (!best || result.cost < best.cost)) {
+				best = result;
+				start = startTerminal.point;
+				end = endTerminal.point;
+			}
+		}
+		if (!best || !start || !end) return fallback(edge);
+		const points = [
+			start,
+			...best.cells.map((cell) => ({
+				x: cell.x * STEP,
+				y: cell.y * STEP
+			})),
+			end
+		];
+		const simplified = [points[0]];
+		for (let index = 1; index < points.length - 1; index++) {
+			const previous = simplified[simplified.length - 1];
+			const next = points[index + 1];
+			const point = points[index];
+			if (!(previous.x === point.x && point.x === next.x || previous.y === point.y && point.y === next.y)) simplified.push(point);
+		}
+		simplified.push(points[points.length - 1]);
+		const clearRun = (a, b) => {
+			const ax = Math.round(a.x / STEP);
+			const ay = Math.round(a.y / STEP);
+			const bx = Math.round(b.x / STEP);
+			const by = Math.round(b.y / STEP);
+			const steps = Math.max(Math.abs(bx - ax), Math.abs(by - ay));
+			const dx = Math.sign(bx - ax);
+			const dy = Math.sign(by - ay);
+			for (let step = 0; step <= steps; step++) if (blocked(ax + dx * step, ay + dy * step) || isUsed(ax + dx * step, ay + dy * step)) return false;
+			return true;
+		};
+		const past = (from, to) => ({
+			x: from.x + Math.sign(to.x - from.x) * 2 * STEP,
+			y: from.y + Math.sign(to.y - from.y) * 2 * STEP
+		});
+		if (simplified.length === 4) {
+			const [p0, p1, p2, p3] = simplified;
+			if (p1.y === p2.y && p0.y !== p3.y) {
+				const mid = Math.round((p0.y + p3.y) / 2 / STEP) * STEP;
+				const shifted = [{
+					x: p1.x,
+					y: mid
+				}, {
+					x: p2.x,
+					y: mid
+				}];
+				if (clearRun(shifted[0], shifted[1]) && clearRun(past(p0, shifted[0]), shifted[0]) && clearRun(shifted[1], past(p3, shifted[1]))) {
+					simplified[1] = shifted[0];
+					simplified[2] = shifted[1];
+				}
+			} else if (p1.x === p2.x && p0.x !== p3.x) {
+				const mid = Math.round((p0.x + p3.x) / 2 / STEP) * STEP;
+				const shifted = [{
+					x: mid,
+					y: p1.y
+				}, {
+					x: mid,
+					y: p2.y
+				}];
+				if (clearRun(shifted[0], shifted[1]) && clearRun(past(p0, shifted[0]), shifted[0]) && clearRun(shifted[1], past(p3, shifted[1]))) {
+					simplified[1] = shifted[0];
+					simplified[2] = shifted[1];
+				}
+			}
+		}
+		for (let index = 0; index < simplified.length - 1; index++) {
+			const a = simplified[index];
+			const b = simplified[index + 1];
+			const ax = Math.round(a.x / STEP);
+			const ay = Math.round(a.y / STEP);
+			const steps = Math.max(Math.abs(Math.round(b.x / STEP) - ax), Math.abs(Math.round(b.y / STEP) - ay));
+			const dx = Math.sign(b.x - a.x);
+			const dy = Math.sign(b.y - a.y);
+			for (let step = 0; step <= steps; step++) markUsed(ax + dx * step, ay + dy * step);
+		}
+		return simplified;
+	};
+};
+//#endregion
+//#region src/uml.ts
+var uml_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$6,
+	isClassDiagram: () => isClassDiagram,
+	parse: () => parse,
+	relationRanks: () => relationRanks,
+	relationStyle: () => relationStyle,
+	relationText: () => relationText
+});
+var DIRECTIONS = [
+	"TB",
+	"BT",
+	"LR",
+	"RL"
+];
+var CLASS = /^class\s+([A-Za-z0-9_~<>-]+)(?:\s*\[\s*"(.*?)"\s*\])?\s*(\{)?\s*$/;
+var INLINE_MEMBER = /^([A-Za-z0-9_~<>-]+)\s*:\s*(.+)$/;
+var STEREOTYPE = /^<<\s*(.*?)\s*>>$/;
+/**
+* Relation arrows, normalized to (kind, whether the LEFT side is the arrow target).
+* `A <|-- B` reads "B inherits A": the parent is on the flat side of the triangle.
+*/
+var RELATIONS = [
+	[
+		"<|--",
+		"inheritance",
+		true
+	],
+	[
+		"--|>",
+		"inheritance",
+		false
+	],
+	[
+		"<|..",
+		"realization",
+		true
+	],
+	[
+		"..|>",
+		"realization",
+		false
+	],
+	[
+		"*--",
+		"composition",
+		false
+	],
+	[
+		"--*",
+		"composition",
+		true
+	],
+	[
+		"o--",
+		"aggregation",
+		false
+	],
+	[
+		"--o",
+		"aggregation",
+		true
+	],
+	[
+		"-->",
+		"association",
+		false
+	],
+	[
+		"<--",
+		"association",
+		true
+	],
+	[
+		"..>",
+		"dependency",
+		false
+	],
+	[
+		"<..",
+		"dependency",
+		true
+	],
+	[
+		"..",
+		"dependency",
+		false
+	],
+	[
+		"--",
+		"association",
+		false
+	]
+];
+var RELATION = new RegExp(`^([A-Za-z0-9_~<>-]+)\\s*(?:"([^"]*)"\\s*)?(${RELATIONS.map(([token]) => token.replace(/[|*.>-]/g, "\\$&")).join("|")})\\s*(?:"([^"]*)"\\s*)?([A-Za-z0-9_~<>-]+)\\s*(?::\\s*(.+))?\$`);
+/** Mermaid generics use `~T~`; render them as `<T>`. */
+var genericLabel = (id) => id.replace(/~([^~]*)~/g, "<$1>");
+/** Parse a mermaid class diagram into a neutral model. Unrecognised lines are ignored. */
+var parse = (source) => {
+	const classes = /* @__PURE__ */ new Map();
+	const relations = [];
+	let direction = "TB";
+	let open;
+	const declare = (id) => {
+		let entry = classes.get(id);
+		if (!entry) {
+			entry = {
+				id,
+				label: genericLabel(id),
+				attributes: [],
+				methods: []
+			};
+			classes.set(id, entry);
+		}
+		return entry;
+	};
+	const addMember = (entry, raw) => {
+		const member = raw.trim();
+		const stereotype = STEREOTYPE.exec(member);
+		if (stereotype) {
+			entry.stereotype = stereotype[1];
+			return;
+		}
+		if (member) (member.includes("(") ? entry.methods : entry.attributes).push(member);
+	};
+	for (const raw of source.split("\n")) {
+		const line = raw.trim();
+		if (!line || line.startsWith("%%") || /^classDiagram(-v2)?$/.test(line)) continue;
+		if (open) {
+			if (line === "}") open = void 0;
+			else addMember(open, line);
+			continue;
+		}
+		const header = /^direction\s+([A-Za-z]{2})$/.exec(line);
+		if (header) {
+			const value = header[1].toUpperCase();
+			direction = DIRECTIONS.includes(value) ? value : "TB";
+			continue;
+		}
+		const cls = CLASS.exec(line);
+		if (cls) {
+			const [, id, label, brace] = cls;
+			const entry = declare(id);
+			if (label) entry.label = label;
+			if (brace) open = entry;
+			continue;
+		}
+		const relation = RELATION.exec(line);
+		if (relation) {
+			const [, left, leftCardinality, token, rightCardinality, right, label] = relation;
+			declare(left);
+			declare(right);
+			const [, kind, leftIsTarget] = RELATIONS.find(([candidate]) => candidate === token);
+			const [from, to] = leftIsTarget ? [right, left] : [left, right];
+			const [fromCardinality, toCardinality] = leftIsTarget ? [rightCardinality, leftCardinality] : [leftCardinality, rightCardinality];
+			relations.push({
+				from,
+				to,
+				kind,
+				...label ? { label: label.trim() } : {},
+				...fromCardinality ? { fromCardinality } : {},
+				...toCardinality ? { toCardinality } : {}
+			});
+			continue;
+		}
+		const inline = INLINE_MEMBER.exec(line);
+		if (inline) {
+			const [, id, member] = inline;
+			addMember(declare(id), member);
+		}
+	}
+	return {
+		direction,
+		classes: [...classes.values()],
+		relations
+	};
+};
+/**
+* Box geometry in scene units; text sizes come from the shared per-weight metrics table
+* (`Layout.FONT_METRICS`): the title renders at the default weight (m), members at s.
+*/
+var TITLE_FONT$1 = FONT_METRICS.m;
+var MEMBER_FONT$1 = FONT_METRICS.s;
+var MIN_W$2 = 160;
+var MAX_W$2 = 400;
+var PAD_X$2 = 24;
+var TITLE_PAD$1 = 10;
+var SECTION_PAD$1 = 14;
+var GAP_MAIN$2 = 90;
+var GAP_CROSS$2 = 60;
+/** Compartment sizes derived from member counts and line lengths, per compartment font. */
+var measure = (entry, maxWidth) => {
+	const titleW = Math.max(entry.label.length, (entry.stereotype?.length ?? 0) + 2) * TITLE_FONT$1.charW;
+	const memberW = Math.max(0, ...[...entry.attributes, ...entry.methods].map((line) => line.length)) * MEMBER_FONT$1.charW;
+	const w = Math.min(maxWidth, Math.max(MIN_W$2, Math.ceil(Math.max(titleW, memberW)) + PAD_X$2));
+	const lines = (text, font) => Math.max(1, Math.ceil(text.length * font.charW / (w - PAD_X$2)));
+	const memberH = (members) => members.length ? members.reduce((sum, line) => sum + lines(line, MEMBER_FONT$1), 0) * MEMBER_FONT$1.lineH + SECTION_PAD$1 : 0;
+	const titleH = (lines(entry.label, TITLE_FONT$1) + (entry.stereotype ? 1 : 0)) * TITLE_FONT$1.lineH + TITLE_PAD$1;
+	const attributesH = memberH(entry.attributes);
+	const methodsH = memberH(entry.methods);
+	return {
+		entry,
+		w,
+		h: titleH + attributesH + methodsH,
+		titleH,
+		attributesH,
+		methodsH
+	};
+};
+/** Arrow styling per relation kind; dependency and realization render dashed, as in UML. */
+var relationStyle = (kind) => kind === "dependency" || kind === "realization" ? { stroke: "dashed" } : {};
+/** Mid-arrow label: cardinalities and the diamond glyph UML puts at the whole end. */
+var relationText = (relation) => {
+	const glyph = relation.kind === "composition" ? "◆" : relation.kind === "aggregation" ? "◇" : void 0;
+	return [
+		relation.fromCardinality,
+		relation.label ?? glyph,
+		relation.toCardinality
+	].filter(Boolean).join(" ") || void 0;
+};
+/**
+* Rank so arrows read upward where UML convention points at abstractions — inheritance,
+* realization, and dependency targets sit above their sources; containment and association
+* flow downward (whole/source above part/target).
+*/
+var relationRanks = (model) => rank$1(model.classes.map((entry) => entry.id), model.relations.map((relation) => relation.kind === "inheritance" || relation.kind === "realization" || relation.kind === "dependency" ? {
+	from: relation.to,
+	to: relation.from
+} : {
+	from: relation.from,
+	to: relation.to
+}));
+/**
+* Compile a mermaid class diagram into scene commands: one world object per class (compartment
+* rects `title`/`attributes`/`methods`) and an `edges` object holding the relations as bound
+* arrows. Supertypes rank above subtypes, so inheritance reads downward.
+*/
+var compile$6 = (source, options = {}) => {
+	const model = parse(source);
+	const { origin = {
+		x: 0,
+		y: 0
+	}, scale = 1, gapMain = GAP_MAIN$2, gapCross = GAP_CROSS$2, maxWidth = MAX_W$2 } = options;
+	const horizontal = model.direction === "LR" || model.direction === "RL";
+	const ranks = relationRanks(model);
+	const boxes = new Map(model.classes.map((entry) => [entry.id, measure(entry, maxWidth)]));
+	const lanes = /* @__PURE__ */ new Map();
+	for (const entry of model.classes) {
+		const value = ranks.get(entry.id) ?? 0;
+		lanes.set(value, [...lanes.get(value) ?? [], boxes.get(entry.id)]);
+	}
+	const cross = (box) => horizontal ? box.h : box.w;
+	const main = (box) => horizontal ? box.w : box.h;
+	const laneSpan = (members) => members.reduce((sum, box) => sum + cross(box), 0) + (members.length - 1) * gapCross;
+	const widest = Math.max(...[...lanes.values()].map(laneSpan), 0);
+	const positions = /* @__PURE__ */ new Map();
+	let mainOffset = 0;
+	for (const lane of [...lanes.keys()].sort((left, right) => left - right)) {
+		const members = lanes.get(lane);
+		let crossOffset = (widest - laneSpan(members)) / 2;
+		for (const box of members) {
+			positions.set(box.entry.id, horizontal ? {
+				x: mainOffset,
+				y: crossOffset
+			} : {
+				x: crossOffset,
+				y: mainOffset
+			});
+			crossOffset += cross(box) + gapCross;
+		}
+		mainOffset += Math.max(...members.map(main)) + gapMain;
+	}
+	const facing = (id, peerId) => {
+		const box = boxes.get(id);
+		const peer = boxes.get(peerId);
+		const targetY = positions.get(peerId).y + peer.h / 2;
+		const baseY = positions.get(id).y;
+		const compartments = [["title", box.titleH / 2]];
+		if (box.attributesH) compartments.push(["attributes", box.titleH + box.attributesH / 2]);
+		if (box.methodsH) compartments.push(["methods", box.titleH + box.attributesH + box.methodsH / 2]);
+		return compartments.reduce((best, candidate) => Math.abs(baseY + candidate[1] - targetY) < Math.abs(baseY + best[1] - targetY) ? candidate : best)[0];
+	};
+	const commands = [];
+	for (const entry of model.classes) {
+		const box = boxes.get(entry.id);
+		const point = positions.get(entry.id);
+		const title = entry.stereotype ? `«${entry.stereotype}»\n${entry.label}` : entry.label;
+		const elements = [{
+			kind: "rect",
+			id: "title",
+			x: 0,
+			y: 0,
+			w: box.w,
+			h: box.titleH,
+			text: title,
+			fill: "solid"
+		}];
+		if (box.attributesH) elements.push({
+			kind: "rect",
+			id: "attributes",
+			x: 0,
+			y: box.titleH,
+			w: box.w,
+			h: box.attributesH,
+			text: entry.attributes.join("\n"),
+			weight: "s"
+		});
+		if (box.methodsH) elements.push({
+			kind: "rect",
+			id: "methods",
+			x: 0,
+			y: box.titleH + box.attributesH,
+			w: box.w,
+			h: box.methodsH,
+			text: entry.methods.join("\n"),
+			weight: "s"
+		});
+		commands.push({
+			op: "upsert-object",
+			object: {
+				id: entry.id,
+				origin: {
+					x: origin.x + point.x * scale,
+					y: origin.y + point.y * scale
+				},
+				scale,
+				elements
+			}
+		});
+	}
+	if (model.relations.length > 0) commands.push({
+		op: "upsert-object",
+		object: {
+			id: "edges",
+			origin,
+			scale,
+			elements: model.relations.map((relation, index) => {
+				const text = relationText(relation);
+				return {
+					kind: "arrow",
+					id: `${relation.from}-${relation.to}-${index}`,
+					from: `${relation.from}/${facing(relation.from, relation.to)}`,
+					to: `${relation.to}/${facing(relation.to, relation.from)}`,
+					...relationStyle(relation.kind),
+					...text ? { text } : {}
+				};
+			})
+		}
+	});
+	return commands;
+};
+/** True when the mermaid source declares a class diagram rather than a flowchart. */
+var isClassDiagram = (source) => /^\s*classDiagram(-v2)?\b/m.test(source);
+//#endregion
+//#region src/uml-grid.ts
+var uml_grid_exports = /* @__PURE__ */ __exportAll({
+	GRID: () => 32,
+	compile: () => compile$5,
+	emit: () => emit$1,
+	measureCell: () => measureCell$1,
+	zRouter: () => zRouter
+});
+/** Half-cell minor grid, used for sub-cell nudges (ports, channel separation, label offsets). */
+var GRID_FINE$1 = 16;
+var MIN_W$1 = 64;
+var MAX_W$1 = 192;
+var MIN_H$1 = 64;
+var MAX_H = 160;
+var MIN_TITLE_H = 32;
+var MAX_TITLE_H = 64;
+var TITLE_PAD = 16;
+var TEXT_PAD = 16;
+var PAD_X$1 = 64;
+var SECTION_PAD = 16;
+var GAP_MAIN$1 = 128;
+var GAP_CROSS$1 = 128;
+var TITLE_FONT = FONT_METRICS.m;
+var MEMBER_FONT = FONT_METRICS.s;
+var snap$3 = (value) => Math.ceil(value / 32) * 32;
+/** Z route along y: leave the facing horizontal edge, run a channel at mid, enter the peer's. */
+var routeAlongY = (from, to, shift, ports) => {
+	const down = to.y >= from.y;
+	const start = {
+		x: ports?.start ?? from.x + from.w / 2,
+		y: down ? from.y + from.h : from.y
+	};
+	const end = {
+		x: ports?.end ?? to.x + to.w / 2,
+		y: down ? to.y : to.y + to.h
+	};
+	if (start.x === end.x) return [{
+		x: start.x + shift,
+		y: start.y
+	}, {
+		x: end.x + shift,
+		y: end.y
+	}];
+	const mid = snap$3((start.y + end.y) / 2) + shift;
+	return [
+		start,
+		{
+			x: start.x,
+			y: mid
+		},
+		{
+			x: end.x,
+			y: mid
+		},
+		end
+	];
+};
+/** Z route along x; mirror of `routeAlongY`. */
+var routeAlongX = (from, to, shift, ports) => {
+	const right = to.x >= from.x;
+	const start = {
+		x: right ? from.x + from.w : from.x,
+		y: ports?.start ?? from.y + from.h / 2
+	};
+	const end = {
+		x: right ? to.x : to.x + to.w,
+		y: ports?.end ?? to.y + to.h / 2
+	};
+	if (start.y === end.y) return [{
+		x: start.x,
+		y: start.y + shift
+	}, {
+		x: end.x,
+		y: end.y + shift
+	}];
+	const mid = snap$3((start.x + end.x) / 2) + shift;
+	return [
+		start,
+		{
+			x: mid,
+			y: start.y
+		},
+		{
+			x: mid,
+			y: end.y
+		},
+		end
+	];
+};
+/**
+* Default router: an orthogonal Z along the flow axis — rank-crossing edges route through the
+* inter-rank gutter (channel shifted per parallel edge); same-rank edges route out the side.
+*/
+var zRouter = ({ from, to, offset, horizontal, ports }) => {
+	const sameLane = horizontal ? from.x === to.x : from.y === to.y;
+	return ((horizontal ? sameLane : !sameLane) ? routeAlongY : routeAlongX)(from, to, offset * GRID_FINE$1, ports);
+};
+/**
+* Pull strength per relation kind when aligning columns: parts stick to their whole's column
+* before subtypes, which in turn beat loose dependencies/associations.
+*/
+var COLUMN_WEIGHT = {
+	composition: 4,
+	aggregation: 3,
+	inheritance: 2,
+	realization: 2,
+	dependency: 1,
+	association: 1
+};
+/**
+* Assign each node an integer column: the first lane keeps declaration order, later lanes pull
+* each node toward the weighted mean column of its already-placed neighbours. The strongest-tied
+* node picks its column first, so a part claims the column under its whole even when weaker
+* relations compete for it; collisions take the free column nearest the desired mean. Aligned
+* columns turn rank-crossing connectors into straight lines.
+*/
+var assignColumns = (model, ranks, lanes) => {
+	const neighbors = /* @__PURE__ */ new Map();
+	for (const relation of model.relations) {
+		const weight = COLUMN_WEIGHT[relation.kind];
+		neighbors.set(relation.from, [...neighbors.get(relation.from) ?? [], {
+			peer: relation.to,
+			weight
+		}]);
+		neighbors.set(relation.to, [...neighbors.get(relation.to) ?? [], {
+			peer: relation.from,
+			weight
+		}]);
+	}
+	const columns = /* @__PURE__ */ new Map();
+	[...lanes.keys()].sort((left, right) => left - right).forEach((lane, position) => {
+		const desired = lanes.get(lane).map((id, index) => {
+			const placed = (neighbors.get(id) ?? []).filter((link) => columns.has(link.peer));
+			const pull = placed.reduce((sum, link) => sum + link.weight, 0);
+			return {
+				id,
+				mean: position > 0 && pull > 0 ? placed.reduce((sum, link) => sum + link.weight * columns.get(link.peer), 0) / pull : index,
+				pull,
+				index
+			};
+		});
+		desired.sort((left, right) => right.pull - left.pull || left.index - right.index);
+		const used = /* @__PURE__ */ new Set();
+		for (const entry of desired) {
+			const base = Math.ceil(entry.mean - .5);
+			let column = base;
+			for (let step = 1; used.has(column); step++) {
+				const left = base - step;
+				const right = base + step;
+				if (!used.has(left) && (used.has(right) || Math.abs(left - entry.mean) <= Math.abs(right - entry.mean))) column = left;
+				else if (!used.has(right)) column = right;
+			}
+			used.add(column);
+			columns.set(entry.id, column);
+		}
+	});
+	const min = Math.min(...columns.values(), 0);
+	return new Map([...columns].map(([id, column]) => [id, column - min]));
+};
+/** One cell fits the largest class: widest line (wrapped at maxWidth) and tallest member list. */
+var measureCell$1 = (model, { maxWidth, cell: override = {}, titleHeight }) => {
+	const memberLines = (entry) => [...entry.attributes, ...entry.methods];
+	const titleW = Math.max(0, ...model.classes.map((entry) => Math.max(entry.label.length, (entry.stereotype?.length ?? 0) + 2))) * TITLE_FONT.charW;
+	const memberW = Math.max(0, ...model.classes.flatMap((entry) => memberLines(entry).map((line) => line.length))) * MEMBER_FONT.charW;
+	const w = snap$3(override.w ?? Math.min(maxWidth, Math.max(MIN_W$1, Math.ceil(Math.max(titleW, memberW)) + PAD_X$1)));
+	const wrapped = (length, font) => Math.max(1, Math.ceil(length * font.charW / (w - 32)));
+	const titleLines = Math.max(1, ...model.classes.map((entry) => wrapped(entry.label.length, TITLE_FONT) + (entry.stereotype ? 1 : 0)));
+	const bodyLines = Math.max(1, ...model.classes.map((entry) => memberLines(entry).reduce((sum, line) => sum + wrapped(line.length, MEMBER_FONT), 0) + (entry.attributes.length && entry.methods.length ? 1 : 0)));
+	const titleH = titleHeight !== void 0 ? Math.ceil(titleHeight / GRID_FINE$1) * GRID_FINE$1 : Math.min(MAX_TITLE_H, Math.max(MIN_TITLE_H, snap$3(titleLines * TITLE_FONT.lineH + TITLE_PAD)));
+	const bodyH = snap$3(bodyLines * MEMBER_FONT.lineH + SECTION_PAD);
+	const measured = Math.min(MAX_H, Math.max(MIN_H$1, titleH + bodyH));
+	return {
+		w,
+		h: override.h !== void 0 ? Math.max(snap$3(override.h), titleH + 32) : measured,
+		titleH
+	};
+};
+/**
+* Compile a mermaid class diagram into scene commands with equal-size grid-aligned nodes: per
+* class a `title` bar plus a `body` compartment filling the cell, and an `edges` object holding
+* orthogonal connector paths (polyline waypoints, an arrowhead segment, and a floating label).
+*/
+var compile$5 = (source, options = {}) => {
+	const model = parse(source);
+	const { origin = {
+		x: 0,
+		y: 0
+	}, scale = 1, maxWidth = MAX_W$1, route } = options;
+	const gapMain = snap$3(options.gapMain ?? GAP_MAIN$1);
+	const gapCross = snap$3(options.gapCross ?? GAP_CROSS$1);
+	const horizontal = model.direction === "LR" || model.direction === "RL";
+	const cell = measureCell$1(model, {
+		maxWidth,
+		cell: options.cell,
+		titleHeight: options.titleHeight
+	});
+	const ranks = relationRanks(model);
+	const lanes = /* @__PURE__ */ new Map();
+	for (const entry of model.classes) {
+		const value = ranks.get(entry.id) ?? 0;
+		lanes.set(value, [...lanes.get(value) ?? [], entry.id]);
+	}
+	const cross = horizontal ? cell.h : cell.w;
+	const main = horizontal ? cell.w : cell.h;
+	const columns = assignColumns(model, ranks, lanes);
+	const rects = /* @__PURE__ */ new Map();
+	for (const [lane, members] of lanes) for (const id of members) {
+		const crossOffset = columns.get(id) * (cross + gapCross);
+		const mainOffset = lane * (main + gapMain);
+		rects.set(id, {
+			x: horizontal ? mainOffset : crossOffset,
+			y: horizontal ? crossOffset : mainOffset,
+			w: cell.w,
+			h: cell.h
+		});
+	}
+	return emit$1({
+		model,
+		cell,
+		rects,
+		ranks
+	}, {
+		origin,
+		scale,
+		route
+	});
+};
+/**
+* Emit scene commands from a placed model — the shared back half of `compile`, also used by the
+* engine-backed dialects (`uml-engine.ts`) which supply their own placement.
+*/
+var emit$1 = ({ model, cell, rects, ranks }, { origin = {
+	x: 0,
+	y: 0
+}, scale = 1, route } = {}) => {
+	const horizontal = model.direction === "LR" || model.direction === "RL";
+	const router = route ?? makeAvoidingRouter([...rects.values()], zRouter, { step: 8 });
+	const commands = [];
+	for (const entry of model.classes) {
+		const rect = rects.get(entry.id);
+		const title = entry.stereotype ? `«${entry.stereotype}»\n${entry.label}` : entry.label;
+		const members = [
+			...entry.attributes,
+			...entry.attributes.length && entry.methods.length ? [""] : [],
+			...entry.methods
+		].join("\n");
+		commands.push({
+			op: "upsert-object",
+			object: {
+				id: entry.id,
+				origin: {
+					x: origin.x + rect.x * scale,
+					y: origin.y + rect.y * scale
+				},
+				scale,
+				elements: [
+					{
+						kind: "rect",
+						id: "frame",
+						x: 0,
+						y: 0,
+						w: cell.w,
+						h: cell.h
+					},
+					{
+						kind: "rect",
+						id: "title",
+						x: 0,
+						y: 0,
+						w: cell.w,
+						h: cell.titleH,
+						text: title,
+						fill: "solid",
+						corners: "top"
+					},
+					...members ? [{
+						kind: "text",
+						id: "body",
+						x: TEXT_PAD,
+						y: cell.titleH + SECTION_PAD / 2,
+						w: cell.w - 32,
+						text: members,
+						weight: "s"
+					}] : []
+				]
+			}
+		});
+	}
+	if (model.relations.length > 0) {
+		const gutterOf = (relation) => {
+			const from = rects.get(relation.from);
+			const to = rects.get(relation.to);
+			const sameLane = horizontal ? from.x === to.x : from.y === to.y;
+			if (horizontal ? sameLane : !sameLane) {
+				if (from.x + from.w / 2 === to.x + to.w / 2) return `v:${from.x + from.w / 2}`;
+				return `y:${snap$3(((to.y >= from.y ? from.y + from.h : from.y) + (to.y >= from.y ? to.y : to.y + to.h)) / 2)}`;
+			}
+			if (from.y + from.h / 2 === to.y + to.h / 2) return `h:${from.y + from.h / 2}`;
+			return `x:${snap$3(((to.x >= from.x ? from.x + from.w : from.x) + (to.x >= from.x ? to.x : to.x + to.w)) / 2)}`;
+		};
+		const gutters = /* @__PURE__ */ new Map();
+		for (const relation of model.relations) {
+			const gutter = gutterOf(relation);
+			gutters.set(gutter, (gutters.get(gutter) ?? 0) + 1);
+		}
+		const portGroups = /* @__PURE__ */ new Map();
+		const addSlot = (key, slot) => portGroups.set(key, [...portGroups.get(key) ?? [], slot]);
+		for (const relation of model.relations) {
+			const from = rects.get(relation.from);
+			const to = rects.get(relation.to);
+			const sameLane = horizontal ? from.x === to.x : from.y === to.y;
+			if (horizontal ? sameLane : !sameLane) {
+				const down = to.y >= from.y;
+				addSlot(`${relation.from}:${down ? "bottom" : "top"}`, {
+					relation,
+					end: false,
+					order: to.x + to.w / 2
+				});
+				addSlot(`${relation.to}:${down ? "top" : "bottom"}`, {
+					relation,
+					end: true,
+					order: from.x + from.w / 2
+				});
+			} else {
+				const right = to.x >= from.x;
+				addSlot(`${relation.from}:${right ? "right" : "left"}`, {
+					relation,
+					end: false,
+					order: to.y + to.h / 2
+				});
+				addSlot(`${relation.to}:${right ? "left" : "right"}`, {
+					relation,
+					end: true,
+					order: from.y + from.h / 2
+				});
+			}
+		}
+		const ports = /* @__PURE__ */ new Map();
+		for (const [key, slots] of portGroups) {
+			if (slots.length < 2) continue;
+			const nodeId = key.slice(0, key.lastIndexOf(":"));
+			const rect = rects.get(nodeId);
+			const across = key.endsWith(":top") || key.endsWith(":bottom");
+			slots.sort((left, right) => left.order - right.order);
+			const taken = /* @__PURE__ */ new Set();
+			slots.forEach((slot, index) => {
+				const fraction = (index + 1) / (slots.length + 1);
+				const exact = across ? rect.x + rect.w * fraction : rect.y + rect.h * fraction;
+				const rounded = Math.round(exact / GRID_FINE$1) * GRID_FINE$1;
+				const coord = taken.has(rounded) ? exact : rounded;
+				taken.add(coord);
+				const entry = ports.get(slot.relation) ?? {};
+				entry[slot.end ? "end" : "start"] = coord;
+				ports.set(slot.relation, entry);
+			});
+		}
+		const takenBySide = /* @__PURE__ */ new Map();
+		for (const [key, slots] of portGroups) {
+			const nodeId = key.slice(0, key.lastIndexOf(":"));
+			const rect = rects.get(nodeId);
+			const across = key.endsWith(":top") || key.endsWith(":bottom");
+			const coords = /* @__PURE__ */ new Map();
+			for (const slot of slots) {
+				const port = ports.get(slot.relation)?.[slot.end ? "end" : "start"];
+				coords.set(slot.relation, port ?? (across ? rect.x + rect.w / 2 : rect.y + rect.h / 2));
+			}
+			takenBySide.set(key, coords);
+		}
+		const fineSnap = (value) => Math.round(value / GRID_FINE$1) * GRID_FINE$1;
+		for (const relation of model.relations) {
+			const from = rects.get(relation.from);
+			const to = rects.get(relation.to);
+			const sameLane = horizontal ? from.x === to.x : from.y === to.y;
+			const alongY = horizontal ? sameLane : !sameLane;
+			const lo = alongY ? Math.max(from.x, to.x) + GRID_FINE$1 : Math.max(from.y, to.y) + GRID_FINE$1;
+			const hi = alongY ? Math.min(from.x + from.w, to.x + to.w) - GRID_FINE$1 : Math.min(from.y + from.h, to.y + to.h) - GRID_FINE$1;
+			if (lo > hi) continue;
+			const startKey = alongY ? `${relation.from}:${to.y >= from.y ? "bottom" : "top"}` : `${relation.from}:${to.x >= from.x ? "right" : "left"}`;
+			const endKey = alongY ? `${relation.to}:${to.y >= from.y ? "top" : "bottom"}` : `${relation.to}:${to.x >= from.x ? "left" : "right"}`;
+			const entry = ports.get(relation) ?? {};
+			const startCoord = entry.start ?? (alongY ? from.x + from.w / 2 : from.y + from.h / 2);
+			const endCoord = entry.end ?? (alongY ? to.x + to.w / 2 : to.y + to.h / 2);
+			const isFree = (coord) => ![startKey, endKey].some((side) => [...takenBySide.get(side) ?? /* @__PURE__ */ new Map()].some(([peer, taken]) => peer !== relation && Math.abs(taken - coord) < GRID_FINE$1));
+			const base = Math.min(hi, Math.max(lo, fineSnap((startCoord + endCoord) / 2)));
+			let chosen;
+			for (let step = 0; step <= Math.ceil((hi - lo) / GRID_FINE$1) && chosen === void 0; step++) for (const candidate of step === 0 ? [base] : [base - step * GRID_FINE$1, base + step * GRID_FINE$1]) if (candidate >= lo && candidate <= hi && isFree(candidate)) {
+				chosen = candidate;
+				break;
+			}
+			if (chosen === void 0) continue;
+			entry.start = chosen;
+			entry.end = chosen;
+			ports.set(relation, entry);
+			takenBySide.get(startKey)?.set(relation, chosen);
+			takenBySide.get(endKey)?.set(relation, chosen);
+		}
+		const assigned = /* @__PURE__ */ new Map();
+		const elements = [];
+		model.relations.forEach((relation, index) => {
+			const gutter = gutterOf(relation);
+			const position = assigned.get(gutter) ?? 0;
+			assigned.set(gutter, position + 1);
+			const offset = position - Math.floor((gutters.get(gutter) - 1) / 2);
+			const points = router({
+				relation,
+				from: rects.get(relation.from),
+				to: rects.get(relation.to),
+				horizontal,
+				offset,
+				ports: ports.get(relation)
+			});
+			const id = `${relation.from}-${relation.to}-${index}`;
+			const style = relationStyle(relation.kind);
+			if (points.length > 2) elements.push({
+				kind: "line",
+				id: `${id}-path`,
+				points: points.slice(0, -1),
+				...style
+			});
+			elements.push({
+				kind: "arrow",
+				id,
+				start: points[points.length - 2],
+				end: points[points.length - 1],
+				...style
+			});
+			const text = relationText(relation);
+			if (text) {
+				const head = points[Math.floor(points.length / 2) - 1];
+				const tail = points[Math.floor(points.length / 2)];
+				elements.push({
+					kind: "text",
+					id: `${id}-label`,
+					x: (head.x + tail.x) / 2 + GRID_FINE$1 / 2,
+					y: (head.y + tail.y) / 2 - MEMBER_FONT.lineH,
+					text,
+					weight: "s"
+				});
+			}
+		});
+		commands.push({
+			op: "upsert-object",
+			object: {
+				id: "edges",
+				origin,
+				scale,
+				elements
+			}
+		});
+	}
+	return commands;
+};
+//#endregion
+//#region src/objective.ts
+var objective_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT: () => DEFAULT,
+	bends: () => bends$1,
+	compactness: () => compactness,
+	connectorLength: () => connectorLength,
+	crossings: () => crossings,
+	evaluate: () => evaluate,
+	framesApart: () => framesApart,
+	noHardDefects: () => noHardDefects,
+	select: () => select,
+	unevenFrameGaps: () => unevenFrameGaps
+});
+var __dxlog_file$1 = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/infinite-canvas-depth-7e0949/packages/common/diagram/src/objective.ts";
+var evaluate = (objective, layout) => {
+	const violations = objective.constraints.flatMap((constraint) => constraint.violations(layout).map((message) => ({
+		constraint: constraint.id,
+		message
+	})));
+	const terms = objective.costs.map((term) => {
+		const value = term.measure(layout);
+		return {
+			id: term.id,
+			value,
+			weighted: value * term.weight
+		};
+	});
+	return {
+		violations,
+		cost: terms.reduce((total, term) => total + term.weighted, 0),
+		terms
+	};
+};
+/**
+* Picks the best candidate: fewest constraint violations first (so an infeasible set still yields
+* the least-bad layout rather than nothing), then lowest cost. Stable on ties, so the generator's
+* own order breaks them.
+*/
+var select = (objective, candidates) => {
+	invariant(candidates.length > 0, "select needs at least one candidate", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 74,
+		S: void 0,
+		A: ["candidates.length > 0", "'select needs at least one candidate'"]
+	});
+	const ranked = candidates.map((candidate) => ({
+		candidate,
+		evaluation: evaluate(objective, candidate.layout)
+	})).sort((left, right) => left.evaluation.violations.length - right.evaluation.violations.length || left.evaluation.cost - right.evaluation.cost);
+	return {
+		chosen: ranked[0],
+		ranked
+	};
+};
+/** Every `error` diagnostic is a violation: overlaps, routes through nodes, labels that do not fit. */
+var noHardDefects = {
+	id: "no-hard-defects",
+	description: "No node overlaps, no connector through a node, every label fits its shape.",
+	violations: ({ report }) => report.diagnostics.filter(({ severity }) => severity === "error").map(({ message }) => message)
+};
+/** Containers keep at least `gap` between them, so packages read as separate. */
+var framesApart = (gap = 32) => ({
+	id: "frames-apart",
+	description: `Frames are at least ${gap} apart.`,
+	violations: ({ report }) => report.metrics.containers >= 2 && report.metrics.frameGapMin < gap ? [`Frames are ${report.metrics.frameGapMin} apart; at least ${gap} required.`] : []
+});
+var crossings = {
+	id: "crossings",
+	description: "Connector pairs that cross.",
+	weight: 3,
+	measure: ({ report }) => report.metrics.crossings
+};
+var bends$1 = {
+	id: "bends",
+	description: "Turns taken by connectors.",
+	weight: 1,
+	measure: ({ report }) => report.metrics.bends
+};
+/**
+* Uneven gutters between frames, in grid units. Weighted so a whole cell of unevenness costs about
+* half a crossing: on the pipeline corpus diagram a weight of 2 made the objective accept three
+* crossings to even out a 7-unit spread, which no reader would.
+*/
+var unevenFrameGaps = {
+	id: "uneven-frame-gaps",
+	description: "Spread of the gaps between neighbouring frames.",
+	weight: .5,
+	measure: ({ report }) => report.metrics.frameGapSpread / 32
+};
+/**
+* Total connector length in grid units: a long edge is hard to follow even when it is straight.
+* Weighted so ~100 grid units of extra connector cost one crossing — at 0.1 the objective traded
+* crossings for shorter edges on the compute and edge corpus diagrams.
+*/
+var connectorLength = {
+	id: "connector-length",
+	description: "Total connector length.",
+	weight: .03,
+	measure: ({ report }) => report.metrics.length / 32
+};
+/** Bounding perimeter in grid units; a light preference for the tighter of otherwise-equal layouts. */
+var compactness = {
+	id: "compactness",
+	description: "Bounding width + height.",
+	weight: .05,
+	measure: ({ report }) => (report.metrics.width + report.metrics.height) / 32
+};
+var DEFAULT = {
+	constraints: [noHardDefects, framesApart()],
+	costs: [
+		crossings,
+		bends$1,
+		connectorLength,
+		unevenFrameGaps,
+		compactness
+	]
+};
+//#endregion
+//#region src/mermaid-engine.ts
+var mermaid_engine_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$4,
+	layout: () => layout$1
+});
+var __dxlog_file = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/infinite-canvas-depth-7e0949/packages/common/diagram/src/mermaid-engine.ts";
+var MIN_W = 96;
+var MAX_W = 192;
+var MIN_H = 64;
+var PAD_X = 32;
+var PAD_Y = 16;
+/** Frame inset around a subgraph's members; the top also holds the frame label. */
+var FRAME_PAD$1 = 32;
+var FRAME_LABEL_H = 32;
+/** Clear space between two frames, so packages read as separate even when their nodes are adjacent. */
+var FRAME_GAP = 32;
+var GRID_FINE = 16;
+var FONT = FONT_METRICS.m;
+var LABEL_FONT = FONT_METRICS.s;
+var ELK_DIRECTION$1 = {
+	TB: "DOWN",
+	BT: "UP",
+	LR: "RIGHT",
+	RL: "LEFT"
+};
+var snapUp = (value) => Math.ceil(value / 32) * 32;
+var fineSnap = (value) => Math.round(value / GRID_FINE) * GRID_FINE;
+var LATTICES = [1.5, 2];
+var ORDERS = ["model", "free"];
+var ARRANGEMENTS = ["layered", "columns"];
+var LAYERINGS = [
+	"down",
+	"up",
+	"free"
+];
+var ALIGNMENTS = ["none", "edges"];
+/** The direction perpendicular to the flow, for arranging groups across it. */
+var ACROSS = {
+	TB: "RIGHT",
+	BT: "RIGHT",
+	LR: "DOWN",
+	RL: "DOWN"
+};
+/** One cell size for every node, sized to the longest label wrapped at `maxWidth`. */
+var measureCell = (graph, maxWidth) => {
+	const longest = Math.max(0, ...graph.nodes.map((node) => node.label.length));
+	const w = snapUp(Math.min(maxWidth, Math.max(MIN_W, longest * FONT.charW + PAD_X * 2)));
+	const perLine = Math.max(1, Math.floor((w - PAD_X) / FONT.charW));
+	const lines = Math.max(1, ...graph.nodes.map((node) => Math.ceil(node.label.length / perLine)));
+	return {
+		w,
+		h: snapUp(Math.max(MIN_H, (lines - 1) * FONT.lineH + FONT.lineH / 1.35 + PAD_Y * 2))
+	};
+};
+/**
+* Lattice pitch for a cell. With groups, the gutter between lattice rows must also hold two frame
+* borders, a label band, and clear space between the frames, or adjacent frames touch or overlap
+* after quantization — so that clearance is a floor on the pitch.
+*/
+var pitchFor = (graph, cell, lattice) => {
+	const framed = graph.groups.some((group) => group.children.length > 0);
+	return {
+		x: snapUp(Math.max(cell.w * lattice, framed ? cell.w + FRAME_PAD$1 * 2 + FRAME_GAP : 0)),
+		y: snapUp(Math.max(cell.h * lattice, framed ? cell.h + FRAME_PAD$1 * 2 + FRAME_LABEL_H + FRAME_GAP : 0))
+	};
+};
+/**
+* Quantize ELK's positions to the lattice. Each node takes the nearest lattice point; when two
+* nodes claim the same point, the later one slides along the cross axis to the nearest free slot,
+* so quantization can never stack nodes.
+*/
+var quantize = (positions, pitch, horizontal) => {
+	const taken = /* @__PURE__ */ new Set();
+	const result = /* @__PURE__ */ new Map();
+	const ordered = [...positions.entries()].sort(([, a], [, b]) => horizontal ? a.x - b.x || a.y - b.y : a.y - b.y || a.x - b.x);
+	for (const [id, point] of ordered) {
+		const col = Math.round(point.x / pitch.x);
+		const row = Math.round(point.y / pitch.y);
+		for (let step = 0;; step++) {
+			const offset = step === 0 ? 0 : (step % 2 ? 1 : -1) * Math.ceil(step / 2);
+			const cell = horizontal ? {
+				col,
+				row: row + offset
+			} : {
+				col: col + offset,
+				row
+			};
+			const key = `${cell.col}:${cell.row}`;
+			if (!taken.has(key)) {
+				taken.add(key);
+				result.set(id, {
+					x: cell.col * pitch.x,
+					y: cell.row * pitch.y
+				});
+				break;
+			}
+		}
+	}
+	return result;
+};
+/**
+* Close surplus gutters between groups along the cross axis. ELK spaces compound nodes by their
+* own padded extents, so after quantization two groups can sit a whole lattice pitch further apart
+* than the frame clearance needs while another pair sits at the minimum — the uneven gaps a reader
+* notices first. Groups are walked in cross-axis order and each, with everything beyond it, is
+* pulled back by whole pitches while its gap to the previous group stays above the clearance, so
+* every node remains on the lattice and cross-group connectors stay straight.
+*/
+var compactGroups = (graph, positions, cell, pitch, horizontal) => {
+	const axis = horizontal ? "y" : "x";
+	const step = horizontal ? pitch.y : pitch.x;
+	const size = horizontal ? cell.h : cell.w;
+	const groups = graph.groups.filter((group) => group.children.some((id) => positions.has(id))).map((group) => {
+		const coords = group.children.flatMap((id) => positions.has(id) ? [positions.get(id)[axis]] : []);
+		return {
+			ids: group.children,
+			start: Math.min(...coords),
+			end: Math.max(...coords)
+		};
+	}).sort((left, right) => left.start - right.start);
+	const result = new Map(positions);
+	for (let index = 1; index < groups.length; index++) {
+		const previous = groups[index - 1];
+		const current = groups[index];
+		const gap = current.start - FRAME_PAD$1 - (previous.end + size + FRAME_PAD$1);
+		let surplus = Math.floor((gap - FRAME_GAP) / step) * step;
+		if (surplus <= 0) continue;
+		const moving = [...result].filter(([, point]) => point[axis] >= current.start);
+		const staying = new Set([...result].filter(([, point]) => point[axis] < current.start).map(([, point]) => `${point.x}:${point.y}`));
+		const collides = (shift) => moving.some(([, point]) => staying.has(`${axis === "x" ? point.x - shift : point.x}:${axis === "y" ? point.y - shift : point.y}`));
+		while (surplus > 0 && collides(surplus)) surplus -= step;
+		if (surplus <= 0) continue;
+		for (const [id, point] of moving) result.set(id, {
+			...point,
+			[axis]: point[axis] - surplus
+		});
+		for (const later of groups.slice(index)) {
+			later.start -= surplus;
+			later.end -= surplus;
+		}
+	}
+	return result;
+};
+/**
+* Edges for ELK's layering. Inheritance points at the abstraction, which ranks ABOVE its
+* subtypes — so those edges are reversed, as `relationRanks` does for class diagrams; has-many
+* and containment already flow owner-above-owned. In `columns`, the root lays out groups without
+* seeing inside them (`SEPARATE_CHILDREN`), so every edge is lifted to its endpoints' root-level
+* representatives — the group, or the node itself when ungrouped — and the groups fall into
+* dependency order; edges within one group stay where they are for that group's own layout.
+* A reference between packages always orders the packages; within one it ranks per `layering`.
+*/
+var layeringEdges = (graph, arrangement, layering) => {
+	const groupOf = new Map(graph.groups.flatMap((group) => group.children.map((id) => [id, group.id])));
+	const betweenGroups = (edge) => groupOf.has(edge.from) && groupOf.has(edge.to) && groupOf.get(edge.from) !== groupOf.get(edge.to);
+	const oriented = graph.edges.flatMap((edge) => {
+		if (edge.kind === "inheritance") return [{
+			from: edge.to,
+			to: edge.from
+		}];
+		if (edge.kind !== "reference" || layering === "down" || betweenGroups(edge)) return [{
+			from: edge.from,
+			to: edge.to
+		}];
+		return layering === "up" ? [{
+			from: edge.to,
+			to: edge.from
+		}] : [];
+	});
+	if (arrangement === "layered") return oriented.map((edge, index) => ({
+		id: `edge-${index}`,
+		sources: [edge.from],
+		targets: [edge.to]
+	}));
+	const edges = [];
+	const seen = /* @__PURE__ */ new Set();
+	oriented.forEach((edge, index) => {
+		const from = groupOf.get(edge.from);
+		const to = groupOf.get(edge.to);
+		if (from !== void 0 && from === to) {
+			edges.push({
+				id: `edge-${index}`,
+				sources: [edge.from],
+				targets: [edge.to]
+			});
+			return;
+		}
+		const lifted = {
+			from: from ?? edge.from,
+			to: to ?? edge.to
+		};
+		const key = `${lifted.from}->${lifted.to}`;
+		if (lifted.from !== lifted.to && !seen.has(key)) {
+			seen.add(key);
+			edges.push({
+				id: `group-edge-${index}`,
+				sources: [lifted.from],
+				targets: [lifted.to]
+			});
+		}
+	});
+	return edges;
+};
+/**
+* ELK compound layout. Groups become hierarchical nodes whose children ELK lays out inside
+* them; positions come back parent-relative and are flattened here. Node origins are then
+* quantized to the lattice and frames recomputed from their quantized members, so quantization
+* can never break containment.
+*/
+var place = async (graph, cell, pitch, order, arrangement, layering) => {
+	const horizontal = graph.direction === "LR" || graph.direction === "RL";
+	const grouped = new Set(graph.groups.flatMap((group) => group.children));
+	const leaf = (id) => ({
+		id,
+		width: cell.w,
+		height: cell.h
+	});
+	const spacing = {
+		"elk.layered.spacing.nodeNodeBetweenLayers": String(horizontal ? pitch.x - cell.w : pitch.y - cell.h),
+		"elk.spacing.nodeNode": String(horizontal ? pitch.y - cell.h : pitch.x - cell.w)
+	};
+	const flow = {
+		"elk.algorithm": "layered",
+		"elk.direction": ELK_DIRECTION$1[graph.direction],
+		"elk.layered.nodePlacement.strategy": "BRANDES_KOEPF",
+		"elk.layered.considerModelOrder.strategy": order === "model" ? "PREFER_NODES" : "NONE"
+	};
+	const children = [...graph.nodes.filter((node) => !grouped.has(node.id)).map((node) => leaf(node.id)), ...graph.groups.filter((group) => group.children.length > 0).map((group) => ({
+		id: group.id,
+		layoutOptions: {
+			...spacing,
+			...arrangement === "columns" ? flow : {},
+			"elk.padding": `[top=${FRAME_PAD$1 + FRAME_LABEL_H},left=${FRAME_PAD$1},bottom=${FRAME_PAD$1},right=${FRAME_PAD$1}]`
+		},
+		children: group.children.map(leaf)
+	}))];
+	const result = await new ELK().layout({
+		id: "root",
+		layoutOptions: arrangement === "columns" ? {
+			...flow,
+			"elk.direction": ACROSS[graph.direction],
+			"elk.hierarchyHandling": "SEPARATE_CHILDREN",
+			...spacing
+		} : {
+			...flow,
+			"elk.hierarchyHandling": "INCLUDE_CHILDREN",
+			...spacing
+		},
+		children,
+		edges: layeringEdges(graph, arrangement, layering)
+	});
+	const raw = /* @__PURE__ */ new Map();
+	const visit = (node, offset) => {
+		for (const child of node.children ?? []) {
+			const x = offset.x + (child.x ?? 0);
+			const y = offset.y + (child.y ?? 0);
+			if (child.children?.length) visit(child, {
+				x,
+				y
+			});
+			else raw.set(child.id, {
+				x,
+				y
+			});
+		}
+	};
+	visit(result, {
+		x: 0,
+		y: 0
+	});
+	return compactGroups(graph, quantize(raw, pitch, horizontal), cell, pitch, horizontal);
+};
+/**
+* Align each package to its cross-package edges: among the whole-row shifts that put one of its
+* members on the row of that member's partner, take the one leaving its edges the least total row
+* offset (nearest to no shift on a tie), onto free lattice points only. Two sweeps, since a partner
+* may itself move in the first.
+*/
+var alignGroups = (graph, positions, direction, alignment) => {
+	if (alignment === "none") return positions;
+	const axis = direction === "LR" || direction === "RL" ? "x" : "y";
+	const groupOf = new Map(graph.groups.flatMap((group) => group.children.map((id) => [id, group.id])));
+	const result = new Map(positions);
+	for (let sweep = 0; sweep < 2; sweep++) for (const group of graph.groups) {
+		const members = new Set(group.children.filter((id) => result.has(id)));
+		const pairs = graph.edges.flatMap((edge) => {
+			const [member, partner] = members.has(edge.from) ? [edge.from, edge.to] : [edge.to, edge.from];
+			const here = result.get(member);
+			const there = result.get(partner);
+			return members.has(member) && !members.has(partner) && groupOf.has(partner) && here && there ? [{
+				here: here[axis],
+				there: there[axis]
+			}] : [];
+		});
+		if (pairs.length === 0) continue;
+		const offset = (shift) => pairs.reduce((sum, pair) => sum + Math.abs(pair.here + shift - pair.there), 0);
+		const shifts = [.../* @__PURE__ */ new Set([0, ...pairs.map((pair) => pair.there - pair.here)])].sort((left, right) => offset(left) - offset(right) || Math.abs(left) - Math.abs(right));
+		const others = new Set([...result].filter(([id]) => !members.has(id)).map(([, point]) => `${point.x}:${point.y}`));
+		const shift = shifts.find((candidate) => ![...members].some((id) => {
+			const point = result.get(id);
+			return point && others.has(`${axis === "x" ? point.x + candidate : point.x}:${axis === "y" ? point.y + candidate : point.y}`);
+		}));
+		if (!shift) continue;
+		for (const id of members) {
+			const point = result.get(id);
+			if (point) result.set(id, {
+				...point,
+				[axis]: point[axis] + shift
+			});
+		}
+	}
+	return result;
+};
+/** Node rects at the origin plus the frame around each group's members. */
+var frame$1 = (graph, positions, cell) => {
+	const minX = Math.min(0, ...[...positions.values()].map((point) => point.x));
+	const minY = Math.min(0, ...[...positions.values()].map((point) => point.y));
+	const nodes = new Map([...positions].map(([id, point]) => [id, {
+		x: point.x - minX,
+		y: point.y - minY,
+		w: cell.w,
+		h: cell.h
+	}]));
+	const frames = /* @__PURE__ */ new Map();
+	for (const group of graph.groups) {
+		const members = group.children.flatMap((id) => nodes.get(id) ?? []);
+		if (members.length === 0) continue;
+		const x = Math.min(...members.map((rect) => rect.x)) - FRAME_PAD$1;
+		const y = Math.min(...members.map((rect) => rect.y)) - FRAME_PAD$1 - FRAME_LABEL_H;
+		const right = Math.max(...members.map((rect) => rect.x + rect.w)) + FRAME_PAD$1;
+		const bottom = Math.max(...members.map((rect) => rect.y + rect.h)) + FRAME_PAD$1;
+		frames.set(group.id, {
+			x,
+			y,
+			w: right - x,
+			h: bottom - y
+		});
+	}
+	return {
+		nodes,
+		frames
+	};
+};
+/**
+* Straightened ports: when an edge's nodes overlap on the cross axis, both terminals take one
+* shared coordinate inside the overlap, so the connector is a single straight run instead of a
+* jog between nearly aligned nodes. Distinct edges leaving the same node side take distinct
+* coordinates. Mirrors the straightening pass in the UML emitter.
+*/
+var straighten = (edges, nodes, isHorizontal) => {
+	const ports = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		const from = nodes.get(edge.from);
+		const to = nodes.get(edge.to);
+		if (!from || !to) continue;
+		const horizontal = isHorizontal(edge);
+		const sameLane = horizontal ? from.x === to.x : from.y === to.y;
+		const alongY = horizontal ? sameLane : !sameLane;
+		const lo = (alongY ? Math.max(from.x, to.x) : Math.max(from.y, to.y)) + GRID_FINE;
+		const hi = (alongY ? Math.min(from.x + from.w, to.x + to.w) : Math.min(from.y + from.h, to.y + to.h)) - GRID_FINE;
+		if (lo > hi) continue;
+		const sides = alongY ? [`${edge.from}:${to.y >= from.y ? "bottom" : "top"}`, `${edge.to}:${to.y >= from.y ? "top" : "bottom"}`] : [`${edge.from}:${to.x >= from.x ? "right" : "left"}`, `${edge.to}:${to.x >= from.x ? "left" : "right"}`];
+		const center = alongY ? (from.x + from.w / 2 + to.x + to.w / 2) / 2 : (from.y + from.h / 2 + to.y + to.h / 2) / 2;
+		const base = Math.min(hi, Math.max(lo, fineSnap(center)));
+		const isFree = (coord) => sides.every((side) => (taken.get(side) ?? []).every((used) => Math.abs(used - coord) >= GRID_FINE));
+		let chosen;
+		for (let step = 0; step <= Math.ceil((hi - lo) / GRID_FINE) && chosen === void 0; step++) for (const candidate of step === 0 ? [base] : [base - step * GRID_FINE, base + step * GRID_FINE]) if (candidate >= lo && candidate <= hi && isFree(candidate)) {
+			chosen = candidate;
+			break;
+		}
+		if (chosen === void 0) continue;
+		ports.set(edge, {
+			start: chosen,
+			end: chosen
+		});
+		for (const side of sides) taken.set(side, [...taken.get(side) ?? [], chosen]);
+	}
+	return ports;
+};
+/**
+* Inheritance bus (TB only): subtypes of one base that sit on one row above which the base sits
+* connect through a shared horizontal bus and a single triangle-headed trunk, the UML tree
+* connector. Returns the elements and the edges it consumed; edges that do not qualify are left
+* to the per-edge router.
+*/
+var inheritanceBuses = (edges, nodes) => {
+	const elements = [];
+	const consumed = /* @__PURE__ */ new Set();
+	const byBase = /* @__PURE__ */ new Map();
+	for (const edge of edges) if (edge.kind === "inheritance" && !edge.label) byBase.set(edge.to, [...byBase.get(edge.to) ?? [], edge]);
+	for (const [baseId, group] of byBase) {
+		const base = nodes.get(baseId);
+		const subs = group.map((edge) => nodes.get(edge.from));
+		if (!base || group.length < 2 || subs.some((sub) => !sub)) continue;
+		const rects = subs;
+		const row = rects[0].y;
+		if (rects.some((sub) => sub.y !== row) || base.y + base.h >= row) continue;
+		const busY = fineSnap((base.y + base.h + row) / 2);
+		const trunkX = fineSnap(base.x + base.w / 2);
+		const centers = rects.map((sub) => fineSnap(sub.x + sub.w / 2));
+		const span = [Math.min(trunkX, ...centers), Math.max(trunkX, ...centers)];
+		elements.push({
+			kind: "line",
+			id: `${baseId}-bus`,
+			points: [{
+				x: span[0],
+				y: busY
+			}, {
+				x: span[1],
+				y: busY
+			}]
+		});
+		group.forEach((edge, index) => {
+			elements.push({
+				kind: "line",
+				id: `${edge.from}-${baseId}-stub-${index}`,
+				points: [{
+					x: centers[index],
+					y: row
+				}, {
+					x: centers[index],
+					y: busY
+				}]
+			});
+			consumed.add(edge);
+		});
+		elements.push({
+			kind: "arrow",
+			id: `${baseId}-inherit`,
+			start: {
+				x: trunkX,
+				y: busY
+			},
+			end: {
+				x: trunkX,
+				y: base.y + base.h
+			},
+			head: "triangle"
+		});
+	}
+	return {
+		elements,
+		consumed
+	};
+};
+/**
+* Scene commands for a placement: one world object per subgraph frame (painted first) and per
+* node, plus an `edges` object of connectors.
+*/
+var emit = (graph, cell, { nodes, frames }, { origin, scale, bus, arrangement, route }) => {
+	const horizontal = graph.direction === "LR" || graph.direction === "RL";
+	const at = (rect) => ({
+		x: origin.x + rect.x * scale,
+		y: origin.y + rect.y * scale
+	});
+	const commands = [];
+	for (const group of graph.groups) {
+		const frame = frames.get(group.id);
+		if (!frame) continue;
+		commands.push({
+			op: "upsert-object",
+			object: {
+				id: group.id,
+				origin: at(frame),
+				scale,
+				elements: [{
+					kind: "rect",
+					id: "frame",
+					x: 0,
+					y: 0,
+					w: frame.w,
+					h: frame.h,
+					stroke: "dashed",
+					color: "grey"
+				}, ...group.label.trim() ? [{
+					kind: "text",
+					id: "label",
+					x: FRAME_PAD$1 / 2,
+					y: (FRAME_LABEL_H - LABEL_FONT.lineH) / 2,
+					text: group.label,
+					weight: "s",
+					color: "grey"
+				}] : []]
+			}
+		});
+	}
+	for (const node of graph.nodes) {
+		const rect = nodes.get(node.id);
+		if (!rect) continue;
+		commands.push({
+			op: "upsert-object",
+			object: {
+				id: node.id,
+				origin: at(rect),
+				scale,
+				...node.ref ? { ref: node.ref } : {},
+				elements: [{
+					kind: "rect",
+					id: "box",
+					x: 0,
+					y: 0,
+					w: cell.w,
+					h: cell.h,
+					text: node.label
+				}]
+			}
+		});
+	}
+	if (graph.edges.length > 0) {
+		const router = route ?? makeAvoidingRouter([...nodes.values()], zRouter, { step: 8 });
+		const buses = bus && !horizontal ? inheritanceBuses(graph.edges, nodes) : {
+			elements: [],
+			consumed: /* @__PURE__ */ new Set()
+		};
+		const routed = graph.edges.filter((edge) => !buses.consumed.has(edge));
+		const groupOf = new Map(graph.groups.flatMap((group) => group.children.map((id) => [id, group.id])));
+		const rootOf = (id) => groupOf.get(id) ?? id;
+		const isHorizontal = (edge) => arrangement === "columns" && rootOf(edge.from) !== rootOf(edge.to) ? !horizontal : horizontal;
+		const ports = straighten(routed, nodes, isHorizontal);
+		const elements = [...buses.elements];
+		const terminals = /* @__PURE__ */ new Map();
+		const taken = (nodeId, point, role) => (terminals.get(nodeId) ?? []).some((other) => other.role !== role && Math.abs(other.point.x - point.x) < GRID_FINE && Math.abs(other.point.y - point.y) < GRID_FINE);
+		const NUDGES = [
+			[0, 0],
+			[1, 1],
+			[-1, -1],
+			[2, 2],
+			[-2, -2],
+			[1, 0],
+			[-1, 0],
+			[0, 1],
+			[0, -1]
+		];
+		const routeEdge = (edge, from, to) => {
+			const horizontal = isHorizontal(edge);
+			const sameLane = horizontal ? from.x === to.x : from.y === to.y;
+			const alongY = horizontal ? sameLane : !sameLane;
+			const base = ports.get(edge) ?? {};
+			const center = (rect) => alongY ? rect.x + rect.w / 2 : rect.y + rect.h / 2;
+			const within = (rect, value) => alongY ? Math.min(rect.x + rect.w - GRID_FINE, Math.max(rect.x + GRID_FINE, value)) : Math.min(rect.y + rect.h - GRID_FINE, Math.max(rect.y + GRID_FINE, value));
+			const route = ([startNudge, endNudge]) => router({
+				relation: edge,
+				from,
+				to,
+				horizontal,
+				offset: 0,
+				ports: {
+					start: within(from, (base.start ?? center(from)) + startNudge * GRID_FINE),
+					end: within(to, (base.end ?? center(to)) + endNudge * GRID_FINE)
+				}
+			});
+			const free = (points) => !taken(edge.from, points[0], "exit") && !taken(edge.to, points[points.length - 1], "entry");
+			const direct = route(NUDGES[0]);
+			if (free(direct)) return direct;
+			let best;
+			for (const nudge of NUDGES.slice(1)) {
+				const attempt = route(nudge);
+				if (free(attempt) && (!best || attempt.length < best.length)) best = attempt;
+			}
+			return best ?? direct;
+		};
+		routed.forEach((edge, index) => {
+			const from = nodes.get(edge.from);
+			const to = nodes.get(edge.to);
+			if (!from || !to) return;
+			const points = routeEdge(edge, from, to);
+			terminals.set(edge.from, [...terminals.get(edge.from) ?? [], {
+				point: points[0],
+				role: "exit"
+			}]);
+			terminals.set(edge.to, [...terminals.get(edge.to) ?? [], {
+				point: points[points.length - 1],
+				role: "entry"
+			}]);
+			const id = `${edge.from}-${edge.to}-${index}`;
+			if (points.length > 2) elements.push({
+				kind: "line",
+				id: `${id}-path`,
+				points: points.slice(0, -1)
+			});
+			elements.push({
+				kind: "arrow",
+				id,
+				start: points[points.length - 2],
+				end: points[points.length - 1],
+				...markers(edge.kind)
+			});
+			if (edge.label) {
+				const head = points[Math.floor(points.length / 2) - 1];
+				const tail = points[Math.floor(points.length / 2)];
+				elements.push({
+					kind: "text",
+					id: `${id}-label`,
+					x: (head.x + tail.x) / 2 + 8,
+					y: (head.y + tail.y) / 2 - LABEL_FONT.lineH,
+					text: edge.label,
+					weight: "s"
+				});
+			}
+		});
+		commands.push({
+			op: "upsert-object",
+			object: {
+				id: "edges",
+				origin,
+				scale,
+				elements
+			}
+		});
+	}
+	return commands;
+};
+var objectsOf = (commands) => commands.flatMap((command) => command.op === "upsert-object" ? [command.object] : []);
+/**
+* Lay out a mermaid flowchart: place once per lattice × ordering, emit with and without the
+* inheritance bus, analyze every candidate, and let the objective choose. All candidates come back
+* ranked so a bench can show what lost and why. Async because ELK is.
+*/
+var layout$1 = async (source, options = {}) => {
+	const graph = parse$1(source);
+	const { origin = {
+		x: 0,
+		y: 0
+	}, scale = 1, maxWidth = MAX_W, objective = DEFAULT, route } = options;
+	const cell = measureCell(graph, maxWidth);
+	const lattices = typeof options.lattice === "number" ? [options.lattice] : options.lattice ?? LATTICES;
+	const orders = options.order ?? ORDERS;
+	const buses = options.bus ?? [true, false];
+	const grouped = graph.groups.filter((group) => group.children.length > 0).length;
+	const arrangements = options.arrangement ?? (grouped >= 2 ? ARRANGEMENTS : ["layered"]);
+	const layerings = options.layering ?? LAYERINGS;
+	const alignments = options.alignment ?? ALIGNMENTS;
+	invariant(lattices.length > 0 && orders.length > 0 && buses.length > 0 && arrangements.length > 0 && layerings.length > 0 && alignments.length > 0, "every candidate axis needs a value", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 806,
+		S: void 0,
+		A: ["lattices.length > 0 &&\n      orders.length > 0 &&\n      buses.length > 0 &&\n      arrangements.length > 0 &&\n      layerings.length > 0 &&\n      alignments.length > 0", "'every candidate axis needs a value'"]
+	});
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const lattice of lattices) for (const order of orders) for (const arrangement of arrangements) for (const layering of layerings) {
+		const positions = await place(graph, cell, pitchFor(graph, cell, lattice), order, arrangement, layering);
+		for (const alignment of arrangement === "columns" ? alignments : ["none"]) {
+			const placement = frame$1(graph, alignGroups(graph, positions, graph.direction, alignment), cell);
+			const key = [...placement.nodes].map(([id, rect]) => `${id}:${rect.x}:${rect.y}`).sort().join(" ");
+			for (const bus of buses) {
+				if (seen.has(`${arrangement}|${bus}|${key}`)) continue;
+				seen.add(`${arrangement}|${bus}|${key}`);
+				const commands = emit(graph, cell, placement, {
+					origin,
+					scale,
+					bus,
+					arrangement,
+					route
+				});
+				const objects = objectsOf(commands);
+				candidates.push({
+					lattice,
+					order,
+					arrangement,
+					layering,
+					alignment,
+					bus,
+					commands,
+					layout: {
+						objects,
+						report: analyze(objects)
+					}
+				});
+			}
+		}
+	}
+	const { chosen, ranked } = select(objective, candidates);
+	return {
+		commands: chosen.candidate.commands,
+		chosen,
+		ranked
+	};
+};
+/** The chosen layout's scene commands; see {@link layout} for the candidates and verdicts. */
+var compile$4 = async (source, options = {}) => (await layout$1(source, options)).commands;
+//#endregion
+//#region src/svg-handler.ts
+/** Discriminates the base `Drawing.Canvas` as SVG-rendered scene content. */
+var SVG_SCHEMA = "dxos.org/svg/1";
+var isSvgRecord = (record) => typeof record?.object === "string" && typeof record?.element === "string" && record?.data !== void 0;
+/** Objects without an index paint first, in insertion order; indexed objects follow in index order. */
+var byIndex = (left, right) => left.index === void 0 ? right.index === void 0 ? 0 : -1 : right.index === void 0 ? 1 : left.index < right.index ? -1 : left.index > right.index ? 1 : 0;
+var SvgHandler = {
+	identify: (record) => isSvgRecord(record) ? {
+		object: record.object,
+		element: record.element
+	} : void 0,
+	render: (object, placement, content) => {
+		let order = Math.max(-1, ...Object.values(content).filter(isSvgRecord).map((record) => record.order)) + 1;
+		const existing = Object.values(content).find((record) => isSvgRecord(record) && record.object === object.id);
+		const ref = "ref" in object && object.ref || existing?.ref;
+		const index = "index" in object && object.index || existing?.index;
+		const records = {};
+		for (const element of object.elements) records[`${object.id}/${element.id}`] = {
+			object: object.id,
+			element: element.id,
+			order: order++,
+			placement: {
+				origin: { ...placement.origin },
+				scale: placement.scale
+			},
+			...ref ? { ref } : {},
+			...index ? { index } : {},
+			data: JSON.parse(JSON.stringify(element))
+		};
+		return records;
+	},
+	read: (content) => {
+		const records = Object.values(content).filter(isSvgRecord).sort((left, right) => left.order - right.order);
+		const objects = /* @__PURE__ */ new Map();
+		let unmanaged = 0;
+		for (const record of Object.values(content)) if (!isSvgRecord(record)) unmanaged++;
+		for (const record of records) {
+			let object = objects.get(record.object);
+			if (!object) {
+				object = {
+					id: record.object,
+					origin: { ...record.placement.origin },
+					scale: record.placement.scale,
+					...record.ref ? { ref: record.ref } : {},
+					...record.index ? { index: record.index } : {},
+					elements: []
+				};
+				objects.set(record.object, object);
+			}
+			object.elements.push(record.data);
+		}
+		return {
+			scene: { objects: [...objects.values()].sort(byIndex) },
+			unmanaged
+		};
+	},
+	translate: (record, delta) => {
+		if (isSvgRecord(record)) record.placement.origin = {
+			x: record.placement.origin.x + delta.x,
+			y: record.placement.origin.y + delta.y
+		};
+	}
+};
+//#endregion
+//#region src/ui.ts
+var ui_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$3,
+	deckOf: () => deckOf,
+	fromSchema: () => fromSchema,
+	renderAscii: () => renderAscii,
+	schemaTitle: () => schemaTitle
+});
+var unwrapSuspend = (ast) => SchemaAST.isSuspend(ast) ? unwrapSuspend(ast.thunk()) : ast;
+var unwrapOptional = (ast) => {
+	let node = ast;
+	while (SchemaAST.isUnion(node) && node.types.length === 2 && SchemaAST.isUndefined(node.types[1])) node = node.types[0];
+	return node;
+};
+var propertiesOf = (ast) => {
+	const node = unwrapSuspend(ast);
+	return node._tag === "Objects" ? node.propertySignatures : [];
+};
+var isLiteralUnion = (node) => SchemaAST.isUnion(node) && node.types.length > 0 && node.types.every(SchemaAST.isLiteral);
+var arrayElementOf = (node) => SchemaAST.isArrays(node) && node.elements.length === 0 && node.rest.length === 1 ? node.rest[0] : void 0;
+var titleOf = (ast) => {
+	const title = ast.annotations?.title ?? SchemaAST.resolve(ast)?.title;
+	return typeof title === "string" ? title : void 0;
+};
+var label = (name, type) => titleOf(type) ?? String(name);
+var controlOf = (type, name, path) => {
+	return {
+		kind: "control",
+		control: isLiteralUnion(type) ? "select" : type._tag === "Boolean" ? "checkbox" : "input",
+		label: label(name, type),
+		path
+	};
+};
+var childOf = (type, name, path, depth) => {
+	const base = unwrapOptional(unwrapSuspend(type));
+	const element = arrayElementOf(base);
+	if (element && depth > 0) {
+		const item = {
+			...childOf(element, "", `${path}[]`, depth - 1),
+			label: ""
+		};
+		return {
+			kind: "array",
+			label: label(name, base),
+			path,
+			item
+		};
+	}
+	if (depth > 0 && !isLiteralUnion(base)) {
+		const properties = propertiesOf(base);
+		if (properties.length > 0) return {
+			kind: "group",
+			label: label(name, base),
+			path,
+			children: properties.map((property) => childOf(property.type, property.name, `${path}.${String(property.name)}`, depth - 1))
+		};
+	}
+	return controlOf(base, name, path);
+};
+/** Convert a schema into a form drawing: the phase-1 slice of the app model. */
+var fromSchema = (schema, options = {}) => {
+	const { maxDepth = 4 } = options;
+	return {
+		kind: "form",
+		children: propertiesOf(schema.ast).filter((property) => property.name !== "id").map((property) => childOf(property.type, property.name, String(property.name), maxDepth))
+	};
+};
+/** The schema's title annotation — container chrome, not form content. */
+var schemaTitle = (schema) => titleOf(schema.ast);
+/** Wrap a form in the app-ontology containers for a full schematic. */
+var deckOf = (form, title) => ({
+	kind: "deck",
+	planks: [{
+		kind: "plank",
+		label: title,
+		child: {
+			kind: "panel",
+			child: form
+		}
+	}]
+});
+var CONTROL_W = 200;
+var CONTROL_H = 28;
+var TOGGLE_W = 28;
+var LABEL_H = 18;
+var GAP$2 = 12;
+var PAD = 16;
+var TITLE_H = 22;
+var PLUS_H = 20;
+var controlHeight = (node) => (node.label ? LABEL_H : 0) + CONTROL_H;
+var heightOf = (node) => {
+	switch (node.kind) {
+		case "control": return controlHeight(node);
+		case "group":
+			if (!node.label) return node.children.reduce((sum, child, index) => sum + heightOf(child) + (index > 0 ? GAP$2 : 0), 0);
+			return TITLE_H + node.children.reduce((sum, child) => sum + heightOf(child) + GAP$2, 0) + PAD;
+		case "array": return TITLE_H + heightOf(node.item) + PAD;
+		case "form": return node.children.reduce((sum, child, index) => sum + heightOf(child) + (index > 0 ? GAP$2 : 0), 0);
+		case "panel": return heightOf(node.child) + 32 + TITLE_H;
+		case "plank": return heightOf(node.child) + 32 + (node.label ? TITLE_H : 0);
+		case "deck": return Math.max(...node.planks.map(heightOf), 0) + 32;
+	}
+};
+var widthOf = (node) => {
+	switch (node.kind) {
+		case "control": return CONTROL_W;
+		case "group": return Math.max(...node.children.map(widthOf), CONTROL_W) + (node.label ? PAD : 0);
+		case "array": return Math.max(widthOf(node.item), CONTROL_W) + PAD;
+		case "form": return Math.max(...node.children.map(widthOf), CONTROL_W);
+		case "panel": return widthOf(node.child) + 32;
+		case "plank": return widthOf(node.child) + 32;
+		case "deck": return node.planks.reduce((sum, plank, index) => sum + widthOf(plank) + (index > 0 ? GAP$2 : 0), 0) + 32;
+	}
+};
+/** Qualify a node id with its container, so two planks over the same schema stay addressable. */
+var qualify = (prefix, path) => prefix ? `${prefix}.${path}` : path;
+/** One world object per control (id = container path), so drawn controls stay individually addressable. */
+var emitControl = (node, x, y, emit, prefix) => {
+	const top = node.label ? LABEL_H : 0;
+	const elements = node.label ? [{
+		kind: "text",
+		id: "label",
+		x: 0,
+		y: 0,
+		text: node.label,
+		weight: "s",
+		color: "grey"
+	}] : [];
+	switch (node.control) {
+		case "checkbox":
+		case "switch":
+			elements.push({
+				kind: "rect",
+				id: "box",
+				x: 0,
+				y: top,
+				w: TOGGLE_W,
+				h: CONTROL_H,
+				stroke: "solid"
+			});
+			break;
+		case "select":
+			elements.push({
+				kind: "rect",
+				id: "box",
+				x: 0,
+				y: top,
+				w: CONTROL_W,
+				h: CONTROL_H,
+				stroke: "solid"
+			}, {
+				kind: "text",
+				id: "caret",
+				x: 180,
+				y: top + 4,
+				text: "*",
+				weight: "s",
+				color: "grey"
+			});
+			break;
+		case "input": elements.push({
+			kind: "rect",
+			id: "box",
+			x: 0,
+			y: top,
+			w: CONTROL_W,
+			h: CONTROL_H,
+			stroke: "solid"
+		});
+	}
+	emit.commands.push({
+		op: "upsert-object",
+		object: {
+			id: qualify(prefix, node.path),
+			origin: {
+				x,
+				y
+			},
+			elements
+		}
+	});
+};
+var frame = (id, x, y, w, h, title, emit) => {
+	const elements = [{
+		kind: "rect",
+		id: "frame",
+		x: 0,
+		y: 0,
+		w,
+		h,
+		stroke: "dashed",
+		color: "grey"
+	}];
+	if (title) elements.push({
+		kind: "text",
+		id: "title",
+		x: PAD / 2,
+		y: 2,
+		text: title,
+		weight: "s"
+	});
+	emit.commands.push({
+		op: "upsert-object",
+		object: {
+			id,
+			origin: {
+				x,
+				y
+			},
+			elements
+		}
+	});
+};
+var emitNode = (node, x, y, emit, prefix = "") => {
+	switch (node.kind) {
+		case "control":
+			emitControl(node, x, y, emit, prefix);
+			break;
+		case "group": {
+			const anonymous = !node.label;
+			if (!anonymous) frame(qualify(prefix, node.path), x, y, widthOf(node), heightOf(node), node.label, emit);
+			let cursor = y + (anonymous ? 0 : TITLE_H);
+			for (const child of node.children) {
+				emitNode(child, x + (anonymous ? 0 : PAD), cursor, emit, prefix);
+				cursor += heightOf(child) + GAP$2;
+			}
+			break;
+		}
+		case "array": {
+			const width = widthOf(node);
+			const id = qualify(prefix, node.path);
+			frame(id, x, y, width, heightOf(node), node.label, emit);
+			emit.commands.push({
+				op: "upsert-object",
+				object: {
+					id: `${id}.add`,
+					origin: {
+						x: x + width - TOGGLE_W - 4,
+						y: y + 2
+					},
+					elements: [{
+						kind: "rect",
+						id: "box",
+						x: 0,
+						y: 0,
+						w: TOGGLE_W,
+						h: PLUS_H,
+						text: "+",
+						stroke: "solid"
+					}]
+				}
+			});
+			emitNode(node.item, x + PAD, y + TITLE_H, emit, prefix);
+			break;
+		}
+		case "form": {
+			let cursor = y;
+			for (const child of node.children) {
+				emitNode(child, x, cursor, emit, prefix);
+				cursor += heightOf(child) + GAP$2;
+			}
+			break;
+		}
+		case "panel": {
+			const id = qualify(prefix, "panel");
+			frame(id, x, y, widthOf(node), heightOf(node), node.label ?? "panel", emit);
+			emitNode(node.child, x + PAD, y + TITLE_H + PAD, emit, id);
+			break;
+		}
+		case "plank": {
+			const id = prefix || "plank";
+			frame(id, x, y, widthOf(node), heightOf(node), node.label, emit);
+			emitNode(node.child, x + PAD, y + PAD + (node.label ? TITLE_H : 0), emit, id);
+			break;
+		}
+		case "deck": {
+			const id = qualify(prefix, "deck");
+			frame(id, x, y, widthOf(node), heightOf(node), void 0, emit);
+			let cursor = x + PAD;
+			node.planks.forEach((plank, index) => {
+				emitNode(plank, cursor, y + PAD, emit, `${id}.plank${index}`);
+				cursor += widthOf(plank) + GAP$2;
+			});
+			break;
+		}
+	}
+};
+/** Compile a UI drawing into scene commands (frames first, controls above them). */
+var compile$3 = (node, options = {}) => {
+	const { origin = {
+		x: 0,
+		y: 0
+	}, scale = 1 } = options;
+	const emit = {
+		commands: [],
+		elements: []
+	};
+	emitNode(node, 0, 0, emit);
+	return emit.commands.map((command) => command.op === "upsert-object" ? {
+		...command,
+		object: {
+			...command.object,
+			scale,
+			origin: {
+				x: origin.x + (command.object.origin?.x ?? 0) * scale,
+				y: origin.y + (command.object.origin?.y ?? 0) * scale
+			}
+		}
+	} : command);
+};
+var GLYPHS = {
+	input: "[__________]",
+	select: "[_________*]",
+	checkbox: "[ ]",
+	switch: "(o )"
+};
+var indent = (lines, prefix) => lines.map((line) => (prefix + line).trimEnd());
+/** Wrap lines in a +--- box, optionally titled. */
+var boxed = (lines, title) => {
+	const width = Math.max(...lines.map((line) => line.length), (title?.length ?? 0) + 4, 12);
+	return [
+		title ? `+- ${title} ${"-".repeat(Math.max(width - title.length - 1, 1))}+` : `+${"-".repeat(width + 2)}+`,
+		...lines.map((line) => `| ${line.padEnd(width)} |`),
+		`+${"-".repeat(width + 2)}+`
+	];
+};
+var asciiLines = (node) => {
+	switch (node.kind) {
+		case "control": return node.label ? [node.label, GLYPHS[node.control]] : [GLYPHS[node.control]];
+		case "group": {
+			const children = node.children.flatMap((child, index) => index > 0 ? ["", ...asciiLines(child)] : asciiLines(child));
+			return node.label ? [node.label, ...indent(children, "  ")] : children;
+		}
+		case "array": return [`${node.label} [+]`, ...indent(asciiLines(node.item), "  ")];
+		case "form": return node.children.flatMap((child, index) => index > 0 ? ["", ...asciiLines(child)] : asciiLines(child));
+		case "panel": return boxed(asciiLines(node.child), node.label);
+		case "plank": return boxed(asciiLines(node.child), node.label);
+		case "deck": return node.planks.flatMap((plank, index) => index > 0 ? ["", ...asciiLines(plank)] : asciiLines(plank));
+	}
+};
+/** Render a UI drawing as ASCII art. */
+var renderAscii = (node) => asciiLines(node).join("\n");
+//#endregion
+//#region src/uml-engine.ts
+var uml_engine_exports = /* @__PURE__ */ __exportAll({ compile: () => compile$2 });
+var GAP_MAIN = 128;
+var GAP_CROSS = 128;
+var snap$2 = (value) => Math.round(value / 32) * 32;
+var DAGRE_DIRECTION = {
+	TB: "TB",
+	BT: "BT",
+	LR: "LR",
+	RL: "RL"
+};
+var ELK_DIRECTION = {
+	TB: "DOWN",
+	BT: "UP",
+	LR: "RIGHT",
+	RL: "LEFT"
+};
+/**
+* Edges oriented for layering: inheritance, realization, and dependency point at abstractions,
+* which rank ABOVE their sources — so those edges are reversed for the engine (which lays out
+* source-above-target), matching `relationRanks`.
+*/
+var orientedEdges = (model) => model.relations.map((relation) => relation.kind === "inheritance" || relation.kind === "realization" || relation.kind === "dependency" ? {
+	from: relation.to,
+	to: relation.from
+} : {
+	from: relation.from,
+	to: relation.to
+});
+/** Snap engine output to the document grid and normalize the top-left to (0, 0). */
+var snapRects = (rects) => {
+	const snapped = new Map([...rects].map(([id, rect]) => [id, {
+		...rect,
+		x: snap$2(rect.x),
+		y: snap$2(rect.y)
+	}]));
+	const minX = Math.min(...[...snapped.values()].map((rect) => rect.x), 0);
+	const minY = Math.min(...[...snapped.values()].map((rect) => rect.y), 0);
+	return new Map([...snapped].map(([id, rect]) => [id, {
+		...rect,
+		x: rect.x - minX,
+		y: rect.y - minY
+	}]));
+};
+/** dagre: network-simplex layering + median-sweep crossing minimization. Sync. */
+var dagrePlace = (model, { cell, gapMain, gapCross, direction }) => {
+	const graph = new graphlib.Graph();
+	graph.setGraph({
+		rankdir: DAGRE_DIRECTION[direction],
+		ranker: "network-simplex",
+		ranksep: gapMain,
+		nodesep: gapCross,
+		edgesep: gapCross / 2
+	});
+	graph.setDefaultEdgeLabel(() => ({}));
+	for (const entry of model.classes) graph.setNode(entry.id, {
+		width: cell.w,
+		height: cell.h
+	});
+	for (const edge of orientedEdges(model)) graph.setEdge(edge.from, edge.to);
+	layout(graph);
+	return snapRects(new Map(model.classes.map((entry) => {
+		const node = graph.node(entry.id);
+		return [entry.id, {
+			x: node.x - cell.w / 2,
+			y: node.y - cell.h / 2,
+			w: cell.w,
+			h: cell.h
+		}];
+	})));
+};
+/** ELK layered: layer-sweep crossing minimization + Brandes-Köpf placement. Async. */
+var elkPlace = async (model, { cell, gapMain, gapCross, direction }) => {
+	const result = await new ELK().layout({
+		id: "root",
+		layoutOptions: {
+			"elk.algorithm": "layered",
+			"elk.direction": ELK_DIRECTION[direction],
+			"elk.layered.spacing.nodeNodeBetweenLayers": String(gapMain),
+			"elk.spacing.nodeNode": String(gapCross),
+			"elk.layered.nodePlacement.strategy": "BRANDES_KOEPF",
+			"elk.layered.considerModelOrder.strategy": "PREFER_NODES"
+		},
+		children: model.classes.map((entry) => ({
+			id: entry.id,
+			width: cell.w,
+			height: cell.h
+		})),
+		edges: orientedEdges(model).map((edge, index) => ({
+			id: `edge-${index}`,
+			sources: [edge.from],
+			targets: [edge.to]
+		}))
+	});
+	return snapRects(new Map((result.children ?? []).map((child) => [child.id, {
+		x: child.x ?? 0,
+		y: child.y ?? 0,
+		w: cell.w,
+		h: cell.h
+	}])));
+};
+/**
+* Compile a mermaid class diagram with engine-backed placement; identical output structure to
+* `UmlGrid.compile` (equal-size grid cells, orthogonal Z-routed connectors), but node positions
+* come from dagre/ELK. Async because ELK is.
+*/
+var compile$2 = async (source, options = {}) => {
+	const { origin, scale, maxWidth = 192, engine = "elk" } = options;
+	const model = parse(source);
+	const cell = measureCell$1(model, {
+		maxWidth,
+		cell: options.cell,
+		titleHeight: options.titleHeight
+	});
+	const place = {
+		cell,
+		gapMain: snap$2(options.gapMain ?? GAP_MAIN),
+		gapCross: snap$2(options.gapCross ?? GAP_CROSS),
+		direction: model.direction
+	};
+	return emit$1({
+		model,
+		cell,
+		rects: engine === "dagre" ? dagrePlace(model, place) : await elkPlace(model, place),
+		ranks: relationRanks(model)
+	}, {
+		origin,
+		scale
+	});
+};
+//#endregion
+//#region src/uml-rules.ts
+var uml_rules_exports = /* @__PURE__ */ __exportAll({
+	buildGroups: () => buildGroups,
+	compile: () => compile$1,
+	frameCommands: () => frameCommands,
+	inheritanceTreeRule: () => inheritanceTreeRule,
+	linearChainRule: () => linearChainRule,
+	packGroups: () => packGroups,
+	resolveRects: () => resolveRects
+});
+var GAP$1 = 64;
+var GROUP_GAP = 96;
+var FRAME_PAD = 32;
+var snap$1 = (value) => Math.round(value / 32) * 32;
+/** Relations oriented so the target should sit ABOVE the source (arrows read upward). */
+var upEdges = (model) => model.relations.map((relation) => relation.kind === "inheritance" || relation.kind === "realization" || relation.kind === "dependency" ? {
+	from: relation.from,
+	to: relation.to
+} : {
+	from: relation.to,
+	to: relation.from
+});
+/**
+* Inheritance trees: each supertype with claimable subtypes forms a group — the hierarchy stacks
+* vertically (root on top, arrows up) and peers share a horizontal axis, packed as a tidy tree
+* (each parent centered over its subtree).
+*/
+var inheritanceTreeRule = {
+	id: "inheritance",
+	apply: (model, unclaimed, cell) => {
+		const children = /* @__PURE__ */ new Map();
+		const hasParent = /* @__PURE__ */ new Set();
+		for (const relation of model.relations) if ((relation.kind === "inheritance" || relation.kind === "realization") && unclaimed.has(relation.from) && unclaimed.has(relation.to)) {
+			children.set(relation.to, [...children.get(relation.to) ?? [], relation.from]);
+			hasParent.add(relation.from);
+		}
+		const groups = [];
+		for (const [root] of children) {
+			if (hasParent.has(root)) continue;
+			const rects = /* @__PURE__ */ new Map();
+			const claimable = (id) => unclaimed.has(id) && !rects.has(id);
+			const widths = /* @__PURE__ */ new Map();
+			const layoutSubtree = (id, x, depth) => {
+				rects.set(id, {
+					x: 0,
+					y: 0,
+					w: cell.w,
+					h: cell.h
+				});
+				const kids = (children.get(id) ?? []).filter(claimable);
+				const kidWidths = kids.map((kid) => subtreeWidth(kid));
+				const rowWidth = kidWidths.reduce((sum, w) => sum + w, 0) + Math.max(0, kids.length - 1) * GAP$1;
+				const width = Math.max(cell.w, rowWidth);
+				let childX = x + (width - rowWidth) / 2;
+				for (const [index, kid] of kids.entries()) {
+					layoutSubtree(kid, childX, depth + 1);
+					childX += kidWidths[index] + GAP$1;
+				}
+				rects.set(id, {
+					x: x + (width - cell.w) / 2,
+					y: depth * (cell.h + GAP$1),
+					w: cell.w,
+					h: cell.h
+				});
+				return width;
+			};
+			const subtreeWidth = (id, seen = /* @__PURE__ */ new Set()) => {
+				const cached = widths.get(id);
+				if (cached !== void 0) return cached;
+				if (seen.has(id)) return cell.w;
+				seen.add(id);
+				const kids = (children.get(id) ?? []).filter((kid) => unclaimed.has(kid) && !rects.has(kid) && !seen.has(kid));
+				const width = kids.length === 0 ? cell.w : Math.max(cell.w, kids.reduce((sum, kid) => sum + subtreeWidth(kid, seen), 0) + (kids.length - 1) * GAP$1);
+				widths.set(id, width);
+				return width;
+			};
+			const width = layoutSubtree(root, 0, 0);
+			const depth = Math.max(...[...rects.values()].map((rect) => rect.y)) + cell.h;
+			if (rects.size < 2) continue;
+			for (const id of rects.keys()) unclaimed.delete(id);
+			groups.push({
+				id: `tree:${root}`,
+				rule: "inheritance",
+				rects,
+				w: width,
+				h: depth
+			});
+		}
+		return groups;
+	}
+};
+/**
+* Longest linear chain: the longest path through the still-unclaimed up-oriented relation graph
+* renders left to right (each target directly right of its source).
+*/
+var linearChainRule = {
+	id: "chain",
+	apply: (model, unclaimed, cell) => {
+		const edges = upEdges(model).filter((edge) => unclaimed.has(edge.from) && unclaimed.has(edge.to));
+		const back = backEdges([...unclaimed], edges);
+		const forward = edges.filter((edge) => !back.has(edge));
+		const next = /* @__PURE__ */ new Map();
+		for (const edge of forward) next.set(edge.from, [...next.get(edge.from) ?? [], edge.to]);
+		const memo = /* @__PURE__ */ new Map();
+		const longestFrom = (id) => {
+			const cached = memo.get(id);
+			if (cached) return cached;
+			let best = [];
+			for (const target of next.get(id) ?? []) {
+				const path = longestFrom(target);
+				if (path.length > best.length) best = path;
+			}
+			const result = [id, ...best];
+			memo.set(id, result);
+			return result;
+		};
+		let chain = [];
+		for (const id of unclaimed) {
+			const path = longestFrom(id);
+			if (path.length > chain.length) chain = path;
+		}
+		if (chain.length < 3) return [];
+		const rects = /* @__PURE__ */ new Map();
+		chain.forEach((id, index) => {
+			rects.set(id, {
+				x: index * (cell.w + GAP$1),
+				y: 0,
+				w: cell.w,
+				h: cell.h
+			});
+			unclaimed.delete(id);
+		});
+		return [{
+			id: `chain:${chain[0]}`,
+			rule: "chain",
+			rects,
+			w: chain.length * cell.w + (chain.length - 1) * GAP$1,
+			h: cell.h
+		}];
+	}
+};
+/** Run the rules over the model; leftovers become singleton groups. */
+var buildGroups = (model, cell, rules) => {
+	const unclaimed = new Set(model.classes.map((entry) => entry.id));
+	const groups = [];
+	for (const rule of rules) groups.push(...rule.apply(model, unclaimed, cell));
+	for (const id of unclaimed) groups.push({
+		id: `node:${id}`,
+		rects: /* @__PURE__ */ new Map([[id, {
+			x: 0,
+			y: 0,
+			w: cell.w,
+			h: cell.h
+		}]]),
+		w: cell.w,
+		h: cell.h
+	});
+	return groups;
+};
+/**
+* Pack groups as super-nodes: rank by up-oriented cross-group edges (target group above), then
+* lay ranks out as rows, bottom rank last — mirroring the node-level convention.
+*/
+var packGroups = (model, groups) => {
+	const groupOf = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const id of group.rects.keys()) groupOf.set(id, group);
+	const crossEdges = upEdges(model).map((edge) => ({
+		from: groupOf.get(edge.from).id,
+		to: groupOf.get(edge.to).id
+	})).filter((edge) => edge.from !== edge.to);
+	const groupRanks = rank$1(groups.map((group) => group.id), crossEdges.map((edge) => ({
+		from: edge.to,
+		to: edge.from
+	})));
+	const lanes = /* @__PURE__ */ new Map();
+	for (const group of groups) {
+		const rank = groupRanks.get(group.id) ?? 0;
+		lanes.set(rank, [...lanes.get(rank) ?? [], group]);
+	}
+	const origins = /* @__PURE__ */ new Map();
+	let y = 0;
+	for (const rank of [...lanes.keys()].sort((left, right) => left - right)) {
+		const members = lanes.get(rank);
+		let x = 0;
+		for (const group of members) {
+			origins.set(group.id, {
+				x: snap$1(x),
+				y: snap$1(y)
+			});
+			x += group.w + GROUP_GAP;
+		}
+		y += Math.max(...members.map((group) => group.h)) + GROUP_GAP;
+	}
+	return origins;
+};
+/** Absolute node rects for a (possibly partial) group placement. */
+var resolveRects = (groups, origins) => {
+	const rects = /* @__PURE__ */ new Map();
+	for (const group of groups) {
+		const at = origins.get(group.id);
+		if (!at) continue;
+		for (const [id, rect] of group.rects) rects.set(id, {
+			...rect,
+			x: at.x + rect.x,
+			y: at.y + rect.y
+		});
+	}
+	return rects;
+};
+/** Dashed frames behind multi-node groups. */
+var frameCommands = (groups, origins, { origin = {
+	x: 0,
+	y: 0
+}, scale = 1 } = {}) => groups.filter((group) => group.rects.size > 1 && origins.has(group.id)).map((group) => {
+	const at = origins.get(group.id);
+	return {
+		op: "upsert-object",
+		object: {
+			id: `group:${group.id}`,
+			origin: {
+				x: origin.x + (at.x - FRAME_PAD) * scale,
+				y: origin.y + (at.y - FRAME_PAD) * scale
+			},
+			scale,
+			elements: [{
+				kind: "rect",
+				id: "frame",
+				x: 0,
+				y: 0,
+				w: group.w + FRAME_PAD * 2,
+				h: group.h + FRAME_PAD * 2,
+				stroke: "dashed",
+				color: "grey"
+			}]
+		}
+	};
+});
+/**
+* Compile with rule-based grouping: rules claim groups, leftovers become singletons, groups pack
+* as super-nodes ranked by their cross-group edges (lanes advance vertically; no borders overlap
+* by construction), and multi-node groups render a dashed frame behind their members.
+*/
+var compile$1 = (source, options = {}) => {
+	const { origin = {
+		x: 0,
+		y: 0
+	}, scale = 1, maxWidth = 192 } = options;
+	const rules = options.rules ?? [inheritanceTreeRule, linearChainRule];
+	const model = parse(source);
+	const cell = measureCell$1(model, {
+		maxWidth,
+		cell: options.cell,
+		titleHeight: options.titleHeight
+	});
+	const groups = buildGroups(model, cell, rules);
+	const origins = packGroups(model, groups);
+	const rects = resolveRects(groups, origins);
+	return [...frameCommands(groups, origins, {
+		origin,
+		scale
+	}), ...emit$1({
+		model,
+		cell,
+		rects,
+		ranks: relationRanks(model)
+	}, {
+		origin,
+		scale
+	})];
+};
+//#endregion
+//#region src/uml-search.ts
+var uml_search_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile,
+	scoreLayout: () => scoreLayout,
+	searchPlacement: () => searchPlacement
+});
+var GAP = 96;
+var snap = (value) => Math.round(value / 32) * 32;
+var segmentsOf = (points) => points.slice(0, -1).map((point, index) => [point, points[index + 1]]);
+/** Orthogonal segment crossing: proper intersections plus collinear overlaps. */
+var crosses = ([a1, a2], [b1, b2]) => {
+	const aVertical = a1.x === a2.x;
+	if (aVertical !== (b1.x === b2.x)) {
+		const [v1, v2] = aVertical ? [a1, a2] : [b1, b2];
+		const [h1, h2] = aVertical ? [b1, b2] : [a1, a2];
+		return v1.x > Math.min(h1.x, h2.x) && v1.x < Math.max(h1.x, h2.x) && h1.y > Math.min(v1.y, v2.y) && h1.y < Math.max(v1.y, v2.y);
+	}
+	if (aVertical) return a1.x === b1.x && Math.min(a1.y, a2.y) < Math.max(b1.y, b2.y) && Math.min(b1.y, b2.y) < Math.max(a1.y, a2.y);
+	return a1.y === b1.y && Math.min(a1.x, a2.x) < Math.max(b1.x, b2.x) && Math.min(b1.x, b2.x) < Math.max(a1.x, a2.x);
+};
+/** Direction changes along a polyline, ignoring zero-length segments. */
+var bends = (route) => {
+	const points = route.filter((point, index) => index === 0 || point.x !== route[index - 1].x || point.y !== route[index - 1].y);
+	let count = 0;
+	for (let index = 2; index < points.length; index++) {
+		const [a, b, c] = [
+			points[index - 2],
+			points[index - 1],
+			points[index]
+		];
+		if (!(a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y)) count++;
+	}
+	return count;
+};
+/**
+* Layout score over the placed subset: +1 per straight or single-bend (L) route, −1 per crossing
+* pair. Routes come from the cheap Z-router — the score ranks candidates, the A* router draws
+* the final picture.
+*/
+var scoreLayout = (model, rects) => {
+	const horizontal = model.direction === "LR" || model.direction === "RL";
+	const routes = [];
+	for (const relation of model.relations) {
+		const from = rects.get(relation.from);
+		const to = rects.get(relation.to);
+		if (!from || !to) continue;
+		routes.push(zRouter({
+			relation,
+			from,
+			to,
+			horizontal,
+			offset: 0
+		}));
+	}
+	let score = 0;
+	for (const route of routes) if (bends(route) <= 1) score += 1;
+	for (let a = 0; a < routes.length; a++) for (let b = a + 1; b < routes.length; b++) if (segmentsOf(routes[a]).some((left) => segmentsOf(routes[b]).some((right) => crosses(left, right)))) score -= 1;
+	return score;
+};
+var overlaps = (a, b) => a.x < b.x + b.w + GAP && b.x < a.x + a.w + GAP && a.y < b.y + b.h + GAP && b.y < a.y + a.h + GAP;
+/**
+* Greedy tree search: place the chain (or largest) group first, then repeatedly place the
+* unplaced group connected to the earliest-placed node, trying axis-aligned candidates around
+* the anchor (below and above preferred, then right/left, sliding off collisions) and keeping
+* the best-scoring one.
+*/
+var searchPlacement = (model, groups) => {
+	const groupOf = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const id of group.rects.keys()) groupOf.set(id, group);
+	const seed = groups.find((group) => group.rule === "chain") ?? [...groups].sort((left, right) => right.rects.size - left.rects.size)[0];
+	if (!seed) return /* @__PURE__ */ new Map();
+	const origins = /* @__PURE__ */ new Map();
+	origins.set(seed.id, {
+		x: 0,
+		y: 0
+	});
+	const placedNodes = [...seed.rects.keys()];
+	const absolute = (id) => {
+		const group = groupOf.get(id);
+		const at = origins.get(group.id);
+		if (!at) return;
+		const local = group.rects.get(id);
+		return {
+			...local,
+			x: at.x + local.x,
+			y: at.y + local.y
+		};
+	};
+	const placedBounds = () => groups.flatMap((group) => {
+		const at = origins.get(group.id);
+		return at ? [{
+			x: at.x,
+			y: at.y,
+			w: group.w,
+			h: group.h
+		}] : [];
+	});
+	while (origins.size < groups.length) {
+		let anchorId;
+		let connection;
+		for (const placed of placedNodes) {
+			for (const relation of model.relations) {
+				const other = relation.from === placed ? relation.to : relation.to === placed ? relation.from : void 0;
+				if (other && !origins.has(groupOf.get(other).id)) {
+					anchorId = placed;
+					connection = {
+						group: groupOf.get(other),
+						node: other
+					};
+					break;
+				}
+			}
+			if (connection) break;
+		}
+		if (!connection || !anchorId) {
+			const group = groups.find((candidate) => !origins.has(candidate.id));
+			const rightmost = Math.max(...placedBounds().map((rect) => rect.x + rect.w), 0);
+			origins.set(group.id, {
+				x: snap(rightmost + GAP),
+				y: 0
+			});
+			placedNodes.push(...group.rects.keys());
+			continue;
+		}
+		const anchor = absolute(anchorId);
+		const local = connection.group.rects.get(connection.node);
+		const anchorCenterX = anchor.x + anchor.w / 2;
+		const anchorCenterY = anchor.y + anchor.h / 2;
+		const candidates = [
+			{
+				x: anchorCenterX - local.x - local.w / 2,
+				y: anchor.y + anchor.h + GAP
+			},
+			{
+				x: anchorCenterX - local.x - local.w / 2,
+				y: anchor.y - GAP - connection.group.h
+			},
+			{
+				x: anchor.x + anchor.w + GAP,
+				y: anchorCenterY - local.y - local.h / 2
+			},
+			{
+				x: anchor.x - GAP - connection.group.w,
+				y: anchorCenterY - local.y - local.h / 2
+			}
+		];
+		let best;
+		for (const [candidateIndex, candidate] of candidates.entries()) {
+			const at = {
+				x: snap(candidate.x),
+				y: snap(candidate.y)
+			};
+			const bounds = placedBounds();
+			let tries = 0;
+			const vertical = candidateIndex < 2;
+			while (bounds.some((rect) => overlaps(rect, {
+				x: at.x,
+				y: at.y,
+				w: connection.group.w,
+				h: connection.group.h
+			})) && tries < 24) {
+				if (vertical) at.x += 64;
+				else at.y += 64;
+				tries++;
+			}
+			if (tries >= 24) continue;
+			origins.set(connection.group.id, at);
+			const score = scoreLayout(model, resolveRects(groups, originsSubset(groups, origins)));
+			origins.delete(connection.group.id);
+			if (!best || score > best.score) best = {
+				at,
+				score
+			};
+		}
+		const at = best?.at ?? {
+			x: snap(Math.max(...placedBounds().map((rect) => rect.x + rect.w)) + GAP),
+			y: 0
+		};
+		origins.set(connection.group.id, at);
+		placedNodes.push(...connection.group.rects.keys());
+	}
+	const minX = Math.min(...[...origins.values()].map((point) => point.x));
+	const minY = Math.min(...[...origins.values()].map((point) => point.y));
+	return new Map([...origins].map(([id, point]) => [id, {
+		x: point.x - minX,
+		y: point.y - minY
+	}]));
+};
+/** Placement restricted to placed groups, so partial layouts score without phantom rects. */
+var originsSubset = (groups, origins) => new Map(groups.filter((group) => origins.has(group.id)).map((group) => [group.id, origins.get(group.id)]));
+/**
+* Compile via the scored search, falling back to whichever of {search, rank packing} scores
+* higher — the search is greedy, so the packing occasionally beats it.
+*/
+var compile = (source, options = {}) => {
+	const { origin = {
+		x: 0,
+		y: 0
+	}, scale = 1, maxWidth = 192 } = options;
+	const rules = options.rules ?? [inheritanceTreeRule, linearChainRule];
+	const model = parse(source);
+	const cell = measureCell$1(model, {
+		maxWidth,
+		cell: options.cell,
+		titleHeight: options.titleHeight
+	});
+	const groups = buildGroups(model, cell, rules);
+	const searched = searchPlacement(model, groups);
+	const packed = packGroups(model, groups);
+	const origins = scoreLayout(model, resolveRects(groups, searched)) >= scoreLayout(model, resolveRects(groups, packed)) ? searched : packed;
+	const rects = resolveRects(groups, origins);
+	return [...frameCommands(groups, origins, {
+		origin,
+		scale
+	}), ...emit$1({
+		model,
+		cell,
+		rects,
+		ranks: relationRanks(model)
+	}, {
+		origin,
+		scale
+	})];
+};
+//#endregion
+export { diagnostics_exports as Diagnostics, DialectRegistry, layout_exports as Layout, mermaid_exports as Mermaid, mermaid_engine_exports as MermaidEngine, objective_exports as Objective, SVG_SCHEMA, scene_exports as Scene, SvgHandler, ui_exports as Ui, uml_exports as Uml, uml_engine_exports as UmlEngine, uml_grid_exports as UmlGrid, uml_rules_exports as UmlRules, uml_search_exports as UmlSearch, applyCommands, nextIndex, sceneDialect };
+
+//# sourceMappingURL=index.mjs.map