@loadmap/dsl 0.0.0-stage → 0.1.1

package/dist/compile-6wNrbYqA.js

@@ -0,0 +1,3065 @@
+import { check, defineModel, estimated, fanout, measured, p, parseAsOf, pass, queue, sink, store, workers } from "@loadmap/core";
+import { fitLinear } from "@loadmap/core/calibrate";
+import { defineView, labelsAt } from "@loadmap/layout";
+import { compact, fmt, pct, secs } from "@loadmap/core/format";
+/** Collects diagnostics and turns offsets into lines and columns. */
+var Reporter = class {
+	source;
+	list = [];
+	seen = /* @__PURE__ */ new Set();
+	starts;
+	constructor(source) {
+		this.source = source;
+		this.starts = [0];
+		for (let i = 0; i < source.length; i++) if (source[i] === "\n") this.starts.push(i + 1);
+	}
+	error(at, message, hint) {
+		this.add("error", at, message, hint);
+	}
+	warning(at, message, hint) {
+		this.add("warning", at, message, hint);
+	}
+	/** The 1-based line and column of an offset. */
+	position(offset) {
+		return position(this.starts, offset);
+	}
+	get failed() {
+		return this.list.some((d) => d.severity === "error");
+	}
+	add(severity, at, message, hint) {
+		const key = `${at.from}:${message}`;
+		if (this.seen.has(key)) return;
+		this.seen.add(key);
+		if (this.list.length >= 200) {
+			if (this.list.length === 200) this.list.push({
+				...this.list.at(-1),
+				severity: "error",
+				message: `more than 200 problems; fix these first`,
+				hint: void 0
+			});
+			return;
+		}
+		const { line, column } = position(this.starts, at.from);
+		this.list.push({
+			severity,
+			message,
+			from: at.from,
+			to: Math.max(at.to, at.from),
+			line,
+			column,
+			hint
+		});
+	}
+};
+function position(starts, offset) {
+	let lo = 0;
+	let hi = starts.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		if (starts[mid] <= offset) lo = mid;
+		else hi = mid - 1;
+	}
+	return {
+		line: lo + 1,
+		column: offset - starts[lo] + 1
+	};
+}
+/**
+* One diagnostic as a terminal shows it:
+*
+*     checkout.loadmap:24:17 error: unknown flow "order"
+*       24 |   demand: flows.order + flows.events
+*          |                 ^^^^^ did you mean "orders"?
+*/
+function formatDiagnostic(d, source, file = "input.loadmap") {
+	const text = source.split("\n")[d.line - 1] ?? "";
+	const n = String(d.line);
+	const pad = " ".repeat(n.length);
+	const width = Math.max(1, Math.min(d.to - d.from, text.length - d.column + 1));
+	const mark = `${" ".repeat(d.column - 1)}${"^".repeat(width)}${d.hint ? ` ${d.hint}` : ""}`;
+	return `${file}:${d.line}:${d.column} ${d.severity}: ${d.message}\n  ${n} | ${text}\n  ${pad} | ${mark}`;
+}
+/** The closest of `options` to `name`, when it is close enough to be a typo. */
+function closest(name, options) {
+	let best;
+	let bestD = Number.POSITIVE_INFINITY;
+	const lower = name.toLowerCase();
+	for (const o of options) {
+		const d = o.toLowerCase() === lower ? 0 : distance(lower, o.toLowerCase());
+		if (d < bestD) {
+			best = o;
+			bestD = d;
+		}
+	}
+	return best != null && bestD <= Math.max(1, Math.floor(name.length / 3)) ? best : void 0;
+}
+function didYouMean(name, options) {
+	const c = closest(name, options);
+	return c ? `did you mean "${c}"?` : void 0;
+}
+function distance(a, b) {
+	const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+	for (let i = 1; i <= a.length; i++) {
+		let prev = row[0];
+		row[0] = i;
+		for (let j = 1; j <= b.length; j++) {
+			const cur = row[j];
+			row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+			prev = cur;
+		}
+	}
+	return row[b.length];
+}
+// src/schema.ts
+/**
+* Every statement of the language: what follows its keyword, its properties and what it may hold. The checker,
+* autocomplete and the language reference (docs/dsl.md) all read this table, so it is the one place to add a feature.
+*/
+/** `o[k]` for an own entry only: a name like "constructor" must not find what every object inherits. */
+function own(o, k) {
+	return Object.hasOwn(o, k) ? o[k] : void 0;
+}
+const STAGE_LABEL = [{
+	name: "id",
+	kind: "id",
+	optional: true
+}, {
+	name: "label",
+	kind: "text",
+	optional: true
+}];
+const STAGE_COMPONENT = {
+	value: "component",
+	scope: "const",
+	doc: "The component whose capacity this stage uses. Defaults to its box's component."
+};
+/** A component's properties: on a box, or in a `component` block. */
+const COMPONENT_PROPS = {
+	name: {
+		value: "string",
+		scope: "const",
+		doc: "The component's name in the limits list. Defaults to the label."
+	},
+	short: {
+		value: "string",
+		scope: "const",
+		doc: "The name inside a sentence, with its article: \"the database\"."
+	},
+	plural: {
+		value: "boolean",
+		scope: "const",
+		doc: "\"are past capacity\" instead of \"is\"."
+	},
+	demand: {
+		value: "number",
+		scope: "ctx",
+		doc: "What the component must handle, in its capacity's unit."
+	},
+	capacity: {
+		value: "capacity",
+		scope: "ctx",
+		doc: "What it can handle: measured(value, unit, source) or estimated(value, unit, source); `value ± 30%` says how sure it is."
+	},
+	when: {
+		value: "boolean",
+		scope: "ctx",
+		doc: "The component is switched off (no utilization) while this is false."
+	},
+	over: {
+		value: "string",
+		scope: "ctx",
+		doc: "What happens past 100 %, as a clause: \"clients get 429s\"."
+	},
+	describe: {
+		value: "string",
+		scope: "ctx",
+		doc: "One line under the name in the limits list."
+	}
+};
+const BOX_ARGS = [
+	{
+		name: "id",
+		kind: "id"
+	},
+	{
+		name: "label",
+		kind: "text",
+		optional: true,
+		dynamic: true
+	},
+	{
+		name: "sub",
+		kind: "text",
+		optional: true,
+		dynamic: true
+	}
+];
+const SUB = {
+	value: "string",
+	scope: "ctx",
+	doc: "The second line of the box."
+};
+const OVERLOAD_WHEN = {
+	value: "boolean",
+	scope: "ctx",
+	doc: "The rule applies only while this is true."
+};
+const COLORS = [
+	"accent",
+	"alt",
+	"ok",
+	"warn",
+	"drop",
+	"muted"
+];
+const SCHEMA = {
+	"": {
+		doc: "A loadmap definition.",
+		example: "",
+		args: [],
+		props: {
+			title: {
+				value: "string",
+				scope: "const",
+				doc: "The heading above the diagram."
+			},
+			layout: {
+				value: "enum",
+				scope: "const",
+				values: ["right", "down"],
+				doc: "Which way the diagram runs. Narrow screens always run down."
+			},
+			speed: {
+				value: "number",
+				scope: "const",
+				doc: "Simulated seconds per real second. Default 10."
+			},
+			assume: {
+				value: "string",
+				scope: "const",
+				repeat: true,
+				doc: "A line added before the generated assumptions."
+			},
+			searchMax: {
+				value: "number",
+				scope: "const",
+				doc: "The highest load multiple the limits search. Default 2000."
+			}
+		},
+		children: [
+			"loadmap",
+			"load",
+			"param",
+			"preset",
+			"scenario",
+			"growth",
+			"expect",
+			"step",
+			"let",
+			"fit",
+			"flow",
+			"component",
+			"node",
+			"cluster",
+			"pool",
+			"thresholds"
+		],
+		edges: "edges"
+	},
+	loadmap: {
+		doc: "The first line: the version of the language this definition is written in.",
+		example: "loadmap 1",
+		args: [{
+			name: "version",
+			kind: "number"
+		}],
+		props: {},
+		children: []
+	},
+	load: {
+		doc: "The load, as a multiple of today. It drives the limits.",
+		example: "load \"Users, × today\" { max: 100; default: 10 }",
+		args: [{
+			name: "label",
+			kind: "text",
+			optional: true
+		}],
+		props: {
+			min: {
+				value: "number",
+				scope: "const",
+				doc: "The lowest multiple. Default 1."
+			},
+			max: {
+				value: "number",
+				scope: "const",
+				doc: "The highest multiple on the slider.",
+				required: true
+			},
+			step: {
+				value: "number",
+				scope: "const",
+				doc: "The slider step. Default 1."
+			},
+			default: {
+				value: "number",
+				scope: "const",
+				doc: "Where the slider starts. Default the minimum."
+			}
+		},
+		children: []
+	},
+	param: {
+		doc: "A control: options make a select, min and max a slider, a true or false default a switch.",
+		example: "param pods \"Worker pods\" { options: [2, 3, 4, 6]; default: 3 }",
+		args: [{
+			name: "id",
+			kind: "id"
+		}, {
+			name: "label",
+			kind: "text",
+			optional: true
+		}],
+		props: {
+			options: {
+				value: "options",
+				scope: "const",
+				doc: "The choices of a select: [2, 3, 4] or [\"a\", \"b\"]."
+			},
+			min: {
+				value: "number",
+				scope: "const",
+				doc: "The lowest value of a slider."
+			},
+			max: {
+				value: "number",
+				scope: "const",
+				doc: "The highest value of a slider."
+			},
+			step: {
+				value: "number",
+				scope: "const",
+				doc: "The step of a slider. Default 1."
+			},
+			default: {
+				value: "value",
+				scope: "const",
+				doc: "The starting value.",
+				required: true
+			},
+			hint: {
+				value: "string",
+				scope: "const",
+				doc: "One line under the control."
+			},
+			tag: {
+				value: "string",
+				scope: "const",
+				doc: "A short tag next to the label, e.g. \"estimate\"."
+			},
+			enabled: {
+				value: "boolean",
+				scope: "values",
+				doc: "Greys the control out while this is false; it reads only parameters."
+			},
+			format: {
+				value: "string",
+				scope: "value",
+				doc: "How a value is shown, from `value`: `${value} pods`."
+			}
+		},
+		children: []
+	},
+	preset: {
+		doc: "A named set of values, offered as a button.",
+		example: "preset \"Black Friday\" { load: 40; pods: 6 }",
+		args: [{
+			name: "label",
+			kind: "text"
+		}],
+		props: {},
+		children: [],
+		open: {
+			names: "values",
+			spec: {
+				value: "value",
+				scope: "const",
+				doc: "A value of the load or a parameter."
+			}
+		}
+	},
+	scenario: {
+		doc: "A named design to compare: the defaults plus these values, never the load. The first is the baseline.",
+		example: "scenario \"Proposed\" { pods: 6; gateways: 2 }",
+		args: [{
+			name: "label",
+			kind: "text"
+		}],
+		props: {},
+		children: [],
+		open: {
+			names: "params",
+			spec: {
+				value: "value",
+				scope: "const",
+				doc: "A value of a parameter."
+			}
+		}
+	},
+	growth: {
+		doc: "How fast the load grows, compounded from asOf, where it is 1×: load multiples become dates.",
+		example: "growth { rate: 0.06; per: month; asOf: \"2026-11-01\" }",
+		args: [],
+		props: {
+			rate: {
+				value: "number",
+				scope: "const",
+				required: true,
+				doc: "Growth per period, as a share: 0.06 is 6 %."
+			},
+			per: {
+				value: "enum",
+				scope: "const",
+				values: ["month", "year"],
+				required: true,
+				doc: "month or year."
+			},
+			asOf: {
+				value: "string",
+				scope: "const",
+				required: true,
+				doc: "The day the load is 1×: \"2026-11-01\"."
+			}
+		},
+		children: []
+	},
+	expect: {
+		doc: "What must keep holding, on the pessimistic edge (every capacity at its low bound): `loadmap check` fails when it does not.",
+		example: "expect \"Today keeps 7×\" { target: 7 }",
+		args: [{
+			name: "label",
+			kind: "text",
+			optional: true
+		}],
+		props: {
+			scenario: {
+				value: "scenario",
+				scope: "const",
+				doc: "The scenario whose values it checks; the defaults without one."
+			},
+			component: {
+				value: "component",
+				scope: "const",
+				doc: "One component; the first limit without one."
+			},
+			target: {
+				value: "number",
+				scope: "const",
+				doc: "The target holds up to at least this load multiple."
+			},
+			full: {
+				value: "number",
+				scope: "const",
+				doc: "Nothing (or the component) runs out before this load multiple."
+			}
+		},
+		children: []
+	},
+	step: {
+		doc: "A step of the story the page walks through, in order: its text, and the values to show it at. `loadmap record --story` plays it.",
+		example: "step \"At 30×, the workers run out first.\" { load: 30; focus: workers }",
+		args: [{
+			name: "label",
+			kind: "text"
+		}],
+		props: {
+			scenario: {
+				value: "scenario",
+				scope: "const",
+				doc: "Start from this scenario's values; without one, from the defaults."
+			},
+			focus: {
+				value: "component",
+				scope: "const",
+				doc: "The component to point at: its box is outlined."
+			},
+			seconds: {
+				value: "number",
+				scope: "const",
+				doc: "How long a recording holds the step. Default 4."
+			}
+		},
+		children: [],
+		open: {
+			names: "values",
+			spec: {
+				value: "value",
+				scope: "const",
+				doc: "A value of the load or a parameter."
+			}
+		}
+	},
+	let: {
+		doc: "A named formula other formulas can use by its name.",
+		example: "let perPosition = watchOnly ? 0.3 : 1.2",
+		args: [{
+			name: "id",
+			kind: "id"
+		}],
+		init: true,
+		props: {},
+		children: []
+	},
+	fit: {
+		doc: "cost = a + b × x, fitted from measured points. Call it like a function: workerCores(rate).",
+		example: "fit workerCores \"Worker CPU per request\" { source: \"load test\"; points rate cores { 200 0.26 } }",
+		args: [{
+			name: "id",
+			kind: "id"
+		}, {
+			name: "label",
+			kind: "text",
+			optional: true
+		}],
+		props: {
+			source: {
+				value: "string",
+				scope: "const",
+				doc: "Where the points came from."
+			},
+			through: {
+				value: "enum",
+				scope: "const",
+				values: ["origin"],
+				doc: "origin: a cost with no idle part (a = 0)."
+			}
+		},
+		children: ["points"]
+	},
+	points: {
+		doc: "The measured points of a fit: the names of x and y, then one \"x y\" row per line.",
+		example: "points rate cores {\n  200 0.2599\n  350 0.3061\n}",
+		args: [{
+			name: "x",
+			kind: "id"
+		}, {
+			name: "y",
+			kind: "id"
+		}],
+		props: {},
+		children: [],
+		rows: true
+	},
+	flow: {
+		doc: "Something that moves through the system, with its rate and its route.",
+		example: "flow orders \"orders\" { unit: \"order\"; rate: 40 * load; route: gateway -> topic -> workers }",
+		args: [{
+			name: "id",
+			kind: "id"
+		}, {
+			name: "label",
+			kind: "text",
+			optional: true
+		}],
+		props: {
+			unit: {
+				value: "string",
+				scope: "const",
+				doc: "One unit of the flow, singular: \"order\"."
+			},
+			rate: {
+				value: "number",
+				scope: "ctx",
+				doc: "Units per second.",
+				required: true
+			},
+			priority: {
+				value: "number",
+				scope: "const",
+				doc: "1 is served first. Flows of the same priority share."
+			},
+			route: {
+				value: "route",
+				scope: "const",
+				doc: "The stages it passes, in order: a -> b -> c.",
+				required: true
+			},
+			from: {
+				value: "node",
+				scope: "const",
+				doc: "The node its dots start from.",
+				required: true
+			},
+			color: {
+				value: "enum",
+				scope: "const",
+				values: COLORS,
+				doc: "A theme colour (accent, alt, ok, warn, drop, muted) or a CSS colour in quotes."
+			}
+		},
+		children: ["drop", "merge"]
+	},
+	drop: {
+		doc: "Units older than olderThan simulated seconds are dropped before they are handled.",
+		example: "drop { olderThan: 60; reason: \"too old\" }",
+		args: [],
+		props: {
+			olderThan: {
+				value: "number",
+				scope: "ctx",
+				doc: "Seconds.",
+				required: true
+			},
+			reason: {
+				value: "string",
+				scope: "ctx",
+				doc: "Shown with the drop meter."
+			},
+			when: OVERLOAD_WHEN
+		},
+		children: []
+	},
+	merge: {
+		doc: "Under backlog, this share of what is handled is superseded by a newer unit: keep the newest per key.",
+		example: "merge { share: 0.37; reason: \"newest kept\" }",
+		args: [],
+		props: {
+			share: {
+				value: "number",
+				scope: "ctx",
+				doc: "The share superseded, 0 to 1.",
+				required: true
+			},
+			reason: {
+				value: "string",
+				scope: "ctx",
+				doc: "Shown with the meter."
+			},
+			when: OVERLOAD_WHEN
+		},
+		children: []
+	},
+	component: {
+		doc: "Something that can run out: its demand against its capacity. On a box, write these lines on the box.",
+		example: "component cache \"Cache\" { demand: flows.reads; capacity: estimated(9000, \"req/s\") }",
+		args: [{
+			name: "id",
+			kind: "id",
+			optional: true
+		}, {
+			name: "label",
+			kind: "text",
+			optional: true
+		}],
+		props: COMPONENT_PROPS,
+		children: []
+	},
+	node: {
+		doc: "A box. It may run a stage (pass, store, sink, fanout) and own a component (demand and capacity lines).",
+		example: "node gateway \"API gateway\" { pass; demand: flows.orders; capacity: estimated(20000, \"req/s\") }",
+		args: BOX_ARGS,
+		props: {
+			sub: SUB,
+			shape: {
+				value: "enum",
+				scope: "const",
+				values: ["box", "cylinder"],
+				doc: "box (the default) or cylinder."
+			},
+			...COMPONENT_PROPS
+		},
+		children: [
+			"pass",
+			"store",
+			"sink",
+			"fanout",
+			"component"
+		]
+	},
+	cluster: {
+		doc: "Members (brokers) holding the partitions of one or more queues (topics).",
+		example: "cluster kafka \"Kafka\" { members: 3; queue topic { partitions { orders: 12 } } }",
+		args: BOX_ARGS,
+		props: {
+			sub: SUB,
+			members: {
+				value: "number",
+				scope: "ctx",
+				doc: "How many members.",
+				required: true
+			},
+			memberLabel: {
+				value: "string",
+				scope: "i",
+				doc: "Each member's label, from its index i: `broker ${i}`."
+			},
+			...COMPONENT_PROPS
+		},
+		children: ["queue", "component"]
+	},
+	pool: {
+		doc: "A workers stage drawn as pods holding a grid of workers.",
+		example: "pool workers \"Workers\" { workers { pods: pods; perPod: 8 } }",
+		args: BOX_ARGS,
+		props: {
+			sub: SUB,
+			podLabel: {
+				value: "string",
+				scope: "i",
+				doc: "Each pod's label, from its index i: `pod ${i}`."
+			},
+			...COMPONENT_PROPS
+		},
+		children: ["workers", "component"]
+	},
+	pass: {
+		doc: "Flows pass through; past capacity the share above 100 % is rejected.",
+		example: "pass \"the gateway\"",
+		args: STAGE_LABEL,
+		props: { component: STAGE_COMPONENT },
+		children: []
+	},
+	store: {
+		doc: "Where a flow ends: written to its component.",
+		example: "store",
+		args: STAGE_LABEL,
+		props: { component: STAGE_COMPONENT },
+		children: []
+	},
+	sink: {
+		doc: "Where a flow ends without a component: a receiver, a viewer.",
+		example: "sink \"contacts\"",
+		args: STAGE_LABEL,
+		props: {},
+		children: []
+	},
+	queue: {
+		doc: "Flows wait here; the next stage of each route drains it.",
+		example: "queue topic \"orders topic\" { partitions { orders: 12 } }",
+		args: STAGE_LABEL,
+		props: { component: STAGE_COMPONENT },
+		children: ["partitions"]
+	},
+	partitions: {
+		doc: "Partitions per flow, drawn as cells across the members.",
+		example: "partitions { orders: 12; events: 24 }",
+		args: [],
+		props: {},
+		children: [],
+		open: {
+			names: "flows",
+			spec: {
+				value: "number",
+				scope: "ctx",
+				doc: "Partitions of this flow."
+			}
+		}
+	},
+	workers: {
+		doc: "A pool of workers: pods × workers per pod.",
+		example: "workers { pods: pods; perPod: 8 }",
+		args: STAGE_LABEL,
+		props: {
+			pods: {
+				value: "number",
+				scope: "ctx",
+				doc: "How many pods.",
+				required: true
+			},
+			perPod: {
+				value: "number",
+				scope: "ctx",
+				doc: "Workers per pod.",
+				required: true
+			},
+			fill: {
+				value: "enum",
+				scope: "const",
+				values: ["round-robin", "in-order"],
+				doc: "round-robin spreads work across pods (the default); in-order fills pod 0 first."
+			},
+			component: STAGE_COMPONENT
+		},
+		children: []
+	},
+	fanout: {
+		doc: "Each unit is copied to several stages; one \"flow -> stage: copies\" line per branch. Last on a route.",
+		example: "fanout \"push broker\" {\n  alerts -> contacts: 1\n}",
+		args: STAGE_LABEL,
+		props: { component: STAGE_COMPONENT },
+		children: [],
+		edges: "branches"
+	},
+	thresholds: {
+		doc: "The utilization of the target and of \"runs out\".",
+		example: "thresholds { target: 0.5; full: 1 }",
+		args: [],
+		props: {
+			target: {
+				value: "number",
+				scope: "const",
+				doc: "Default 0.5."
+			},
+			full: {
+				value: "number",
+				scope: "const",
+				doc: "Default 1."
+			}
+		},
+		children: []
+	}
+};
+/** The properties of an edge's block: `a -> b { label: …; when: … }`. */
+const EDGE_PROPS = {
+	label: {
+		value: "string",
+		scope: "ctx",
+		doc: "The text on the edge."
+	},
+	when: {
+		value: "boolean",
+		scope: "ctx",
+		doc: "The edge is left out while this is false."
+	}
+};
+const BOXES = [
+	"node",
+	"cluster",
+	"pool"
+];
+const STAGES = [
+	"pass",
+	"store",
+	"sink",
+	"queue",
+	"workers",
+	"fanout"
+];
+// src/expr.ts
+/** A formula failed while the model ran: where, and why. */
+var FormulaError = class extends Error {
+	span;
+	constructor(span, message) {
+		super(message);
+		this.span = span;
+	}
+};
+const num = (f) => f;
+/** Functions renamed before 0.1: a definition from before says what to write instead. */
+const RENAMED = { kfmt: "compact" };
+const BUILTINS = {
+	min: {
+		args: ["number"],
+		variadic: true,
+		min: 1,
+		result: "number",
+		fn: num(Math.min)
+	},
+	max: {
+		args: ["number"],
+		variadic: true,
+		min: 1,
+		result: "number",
+		fn: num(Math.max)
+	},
+	round: {
+		args: ["number"],
+		result: "number",
+		fn: num(Math.round)
+	},
+	floor: {
+		args: ["number"],
+		result: "number",
+		fn: num(Math.floor)
+	},
+	ceil: {
+		args: ["number"],
+		result: "number",
+		fn: num(Math.ceil)
+	},
+	abs: {
+		args: ["number"],
+		result: "number",
+		fn: num(Math.abs)
+	},
+	sqrt: {
+		args: ["number"],
+		result: "number",
+		fn: num(Math.sqrt)
+	},
+	log: {
+		args: ["number"],
+		result: "number",
+		fn: num(Math.log)
+	},
+	exp: {
+		args: ["number"],
+		result: "number",
+		fn: num(Math.exp)
+	},
+	pow: {
+		args: ["number", "number"],
+		result: "number",
+		fn: num(Math.pow)
+	},
+	fmt: {
+		args: ["number"],
+		result: "string",
+		fn: fmt
+	},
+	compact: {
+		args: ["number"],
+		result: "string",
+		fn: compact
+	},
+	pct: {
+		args: ["number"],
+		result: "string",
+		fn: pct
+	},
+	secs: {
+		args: ["number"],
+		result: "string",
+		fn: secs
+	},
+	measured: {
+		args: [
+			"number",
+			"string",
+			"string"
+		],
+		min: 2,
+		result: "capacity",
+		fn: measured
+	},
+	estimated: {
+		args: [
+			"number",
+			"string",
+			"string"
+		],
+		min: 2,
+		result: "capacity",
+		fn: estimated
+	}
+};
+/** The tables a formula may read with a ".": flows.orders, demand.db, util.db, derived.x. */
+const TABLES = [
+	"flows",
+	"demand",
+	"util",
+	"derived"
+];
+/** Names a declaration cannot take: the tables, the locals, the literals and what plain objects already have. */
+const RESERVED = /* @__PURE__ */ new Set([
+	"load",
+	...TABLES,
+	"i",
+	"value",
+	"true",
+	"false",
+	"Math",
+	...Object.keys(BUILTINS),
+	...Object.getOwnPropertyNames(Object.prototype),
+	"prototype"
+]);
+const WORD = {
+	number: "a number",
+	boolean: "true or false",
+	string: "a text",
+	capacity: "a capacity",
+	any: "a value"
+};
+const typeWord = (t) => WORD[t];
+/**
+* Checks a formula against what it may read (`scope`) and compiles it. Errors are reported; the result then has type
+* `any` and returns undefined, so checking goes on.
+*/
+function compileFormula(e, names, scope, report) {
+	return new Compiler$1(names, scope, report).compile(e);
+}
+const bad = {
+	type: "any",
+	constant: true,
+	run: () => void 0
+};
+var Compiler$1 = class {
+	names;
+	scope;
+	report;
+	constructor(names, scope, report) {
+		this.names = names;
+		this.scope = scope;
+		this.report = report;
+	}
+	canRead(e, what) {
+		if (this.scope === "ctx" || this.scope === "values" && what === "a parameter") return true;
+		const here = this.scope === "const" ? "this value must be a constant" : this.scope === "values" ? "this formula reads only parameters" : `this formula reads only "${this.scope}"`;
+		this.report.error(e, `${here}; it cannot read ${what}`);
+		return false;
+	}
+	compile(e) {
+		switch (e.t) {
+			case "error": return bad;
+			case "num":
+			case "str":
+			case "bool": {
+				const v = e.value;
+				return {
+					type: e.t === "num" ? "number" : e.t === "str" ? "string" : "boolean",
+					constant: true,
+					run: () => v
+				};
+			}
+			case "tpl": {
+				const parts = e.parts.map((p) => this.compile(p));
+				const { quasis } = e;
+				const runs = parts.map((p) => p.run);
+				return {
+					type: "string",
+					constant: parts.every((p) => p.constant),
+					run: (c, l) => {
+						let s = quasis[0];
+						for (let i = 0; i < runs.length; i++) s += String(runs[i](c, l)) + quasis[i + 1];
+						return s;
+					}
+				};
+			}
+			case "id": return this.name(e, e.name);
+			case "member": return this.member(e);
+			case "call": return this.call(e);
+			case "unary": {
+				const a = this.compile(e.arg);
+				const run = a.run;
+				if (e.op === "!") return {
+					type: "boolean",
+					constant: a.constant,
+					run: (c, l) => !run(c, l)
+				};
+				this.want(e.arg, a, "number");
+				return {
+					type: "number",
+					constant: a.constant,
+					run: e.op === "-" ? (c, l) => -run(c, l) : run
+				};
+			}
+			case "bin": return this.binary(e);
+			case "cond": {
+				const test = this.compile(e.test);
+				const then = this.compile(e.then);
+				const other = this.compile(e.else);
+				const [t, a, b] = [
+					test.run,
+					then.run,
+					other.run
+				];
+				return {
+					type: then.type === other.type ? then.type : "any",
+					constant: test.constant && then.constant && other.constant,
+					run: (c, l) => t(c, l) ? a(c, l) : b(c, l)
+				};
+			}
+			case "array":
+				this.report.error(e, "a list is only allowed as the options of a parameter");
+				return bad;
+			case "pm":
+				this.report.error(e, "\"±\" only goes in the first value of measured(…) or estimated(…)");
+				return bad;
+		}
+	}
+	name(e, name) {
+		if (name === "i" || name === "value") {
+			if (this.scope !== name) {
+				this.report.error(e, `"${name}" is only known in ${name === "i" ? "memberLabel and podLabel" : "format"}`);
+				return bad;
+			}
+			return {
+				type: name === "i" ? "number" : "any",
+				constant: false,
+				run: (_, l) => l
+			};
+		}
+		const param = this.names.params.get(name);
+		if (param) {
+			if (!this.canRead(e, "a parameter")) return bad;
+			return {
+				type: param,
+				constant: false,
+				run: (c) => c[name]
+			};
+		}
+		const let_ = this.names.lets.get(name);
+		if (let_) {
+			if (!this.canRead(e, `"${name}"`)) return bad;
+			return {
+				type: let_,
+				constant: false,
+				run: (c) => c.derived[name]
+			};
+		}
+		if (TABLES.includes(name)) {
+			this.report.error(e, `"${name}" is a table: name one of its entries, like ${name}.${this.example(name)}`);
+			return bad;
+		}
+		if (this.names.fits.has(name) || own(BUILTINS, name) || own(this.names.functions, name)) {
+			this.report.error(e, `"${name}" is a function: call it, ${name}(…)`);
+			return bad;
+		}
+		const known = [...this.names.params.keys(), ...this.names.lets.keys()];
+		this.report.error(e, `unknown name "${name}"`, didYouMean(name, known));
+		return bad;
+	}
+	example(table) {
+		return [...table === "flows" ? this.names.flows : table === "derived" ? this.names.lets.keys() : this.names.components][0] ?? "x";
+	}
+	member(e) {
+		const table = e.object.name;
+		const key = e.prop.name;
+		const pool = table === "flows" ? this.names.flows : table === "demand" || table === "util" ? this.names.components : table === "derived" ? this.names.lets.keys() : void 0;
+		if (!pool) {
+			this.report.error(e.object, `"${table}" has no entries: only flows., demand., util. and derived. do`);
+			return bad;
+		}
+		if (!(table === "derived" ? this.names.lets.has(key) : pool.has(key))) {
+			const what = table === "flows" ? "flow" : table === "derived" ? "let" : "component";
+			this.report.error(e.prop, `unknown ${what} "${key}"`, didYouMean(key, pool));
+			return bad;
+		}
+		if (!this.canRead(e, `${table}.${key}`)) return bad;
+		return {
+			type: table === "derived" ? this.names.lets.get(key) : "number",
+			constant: false,
+			run: (c) => c[table][key]
+		};
+	}
+	call(e) {
+		const name = e.callee.name;
+		const pm = e.args[0]?.t === "pm" ? e.args[0] : null;
+		if (pm && (name === "measured" || name === "estimated")) return this.capacity(e, pm);
+		const args = e.args.map((a) => this.compile(a));
+		const runs = args.map((a) => a.run);
+		const fit = this.names.fits.get(name);
+		if (this.names.fits.has(name)) {
+			if (args.length !== 1) this.report.error(e, `the fit "${name}" takes one number`);
+			else this.want(e.args[0], args[0], "number");
+			const a = runs[0] ?? (() => void 0);
+			return {
+				type: "number",
+				constant: args.every((x) => x.constant),
+				run: (c, l) => fit?.(a(c, l))
+			};
+		}
+		const b = own(BUILTINS, name);
+		if (b) {
+			const max = b.variadic ? Number.POSITIVE_INFINITY : b.args.length;
+			const min = b.min ?? b.args.length;
+			if (args.length < min || args.length > max) this.report.error(e, `${name}() takes ${min === max ? min : `${min} to ${max}`} values, not ${args.length}`);
+			for (const [i, a] of args.entries()) this.want(e.args[i], a, b.args[Math.min(i, b.args.length - 1)]);
+			const fn = b.fn;
+			return {
+				type: b.result,
+				constant: args.every((a) => a.constant),
+				run: (c, l) => fn(...runs.map((r) => r(c, l)))
+			};
+		}
+		const host = own(this.names.functions, name);
+		if (host) return {
+			type: "any",
+			constant: false,
+			run: (c, l) => host(...runs.map((r) => r(c, l)))
+		};
+		const known = [
+			...Object.keys(BUILTINS),
+			...this.names.fits.keys(),
+			...Object.keys(this.names.functions)
+		];
+		this.report.error(e.callee, `unknown function "${name}"`, (own(RENAMED, name) ? `renamed to ${own(RENAMED, name)}()` : void 0) ?? didYouMean(name, known) ?? "a host page can provide it in compile(…, { functions })");
+		return bad;
+	}
+	/** measured(value ± within[%], unit, source): the ± becomes the capacity's `within`, a share of the value. */
+	capacity(e, pm) {
+		const fn = e.callee.name === "measured" ? measured : estimated;
+		const [value, within] = [this.compile(pm.value), this.compile(pm.within)];
+		const rest = e.args.slice(1).map((a) => this.compile(a));
+		this.want(pm.value, value, "number");
+		this.want(pm.within, within, "number");
+		if (rest.length < 1 || rest.length > 2) this.report.error(e, `${e.callee.name}() takes 2 to 3 values, not ${rest.length + 1}`);
+		for (const [i, a] of rest.entries()) this.want(e.args[i + 1], a, "string");
+		const [v, w] = [value.run, within.run];
+		const [unit, source] = rest.map((a) => a.run);
+		const { percent } = pm;
+		return {
+			type: "capacity",
+			constant: [
+				value,
+				within,
+				...rest
+			].every((a) => a.constant),
+			run: (c, l) => {
+				const x = v(c, l);
+				const pmv = w(c, l);
+				const share = percent ? pmv / 100 : x ? pmv / x : 0;
+				if (!(share >= 0 && share < 1)) {
+					const said = percent ? `${pmv} %` : `${pmv} of ${x}`;
+					throw new Error(`± ${said} is not a share from 0 to below 100 %`);
+				}
+				return fn(x, unit?.(c, l), {
+					source: source?.(c, l),
+					within: share
+				});
+			}
+		};
+	}
+	binary(e) {
+		const l = this.compile(e.left);
+		const r = this.compile(e.right);
+		const [a, b] = [l.run, r.run];
+		const constant = l.constant && r.constant;
+		const f = (type, run) => ({
+			type,
+			constant,
+			run
+		});
+		switch (e.op) {
+			case "||": return f(l.type === r.type ? l.type : "any", (c, x) => a(c, x) || b(c, x));
+			case "&&": return f(l.type === r.type ? l.type : "any", (c, x) => a(c, x) && b(c, x));
+			case "==": return f("boolean", (c, x) => a(c, x) === b(c, x));
+			case "!=": return f("boolean", (c, x) => a(c, x) !== b(c, x));
+			case "<": return f("boolean", (c, x) => a(c, x) < b(c, x));
+			case "<=": return f("boolean", (c, x) => a(c, x) <= b(c, x));
+			case ">": return f("boolean", (c, x) => a(c, x) > b(c, x));
+			case ">=": return f("boolean", (c, x) => a(c, x) >= b(c, x));
+			case "+": {
+				const type = l.type === "string" || r.type === "string" ? "string" : l.type === "number" && r.type === "number" ? "number" : "any";
+				if (type !== "string") {
+					this.want(e.left, l, "number");
+					this.want(e.right, r, "number");
+				}
+				return f(type, (c, x) => a(c, x) + b(c, x));
+			}
+			default: {
+				this.want(e.left, l, "number");
+				this.want(e.right, r, "number");
+				const op = e.op;
+				return f("number", (c, x) => {
+					const u = a(c, x);
+					const v = b(c, x);
+					return op === "-" ? u - v : op === "*" ? u * v : op === "/" ? u / v : u % v;
+				});
+			}
+		}
+	}
+	want(at, f, type) {
+		if (f.type !== type && f.type !== "any" && type !== "any") this.report.error(at, `expected ${typeWord(type)}, this is ${typeWord(f.type)}`);
+	}
+};
+/**
+* Wraps a formula for the model: it takes the context, and any error it throws carries the formula's place. An error
+* already placed (from a formula this one read) keeps its place: the innermost formula is the one to fix.
+*/
+function placed(span, run) {
+	return (ctx, local) => {
+		try {
+			return run(ctx, local);
+		} catch (err) {
+			if (err instanceof FormulaError) throw err;
+			throw new FormulaError(span, err instanceof Error ? err.message.replace(/^loadmap: /, "") : String(err));
+		}
+	};
+}
+const isCapacity = (v) => typeof v === "object" && v != null && "provenance" in v && "value" in v;
+// src/lexer.ts
+const PUNCT = [
+	"===",
+	"!==",
+	"+/-",
+	"->",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"&&",
+	"||",
+	..."{}()[],;:.?+-*/%<>!=±"
+];
+/** The token kinds and marks an editor needs to highlight the language like the parser reads it. */
+const LEXICON = {
+	punct: PUNCT,
+	comment: "#"
+};
+/**
+* Splits `source[from, to)` into tokens. Newlines end statements, except inside parentheses and brackets, so a long
+* formula can wrap there. `#` starts a comment to the end of the line.
+*/
+function lex(source, report, from = 0, to = source.length) {
+	const out = [];
+	let depth = 0;
+	let i = from;
+	const push = (t) => out.push(t);
+	while (i < to) {
+		const c = source[i];
+		if (c === "\n") {
+			if (depth === 0 && out.at(-1)?.kind !== "newline") push({
+				kind: "newline",
+				text: "\n",
+				from: i,
+				to: i + 1
+			});
+			i++;
+		} else if (c === " " || c === "	" || c === "\r") i++;
+		else if (c === "#") while (i < to && source[i] !== "\n") i++;
+		else if (isIdStart(c)) {
+			const s = i;
+			while (i < to && isIdPart(source[i])) i++;
+			push({
+				kind: "ident",
+				text: source.slice(s, i),
+				from: s,
+				to: i
+			});
+		} else if (isDigit(c) || c === "." && isDigit(source[i + 1] ?? "")) {
+			const s = i;
+			while (i < to && (isDigit(source[i]) || source[i] === "_")) i++;
+			if (source[i] === "." && isDigit(source[i + 1] ?? "")) {
+				i++;
+				while (i < to && (isDigit(source[i]) || source[i] === "_")) i++;
+			}
+			const sign = source[i + 1] === "+" || source[i + 1] === "-" ? 1 : 0;
+			if ((source[i] === "e" || source[i] === "E") && isDigit(source[i + 1 + sign] ?? "")) {
+				i += 1 + sign;
+				while (i < to && isDigit(source[i])) i++;
+			}
+			const text = source.slice(s, i);
+			if (text.endsWith("_") || text.includes("__")) report.error({
+				from: s,
+				to: i
+			}, `"${text}" is not a number`);
+			push({
+				kind: "number",
+				text,
+				value: Number(text.replaceAll("_", "")),
+				from: s,
+				to: i
+			});
+		} else if (c === "\"" || c === "'") {
+			const s = i;
+			const r = readString(source, i + 1, to, c);
+			if (!r.closed) report.error({
+				from: s,
+				to: r.end
+			}, "this text has no closing quote", `end it with ${c}`);
+			i = r.end;
+			push({
+				kind: "string",
+				text: source.slice(s, i),
+				value: r.value,
+				from: s,
+				to: i
+			});
+		} else if (c === "`") {
+			const s = i;
+			const t = readTemplate(source, i + 1, to, report);
+			if (!t.closed) report.error({
+				from: s,
+				to: t.end
+			}, "this template has no closing backtick", "end it with `");
+			i = t.end;
+			push({
+				kind: "template",
+				text: source.slice(s, i),
+				quasis: t.quasis,
+				parts: t.parts,
+				from: s,
+				to: i
+			});
+		} else {
+			const p = PUNCT.find((m) => source.startsWith(m, i));
+			if (!p) {
+				report.error({
+					from: i,
+					to: i + 1
+				}, `unexpected character "${c}"`);
+				i++;
+				continue;
+			}
+			if (p === "(" || p === "[") depth++;
+			else if ((p === ")" || p === "]") && depth > 0) depth--;
+			else if (p === "{" || p === "}") depth = 0;
+			push({
+				kind: "punct",
+				text: p,
+				from: i,
+				to: i + p.length
+			});
+			i += p.length;
+		}
+	}
+	push({
+		kind: "eof",
+		text: "",
+		from: to,
+		to
+	});
+	return out;
+}
+const isIdStart = (c) => /[A-Za-z_]/.test(c);
+const isIdPart = (c) => /[A-Za-z0-9_]/.test(c);
+const isDigit = (c) => c >= "0" && c <= "9";
+const ESCAPES = {
+	n: "\n",
+	t: "	",
+	"\\": "\\",
+	"\"": "\"",
+	"'": "'",
+	"`": "`",
+	$: "$"
+};
+function readString(src, i, to, q) {
+	let value = "";
+	while (i < to && src[i] !== q && src[i] !== "\n") if (src[i] === "\\" && i + 1 < to) {
+		value += ESCAPES[src[i + 1]] ?? src[i + 1];
+		i += 2;
+	} else value += src[i++];
+	const closed = src[i] === q;
+	return {
+		value,
+		end: closed ? i + 1 : i,
+		closed
+	};
+}
+/** Templates nested deeper than this are refused: the lexer reads them recursively. */
+const MAX_TEMPLATE_DEPTH = 16;
+function readTemplate(src, i, to, report, depth = 0) {
+	const quasis = [];
+	const parts = [];
+	let cur = "";
+	while (i < to && src[i] !== "`") if (src[i] === "\\" && i + 1 < to) {
+		cur += ESCAPES[src[i + 1]] ?? src[i + 1];
+		i += 2;
+	} else if (src[i] === "$" && src[i + 1] === "{") {
+		quasis.push(cur);
+		cur = "";
+		const start = i + 2;
+		const end = skipExpression(src, start, to, report, depth);
+		parts.push({
+			from: start,
+			to: end
+		});
+		if (src[end] === "}") i = end + 1;
+		else {
+			report.error({
+				from: i,
+				to: end
+			}, "this \"${\" has no closing \"}\"");
+			i = end;
+		}
+	} else cur += src[i++];
+	quasis.push(cur);
+	const closed = src[i] === "`";
+	return {
+		quasis,
+		parts,
+		end: closed ? i + 1 : i,
+		closed
+	};
+}
+/** The offset of the `}` that closes a template's `${`, skipping nested braces, strings and templates. */
+function skipExpression(src, i, to, report, depth) {
+	let braces = 0;
+	while (i < to) {
+		const c = src[i];
+		if (c === "}" && braces === 0) return i;
+		if (c === "{") braces++;
+		else if (c === "}") braces--;
+		else if (c === "\"" || c === "'") {
+			i = readString(src, i + 1, to, c).end;
+			continue;
+		} else if (c === "`") {
+			if (depth + 1 >= MAX_TEMPLATE_DEPTH) {
+				report.error({
+					from: i,
+					to: i + 1
+				}, `templates are nested more than ${MAX_TEMPLATE_DEPTH} deep`);
+				return to;
+			}
+			i = readTemplate(src, i + 1, to, report, depth + 1).end;
+			continue;
+		} else if (c === "\n") return i;
+		i++;
+	}
+	return i;
+}
+// src/parser.ts
+/** Deeper formulas are refused: a shared link must not be able to exhaust the stack. */
+const MAX_DEPTH = 64;
+/** Longer sources are refused before parsing. */
+const MAX_SOURCE = 2e5;
+const PREC = {
+	"||": 1,
+	"&&": 2,
+	"==": 3,
+	"!=": 3,
+	"===": 3,
+	"!==": 3,
+	"<": 4,
+	"<=": 4,
+	">": 4,
+	">=": 4,
+	"+": 5,
+	"-": 5,
+	"*": 6,
+	"/": 6,
+	"%": 6
+};
+/** Thrown after a syntax error has been reported, to skip to the next statement. */
+var Bail$1 = class {};
+/** Parses a definition into statements. Never throws: errors go to the reporter, and parsing goes on at the next line. */
+function parse(source, report = new Reporter(source)) {
+	if (source.length > 2e5) {
+		report.error({
+			from: 0,
+			to: 0
+		}, `the definition is ${source.length} characters long; at most ${MAX_SOURCE}`);
+		return {
+			doc: { body: [] },
+			report
+		};
+	}
+	return {
+		doc: { body: new Parser(lex(source, report), source, report).block(false) },
+		report
+	};
+}
+/** Parses one formula on its own, e.g. a template's `${…}` part. */
+function parseExpression(source, from, to, report, depth = 0) {
+	const p = new Parser(lex(source, report, from, to), source, report);
+	p.depth = depth;
+	try {
+		const e = p.expr();
+		if (p.peek().kind !== "eof") p.fail(p.peek(), `unexpected ${describe(p.peek())} in the formula`);
+		return e;
+	} catch (e) {
+		if (e instanceof Bail$1) return {
+			t: "error",
+			from,
+			to
+		};
+		throw e;
+	}
+}
+var Parser = class {
+	toks;
+	source;
+	report;
+	i = 0;
+	depth = 0;
+	/** Blocks open around the statement being read. */
+	blocks = 0;
+	constructor(toks, source, report) {
+		this.toks = toks;
+		this.source = source;
+		this.report = report;
+	}
+	peek(k = 0) {
+		return this.toks[Math.min(this.i + k, this.toks.length - 1)];
+	}
+	next() {
+		const t = this.peek();
+		if (t.kind !== "eof") this.i++;
+		return t;
+	}
+	is(text, k = 0) {
+		const t = this.peek(k);
+		return t.kind === "punct" && t.text === text;
+	}
+	eat(text) {
+		if (!this.is(text)) return false;
+		this.i++;
+		return true;
+	}
+	expect(text, what) {
+		if (!this.is(text)) this.fail(this.peek(), `expected ${what}, found ${describe(this.peek())}`);
+		return this.next();
+	}
+	fail(at, message, hint) {
+		this.report.error(at, message, hint);
+		throw new Bail$1();
+	}
+	/** Statements up to the end of the file, or up to the `}` that closes this block (left for the caller). */
+	block(inBraces) {
+		const out = [];
+		for (;;) {
+			while (this.peek().kind === "newline" || this.is(";")) this.next();
+			const t = this.peek();
+			if (t.kind === "eof") break;
+			if (this.is("}")) {
+				if (inBraces) break;
+				this.report.error(t, "this \"}\" closes no block");
+				this.next();
+				continue;
+			}
+			try {
+				out.push(this.statement());
+				const end = this.peek();
+				if (!(end.kind === "newline" || end.kind === "eof" || this.is(";") || this.is("}"))) this.fail(end, `expected the end of the line, found ${describe(end)}`);
+			} catch (e) {
+				if (!(e instanceof Bail$1)) throw e;
+				this.recover();
+			}
+		}
+		return out;
+	}
+	/** Skips to the end of the broken statement: the next line, `;` or the `}` of the enclosing block. */
+	recover() {
+		let depth = 0;
+		for (;;) {
+			const t = this.peek();
+			if (t.kind === "eof") return;
+			if (depth === 0 && (t.kind === "newline" || this.is(";") || this.is("}"))) return;
+			if (this.is("{")) depth++;
+			else if (this.is("}")) depth--;
+			this.next();
+		}
+	}
+	statement() {
+		const t = this.peek();
+		if (t.kind === "number" || this.is("-") && this.peek(1).kind === "number") return this.row();
+		if (t.kind !== "ident") this.fail(t, `expected a statement, found ${describe(t)}`);
+		if (this.is(":", 1)) return this.property();
+		if (this.is("->", 1)) return this.edge();
+		return this.decl();
+	}
+	ident(what = "a name") {
+		const t = this.peek();
+		if (t.kind !== "ident") this.fail(t, `expected ${what}, found ${describe(t)}`);
+		this.next();
+		return {
+			name: t.text,
+			from: t.from,
+			to: t.to
+		};
+	}
+	property() {
+		const key = this.ident();
+		this.expect(":", "\":\"");
+		if (this.endsStatement()) this.fail(this.peek(), `"${key.name}" has no value`);
+		const value = this.expr();
+		if (this.is("->")) {
+			if (value.t !== "id") this.fail(value, "a route is a list of names joined by \"->\"");
+			const chain = [{
+				name: value.name,
+				from: value.from,
+				to: value.to
+			}];
+			while (this.eat("->")) chain.push(this.ident("a stage"));
+			return {
+				kind: "prop",
+				key,
+				value,
+				chain,
+				from: key.from,
+				to: chain.at(-1).to
+			};
+		}
+		return {
+			kind: "prop",
+			key,
+			value,
+			from: key.from,
+			to: value.to
+		};
+	}
+	edge() {
+		const chain = [this.ident()];
+		while (this.eat("->")) chain.push(this.ident("a name after \"->\""));
+		const e = {
+			kind: "edge",
+			chain,
+			from: chain[0].from,
+			to: chain.at(-1).to
+		};
+		if (this.eat(":")) {
+			if (this.endsStatement()) this.fail(this.peek(), "expected a value after \":\"");
+			e.value = this.expr();
+			e.to = e.value.to;
+		}
+		if (this.is("{")) this.body(e);
+		return e;
+	}
+	decl() {
+		const k = this.next();
+		const d = {
+			kind: "decl",
+			keyword: {
+				name: k.text,
+				from: k.from,
+				to: k.to
+			},
+			args: [],
+			from: k.from,
+			to: k.to
+		};
+		for (;;) {
+			const t = this.peek();
+			if (t.kind === "ident" || t.kind === "string" || t.kind === "template" || t.kind === "number") d.args.push(this.primary());
+			else if (this.is("-") && this.peek(1).kind === "number") d.args.push(this.unary());
+			else break;
+			d.to = d.args.at(-1).to;
+		}
+		if (this.eat("=")) {
+			if (this.endsStatement()) this.fail(this.peek(), "expected a formula after \"=\"");
+			d.init = this.expr();
+			d.to = d.init.to;
+		}
+		if (this.is("{")) this.body(d);
+		else if (!this.endsStatement()) this.fail(this.peek(), `expected "{" or the end of the line, found ${describe(this.peek())}`);
+		return d;
+	}
+	body(d) {
+		if (this.blocks >= 64) {
+			const open = this.next();
+			this.report.error(open, `blocks are nested more than 64 deep`);
+			for (let depth = 1; depth > 0 && this.peek().kind !== "eof";) {
+				const t = this.next();
+				if (t.kind === "punct" && t.text === "{") depth++;
+				else if (t.kind === "punct" && t.text === "}") depth--;
+			}
+			d.to = this.peek().from;
+			return;
+		}
+		this.blocks++;
+		try {
+			this.bodyInside(d);
+		} finally {
+			this.blocks--;
+		}
+	}
+	bodyInside(d) {
+		const open = this.next();
+		d.body = this.block(true);
+		const close = this.peek();
+		if (!this.is("}")) {
+			this.report.error(open, `this "{" of "${"keyword" in d ? d.keyword.name : "edge"}" is never closed`);
+			d.bodySpan = {
+				from: open.from,
+				to: close.from + 1
+			};
+			d.to = close.from;
+			return;
+		}
+		this.next();
+		d.bodySpan = {
+			from: open.from,
+			to: close.to
+		};
+		d.to = close.to;
+	}
+	row() {
+		const values = [];
+		while (this.peek().kind === "number" || this.is("-") && this.peek(1).kind === "number") {
+			values.push(this.unary());
+			this.eat(",");
+		}
+		return {
+			kind: "row",
+			values,
+			from: values[0].from,
+			to: values.at(-1).to
+		};
+	}
+	endsStatement() {
+		const t = this.peek();
+		return t.kind === "newline" || t.kind === "eof" || this.is(";") || this.is("}");
+	}
+	expr() {
+		if (++this.depth > 64) this.fail(this.peek(), `the formula is nested more than 64 deep`);
+		try {
+			const test = this.binary(1);
+			if (this.is("±") || this.is("+/-")) return this.pm(test);
+			if (!this.eat("?")) return test;
+			const then = this.expr();
+			this.expect(":", "\":\" of the \"?\"");
+			const otherwise = this.expr();
+			return {
+				t: "cond",
+				test,
+				then,
+				else: otherwise,
+				from: test.from,
+				to: otherwise.to
+			};
+		} finally {
+			this.depth--;
+		}
+	}
+	/** `value ± within` or `value ± within%`: parsed anywhere, so the checker can say where it belongs. */
+	pm(value) {
+		this.next();
+		const within = this.unary();
+		const percent = this.is("%") ? this.next() : null;
+		return {
+			t: "pm",
+			value,
+			within,
+			percent: !!percent,
+			from: value.from,
+			to: percent?.to ?? within.to
+		};
+	}
+	binary(min) {
+		let left = this.unary();
+		for (;;) {
+			const t = this.peek();
+			const prec = t.kind === "punct" ? PREC[t.text] : void 0;
+			if (prec == null || prec < min) return left;
+			this.next();
+			const right = this.binary(prec + 1);
+			left = {
+				t: "bin",
+				op: t.text === "===" ? "==" : t.text === "!==" ? "!=" : t.text,
+				left,
+				right,
+				from: left.from,
+				to: right.to
+			};
+		}
+	}
+	unary() {
+		const t = this.peek();
+		if (this.is("-") || this.is("+") || this.is("!")) {
+			this.next();
+			if (++this.depth > 64) this.fail(t, `the formula is nested more than 64 deep`);
+			try {
+				const arg = this.unary();
+				return {
+					t: "unary",
+					op: t.text,
+					arg,
+					from: t.from,
+					to: arg.to
+				};
+			} finally {
+				this.depth--;
+			}
+		}
+		return this.primary();
+	}
+	primary() {
+		const t = this.peek();
+		if (!(t.kind !== "punct" ? t.kind !== "newline" && t.kind !== "eof" : t.text === "(" || t.text === "[")) this.fail(t, `expected a value, found ${describe(t)}`);
+		this.next();
+		switch (t.kind) {
+			case "number": return {
+				t: "num",
+				value: t.value,
+				from: t.from,
+				to: t.to
+			};
+			case "string": return {
+				t: "str",
+				value: t.value,
+				from: t.from,
+				to: t.to
+			};
+			case "template": return {
+				t: "tpl",
+				quasis: t.quasis,
+				parts: t.parts.map((s) => this.part(s)),
+				from: t.from,
+				to: t.to
+			};
+			case "ident": {
+				if (t.text === "true" || t.text === "false") return {
+					t: "bool",
+					value: t.text === "true",
+					from: t.from,
+					to: t.to
+				};
+				let callee = {
+					name: t.text,
+					from: t.from,
+					to: t.to
+				};
+				if (this.is(".")) {
+					this.next();
+					const prop = this.ident("a name after \".\"");
+					if (!this.is("(")) {
+						if (this.is(".")) this.fail(this.peek(), "only one \".\" is allowed: flows.orders, util.db");
+						return {
+							t: "member",
+							object: callee,
+							prop,
+							from: t.from,
+							to: prop.to
+						};
+					}
+					if (callee.name !== "Math") this.fail(callee, `"${callee.name}.${prop.name}(…)" is not a function`);
+					callee = prop;
+				}
+				if (this.is("(")) {
+					this.next();
+					const args = [];
+					while (!this.is(")")) {
+						args.push(this.expr());
+						if (!this.eat(",")) break;
+					}
+					const close = this.expect(")", "\")\" or \",\"");
+					return {
+						t: "call",
+						callee,
+						args,
+						from: t.from,
+						to: close.to
+					};
+				}
+				return {
+					t: "id",
+					name: t.text,
+					from: t.from,
+					to: t.to
+				};
+			}
+			case "punct":
+				if (t.text === "(") {
+					const e = this.expr();
+					const close = this.expect(")", "\")\"");
+					return {
+						...e,
+						from: t.from,
+						to: close.to
+					};
+				}
+				if (t.text === "[") {
+					const items = [];
+					while (!this.is("]")) {
+						items.push(this.expr());
+						if (!this.eat(",")) break;
+					}
+					const close = this.expect("]", "\"]\" or \",\"");
+					return {
+						t: "array",
+						items,
+						from: t.from,
+						to: close.to
+					};
+				}
+		}
+		this.fail(t, `expected a value, found ${describe(t)}`);
+	}
+	/** One `${…}` of a template, parsed from its place in the source so errors point into it. */
+	part(s) {
+		if (s.to > s.from) return parseExpression(this.source, s.from, s.to, this.report, this.depth);
+		this.report.error({
+			from: s.from - 2,
+			to: s.to + 1
+		}, "an empty part in a template");
+		return {
+			t: "error",
+			from: s.from,
+			to: s.to
+		};
+	}
+};
+function describe(t) {
+	switch (t.kind) {
+		case "eof": return "the end of the file";
+		case "newline": return "the end of the line";
+		case "string":
+		case "template": return "a text";
+		case "number": return `the number ${t.text}`;
+		default: return `"${t.text}"`;
+	}
+}
+// src/compile.ts
+/** The version of the language this package reads: the number on a definition's first line. */
+const LANGUAGE_VERSION = 1;
+/** Counts that size the drawing; larger ones would hang the layout, so a shared link cannot ask for them. */
+const LIMITS = {
+	members: 64,
+	pods: 256,
+	perPod: 256,
+	partitions: 1024
+};
+/** Reads a definition: parses, checks, and builds the model and view `<Loadmap>` takes. Never throws. */
+function compile(source, o = {}) {
+	const report = new Reporter(source);
+	const c = new Compiler(source, report, o.functions ?? {});
+	let doc = { body: [] };
+	let definition;
+	let expectations = [];
+	try {
+		doc = parse(source, report).doc;
+		definition = c.run(doc);
+		if (definition) expectations = check(definition.model).map((result, i) => {
+			const at = c.expectSpans[i];
+			return {
+				at,
+				...report.position(at.from),
+				result
+			};
+		});
+	} catch (err) {
+		if (err instanceof FormulaError) report.error(err.span, err.message);
+		else if (!(err instanceof Bail)) report.error({
+			from: 0,
+			to: 0
+		}, `internal error: ${err?.message ?? err}`);
+	}
+	const diagnostics = [...report.list].sort((a, b) => a.from - b.from);
+	return {
+		ok: !report.failed && !!definition,
+		diagnostics,
+		definition,
+		expectations,
+		symbols: c.symbols,
+		doc
+	};
+}
+/**
+* The diagnostics and every failing expectation, in source order: an editor marks a failure as a warning (the
+* diagram still shows), `loadmap check` as an error.
+*/
+function problems(r, failed = "warning") {
+	const out = [...r.diagnostics];
+	for (const e of r.expectations) if (!e.result.ok) {
+		const name = e.result.expectation.label ? `"${e.result.expectation.label}" fails: ` : "";
+		out.push({
+			severity: failed,
+			message: `${name}${e.result.message}`,
+			...e.at,
+			line: e.line,
+			column: e.column
+		});
+	}
+	return out.sort((a, b) => a.from - b.from);
+}
+/** Stops compiling after an error that leaves nothing sensible to check. */
+var Bail = class {};
+var Compiler = class {
+	source;
+	report;
+	functions;
+	symbols = [];
+	/** Where each expectation of the model is written, in order. */
+	expectSpans = [];
+	names;
+	fits = /* @__PURE__ */ new Map();
+	lets = /* @__PURE__ */ new Map();
+	constructor(source, report, functions) {
+		this.source = source;
+		this.report = report;
+		this.functions = functions;
+	}
+	run(doc) {
+		const root = this.shape("", SCHEMA[""], doc.body, {
+			from: 0,
+			to: 0
+		});
+		this.header(doc.body);
+		const byKind = (k) => root.children.filter((b) => b.keyword === k);
+		const loads = byKind("load");
+		if (!loads.length) this.report.error({
+			from: 0,
+			to: 0
+		}, "a definition needs a load line", "load { max: 100 }");
+		for (const extra of loads.slice(1)) this.report.error(extra.at, "only one load line is allowed");
+		const params = byKind("param");
+		const lets = byKind("let");
+		const fits = byKind("fit");
+		const flows = byKind("flow");
+		const boxes = root.children.filter((b) => BOXES.includes(b.keyword) && b.args.id).map((b) => this.box(b));
+		const loose = byKind("component");
+		const formulaNames = /* @__PURE__ */ new Map();
+		const own = (kind, b, taken) => {
+			const id = b.args.id;
+			if (!id) return;
+			this.declare(kind, id.name, id, b, taken);
+		};
+		for (const b of [
+			...params,
+			...lets,
+			...fits
+		]) {
+			own(b.keyword === "param" ? "param" : b.keyword === "let" ? "let" : "fit", b, formulaNames);
+			if (b.args.id && RESERVED.has(b.args.id.name)) this.report.error(b.args.id, `"${b.args.id.name}" is a reserved name; pick another`);
+		}
+		const flowNames = /* @__PURE__ */ new Map();
+		for (const b of flows) own("flow", b, flowNames);
+		const nodeNames = /* @__PURE__ */ new Map();
+		const stageNames = /* @__PURE__ */ new Map();
+		const componentNames = /* @__PURE__ */ new Map();
+		for (const box of boxes) {
+			this.declare("node", box.id, box.block.args.id, box.block, nodeNames, box.block.keyword);
+			for (const s of box.stages) this.declare("stage", s.id, s.block.args.id ?? s.block.at, s.block, stageNames, box.id);
+			if (box.component) {
+				const c = box.component;
+				this.declare("component", c.id, c.own ? box.block.args.id : c.block.args.id ?? c.block.at, c.block, componentNames);
+			}
+		}
+		for (const b of loose) if (!b.args.id) this.report.error(b.at, "a component outside a box needs an id: component cache \"Cache\"");
+		else own("component", b, componentNames);
+		const paramTypes = /* @__PURE__ */ new Map([["load", "number"]]);
+		for (const b of params) if (b.args.id) paramTypes.set(b.args.id.name, this.paramType(b));
+		for (const f of fits) this.fit(f);
+		this.names = {
+			params: paramTypes,
+			lets: this.lets,
+			flows: new Set(flowNames.keys()),
+			components: new Set(componentNames.keys()),
+			fits: this.fits,
+			functions: this.functions
+		};
+		for (const b of lets) if (b.args.id) this.lets.set(b.args.id.name, "any");
+		for (let changed = true, pass = 0; changed && pass <= lets.length; pass++) {
+			changed = false;
+			for (const b of lets) {
+				if (!b.args.id || !b.decl?.init) continue;
+				const type = compileFormula(b.decl.init, this.names, "ctx", new Reporter(this.source)).type;
+				if (type !== this.lets.get(b.args.id.name)) changed = true;
+				this.lets.set(b.args.id.name, type);
+			}
+		}
+		const stageOf = /* @__PURE__ */ new Map();
+		for (const box of boxes) for (const s of box.stages) stageOf.set(s.id, {
+			block: s.block,
+			box
+		});
+		const boxById = new Map(boxes.map((b) => [b.id, b]));
+		const load = loads[0] && this.load(loads[0]);
+		const paramDefs = {};
+		for (const b of params) if (b.args.id) paramDefs[b.args.id.name] = this.param(b);
+		const presets = {};
+		for (const b of byKind("preset")) {
+			const label = this.text(b.args.label);
+			if (label != null) presets[label] = this.preset(b, params);
+		}
+		const scenarios = {};
+		for (const b of byKind("scenario")) {
+			const label = this.text(b.args.label);
+			if (label == null) continue;
+			if (Object.hasOwn(scenarios, label)) this.report.error(b.args.label, `scenario "${label}" is declared twice`);
+			else scenarios[label] = this.preset(b, params, "scenario");
+			this.symbols.push({
+				kind: "scenario",
+				id: label,
+				span: b.args.label,
+				decl: b.decl ?? b.at
+			});
+		}
+		const expects = [];
+		for (const b of byKind("expect")) {
+			const e = this.expectation(b, scenarios, componentNames);
+			if (!e) continue;
+			expects.push(e);
+			this.expectSpans.push({
+				from: b.at.from,
+				to: b.args.label?.to ?? b.at.to
+			});
+		}
+		const story = [];
+		for (const b of byKind("step")) {
+			const st = this.step(b, scenarios, componentNames, params, load);
+			if (st) story.push(st);
+		}
+		const growths = byKind("growth");
+		for (const extra of growths.slice(1)) this.report.error(extra.at, "only one growth line is allowed");
+		const growth = growths[0] && this.growth(growths[0]);
+		const derived = {};
+		for (const b of lets) if (b.args.id && b.decl?.init) derived[b.args.id.name] = placed(b.decl.init, this.formula(b.decl.init, "ctx").run);
+		const resolveStage = (n, what) => {
+			if (stageOf.has(n.name)) return n.name;
+			const box = boxById.get(n.name);
+			if (box?.stages.length === 1) return box.stages[0].id;
+			if (box) this.report.error(n, box.stages.length ? `"${n.name}" holds ${box.stages.length} stages; name one: ${box.stages.map((s) => s.id).join(", ")}` : `the box "${n.name}" runs no stage`);
+			else this.report.error(n, `unknown ${what} "${n.name}"`, didYouMean(n.name, [...stageOf.keys(), ...boxById.keys()]));
+		};
+		const flowDefs = {};
+		const flowViews = {};
+		const routes = {};
+		const reached = /* @__PURE__ */ new Set();
+		for (const b of flows) {
+			const id = b.args.id;
+			if (!id) continue;
+			const label = this.text(b.args.label);
+			const def = {};
+			if (label != null) def.label = label;
+			const unit = this.constProp(b, "unit");
+			if (unit != null) def.unit = unit;
+			def.rate = this.dynProp(b, "rate", "number");
+			const priority = this.constProp(b, "priority");
+			if (priority != null) def.priority = priority;
+			const overload = this.overload(b);
+			if (overload) def.overload = overload;
+			flowDefs[id.name] = def;
+			const route = this.prop(b, "route");
+			const stages = [];
+			for (const [i, n] of (route?.chain ?? (route?.value.t === "id" ? [route.value] : [])).entries()) {
+				const s = resolveStage(n, "stage");
+				if (!s) continue;
+				if (stageOf.get(s).block.keyword === "fanout" && i < (route?.chain?.length ?? 1) - 1) this.report.error(n, `the fan-out "${s}" must be the last stage of the route`);
+				stages.push(s);
+				reached.add(s);
+			}
+			if (route && route.value.t !== "id") this.report.error(route.value, "a route is a list of stages: a -> b -> c");
+			routes[id.name] = stages;
+			const from = this.prop(b, "from");
+			const view = {
+				from: "",
+				color: "accent"
+			};
+			if (from) {
+				if (from.value.t === "id" && boxById.has(from.value.name)) view.from = from.value.name;
+				else this.report.error(from.value, `unknown node "${this.slice(from.value)}"`, didYouMean(this.slice(from.value), boxById.keys()));
+			}
+			const color = this.prop(b, "color");
+			if (color) view.color = this.color(color.value);
+			if (label != null) view.label = label;
+			flowViews[id.name] = view;
+		}
+		const componentDefs = {};
+		for (const box of boxes) if (box.component) componentDefs[box.component.id] = this.component(box.component.block, box.block);
+		for (const b of loose) if (b.args.id) componentDefs[b.args.id.name] = this.component(b);
+		const stageDefs = {};
+		for (const box of boxes) for (const s of box.stages) {
+			const def = this.stage(s.block, box, componentNames, resolveStage, flowNames, reached);
+			if (def) stageDefs[s.id] = def;
+		}
+		for (const [id, s] of stageOf) if (!reached.has(id) && s.block.keyword !== "fanout") this.report.warning(s.block.args.id ?? s.block.at, `no flow passes the stage "${id}"`);
+		const calibration = {};
+		for (const f of fits) {
+			const fit = f.args.id && this.fits.get(f.args.id.name);
+			if (fit) calibration[this.text(f.args.label) ?? f.args.id.name] = fit;
+		}
+		const model = {
+			load,
+			params: paramDefs,
+			flows: flowDefs,
+			components: componentDefs,
+			stages: stageDefs,
+			routes
+		};
+		const title = this.constProp(root, "title");
+		if (title != null) model.title = title;
+		if (Object.keys(presets).length) model.presets = presets;
+		if (Object.keys(scenarios).length) model.scenarios = scenarios;
+		if (growth) model.growth = growth;
+		if (expects.length) model.expect = expects;
+		if (story.length) model.story = story;
+		if (Object.keys(derived).length) model.derived = derived;
+		if (Object.keys(calibration).length) model.calibration = calibration;
+		const th = byKind("thresholds")[0];
+		if (th) {
+			const t = {};
+			for (const k of ["target", "full"]) {
+				const v = this.constProp(th, k);
+				if (v != null) t[k] = v;
+			}
+			model.thresholds = t;
+		}
+		const searchMax = this.constProp(root, "searchMax");
+		if (searchMax != null) model.searchMax = searchMax;
+		const nodes = {};
+		for (const box of boxes) nodes[box.id] = this.node(box);
+		const edges = [];
+		for (const e of root.edges) edges.push(...this.edges(e, boxById));
+		if (!flows.length) this.report.error({
+			from: 0,
+			to: 0
+		}, "a definition needs at least one flow");
+		const options = { assumptions: [] };
+		const speed = this.constProp(root, "speed");
+		if (speed != null) options.speed = speed;
+		const layout = this.prop(root, "layout");
+		if (layout) options.direction = this.enumValue(layout, SCHEMA[""].props.layout) === "down" ? "DOWN" : "RIGHT";
+		for (const a of root.props.get("assume") ?? []) {
+			const v = this.constant(a.value, "string");
+			if (typeof v === "string") options.assumptions.push(v);
+		}
+		if (this.report.failed) return void 0;
+		return this.build(model, {
+			nodes,
+			edges,
+			flows: flowViews
+		}, options, byKind("preset"), byKind("scenario"));
+	}
+	/** Hands the parts to core and layout, then runs the model once per preset and scenario so formula errors show now. */
+	build(modelDef, viewDef, options, presets, scenarios) {
+		const top = {
+			from: 0,
+			to: 0
+		};
+		let model;
+		let view;
+		try {
+			model = defineModel(modelDef);
+			view = defineView(model, viewDef);
+		} catch (err) {
+			this.report.error(top, err instanceof Error ? err.message.replace(/^loadmap: /, "") : String(err));
+			return;
+		}
+		const runs = [{
+			values: {},
+			at: top
+		}];
+		for (const b of presets) {
+			const label = this.text(b.args.label);
+			const v = label != null && modelDef.presets?.[label];
+			if (v) runs.push({
+				values: v,
+				at: b.at
+			});
+		}
+		for (const b of scenarios) {
+			const label = this.text(b.args.label);
+			const v = label != null && model.scenarios.find((s) => s.label === label)?.values;
+			if (v) runs.push({
+				values: v,
+				at: b.at
+			});
+		}
+		for (const { values, at } of runs) try {
+			const ev = model.evaluate(values);
+			labelsAt(view, ev);
+			for (const k of Object.keys(modelDef.derived ?? {})) ev.ctx.derived[k];
+			for (const n of Object.values(viewDef.nodes)) {
+				if (n.kind === "cluster") {
+					const members = typeof n.members === "function" ? n.members(ev.ctx) : n.members;
+					n.memberLabel?.(Math.max(0, members - 1));
+				}
+				if (n.kind === "pool") n.podLabel?.(0);
+			}
+			for (const e of viewDef.edges) e.when?.(ev.ctx);
+			for (const f of model.flowIds) if (!Number.isFinite(ev.flows[f])) this.report.warning(this.flowRate.get(f) ?? at, `the rate of "${f}" is ${ev.flows[f]} here`);
+		} catch (err) {
+			if (err instanceof FormulaError) this.report.error(err.span, err.message);
+			else this.report.error(at, err instanceof Error ? err.message.replace(/^loadmap: /, "") : String(err));
+		}
+		if (this.report.failed) return void 0;
+		return {
+			model,
+			view,
+			options
+		};
+	}
+	flowRate = /* @__PURE__ */ new Map();
+	shape(keyword, spec, stmts, at, decl) {
+		const b = {
+			keyword,
+			spec,
+			at,
+			decl,
+			args: {},
+			props: /* @__PURE__ */ new Map(),
+			children: [],
+			edges: [],
+			rows: []
+		};
+		if (decl) this.args(b, decl);
+		const here = keyword ? `in ${keyword}` : "at the top";
+		for (const s of stmts) if (s.kind === "prop") {
+			const k = s.key.name;
+			if (!spec.open && !own(spec.props, k)) {
+				const hint = spec.children.includes(k) ? `write it as a block: ${k} { … }` : didYouMean(k, [...Object.keys(spec.props), ...spec.children]);
+				this.report.error(s.key, `unknown property "${k}" ${here}`, hint);
+				continue;
+			}
+			const list = b.props.get(k) ?? [];
+			if (list.length && !(own(spec.props, k)?.repeat ?? false)) this.report.error(s.key, `"${k}" is set twice ${here}`, "remove one of them");
+			list.push(s);
+			b.props.set(k, list);
+		} else if (s.kind === "decl") {
+			const k = s.keyword.name;
+			const childSpec = own(SCHEMA, k);
+			if (!spec.children.includes(k) || !childSpec || k === "") {
+				if (own(spec.props, k)) this.report.error(s.keyword, `"${k}" is a property: write "${k}: …"`);
+				else if (childSpec) this.report.error(s.keyword, `"${k}" cannot go ${here}`, where(k));
+				else this.report.error(s.keyword, `unknown statement "${k}" ${here}`, didYouMean(k, [...spec.children, ...Object.keys(spec.props)]));
+				continue;
+			}
+			b.children.push(this.shape(k, childSpec, s.body ?? [], s.keyword, s));
+		} else if (s.kind === "edge") {
+			if (!spec.edges) this.report.error(s.chain[0], `an "a -> b" line cannot go ${here}`);
+			else b.edges.push(s);
+		} else if (!spec.rows) this.report.error(s, `a row of numbers can only go in "points"`);
+		else b.rows.push(s);
+		if (decl) {
+			for (const [k, p] of Object.entries(spec.props)) if (p.required && !b.props.has(k)) this.report.error(at, `"${keyword}" needs "${k}: …"`, p.doc);
+		}
+		return b;
+	}
+	args(b, d) {
+		const slots = [...b.spec.args];
+		for (const a of d.args) {
+			const kind = a.t === "id" ? "id" : a.t === "str" || a.t === "tpl" ? "text" : a.t === "num" ? "number" : null;
+			const i = slots.findIndex((s) => s.kind === kind);
+			if (kind == null || i < 0 || slots.slice(0, i).some((s) => !s.optional)) {
+				this.report.error(a, `unexpected ${this.slice(a)} after "${b.keyword}"`, usage(b.keyword));
+				continue;
+			}
+			const slot = slots[i];
+			slots.splice(0, i + 1);
+			if (a.t === "tpl" && !slot.dynamic && !a.parts.length) {
+				b.args[slot.name] = {
+					t: "str",
+					value: a.quasis[0],
+					from: a.from,
+					to: a.to
+				};
+				continue;
+			}
+			if (a.t === "tpl" && !slot.dynamic) this.report.error(a, `the ${slot.name} of "${b.keyword}" must be a plain text`);
+			if (a.t === "id") b.args[slot.name] = {
+				name: a.name,
+				from: a.from,
+				to: a.to
+			};
+			else b.args[slot.name] = a;
+		}
+		const missing = slots.find((s) => !s.optional);
+		if (missing) this.report.error(b.at, `"${b.keyword}" needs its ${missing.name}`, usage(b.keyword));
+		if (b.spec.init && !d.init) this.report.error(b.at, `"${b.keyword}" needs "= formula"`, usage(b.keyword));
+		if (!b.spec.init && d.init) this.report.error(d.init, `"${b.keyword}" takes no "="`);
+	}
+	header(body) {
+		const first = body[0];
+		const isHeader = (s) => s?.kind === "decl" && s.keyword.name === "loadmap";
+		if (!isHeader(first)) {
+			this.report.error(first ?? {
+				from: 0,
+				to: 0
+			}, `a definition starts with "loadmap 1"`, `add "loadmap 1" as the first line`);
+			throw new Bail();
+		}
+		for (const s of body.slice(1)) if (isHeader(s)) this.report.error(s.keyword, "the \"loadmap\" line must be the first and only one");
+		const v = first.args[0];
+		if (v?.t === "num" && v.value !== 1) {
+			this.report.error(v, v.value > 1 ? `this definition is written in language version ${v.value}; this loadmap reads version 1` : `there is no language version ${v.value}; the first is 1`, v.value > 1 ? "update @loadmap/dsl" : void 0);
+			throw new Bail();
+		}
+	}
+	declare(kind, id, span, b, taken, detail) {
+		if (FORBIDDEN.has(id)) this.report.error(span, `"${id}" cannot be used as a name`);
+		if (taken.has(id)) this.report.error(span, `"${id}" is declared twice`, "rename one of them");
+		else taken.set(id, span);
+		this.symbols.push({
+			kind,
+			id,
+			span,
+			decl: b.decl ?? b.at,
+			detail
+		});
+	}
+	box(b) {
+		const id = b.args.id.name;
+		const stageBlocks = b.children.filter((c) => STAGES.includes(c.keyword));
+		const stages = stageBlocks.map((s) => ({
+			block: s,
+			id: s.args.id?.name ?? id
+		}));
+		const ownLines = Object.keys(COMPONENT_PROPS).some((k) => b.props.has(k));
+		const nested = b.children.filter((c) => c.keyword === "component");
+		let component;
+		if (ownLines) component = {
+			block: b,
+			id,
+			own: true
+		};
+		for (const n of nested) if (component) this.report.error(n.at, `"${id}" already has a component`, "one component per box; put others at the top");
+		else component = {
+			block: n,
+			id: n.args.id?.name ?? id,
+			own: false
+		};
+		if (b.keyword === "node" && stages.length > 1) this.report.error(stageBlocks[1].at, "a node runs at most one stage; a cluster can hold several queues");
+		if (b.keyword === "cluster" && !stages.length) this.report.error(b.at, "a cluster needs a queue", "queue topic { partitions { orders: 12 } }");
+		if (b.keyword === "pool" && stages.length !== 1) this.report.error(b.at, "a pool needs exactly one workers stage", "workers { pods: 3; perPod: 8 }");
+		const ids = /* @__PURE__ */ new Set();
+		for (const s of stages) {
+			if (ids.has(s.id)) this.report.error(s.block.at, `"${id}" has two stages called "${s.id}"`, "give each an id");
+			ids.add(s.id);
+		}
+		return {
+			block: b,
+			id,
+			stages,
+			component
+		};
+	}
+	slice(s) {
+		return this.source.slice(s.from, s.to);
+	}
+	prop(b, key) {
+		return b.props.get(key)?.[0];
+	}
+	formula(e, scope, want) {
+		const f = compileFormula(e, this.names, scope, this.report);
+		if (want && want !== "any" && f.type !== want && f.type !== "any") {
+			if (want === "string" && f.type === "number") {
+				const run = f.run;
+				return {
+					...f,
+					type: "string",
+					run: (c, l) => String(run(c, l))
+				};
+			}
+			if (want === "capacity" && f.type === "number") this.report.error(e, "a capacity says where it came from", `write measured(${this.slice(e)}, "unit", "source") or estimated(…)`);
+			else this.report.error(e, `expected ${typeWord(want)}, this is ${typeWord(f.type)}`);
+		}
+		return f;
+	}
+	/** A value that must not depend on the model. */
+	constant(e, want) {
+		const f = this.formula(e, "const", want);
+		try {
+			return f.run(void 0);
+		} catch (err) {
+			this.report.error(e, err instanceof Error ? err.message : String(err));
+			return;
+		}
+	}
+	constProp(b, key) {
+		const p = this.prop(b, key);
+		if (!p) return void 0;
+		const spec = b.spec.props[key];
+		if (spec.value === "enum") return this.enumValue(p, spec);
+		return this.constant(p.value, spec.value);
+	}
+	/**
+	* A plain or computed value: a constant is computed now, so the model sees it as it would from TypeScript. `check`
+	* throws on a value the drawing cannot take (a count too large); at run time its error carries the formula's place.
+	*/
+	dyn(e, want, scope = "ctx", check) {
+		const f = this.formula(e, scope, want);
+		if (f.constant) {
+			const v = this.constant(e, want);
+			try {
+				if (v !== void 0) check?.(v);
+			} catch (err) {
+				this.report.error(e, err.message);
+			}
+			return v;
+		}
+		const run = f.run;
+		if (!check) return placed(e, run);
+		return placed(e, (c, l) => {
+			const v = run(c, l);
+			check(v);
+			return v;
+		});
+	}
+	dynProp(b, key, want, check) {
+		const p = this.prop(b, key);
+		if (!p) return void 0;
+		if (key === "rate" && b.args.id) this.flowRate.set(b.args.id.name, p.value);
+		return this.dyn(p.value, want, own(b.spec.props, key)?.scope ?? "ctx", check);
+	}
+	/** A label or name argument: a plain text, or a template when the argument may be computed. */
+	text(e) {
+		if (!e) return void 0;
+		const v = this.constant(e, "string");
+		return typeof v === "string" ? v : void 0;
+	}
+	label(e) {
+		if (!e) return void 0;
+		return this.dyn(e, "string");
+	}
+	enumValue(p, spec) {
+		const raw = p.value.t === "str" ? p.value.value : this.slice(p.value).replace(/\s+/g, "");
+		if (spec.values?.includes(raw)) return raw;
+		this.report.error(p.value, `"${raw}" is not one of ${spec.values.join(", ")}`, didYouMean(raw, spec.values ?? []));
+	}
+	color(e) {
+		if (e.t === "id") {
+			if (COLORS.includes(e.name)) return e.name;
+			this.report.error(e, `"${e.name}" is not a theme colour`, didYouMean(e.name, COLORS) ?? "or quote a CSS colour");
+		} else if (e.t === "str") {
+			if (CSS_COLOR.test(e.value.trim())) return e.value.trim();
+			this.report.error(e, `"${e.value}" is not a colour`, "use #rrggbb, rgb(…), hsl(…) or a theme colour");
+		} else this.report.error(e, "a colour is a theme colour or a CSS colour in quotes");
+		return "accent";
+	}
+	count(what) {
+		const max = LIMITS[what];
+		return (v) => {
+			if (typeof v !== "number" || !Number.isInteger(v) || v < 0) throw new Error(`${what} must be a whole number of at least 0, not ${String(v)}`);
+			if (v > max) throw new Error(`${what} is ${v}; at most ${max}`);
+		};
+	}
+	load(b) {
+		const o = {};
+		const label = this.text(b.args.label);
+		if (label != null) o.label = label;
+		for (const k of [
+			"min",
+			"max",
+			"step",
+			"default"
+		]) {
+			const v = this.constProp(b, k);
+			if (v != null) o[k] = v;
+		}
+		if (typeof o.max !== "number") o.max = 1;
+		return p.load(o);
+	}
+	paramType(b) {
+		const options = this.prop(b, "options");
+		if (options?.value.t === "array") return options.value.items[0]?.t === "str" ? "string" : "number";
+		if (b.props.has("min") || b.props.has("max")) return "number";
+		const d = this.prop(b, "default")?.value;
+		return d?.t === "bool" ? "boolean" : d?.t === "str" ? "string" : d?.t === "num" ? "number" : "any";
+	}
+	param(b) {
+		const o = { label: this.text(b.args.label) ?? b.args.id.name };
+		for (const k of ["hint", "tag"]) {
+			const v = this.constProp(b, k);
+			if (v != null) o[k] = v;
+		}
+		const enabled = this.prop(b, "enabled");
+		if (enabled) o.enabled = placed(enabled.value, this.formula(enabled.value, "values").run);
+		const format = this.prop(b, "format");
+		if (format) {
+			const run = placed(format.value, this.formula(format.value, "value", "string").run);
+			o.format = (v) => run(void 0, v);
+		}
+		const dflt = this.prop(b, "default");
+		if (!dflt) return void 0;
+		const value = this.constant(dflt.value, "any");
+		const options = this.prop(b, "options");
+		if (options) {
+			for (const k of [
+				"min",
+				"max",
+				"step"
+			]) if (b.props.has(k)) this.report.error(this.prop(b, k).key, `"${k}" is for a slider; this param has options`);
+			const list = this.options(options);
+			if (!list) return void 0;
+			if (!list.includes(value)) {
+				this.report.error(dflt.value, `the default ${this.slice(dflt.value)} is not one of the options`, list.join(", "));
+				return;
+			}
+			return p.select({
+				...o,
+				options: list,
+				default: value
+			});
+		}
+		if (b.props.has("min") || b.props.has("max")) {
+			for (const k of ["min", "max"]) if (!b.props.has(k)) this.report.error(b.at, `a slider needs "${k}: …"`);
+			const r = { ...o };
+			for (const k of [
+				"min",
+				"max",
+				"step"
+			]) {
+				const v = this.constProp(b, k);
+				if (v != null) r[k] = v;
+			}
+			if (typeof value !== "number") this.report.error(dflt.value, "the default of a slider is a number");
+			return p.range({
+				...r,
+				default: value
+			});
+		}
+		if (typeof value === "boolean") return p.switch({
+			...o,
+			default: value
+		});
+		this.report.error(b.at, `"${b.args.id.name}" is neither a select, a slider nor a switch`, "give it options: [...], min and max, or a default of true or false");
+	}
+	options(prop) {
+		if (prop.value.t !== "array" || !prop.value.items.length) {
+			this.report.error(prop.value, "options are a list: [2, 3, 4] or [\"a\", \"b\"]");
+			return;
+		}
+		const list = prop.value.items.map((e) => this.constant(e, "any"));
+		const kind = typeof list[0];
+		if (!list.every((v) => (typeof v === "number" || typeof v === "string") && typeof v === kind)) {
+			this.report.error(prop.value, "options are all numbers or all texts");
+			return;
+		}
+		return list;
+	}
+	/** A preset's values, or a scenario's: the same, but a scenario leaves the load to the slider. */
+	preset(b, params, kind = "preset") {
+		const out = {};
+		const known = new Map(params.filter((x) => x.args.id).map((x) => [x.args.id.name, x]));
+		for (const [k, props] of b.props) {
+			if (own(b.spec.props, k)) continue;
+			const prop = props[0];
+			const v = this.constant(prop.value, "any");
+			if (k === "load" && kind === "scenario") {
+				this.report.error(prop.key, "a scenario leaves the load to the slider", "use a preset for a load");
+				continue;
+			}
+			if (k !== "load" && !known.has(k)) {
+				const names = [...kind === "preset" ? ["load"] : [], ...known.keys()];
+				this.report.error(prop.key, `unknown parameter "${k}"`, didYouMean(k, names));
+				continue;
+			}
+			const type = this.names.params.get(k);
+			if (type && type !== "any" && typeof v !== type) {
+				this.report.error(prop.value, `"${k}" takes ${typeWord(type)}`);
+				continue;
+			}
+			const opts = known.get(k) && this.prop(known.get(k), "options");
+			if (opts?.value.t === "array") {
+				const list = opts.value.items.map((e) => e.t === "num" || e.t === "str" ? e.value : void 0);
+				if (!list.includes(v)) this.report.error(prop.value, `${String(v)} is not an option of "${k}"`, list.join(", "));
+			}
+			out[k] = v;
+		}
+		return out;
+	}
+	/** An `expect` line as the model takes it: names checked here, so a mistake points at its word. */
+	expectation(b, scenarios, components) {
+		const e = {};
+		const label = this.text(b.args.label);
+		if (label != null) e.label = label;
+		const scenario = this.named(b, "scenario", Object.keys(scenarios), "scenario");
+		const component = this.named(b, "component", [...components.keys()], "component");
+		if (scenario === null || component === null) return void 0;
+		if (scenario != null) e.scenario = scenario;
+		if (component != null) e.component = component;
+		for (const k of ["target", "full"]) {
+			const v = this.constProp(b, k);
+			if (v == null) continue;
+			if (!(v > 0 && Number.isFinite(v))) this.report.error(this.prop(b, k).value, `${k} is a load multiple above 0`);
+			else e[k] = v;
+		}
+		if (!b.props.has("target") && !b.props.has("full")) {
+			this.report.error(b.at, "an expect needs a target or a full multiple", "expect { target: 8 }");
+			return;
+		}
+		return e.target != null || e.full != null ? e : void 0;
+	}
+	/** A property naming a scenario or a component: undefined when absent, null when wrong (reported). */
+	named(b, key, known, what) {
+		const p = this.prop(b, key);
+		if (!p) return void 0;
+		const v = p.value.t === "id" ? p.value.name : p.value.t === "str" ? p.value.value : void 0;
+		if (v == null) this.report.error(p.value, `${key} is the name of a ${what}`);
+		else if (!known.includes(v)) this.report.error(p.value, `unknown ${what} "${v}"`, didYouMean(v, known));
+		else return v;
+		return null;
+	}
+	/** A story step as the model takes it. */
+	step(b, scenarios, components, params, load) {
+		const text = this.text(b.args.label);
+		for (const k of Object.keys(b.spec.props)) {
+			const at = b.props.get(k)?.[0];
+			if (at && params.some((x) => x.args.id?.name === k)) this.report.error(at.key, `"${k}" in a step is the step's own ${k}, not the parameter "${k}"`, "rename the parameter to set it in a step");
+		}
+		const scenario = this.named(b, "scenario", Object.keys(scenarios), "scenario");
+		const focus = this.named(b, "focus", [...components.keys()], "component");
+		const seconds = this.constProp(b, "seconds");
+		if (seconds != null && !(seconds > 0 && Number.isFinite(seconds))) this.report.error(this.prop(b, "seconds").value, "seconds is a duration above 0");
+		const set = this.preset(b, params);
+		const l = this.prop(b, "load");
+		if (l && load && typeof set.load === "number" && !(set.load >= load.min && set.load <= load.max)) this.report.error(l.value, `the load goes from ${load.min} to ${load.max}`);
+		if (text == null || scenario === null || focus === null) return void 0;
+		return {
+			text,
+			...scenario != null ? { scenario } : {},
+			...focus != null ? { focus } : {},
+			...seconds != null && seconds > 0 ? { seconds } : {},
+			...Object.keys(set).length ? { set } : {}
+		};
+	}
+	growth(b) {
+		const rate = this.constProp(b, "rate");
+		const per = this.constProp(b, "per");
+		const asOf = this.constProp(b, "asOf");
+		if (rate != null && !(rate > 0)) this.report.error(this.prop(b, "rate").value, "growth needs a rate above 0");
+		if (asOf != null && !parseAsOf(asOf)) this.report.error(this.prop(b, "asOf").value, `"${asOf}" is not a date`, "a day like \"2026-11-01\"");
+		if (rate == null || per == null || asOf == null) return void 0;
+		return {
+			rate,
+			per,
+			asOf
+		};
+	}
+	fit(b) {
+		const id = b.args.id;
+		if (!id) return;
+		this.fits.set(id.name, null);
+		const pts = b.children.filter((c) => c.keyword === "points");
+		if (pts.length !== 1) {
+			this.report.error(b.at, pts.length ? "a fit has one points block" : "a fit needs its points", usage("points"));
+			return;
+		}
+		const block = pts[0];
+		const { x, y } = block.args;
+		if (!x || !y) return;
+		if (x.name === y.name) this.report.error(y, "x and y need different names");
+		const points = [];
+		for (const r of block.rows) {
+			if (r.values.length !== 2) {
+				this.report.error(r, `a row is two numbers: ${x.name} and ${y.name}`);
+				continue;
+			}
+			const [a, c] = r.values.map((v) => this.constant(v, "number"));
+			points.push({
+				[x.name]: a,
+				[y.name]: c
+			});
+		}
+		const source = this.constProp(b, "source");
+		const through = this.constProp(b, "through");
+		try {
+			const o = {
+				x: x.name,
+				y: y.name
+			};
+			if (source != null) o.source = source;
+			if (through) o.through = through;
+			this.fits.set(id.name, fitLinear(points, o));
+		} catch (err) {
+			this.report.error(block.at, err.message.replace(/^loadmap: /, ""));
+		}
+	}
+	overload(b) {
+		const rules = b.children.filter((c) => c.keyword === "drop" || c.keyword === "merge");
+		if (!rules.length) return void 0;
+		const seen = /* @__PURE__ */ new Set();
+		const parts = [];
+		for (const r of rules) {
+			const key = r.keyword;
+			if (seen.has(key)) this.report.error(r.at, `"${key}" is set twice in this flow`);
+			seen.add(key);
+			const fields = [];
+			const first = key === "drop" ? "olderThan" : "share";
+			for (const k of [first, "reason"]) {
+				const v = this.dynProp(r, k, k === "reason" ? "string" : "number");
+				if (v !== void 0) fields.push([k, v]);
+			}
+			const when = this.prop(r, "when");
+			parts.push({
+				key,
+				fields,
+				when: when && placed(when.value, this.formula(when.value, "ctx").run)
+			});
+		}
+		const fixed = parts.every((x) => !x.when && x.fields.every(([, v]) => typeof v !== "function"));
+		const at = (ctx) => {
+			const o = {};
+			for (const x of parts) {
+				if (x.when && !x.when(ctx)) continue;
+				const rule = {};
+				for (const [k, v] of x.fields) rule[k] = typeof v === "function" ? v(ctx) : v;
+				o[x.key] = rule;
+			}
+			return o;
+		};
+		return fixed ? at(void 0) : at;
+	}
+	component(b, box) {
+		const o = {};
+		const name = this.constProp(b, "name") ?? this.text(b.args.label) ?? this.text(box?.args.label);
+		if (name == null) {
+			const label = box?.args.label ?? b.args.label;
+			if (label) this.report.error(label, "a computed label cannot name the component", "add name: \"…\"");
+		}
+		o.name = name ?? (b.args.id ?? box?.args.id)?.name;
+		for (const k of ["short", "plural"]) {
+			const v = this.constProp(b, k);
+			if (v != null) o[k] = v;
+		}
+		for (const [k, want] of [
+			["demand", "number"],
+			["capacity", "capacity"],
+			["when", "any"],
+			["over", "string"],
+			["describe", "string"]
+		]) {
+			const prop = this.prop(b, k);
+			if (!prop) continue;
+			const check = k === "capacity" ? (v) => {
+				if (!isCapacity(v)) throw new Error("a capacity comes from measured(…) or estimated(…)");
+			} : void 0;
+			o[k] = this.dyn(prop.value, want, "ctx", check);
+		}
+		const at = box ? box.args.id ?? box.at : b.at;
+		for (const k of [
+			"demand",
+			"capacity",
+			"over"
+		]) if (!(k in o)) this.report.error(at, `the component needs "${k}: …"`, COMPONENT_PROPS[k].doc);
+		return o;
+	}
+	stage(b, box, components, resolve, flows, reached) {
+		const label = this.text(b.args.label);
+		const base = label != null ? { label } : {};
+		let component = box.component?.id;
+		const named = this.prop(b, "component");
+		if (named) {
+			const n = named.value;
+			if (n.t === "id" && components.has(n.name)) component = n.name;
+			else this.report.error(n, `unknown component "${this.slice(n)}"`, didYouMean(this.slice(n), components.keys()));
+		}
+		const needs = () => {
+			this.report.error(b.at, `a ${b.keyword} stage needs a component`, "give the box demand and capacity lines, or name one: component: db");
+		};
+		switch (b.keyword) {
+			case "pass": return component ? pass(component, base) : needs();
+			case "store": return component ? store(component, base) : needs();
+			case "sink": return sink(base);
+			case "workers": {
+				if (!component) return needs();
+				const pods = this.dynProp(b, "pods", "number", this.count("pods"));
+				const perPod = this.dynProp(b, "perPod", "number", this.count("perPod"));
+				const fill = this.constProp(b, "fill");
+				return workers(component, {
+					...base,
+					pods: pods ?? 0,
+					perPod: perPod ?? 0,
+					...fill ? { fill } : {}
+				});
+			}
+			case "queue": {
+				const block = b.children.find((c) => c.keyword === "partitions");
+				if (!block) {
+					this.report.error(b.at, "a queue needs its partitions", "partitions { orders: 12 }");
+					return;
+				}
+				const entries = [];
+				for (const [f, props] of block.props) {
+					const prop = props[0];
+					if (!flows.has(f)) {
+						this.report.error(prop.key, `unknown flow "${f}"`, didYouMean(f, flows.keys()));
+						continue;
+					}
+					entries.push([f, this.dyn(prop.value, "number", "ctx", this.count("partitions"))]);
+				}
+				const fixed = entries.every(([, v]) => typeof v === "number");
+				const at = (ctx) => Object.fromEntries(entries.map(([k, v]) => [k, typeof v === "function" ? v(ctx) : v]));
+				const partitions = fixed ? at(void 0) : at;
+				return queue({
+					...base,
+					partitions,
+					...component ? { component } : {}
+				});
+			}
+			case "fanout": {
+				const branches = [];
+				for (const e of b.edges) {
+					if (e.chain.length !== 2) {
+						this.report.error(e, "a branch is one \"flow -> stage: copies\" line");
+						continue;
+					}
+					const [f, s] = e.chain;
+					if (!flows.has(f.name)) this.report.error(f, `unknown flow "${f.name}"`, didYouMean(f.name, flows.keys()));
+					const stage = resolve(s, "stage");
+					if (stage) reached.add(stage);
+					if (!e.value) this.report.error(e, "how many copies per unit?", `${f.name} -> ${s.name}: 1`);
+					if (e.body) this.report.error(e.bodySpan ?? e, "a branch has no block");
+					if (stage && e.value && flows.has(f.name)) branches.push([
+						f.name,
+						stage,
+						this.dyn(e.value, "number")
+					]);
+				}
+				const build = (ctx) => {
+					const to = {};
+					for (const [f, stage, share] of branches) {
+						const list = to[f] ?? [];
+						list.push({
+							stage,
+							share: typeof share === "function" ? share(ctx) : share
+						});
+						to[f] = list;
+					}
+					return to;
+				};
+				const fixed = branches.every(([, , v]) => typeof v === "number");
+				return fanout({
+					...base,
+					to: fixed ? build(void 0) : build,
+					...component ? { component } : {}
+				});
+			}
+		}
+	}
+	node(box) {
+		const b = box.block;
+		const label = this.label(b.args.label) ?? box.id;
+		const subProp = this.prop(b, "sub");
+		if (subProp && b.args.sub) this.report.error(subProp.key, "the sub-line is set twice: on the first line and here");
+		const sub = this.label(b.args.sub ?? subProp?.value);
+		const o = { label };
+		if (sub != null) o.sub = sub;
+		const indexLabel = (key) => {
+			const prop = this.prop(b, key);
+			if (!prop) return void 0;
+			const run = placed(prop.value, this.formula(prop.value, "i", "string").run);
+			return (i) => run(void 0, i);
+		};
+		const stageIds = box.stages.map((s) => s.id);
+		if (b.keyword === "cluster") {
+			o.stage = stageIds.length === 1 ? stageIds[0] : stageIds;
+			const members = this.prop(b, "members");
+			o.members = members ? this.dyn(members.value, "number", "ctx", this.count("members")) : 1;
+			const memberLabel = indexLabel("memberLabel");
+			if (memberLabel) o.memberLabel = memberLabel;
+			return {
+				kind: "cluster",
+				...o
+			};
+		}
+		if (b.keyword === "pool") {
+			o.stage = stageIds[0];
+			const podLabel = indexLabel("podLabel");
+			if (podLabel) o.podLabel = podLabel;
+			return {
+				kind: "pool",
+				...o
+			};
+		}
+		if (stageIds.length) o.stage = stageIds[0];
+		else if (box.component) o.component = box.component.id;
+		return {
+			kind: "node",
+			shape: this.constProp(b, "shape") ?? "box",
+			...o
+		};
+	}
+	edges(e, boxes) {
+		for (const n of e.chain) if (!boxes.has(n.name)) this.report.error(n, `unknown node "${n.name}"`, didYouMean(n.name, boxes.keys()));
+		const props = /* @__PURE__ */ new Map();
+		for (const s of e.body ?? []) {
+			if (s.kind !== "prop" || !own(EDGE_PROPS, s.key.name)) {
+				const at = s.kind === "prop" ? s.key : s.kind === "decl" ? s.keyword : s;
+				this.report.error(at, "an edge holds only label and when", didYouMean(this.slice(at), Object.keys(EDGE_PROPS)));
+				continue;
+			}
+			if (props.has(s.key.name)) this.report.error(s.key, `"${s.key.name}" is set twice on this edge`);
+			props.set(s.key.name, s);
+		}
+		const labelExpr = e.value ?? props.get("label")?.value;
+		if (e.value && props.has("label")) this.report.error(props.get("label").key, "the label is set twice");
+		if (labelExpr && e.chain.length > 2) this.report.error(labelExpr, "a label goes on a single edge: a -> b: \"…\"");
+		const label = this.label(labelExpr);
+		const when = props.get("when");
+		const out = [];
+		for (let i = 0; i + 1 < e.chain.length; i++) {
+			const d = {
+				from: e.chain[i].name,
+				to: e.chain[i + 1].name
+			};
+			if (label != null) d.label = label;
+			if (when) d.when = placed(when.value, this.formula(when.value, "ctx").run);
+			out.push(d);
+		}
+		return out;
+	}
+};
+const FORBIDDEN = /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(Object.prototype), "prototype"]);
+const CSS_COLOR = /^(#[0-9a-f]{3,8}|(rgb|hsl)a?\([\d\s.,%/+-]+\))$/i;
+function usage(keyword) {
+	const ex = own(SCHEMA, keyword)?.example;
+	return ex ? `e.g. ${ex.split("\n")[0]}` : void 0;
+}
+function where(keyword) {
+	const parents = Object.entries(SCHEMA).filter(([, s]) => s.children.includes(keyword)).map(([k]) => k === "" ? "the top level" : k);
+	return parents.length ? `it goes in ${parents.join(" or ")}` : void 0;
+}
+export { formatDiagnostic as C, didYouMean as S, SCHEMA as _, MAX_DEPTH as a, Reporter as b, parseExpression as c, BUILTINS as d, FormulaError as f, EDGE_PROPS as g, COMPONENT_PROPS as h, problems as i, LEXICON as l, COLORS as m, LIMITS as n, MAX_SOURCE as o, BOXES as p, compile as r, parse as s, LANGUAGE_VERSION as t, lex as u, STAGES as v, closest as x, own as y };