@dxos/diagram 0.11.1 → 0.14.0

package/dist/lib/index.mjs

@@ -1,23 +1,13 @@
+import { $ as scene_exports, A as compile$7, B as compile$5, C as SEMANTIC_KEYWORDS, D as mermaid_engine_exports, E as compile$6, F as objective_exports, H as parse$1, I as emit, J as layout_exports, K as diagnostics_exports, L as measureCell, M as appeal_exports, N as view_exports, O as ports_exports, P as rules_exports, Q as Command, R as uml_grid_exports, S as RESERVED, T as semantic_exports, U as relationRanks, V as isClassDiagram, W as uml_exports, X as architecture_exports, Y as rank, Z as judge$1, _ as ELEMENT_KINDS, a as withLayout, b as OBJECT_ATTRS, c as semantic_engine_exports, d as BARE_ID, et as __exportAll, f as BARE_REF, g as ELEMENT_ATTRS, h as EDGE_ATTRS, i as toScene, j as mermaid_exports, k as nudge_exports, l as semantic_route_exports, m as DIAGRAM_ATTRS, n as parseScene, o as parser, p as CLAUSE_KEYWORDS, q as backEdges, r as read, s as compile$8, t as parse, u as semantic_place_exports, v as GROUP_ATTRS, w as STATEMENT_KEYWORDS, x as RELATION_WORDS, y as NODE_ATTRS, z as zRouter } from "./chunk-parse.mjs";
 import { invariant } from "@dxos/invariant";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+import * as Data from "effect/Data";
 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";
+var __dxlog_file$1 = "/__w/dxos/dxos/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);
@@ -60,7 +50,7 @@ var applyCommands = (content, commands, handler) => {
 			const previous = find(command.objectId);
 			invariant(previous, `unknown object: ${command.objectId} (use upsert-object to create it)`, {
 				"~LogMeta": "~LogMeta",
-				F: __dxlog_file$3,
+				F: __dxlog_file$1,
 				L: 128,
 				S: void 0,
 				A: ["previous", "`unknown object: ${command.objectId} (use upsert-object to create it)`"]
@@ -76,2865 +66,525 @@ var applyCommands = (content, commands, handler) => {
 		}
 		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);
+			removed += remove((identity) => identity.object === command.objectId && ids.has(identity.element));
+			break;
 		}
-		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
+		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$1,
+				L: 149,
+				S: void 0,
+				A: ["previous", "`unknown object: ${command.objectId}`"]
 			});
-			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
-			}
-		});
+			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 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
+		upserted: [...upserted],
+		removed
 	};
 };
-/** 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
+/** 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);
 };
-/** 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
+//#endregion
+//#region src/dialect.ts
+var __dxlog_file = "/__w/dxos/dxos/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 DEFAULT = {
-	constraints: [noHardDefects, framesApart()],
-	costs: [
-		crossings,
-		bends$1,
-		connectorLength,
-		unevenFrameGaps,
-		compactness
-	]
+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,
+			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/mermaid-engine.ts
-var mermaid_engine_exports = /* @__PURE__ */ __exportAll({
-	compile: () => compile$4,
-	layout: () => layout$1
+//#region src/aesthetics.ts
+var aesthetics_exports = /* @__PURE__ */ __exportAll({
+	IMAGE_RULES: () => IMAGE_RULES,
+	RULES: () => RULES,
+	judge: () => judge
 });
-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 HOW_TO_READ = "The input is a diagram as drawn: `layout` renders the page as text, a character drawing followed by a row-by-row reading of the boxes and of which way each arrow runs. Judge how the drawing reads to a person looking at it, not whether the architecture it shows is good.";
+var HOW_TO_SEE = "The input is a diagram as drawn: the attached image is the page. Judge how the drawing reads to a person looking at it, not whether the architecture it shows is good.";
+var rule = (id, key, description, question, criteria) => ({
+	id,
+	key,
+	description,
+	instructions: `${HOW_TO_READ} ${question}`,
+	criteria
+});
+var RULES = [
+	rule("arrows-follow-flow", "arrowsFollowFlow", "Arrows run with the main direction of the diagram, inside groups as well as between them.", "Do the arrows run with the main direction of the diagram (down in a top-to-bottom drawing, right in a left-to-right one), inside groups as well as between them, with at most a few pointing back against it? Arrows with a hollow triangle head (inheritance, implementation) point to the abstraction above by convention and do not count against the flow.", {
+		true: "Nearly every arrow runs with the flow; a reader follows dependencies in one direction.",
+		false: "Many arrows, or whole chains inside a group, run up or back against the flow."
+	}),
+	rule("readable-labels", "readableLabels", "Every box and arrow label can be read on its own.", "Can every box label and arrow label be read on its own, without running into another label, a line or a box?", {
+		true: "Every label sits clear of other text and lines.",
+		false: "Some label overlaps another label, a box or a line, or is cut off."
+	}),
+	rule("traceable-arrows", "traceableArrows", "Each arrow can be followed from its start to its end.", "Can a reader follow each arrow from its start to its end without ambiguity — no two arrows sharing a line segment or merged into one trunk, no arrow running through a group it does not connect to, no long detours around the page, and few crossings?", {
+		true: "Each arrow has its own short, direct route.",
+		false: "Arrows share trunks, detour far, or cross so that their ends are hard to pair up."
+	}),
+	rule("entries-face-callers", "entriesFaceCallers", "Boxes that outside arrows reach sit on the side of their group facing the callers.", "Within each group, do the boxes that arrows from outside the group reach sit on the side of the group facing those callers, so that cross-group arrows are short and do not run through or around the group?", {
+		true: "Cross-group arrows land on the near side of each group.",
+		false: "An arrow from outside travels through or around a group to reach a box on its far side."
+	}),
+	rule("compact", "compact", "The drawing is packed tightly: no large empty regions, groups sized to their content.", "Is the drawing compact — no large empty regions between or inside groups, groups no bigger than what they hold, and boxes that are connected placed next to each other?", {
+		true: "The page is tightly packed; connected boxes are neighbours.",
+		false: "There are large empty regions, stretched groups, or connected boxes far apart."
+	}),
+	rule("groups-aligned", "groupsAligned", "Groups line up with each other rather than floating at arbitrary offsets.", "Do the groups line up with one another — sharing a top edge or a left edge where they sit side by side or stacked — rather than one group floating at an arbitrary height or offset beside another?", {
+		true: "Groups share edges and read as one arrangement.",
+		false: "A group sits at an arbitrary offset from its neighbours."
+	}),
+	rule("names-only", "namesOnly", "Each box is labelled with a component name alone, without comments or qualifiers.", "Is every box labelled with just the name of what it is, with no comments, limits or qualifiers mixed into the name (such as \"no cap\", \"≤10\" or a colon followed by a description)?", {
+		true: "Box labels are plain names; any commentary sits on arrows or not at all.",
+		false: "Some box label mixes a name with a comment, a limit or a description."
+	}),
+	rule("aligned-grid", "alignedGrid", "Boxes line up in rows and columns with consistent spacing.", "Are the boxes aligned into clear rows and columns with consistent spacing, so the structure reads as a grid?", {
+		true: "Boxes share rows and columns with even gaps.",
+		false: "Boxes are staggered or unevenly spaced, with no clear rows or columns."
+	})
 ];
-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))
-	};
-};
+/** {@link RULES} for a judge shown the page as an image (`Architecture.Subject.images`) instead of `layout`. */
+var IMAGE_RULES = RULES.map((rule) => ({
+	...rule,
+	instructions: `${HOW_TO_SEE}${rule.instructions.slice(269)}`
+}));
 /**
-* 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.
+* Every aesthetic rule as a score from one `DecisionModel` call. Without `layout` or an image of the
+* page there is nothing to judge, so each rule reports an error rather than a guess.
 */
-var pitchFor = (graph, cell, lattice) => {
-	const framed = graph.groups.some((group) => group.children.length > 0);
+var judge = (rules = RULES) => {
+	const inner = judge$1(rules, "aesthetics");
 	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))
+		entries: inner.entries,
+		evaluate: (subject) => subject.content.layout || subject.images?.length ? inner.evaluate(subject) : Effect.succeed(rules.map(() => ({
+			score: 0,
+			error: "No layout to judge."
+		})))
 	};
 };
-/**
-* 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;
+//#endregion
+//#region src/dsl/print.ts
+var ESCAPES = {
+	"\\": "\\\\",
+	"\"": "\\\"",
+	"\n": "\\n",
+	"	": "\\t",
+	"\r": "\\r"
 };
 /**
-* 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.
+* Shortest form that reads back: integers keep no trailing zeros, negatives keep their sign, and
+* the exponent notation `String` switches to outside ~1e-7..1e21 is spelled as-is, which the
+* grammar accepts. `NaN` and `Infinity` have no readable form at all, so they are refused here
+* rather than silently producing a document that cannot be parsed.
 */
-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;
-};
+var formatNumber = (value) => {
+	if (!Number.isFinite(value)) throw new TypeError(`A scene coordinate must be finite; got ${value}.`);
+	return String(value);
+};
+var formatString = (value) => `"${value.replace(/[\\"\n\t\r]/g, (character) => ESCAPES[character] ?? character)}"`;
+/** Bare where the grammar allows it, quoted where a word would be read as a keyword or fail to lex. */
+var formatId = (id) => BARE_ID.test(id) && !RESERVED.has(id) ? id : formatString(id);
+var formatPoint = ({ x, y }) => `${formatNumber(x)},${formatNumber(y)}`;
+var formatSize = (w, h) => `${formatNumber(w)}x${formatNumber(h)}`;
 /**
-* 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`.
+* Quoted unless every id in it is a bare word: a dialect may build a ref from a node id the
+* grammar cannot lex, such as mermaid's `1st` becoming `1st/box`, and an unquoted one would make
+* the printed scene fail to parse.
 */
-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;
+var formatRef = (ref) => BARE_REF.test(ref) && !RESERVED.has(ref) ? ref : formatString(ref);
+/** `_` is the end the schema leaves unset; a bound end prints as its ref, a free one as a point. */
+var formatEndpoint = (ref, point) => ref !== void 0 ? formatRef(ref) : point !== void 0 ? formatPoint(point) : "_";
+/** Prints `name=value` for the attributes of `kind` that are set, in the table's order. */
+var formatAttrs = (kind, values) => ELEMENT_ATTRS[kind].flatMap(({ name, type }) => {
+	const value = values[name];
+	if (value === void 0) return [];
+	return [`${name}=${type === "string" && typeof value === "string" ? formatString(value) : String(value)}`];
+});
+var style = ({ color, fill, stroke, weight }) => ({
+	color,
+	fill,
+	stroke,
+	weight
+});
+var formatElement = (element) => {
+	switch (element.kind) {
+		case "rect":
+		case "ellipse":
+		case "diamond":
+		case "triangle": return [
+			element.kind,
+			formatId(element.id),
+			formatPoint(element),
+			formatSize(element.w, element.h),
+			...element.text === void 0 ? [] : [formatString(element.text)],
+			...formatAttrs(element.kind, {
+				rotation: element.rotation,
+				corners: element.corners,
+				...style(element)
+			})
+		].join(" ");
+		case "circle": return [
+			"circle",
+			formatId(element.id),
+			formatPoint({
+				x: element.cx,
+				y: element.cy
+			}),
+			formatNumber(element.r),
+			...element.text === void 0 ? [] : [formatString(element.text)],
+			...formatAttrs("circle", style(element))
+		].join(" ");
+		case "line": return [
+			"line",
+			formatId(element.id),
+			...element.points.map(formatPoint),
+			...formatAttrs("line", {
+				closed: element.closed,
+				...style(element)
+			})
+		].join(" ");
+		case "curve": return [
+			"curve",
+			formatId(element.id),
+			...element.points.map(formatPoint),
+			...formatAttrs("curve", style(element))
+		].join(" ");
+		case "arc": return [
+			"arc",
+			formatId(element.id),
+			formatPoint({
+				x: element.cx,
+				y: element.cy
+			}),
+			formatNumber(element.r),
+			`${formatNumber(element.startAngle)}..${formatNumber(element.endAngle)}`,
+			...formatAttrs("arc", style(element))
+		].join(" ");
+		case "text": return [
+			"text",
+			formatId(element.id),
+			formatPoint(element),
+			formatString(element.text),
+			...formatAttrs("text", {
+				w: element.w,
+				...style(element)
+			})
+		].join(" ");
+		case "arrow": return [
+			"arrow",
+			formatId(element.id),
+			formatEndpoint(element.from, element.start),
+			"->",
+			formatEndpoint(element.to, element.end),
+			...element.text === void 0 ? [] : [formatString(element.text)],
+			...formatAttrs("arrow", {
+				head: element.head,
+				tail: element.tail,
+				relation: element.relation,
+				...style(element)
+			})
+		].join(" ");
+		case "portal": return [
+			"portal",
+			formatId(element.id),
+			formatPoint(element),
+			formatSize(element.w, element.h),
+			...element.text === void 0 ? [] : [formatString(element.text)],
+			...formatAttrs("portal", {
+				ref: element.ref,
+				...style(element)
+			})
+		].join(" ");
+	}
 };
-/**
-* 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);
+var block = (header, elements) => [
+	`${header} {`,
+	...elements.map((element) => `  ${formatElement(element)}`),
+	"}"
+].join("\n");
+var formatObject = (object) => block([
+	"object",
+	formatId(object.id),
+	...object.origin === void 0 ? [] : ["@", formatPoint(object.origin)],
+	...OBJECT_ATTRS.flatMap(({ name, type }) => {
+		const value = {
+			scale: object.scale,
+			index: object.index,
+			ref: object.ref
+		}[name];
+		if (value === void 0) return [];
+		return [`${name}=${type === "string" && typeof value === "string" ? formatString(value) : String(value)}`];
+	})
+].join(" "), object.elements);
+var formatCommand = (command) => {
+	switch (command.op) {
+		case "upsert-object": return formatObject(command.object);
+		case "upsert-elements": return block(`elements ${formatId(command.objectId)}`, command.elements);
+		case "move-object": return `move ${formatId(command.objectId)} @ ${formatPoint(command.origin)}`;
+		case "remove-object": return `remove object ${formatId(command.objectId)}`;
+		case "remove-elements": return `remove elements ${formatId(command.objectId)} ${command.elementIds.map(formatId).join(" ")}`;
+	}
 };
-/**
-* 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
-			});
-		}
+/** A whole document: statements separated by a blank line, newline-terminated. */
+var printCommands = (commands) => commands.length === 0 ? "" : `${commands.map(formatCommand).join("\n\n")}\n`;
+/** A scene document — every statement an `object`, which is what a drawing serializes to. */
+var print = (scene) => printCommands(scene.objects.map((object) => ({
+	op: "upsert-object",
+	object
+})));
+var SOURCES = [
+	{
+		id: "uml",
+		description: "Mermaid classDiagram.",
+		detect: isClassDiagram,
+		compile: (source) => Effect.sync(() => compile$5(source))
+	},
+	{
+		id: "mermaid",
+		description: "Mermaid flowchart, including the `%% ref` and UML edge-token extensions.",
+		detect: (source) => /^\s*(flowchart|graph)\s+/m.test(source),
+		compile: (source) => Effect.promise(() => compile$6(source))
+	},
+	{
+		id: "mermaid-layered",
+		description: "Mermaid flowchart with the dialect's own layered placement rather than ELK.",
+		detect: () => false,
+		compile: (source) => Effect.sync(() => compile$7(source))
+	}
+];
+/** The language a source string is written in, or undefined when nothing claims it. */
+var detect = (source) => SOURCES.find(({ detect }) => detect(source));
+var known = () => SOURCES.map(({ id }) => id).join(", ");
+/** Tagged so the failure channel stays discriminated rather than collapsing into bare `Error`. */
+var UnknownSourceError = class extends Data.TaggedError("DiagramUnknownSource") {
+	get message() {
+		return `Unknown source language "${this.id}"; known: ${known()}.`;
 	}
-	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
-		});
+var UndetectedSourceError = class extends Data.TaggedError("DiagramUndetectedSource") {
+	get message() {
+		return `Could not tell what language this is; pass one of: ${known()}.`;
 	}
-	return {
-		nodes,
-		frames
-	};
 };
+/** Compiles `text` through its dialect and prints the result as DSL text. */
+var convert = (text, { source } = {}) => Effect.gen(function* () {
+	const language = source === void 0 ? detect(text) : SOURCES.find(({ id }) => id === source);
+	if (!language) return yield* Effect.fail(source === void 0 ? new UndetectedSourceError() : new UnknownSourceError({ id: source }));
+	return printCommands(yield* language.compile(text));
+});
+//#endregion
+//#region src/dsl/compile.ts
 /**
-* 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.
+* Reads a document and lays out its semantic statements with the full search, which also tries the
+* mermaid engine's placements when nothing was hinted. Asynchronous only because that engine's ELK
+* is; a document of scene statements alone reads exactly as {@link parse} reads it.
 */
-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;
-};
+var compile$4 = Effect.fn("Dsl.compile")(function* (text, options = {}) {
+	const reading = read(text);
+	const { diagram } = reading;
+	if (!diagram) return withLayout(reading);
+	const solution = yield* Effect.promise(() => compile$8(diagram, options));
+	return withLayout(reading, solution);
+});
+//#endregion
+//#region src/dsl/index.ts
+var dsl_exports = /* @__PURE__ */ __exportAll({
+	CLAUSE_KEYWORDS: () => CLAUSE_KEYWORDS,
+	DIAGRAM_ATTRS: () => DIAGRAM_ATTRS,
+	EDGE_ATTRS: () => EDGE_ATTRS,
+	ELEMENT_ATTRS: () => ELEMENT_ATTRS,
+	ELEMENT_KINDS: () => ELEMENT_KINDS,
+	GROUP_ATTRS: () => GROUP_ATTRS,
+	NODE_ATTRS: () => NODE_ATTRS,
+	OBJECT_ATTRS: () => OBJECT_ATTRS,
+	RELATION_WORDS: () => RELATION_WORDS,
+	RESERVED: () => RESERVED,
+	SEMANTIC_KEYWORDS: () => SEMANTIC_KEYWORDS,
+	SOURCES: () => SOURCES,
+	STATEMENT_KEYWORDS: () => STATEMENT_KEYWORDS,
+	UndetectedSourceError: () => UndetectedSourceError,
+	UnknownSourceError: () => UnknownSourceError,
+	compile: () => compile$4,
+	convert: () => convert,
+	detect: () => detect,
+	formatCommand: () => formatCommand,
+	formatElement: () => formatElement,
+	formatId: () => formatId,
+	formatObject: () => formatObject,
+	formatString: () => formatString,
+	parse: () => parse,
+	parseScene: () => parseScene,
+	parser: () => parser,
+	print: () => print,
+	printCommands: () => printCommands,
+	read: () => read,
+	toScene: () => toScene,
+	withLayout: () => withLayout
+});
+//#endregion
+//#region src/dx-svg.ts
+var dx_svg_exports = /* @__PURE__ */ __exportAll({
+	FORMAT: () => FORMAT,
+	embed: () => embed,
+	extract: () => extract,
+	isDxSvg: () => isDxSvg
+});
+/** The container format; versions the slot and encoding, not the payload, which versions itself. */
+var FORMAT = "org.dxos.dx-svg@1";
+var NAMESPACE = "https://dxos.org/ns/dx-svg";
+var MEDIA_TYPE = "application/vnd.dxos.dx+json";
+var NOTICE = "<!-- Drawn in DXOS: the embedded data is the source; edits to the picture alone are not reflected in it. -->";
 /**
-* 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.
+* JSON with `<`, `>` and `&` as unicode escapes, so the text needs neither CDATA nor entity decoding
+* and `JSON.parse` restores it exactly. A top-level `objects` array goes one object per line, so a
+* changed drawing diffs by object.
 */
-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"
-		});
+var encode = (payload) => {
+	const escape = (json) => json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+	if (payload && typeof payload === "object" && !Array.isArray(payload) && "objects" in payload && Array.isArray(payload.objects)) {
+		const { objects, ...rest } = payload;
+		const head = JSON.stringify(rest);
+		const body = objects.map((object) => escape(JSON.stringify(object))).join(",\n");
+		return `${escape(head.slice(0, -1))}${head.length > 2 ? "," : ""}"objects":[\n${body}\n]}`;
 	}
-	return {
-		elements,
-		consumed
-	};
-};
+	return escape(JSON.stringify(payload));
+};
+/** Embeds a payload in a standalone SVG: a marker on the root and the payload as its first child. */
+var embed = (svg, payload) => {
+	const root = /<svg\b[^>]*>/.exec(svg);
+	if (!root) throw new Error("Not an SVG document: no <svg> element.");
+	if (/\bdx:payload=/.test(root[0])) throw new Error("The SVG already carries a dx-svg payload.");
+	const open = root[0].replace(/<svg\b/, `<svg xmlns:dx="${NAMESPACE}" dx:payload="${FORMAT}"`);
+	const metadata = `<metadata id="dx-payload" data-type="${MEDIA_TYPE}" data-version="1" data-encoding="json">\n${encode(payload)}\n</metadata>`;
+	return `${svg.slice(0, root.index)}${NOTICE}\n${open}${metadata}${svg.slice(root.index + root[0].length)}`;
+};
+/** Whether an SVG carries a payload, without parsing it. */
+var isDxSvg = (svg) => /<metadata\b[^>]*\bid="dx-payload"/.test(svg);
 /**
-* Scene commands for a placement: one world object per subgraph frame (painted first) and per
-* node, plus an `edges` object of connectors.
+* The payload of a `.dx.svg`, or undefined for a plain SVG. Works on the text alone, so it runs in node,
+* workers and the browser. An encoding this version does not know is an error, not a missing payload.
 */
-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()
+var extract = (svg) => {
+	const match = /<metadata\b([^>]*)\bid="dx-payload"([^>]*)>([\s\S]*?)<\/metadata>/.exec(svg);
+	if (!match) return;
+	const attributes = `${match[1]} ${match[2]}`;
+	const encoding = /\bdata-encoding="([^"]*)"/.exec(attributes)?.[1] ?? "json";
+	if (encoding !== "json") throw new Error(`Unsupported dx-svg payload encoding: ${encoding}.`);
+	return JSON.parse(match[3]);
+};
+//#endregion
+//#region src/score.ts
+var score_exports = /* @__PURE__ */ __exportAll({
+	HALF_COST: () => 3,
+	constraintScorer: () => constraintScorer,
+	costScorer: () => costScorer,
+	evaluate: () => evaluate,
+	fromCost: () => fromCost,
+	fromObjective: () => fromObjective,
+	overall: () => overall
+});
+/** Maps a weighted cost in [0, ∞) onto (0, 1]: 1 at no cost, 0.5 at `half`, falling off hyperbolically. */
+var fromCost = (weighted, half = 3) => 1 / (1 + Math.max(0, weighted) / half);
+/** A hard requirement: 1 when it holds, 0 when anything violates it. */
+var constraintScorer = (constraint) => ({
+	id: constraint.id,
+	kind: "constraint",
+	description: constraint.description,
+	evaluate: (layout) => Effect.sync(() => {
+		const violations = constraint.violations(layout);
+		return {
+			score: violations.length ? 0 : 1,
+			...violations.length ? { detail: violations.join("\n") } : {}
 		};
-		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;
+	})
+});
+/** A soft preference: its weighted cost through {@link fromCost}. */
+var costScorer = (term, half = 3) => ({
+	id: term.id,
+	kind: "cost",
+	description: term.description,
+	evaluate: (layout) => Effect.sync(() => {
+		const value = term.measure(layout);
+		const weighted = value * term.weight;
+		return {
+			score: fromCost(weighted, half),
+			detail: `${round(value)} × ${term.weight} = ${round(weighted)}`
 		};
-		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] : []);
+	})
+});
+/** Every constraint and cost term of an objective, constraints first. */
+var fromObjective = (objective, half = 3) => [...objective.constraints.map(constraintScorer), ...objective.costs.map((term) => costScorer(term, half))];
+var isBatch = (source) => "entries" in source;
+/** Runs every source against one subject concurrently; results keep the sources' order, batches flattened. */
+var evaluate = (sources, subject) => Effect.all(sources.map((source) => isBatch(source) ? source.evaluate(subject).pipe(Effect.map((results) => source.entries.map((entry, index) => ({
+	...entry,
+	...results[index]
+})))) : source.evaluate(subject).pipe(Effect.map((result) => [{
+	id: source.id,
+	kind: source.kind,
+	description: source.description,
+	...result
+}]))), { concurrency: "unbounded" }).pipe(Effect.map((groups) => groups.flat()));
 /**
-* 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.
+* One number for a set of scores: the worst constraint gates the mean of everything else, so a
+* layout that breaks a constraint scores 0 however good it otherwise is — the same precedence
+* `Objective.select` gives violations over cost — while every other kind contributes equally.
+* `undefined` when nothing could be judged, so a set of failed scorers never reads as a perfect score.
 */
-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;
+var overall = (all) => {
+	const scores = all.filter(({ error }) => error === void 0);
+	if (scores.length === 0) return;
+	const gate = Math.min(1, ...scores.filter(({ kind }) => kind === "constraint").map(({ score }) => score));
+	const rest = scores.filter(({ kind }) => kind !== "constraint");
+	return gate * (rest.length ? rest.reduce((total, { score }) => total + score, 0) / rest.length : 1);
+};
+var round = (value) => Number.isInteger(value) ? `${value}` : value.toFixed(2);
 //#endregion
 //#region src/svg-handler.ts
 /** Discriminates the base `Drawing.Canvas` as SVG-rendered scene content. */
@@ -3451,8 +1101,8 @@ var elkPlace = async (model, { cell, gapMain, gapCross, direction }) => {
 */
 var compile$2 = async (source, options = {}) => {
 	const { origin, scale, maxWidth = 192, engine = "elk" } = options;
-	const model = parse(source);
-	const cell = measureCell$1(model, {
+	const model = parse$1(source);
+	const cell = measureCell(model, {
 		maxWidth,
 		cell: options.cell,
 		titleHeight: options.titleHeight
@@ -3463,10 +1113,11 @@ var compile$2 = async (source, options = {}) => {
 		gapCross: snap$2(options.gapCross ?? GAP_CROSS),
 		direction: model.direction
 	};
-	return emit$1({
+	const rects = engine === "dagre" ? dagrePlace(model, place) : await elkPlace(model, place);
+	return emit({
 		model,
 		cell,
-		rects: engine === "dagre" ? dagrePlace(model, place) : await elkPlace(model, place),
+		rects,
 		ranks: relationRanks(model)
 	}, {
 		origin,
@@ -3644,7 +1295,7 @@ var packGroups = (model, groups) => {
 		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) => ({
+	const groupRanks = rank(groups.map((group) => group.id), crossEdges.map((edge) => ({
 		from: edge.to,
 		to: edge.from
 	})));
@@ -3722,8 +1373,8 @@ var compile$1 = (source, options = {}) => {
 		y: 0
 	}, scale = 1, maxWidth = 192 } = options;
 	const rules = options.rules ?? [inheritanceTreeRule, linearChainRule];
-	const model = parse(source);
-	const cell = measureCell$1(model, {
+	const model = parse$1(source);
+	const cell = measureCell(model, {
 		maxWidth,
 		cell: options.cell,
 		titleHeight: options.titleHeight
@@ -3734,7 +1385,7 @@ var compile$1 = (source, options = {}) => {
 	return [...frameCommands(groups, origins, {
 		origin,
 		scale
-	}), ...emit$1({
+	}), ...emit({
 		model,
 		cell,
 		rects,
@@ -3945,8 +1596,8 @@ var compile = (source, options = {}) => {
 		y: 0
 	}, scale = 1, maxWidth = 192 } = options;
 	const rules = options.rules ?? [inheritanceTreeRule, linearChainRule];
-	const model = parse(source);
-	const cell = measureCell$1(model, {
+	const model = parse$1(source);
+	const cell = measureCell(model, {
 		maxWidth,
 		cell: options.cell,
 		titleHeight: options.titleHeight
@@ -3959,7 +1610,7 @@ var compile = (source, options = {}) => {
 	return [...frameCommands(groups, origins, {
 		origin,
 		scale
-	}), ...emit$1({
+	}), ...emit({
 		model,
 		cell,
 		rects,
@@ -3970,6 +1621,6 @@ var compile = (source, options = {}) => {
 	})];
 };
 //#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 };
+export { aesthetics_exports as Aesthetics, appeal_exports as Appeal, architecture_exports as Architecture, diagnostics_exports as Diagnostics, DialectRegistry, dsl_exports as Dsl, dx_svg_exports as DxSvg, layout_exports as Layout, mermaid_exports as Mermaid, mermaid_engine_exports as MermaidEngine, nudge_exports as Nudge, objective_exports as Objective, ports_exports as Ports, rules_exports as Rules, SVG_SCHEMA, scene_exports as Scene, score_exports as Score, semantic_exports as Semantic, semantic_engine_exports as SemanticEngine, semantic_place_exports as SemanticPlace, semantic_route_exports as SemanticRoute, 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, view_exports as View, applyCommands, nextIndex, sceneDialect };
 
 //# sourceMappingURL=index.mjs.map