@loadmap/cli 0.0.0-stage → 0.1.1

package/dist/src-B81_QU8o.js

@@ -0,0 +1,4257 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, join, normalize } from "node:path";
+import { parseArgs } from "node:util";
+import { chromium } from "playwright";
+// ../core/src/capacity.ts
+/** A capacity read off a dashboard or a load test. */
+function measured(value, unit, o) {
+	return capacity(value, unit, "measured", o);
+}
+/** A capacity from a vendor's figure, a benchmark elsewhere or a guess: the verdict says so. */
+function estimated(value, unit, o) {
+	return capacity(value, unit, "estimated", o);
+}
+function capacity(value, unit, provenance, o) {
+	const { source, within } = typeof o === "string" ? {
+		source: o,
+		within: void 0
+	} : o ?? {};
+	if (within != null && !(within >= 0 && within < 1)) throw new Error(`loadmap: within is a share from 0 to below 1 (0.3 is ±30 %), not ${within}`);
+	const c = {
+		value,
+		unit,
+		provenance,
+		source
+	};
+	if (within) c.within = within;
+	return c;
+}
+/** The capacity's value at its low or high bound; the value itself without a ±. */
+function boundOf(c, bound) {
+	if (!bound || !c.within) return c.value;
+	return c.value * (bound === "low" ? 1 - c.within : 1 + c.within);
+}
+// ../core/src/format.ts
+/** A number for a reader: 1,234 / 12.3 / 0.4. */
+function fmt(n) {
+	if (!Number.isFinite(n)) return n > 0 ? "∞" : "—";
+	if (Math.abs(n) >= 1e3) return Math.round(n).toLocaleString("en-US");
+	return (Math.round(n * 10) / 10).toString();
+}
+/** A compact number: 980 / 1.2k / 34k / 1.5M. */
+function compact(n) {
+	if (!Number.isFinite(n)) return n > 0 ? "∞" : "—";
+	const a = Math.abs(n);
+	if (a >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+	if (a >= 1e4) return `${Math.round(n / 1e3)}k`;
+	if (a >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+	return Math.round(n).toString();
+}
+/** A load multiple, rounded down so it never promises more than the model: 2.6× / 53×. */
+function multiple(u, searchMax = 2e3) {
+	if (u == null) return "—";
+	if (!Number.isFinite(u)) return `beyond ${fmt(searchMax)}×`;
+	return u >= 10 ? `${Math.floor(u)}×` : `${Math.floor(u * 10) / 10}×`;
+}
+/**
+* Two load multiples: "7.4×" when both edges read the same, else "between 7.4× and 10×" or, short, "7.4×–10×". An
+* edge that never comes reads "7.4× or more" ("≥ 7.4×").
+*/
+function multiples(r, searchMax = 2e3, short = false) {
+	const [lo, hi] = [multiple(r.low, searchMax), multiple(r.high, searchMax)];
+	if (lo === hi) return lo;
+	if (!Number.isFinite(r.high)) return short ? `≥ ${lo}` : `${lo} or more`;
+	return short ? `${lo}–${hi}` : `between ${lo} and ${hi}`;
+}
+/** When two edges are reached: "(around March 2029)", "(between March 2029 and May 2030)" or "(… or later)". */
+function months(low, high) {
+	if (!low) return "";
+	if (!high) return ` (${around(low)} or later)`;
+	return monthOf(low) === monthOf(high) ? ` (${around(low)})` : ` (between ${monthOf(low)} and ${monthOf(high)})`;
+}
+/** A percentage of a 0–1 share: 50 %. */
+function pct(share) {
+	return `${Math.round(share * 100)} %`;
+}
+/** A duration in seconds for a meter: 0 s / 42 s / 3 min / > 1 h / stalled. */
+function secs(s) {
+	if (!Number.isFinite(s)) return "stalled";
+	if (s < 1) return "0 s";
+	if (s < 60) return `${Math.round(s)} s`;
+	if (s < 3600) return `${Math.round(s / 60)} min`;
+	return "> 1 h";
+}
+/** "a", "a and b", "a, b and c". */
+function joinAnd(items) {
+	if (items.length <= 1) return items[0] ?? "";
+	return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+const MONTHS = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+/** A month in UTC, "March 2028" or short "Mar 2028". Fixed names, whatever the locale. */
+function monthOf(d, short = false) {
+	const name = MONTHS[d.getUTCMonth()];
+	return `${short ? name.slice(0, 3) : name} ${d.getUTCFullYear()}`;
+}
+/** A date as a reader plans with it, by month: "around March 2028". */
+function around(d) {
+	return `around ${monthOf(d)}`;
+}
+// ../core/src/growth.ts
+const AS_OF = /^(\d{4})-(\d{2})(?:-(\d{2}))?$/;
+/** The day `asOf` names, at midnight UTC; null when it is not a real date. */
+function parseAsOf(asOf) {
+	const m = AS_OF.exec(asOf);
+	if (!m) return null;
+	const [y, mo, d] = [
+		Number(m[1]),
+		Number(m[2]),
+		Number(m[3] ?? 1)
+	];
+	const date = new Date(Date.UTC(y, mo - 1, d));
+	return date.getUTCFullYear() === y && date.getUTCMonth() === mo - 1 && date.getUTCDate() === d ? date : null;
+}
+function growth(o) {
+	if (!(o.rate > 0) || !Number.isFinite(o.rate)) throw new Error(`loadmap: growth needs a rate above 0, not ${o.rate}`);
+	if (o.per !== "month" && o.per !== "year") throw new Error(`loadmap: growth is per month or per year, not "${o.per}"`);
+	if (!parseAsOf(o.asOf)) throw new Error(`loadmap: growth asOf "${o.asOf}" is not a date like 2026-11-01`);
+	return {
+		rate: o.rate,
+		per: o.per,
+		asOf: o.asOf
+	};
+}
+/**
+* When the load reaches `multiple`: `ln(multiple) / ln(1 + rate)` periods after `asOf`. Null without a multiple or
+* when it is never reached; `asOf` itself for 1× and below.
+*/
+function dateAt(g, multiple) {
+	const start = parseAsOf(g.asOf);
+	if (!start || multiple == null || !Number.isFinite(multiple)) return null;
+	if (multiple <= 1) return start;
+	const months = Math.log(multiple) / Math.log(1 + g.rate) * (g.per === "year" ? 12 : 1);
+	const whole = Math.floor(months);
+	const y = start.getUTCFullYear();
+	const mo = start.getUTCMonth() + whole;
+	const days = new Date(Date.UTC(y, mo + 1, 0)).getUTCDate();
+	const at = Date.UTC(y, mo, Math.min(start.getUTCDate(), days));
+	return new Date(at + (months - whole) * days * 864e5);
+}
+// ../core/src/params.ts
+const p = {
+	/** The load, as a multiple of today. One per model; it drives the limits. */
+	load(o) {
+		const min = o.min ?? 1;
+		return {
+			kind: "load",
+			label: o.label ?? "Load, × today",
+			min,
+			max: o.max,
+			step: o.step ?? 1,
+			default: o.default ?? min
+		};
+	},
+	select(o) {
+		if (!o.options.includes(o.default)) throw new Error(`loadmap: "${o.label}" defaults to ${o.default}, not an option`);
+		return {
+			kind: "select",
+			...o
+		};
+	},
+	switch(o) {
+		return {
+			kind: "switch",
+			...o
+		};
+	},
+	range(o) {
+		return {
+			kind: "range",
+			step: 1,
+			...o
+		};
+	}
+};
+function isEnabled(def, values) {
+	return def.kind === "load" || !def.enabled || Boolean(def.enabled(values));
+}
+// ../core/src/stages.ts
+function pass(component, o = {}) {
+	return {
+		kind: "pass",
+		component,
+		...o
+	};
+}
+function queue(o) {
+	return {
+		kind: "queue",
+		...o
+	};
+}
+function workers(component, o) {
+	return {
+		kind: "workers",
+		component,
+		...o,
+		fill: o.fill ?? "round-robin"
+	};
+}
+function store(component, o = {}) {
+	return {
+		kind: "store",
+		component,
+		...o
+	};
+}
+function sink(o = {}) {
+	return {
+		kind: "sink",
+		...o
+	};
+}
+function fanout(o) {
+	return {
+		kind: "fanout",
+		...o
+	};
+}
+function dyn(v, ctx) {
+	return typeof v === "function" ? v(ctx) : v;
+}
+function resolveStage(id, s, ctx, flowIds) {
+	const label = s.label ?? id;
+	switch (s.kind) {
+		case "queue": return {
+			id,
+			label,
+			kind: "queue",
+			component: s.component,
+			partitions: dyn(s.partitions, ctx)
+		};
+		case "workers": return {
+			id,
+			label,
+			kind: "workers",
+			component: s.component,
+			pods: dyn(s.pods, ctx),
+			perPod: dyn(s.perPod, ctx),
+			fill: s.fill
+		};
+		case "fanout": {
+			const to = dyn(s.to, ctx);
+			const perFlow = {};
+			for (const f of flowIds) perFlow[f] = Array.isArray(to) ? to : to[f] ?? [];
+			return {
+				id,
+				label,
+				kind: "fanout",
+				component: s.component,
+				to: perFlow
+			};
+		}
+		case "sink": return {
+			id,
+			label,
+			kind: "sink"
+		};
+		default: return {
+			id,
+			label,
+			kind: s.kind,
+			component: s.component
+		};
+	}
+}
+// ../core/src/model.ts
+const RESERVED$1 = [
+	"load",
+	"flows",
+	"demand",
+	"util",
+	"derived"
+];
+function defineModel(def) {
+	const params = def.params ?? {};
+	for (const id of Object.keys(params)) if (RESERVED$1.includes(id)) throw new Error(`loadmap: "${id}" is reserved and cannot name a parameter`);
+	const flowIds = Object.keys(def.flows);
+	const componentIds = Object.keys(def.components);
+	const stageIds = Object.keys(def.stages);
+	for (const f of flowIds) {
+		const route = def.routes[f];
+		if (!route?.length) throw new Error(`loadmap: flow "${f}" has no route`);
+		route.forEach((s, i) => {
+			const st = def.stages[s];
+			if (!st) throw new Error(`loadmap: flow "${f}" routes through unknown stage "${s}"`);
+			if (st.kind === "fanout" && i < route.length - 1) throw new Error(`loadmap: fan-out "${s}" must be the last stage of the route of "${f}"`);
+		});
+	}
+	const thresholds = {
+		target: def.thresholds?.target ?? .5,
+		full: def.thresholds?.full ?? 1
+	};
+	const searchMax = def.searchMax ?? 2e3;
+	const growth$1 = def.growth && growth(def.growth);
+	const when = (x) => growth$1 && x != null && x > 1 ? dateAt(growth$1, x) : null;
+	const paramList = [{
+		id: "load",
+		def: def.load
+	}, ...Object.entries(params).map(([id, d]) => ({
+		id,
+		def: d
+	}))];
+	const defaults = () => {
+		const v = { load: def.load.default };
+		for (const [id, d] of Object.entries(params)) v[id] = d.default;
+		return v;
+	};
+	/** Throws unless every value is one its parameter (or the load, where allowed) can take. */
+	const takes = (owner, set, load) => {
+		for (const k of Object.keys(set)) {
+			const v = set[k];
+			if (k === "load") {
+				if (!load) throw new Error(`loadmap: ${owner} sets the load; a scenario leaves it to the slider`);
+				if (!(typeof v === "number" && v >= def.load.min && v <= def.load.max)) throw new Error(`loadmap: ${owner} sets the load to ${String(v)}, outside ${def.load.min} to ${def.load.max}`);
+				continue;
+			}
+			const p = Object.hasOwn(params, k) ? params[k] : void 0;
+			if (!p) throw new Error(`loadmap: ${owner} sets unknown parameter "${k}"`);
+			if (!(p.kind === "select" ? p.options.includes(v) : p.kind === "switch" ? typeof v === "boolean" : typeof v === "number" && v >= p.min && v <= p.max)) throw new Error(`loadmap: ${owner} sets "${k}" to ${String(v)}, which it cannot take`);
+		}
+	};
+	const scenarios = Object.entries(def.scenarios ?? {}).map(([label, set]) => {
+		takes(`scenario "${label}"`, set, false);
+		const { load: _, ...values } = {
+			...defaults(),
+			...set
+		};
+		return {
+			label,
+			values
+		};
+	});
+	const scenarioOf = (values) => scenarios.find((s) => Object.entries(s.values).every(([k, v]) => values[k] === v)) ?? null;
+	const expectations = (def.expect ?? []).map((e) => {
+		const name = e.label ? `expectation "${e.label}"` : "an expectation";
+		if (e.scenario != null && !scenarios.some((s) => s.label === e.scenario)) throw new Error(`loadmap: ${name} names unknown scenario "${e.scenario}"`);
+		if (e.component != null && !componentIds.includes(e.component)) throw new Error(`loadmap: ${name} names unknown component "${e.component}"`);
+		if (e.target == null && e.full == null) throw new Error(`loadmap: ${name} needs a target or a full multiple`);
+		for (const k of ["target", "full"]) {
+			const x = e[k];
+			if (x != null && !(x > 0 && Number.isFinite(x))) throw new Error(`loadmap: ${name} needs a ${k} multiple above 0, not ${x}`);
+		}
+		return { ...e };
+	});
+	const story = (def.story ?? []).map((st, i) => {
+		const name = `story step ${i + 1}`;
+		const from = st.scenario == null ? void 0 : scenarios.find((s) => s.label === st.scenario);
+		if (st.scenario != null && !from) throw new Error(`loadmap: ${name} names unknown scenario "${st.scenario}"`);
+		if (st.focus != null && !componentIds.includes(st.focus)) throw new Error(`loadmap: ${name} points at unknown component "${st.focus}"`);
+		if (st.seconds != null && !(st.seconds > 0 && Number.isFinite(st.seconds))) throw new Error(`loadmap: ${name} needs seconds above 0, not ${st.seconds}`);
+		takes(name, st.set ?? {}, true);
+		return {
+			text: st.text,
+			values: {
+				...defaults(),
+				...from?.values,
+				...st.set
+			},
+			...st.scenario != null ? { scenario: st.scenario } : {},
+			...st.focus != null ? { focus: st.focus } : {},
+			seconds: st.seconds ?? 4
+		};
+	});
+	const utilAt = (values, bound, pinned) => (load) => context(def, {
+		...values,
+		load
+	}, bound, pinned).ctx.util;
+	/** The highest utilization of any live component: it crosses a threshold where the first of them does. */
+	const envelope = (values, bound, pinned) => (load) => {
+		const util = utilAt(values, bound, pinned)(load);
+		let top = null;
+		for (const c of componentIds) {
+			const u = util[c];
+			if (u != null && (top == null || u > top)) top = u;
+		}
+		return top;
+	};
+	const crossingCache = /* @__PURE__ */ new Map();
+	const crossingsFor = (values) => {
+		const { load: _, ...rest } = values;
+		const key = JSON.stringify(rest);
+		const hit = crossingCache.get(key);
+		if (hit) return hit;
+		const stated = context(def, values);
+		const uncertain = componentIds.filter((c) => (stated.capacity(c).within ?? 0) > 0);
+		const components = {};
+		for (const c of componentIds) {
+			const at = (bound) => (load) => utilAt(values, bound)(load)[c];
+			const both = (th) => {
+				const x = crossing(at(), th, searchMax);
+				if (x == null) return {
+					x,
+					range: null
+				};
+				if (!uncertain.length) return {
+					x,
+					range: {
+						low: x,
+						high: x
+					}
+				};
+				return {
+					x,
+					range: {
+						low: crossing(at("low"), th, searchMax) ?? x,
+						high: crossing(at("high"), th, searchMax) ?? x
+					}
+				};
+			};
+			const t = both(thresholds.target);
+			const f = both(thresholds.full);
+			components[c] = {
+				target: t.x,
+				full: f.x,
+				targetRange: t.range,
+				fullRange: f.range
+			};
+		}
+		let hint;
+		const out = {
+			components,
+			measure: () => hint ??= measure(values, uncertain, components)
+		};
+		if (crossingCache.size > 64) crossingCache.delete(crossingCache.keys().next().value);
+		crossingCache.set(key, out);
+		return out;
+	};
+	/**
+	* The capacity whose ± matters most: with it at its stated value (the others still ranged), the target range
+	* narrows the most. Only when the range is wider than 10 %.
+	*/
+	const measure = (values, uncertain, components) => {
+		const ranges = Object.values(components).flatMap((r) => r.targetRange ? [r.targetRange] : []);
+		if (!uncertain.length || !ranges.length) return null;
+		const now = {
+			low: Math.min(...ranges.map((r) => r.low)),
+			high: Math.min(...ranges.map((r) => r.high))
+		};
+		const width = (r) => Math.log(Math.min(r.high, searchMax * 2) / r.low);
+		if (!(now.low > 0 && Number.isFinite(now.low)) || width(now) <= Math.log(1.1)) return null;
+		let best = null;
+		for (const k of uncertain) {
+			const low = crossing(envelope(values, "low", k), thresholds.target, searchMax);
+			const high = crossing(envelope(values, "high", k), thresholds.target, searchMax);
+			if (low == null || high == null || !(low > 0)) continue;
+			const target = {
+				low,
+				high
+			};
+			const gain = width(now) - width(target);
+			if (gain > .01 && (!best || gain > best.gain)) best = {
+				component: k,
+				target,
+				gain
+			};
+		}
+		if (!best) return null;
+		const util = utilAt(values, "low", best.component)(best.target.low);
+		let first = best.component;
+		for (const c of componentIds) {
+			const u = util[c];
+			if (u != null && u > (util[first] ?? Number.NEGATIVE_INFINITY)) first = c;
+		}
+		return {
+			component: best.component,
+			target: best.target,
+			firstLimit: first
+		};
+	};
+	const evaluate = (partial) => {
+		const values = {
+			...defaults(),
+			...partial
+		};
+		const { ctx, capacity, over, describe } = context(def, values);
+		const crossings = crossingsFor(values);
+		const components = {};
+		for (const c of componentIds) {
+			const d = def.components[c];
+			const util = ctx.util[c];
+			const off = util == null;
+			components[c] = {
+				id: c,
+				name: d.name,
+				short: d.short ?? d.name,
+				plural: d.plural ?? false,
+				util,
+				demand: off ? null : ctx.demand[c],
+				capacity: off ? null : capacity(c),
+				state: off ? "off" : util > thresholds.full ? "over" : util > thresholds.target ? "warn" : "ok",
+				...crossings.components[c],
+				over: over(c),
+				describe: describe(c)
+			};
+		}
+		const all = componentIds.map((c) => components[c]);
+		const live = all.filter((r) => r.util != null);
+		const order = (x) => x == null ? Number.POSITIVE_INFINITY : x;
+		const cmp = (x, y) => order(x) === order(y) ? 0 : order(x) < order(y) ? -1 : 1;
+		const ranked = [...all].sort((a, b) => Number(a.util == null) - Number(b.util == null) || cmp(a.targetRange?.low, b.targetRange?.low) || cmp(a.target, b.target) || cmp(a.fullRange?.low, b.fullRange?.low));
+		const firstLimit = live.length ? ranked[0] : null;
+		const firstFull = live.length ? live.reduce((a, b) => cmp(b.fullRange?.low, a.fullRange?.low) < 0 ? b : a) : null;
+		const edges = (k) => {
+			const rs = live.flatMap((r) => r[k] ? [r[k]] : []);
+			return rs.length ? {
+				low: Math.min(...rs.map((r) => r.low)),
+				high: Math.min(...rs.map((r) => r.high))
+			} : null;
+		};
+		const target = edges("targetRange");
+		const full = edges("fullRange");
+		const flows = {};
+		for (const f of flowIds) flows[f] = ctx.flows[f];
+		const stages = {};
+		for (const s of stageIds) stages[s] = resolveStage(s, def.stages[s], ctx, flowIds);
+		for (const st of Object.values(stages)) if (st.kind === "fanout") for (const b of Object.values(st.to).flat()) {
+			const to = stages[b.stage];
+			if (!to || to.kind === "queue" || to.kind === "workers" || to.kind === "fanout") throw new Error(`loadmap: fan-out "${st.id}" branches to "${b.stage}", which is not a sink, store or pass stage`);
+		}
+		const overload = {};
+		for (const f of flowIds) {
+			const o = def.flows[f].overload;
+			overload[f] = (typeof o === "function" ? o(ctx) : o) ?? {};
+		}
+		const assumptions = [];
+		for (const c of componentIds) {
+			const cap = components[c].capacity ?? capacity(c);
+			assumptions.push({
+				kind: "capacity",
+				component: c,
+				name: def.components[c].name,
+				capacity: cap
+			});
+		}
+		for (const [name, fit] of Object.entries(def.calibration ?? {})) assumptions.push({
+			kind: "fit",
+			name,
+			fit
+		});
+		return {
+			values,
+			flows,
+			components,
+			ranked,
+			firstLimit,
+			firstFull,
+			target,
+			full,
+			verdict: verdict(values.load, live, firstLimit, target, thresholds, searchMax, when),
+			get measure() {
+				return measureText(crossings.measure(), components, firstLimit, thresholds, searchMax);
+			},
+			presets: presets(def, target, full, thresholds, searchMax),
+			assumptions,
+			stages,
+			routes: def.routes,
+			overload,
+			ctx
+		};
+	};
+	return {
+		def,
+		title: def.title,
+		load: def.load,
+		params: paramList,
+		flowIds,
+		componentIds,
+		stageIds,
+		thresholds,
+		searchMax,
+		scenarios,
+		expectations,
+		story,
+		growth: growth$1,
+		defaults,
+		isEnabled: (id, values) => {
+			const d = paramList.find((x) => x.id === id)?.def;
+			return d ? isEnabled(d, values) : false;
+		},
+		evaluate,
+		utilization: (partial, bound) => {
+			const util = context(def, {
+				...defaults(),
+				...partial
+			}, bound).ctx.util;
+			return Object.fromEntries(componentIds.map((c) => [c, util[c]]));
+		},
+		scenarioOf,
+		dateAt: when
+	};
+}
+/**
+* The model's numbers for one set of values. Every number is computed on first use and kept, so a model function
+* may read any other; a value that needs itself throws, naming the loop.
+*/
+function context(def, values, bound, pinned) {
+	const cache = /* @__PURE__ */ new Map();
+	const stack = [];
+	const memo = (key, f) => {
+		if (cache.has(key)) return cache.get(key);
+		if (stack.includes(key)) throw new Error(`loadmap: ${[...stack.slice(stack.indexOf(key)), key].join(" → ")} is a loop`);
+		stack.push(key);
+		try {
+			const v = f();
+			cache.set(key, v);
+			return v;
+		} finally {
+			stack.pop();
+		}
+	};
+	const table = (ids, get) => {
+		const t = {};
+		for (const id of ids) Object.defineProperty(t, id, {
+			enumerable: true,
+			get: () => get(id)
+		});
+		return Object.freeze(t);
+	};
+	const ctx = { ...values };
+	const flowIds = Object.keys(def.flows);
+	const componentIds = Object.keys(def.components);
+	const capacity = (c) => memo(`capacity of ${c}`, () => {
+		const cap = def.components[c].capacity;
+		return typeof cap === "function" ? cap(ctx) : cap;
+	});
+	const enabled = (c) => memo(`${c} enabled`, () => def.components[c].when?.(ctx) ?? true);
+	ctx.flows = table(flowIds, (f) => memo(`flow ${f}`, () => def.flows[f].rate(ctx)));
+	ctx.demand = table(componentIds, (c) => memo(`demand of ${c}`, () => def.components[c].demand(ctx)));
+	ctx.util = table(componentIds, (c) => memo(`utilization of ${c}`, () => {
+		if (!enabled(c)) return null;
+		const cap = boundOf(capacity(c), c === pinned ? void 0 : bound);
+		const d = ctx.demand[c];
+		return cap > 0 ? d / cap : d > 0 ? Number.POSITIVE_INFINITY : 0;
+	}));
+	ctx.derived = table(Object.keys(def.derived ?? {}), (k) => memo(`derived ${k}`, () => def.derived[k](ctx)));
+	const text = (v) => typeof v === "function" ? v(ctx) : v;
+	return {
+		ctx: Object.freeze(ctx),
+		capacity,
+		over: (c) => text(def.components[c].over) ?? "",
+		describe: (c) => text(def.components[c].describe)
+	};
+}
+/**
+* The lowest load multiple at which `util(load)` reaches `th`. A coarse geometric scan finds the first bracket, so a
+* utilization that does not rise steadily with the load is not mis-bisected; bisection then narrows it.
+*/
+function crossing(util, th, max) {
+	const u0 = util(0);
+	if (u0 == null) return null;
+	if (u0 >= th) return 0;
+	const steps = 96;
+	const lo0 = .01;
+	let prev = 0;
+	for (let i = 0; i <= steps; i++) {
+		const at = lo0 * (max / lo0) ** (i / steps);
+		const u = util(at);
+		if (u != null && u >= th) {
+			let lo = prev;
+			let hi = at;
+			for (let k = 0; k < 60; k++) {
+				const mid = (lo + hi) / 2;
+				const um = util(mid);
+				if (um != null && um >= th) hi = mid;
+				else lo = mid;
+			}
+			return hi;
+		}
+		prev = at;
+	}
+	return Number.POSITIVE_INFINITY;
+}
+/** Where a range of multiples is reached, with its dates: "between 7.4× and 10× (between May 2029 and …)". */
+function reach(r, searchMax, when = () => null) {
+	if (!r) return multiple(null);
+	return `${multiples(r, searchMax)}${months(when(r.low), when(r.high))}`;
+}
+/** " (capacity estimated ±30 %)"; nothing for a measured capacity without a ±. */
+function sureness(c) {
+	if (!c || c.provenance === "measured" && !c.within) return "";
+	return ` (capacity ${c.provenance}${c.within ? ` ±${pct(c.within)}` : ""})`;
+}
+function verdict(load, live, first, range, th, searchMax, when) {
+	const at = `At ${fmt(load)}×`;
+	const target = `${pct(th.target)} target`;
+	if (!first) return {
+		tier: "ok",
+		text: `${at}, every component is switched off.`
+	};
+	const est = (c) => sureness(c.capacity);
+	const upTo = reach(range, searchMax, when);
+	const holds = `The ${target} holds up to ${upTo}, limited by ${first.short}${est(first)}.`;
+	const verb = (list, one, many) => list.length > 1 || list[0]?.plural ? many : one;
+	const overs = live.filter((c) => (c.util ?? 0) > th.full).sort((a, b) => (b.util ?? 0) - (a.util ?? 0));
+	if (overs.length) return {
+		tier: "over",
+		text: `${at}, ${joinAnd(overs.map((c) => c.short))} ${verb(overs, "is", "are")} past capacity: ${overs.map((c) => c.over).join("; ")}. ${holds}`
+	};
+	const may = (k) => live.filter((c) => c[k] != null && load > c[k].low);
+	const mayOver = may("fullRange");
+	if (mayOver.length) return {
+		tier: "warn",
+		text: `${at}, everything fits at the stated capacities, but ${joinAnd(mayOver.map((c) => c.short))} may already be past capacity: ${mayOver.map((c) => c.over).join("; ")}. ${holds}`
+	};
+	const warns = live.filter((c) => (c.util ?? 0) > th.target);
+	if (warns.length) return {
+		tier: "warn",
+		text: `${at}, everything still fits, but ${joinAnd(warns.map((c) => c.short))} ${verb(warns, "runs", "run")} above the ${target}. ${holds}`
+	};
+	const mayWarn = may("targetRange");
+	if (mayWarn.length) return {
+		tier: "warn",
+		text: `${at}, every component is under the ${target} at its stated capacity, but ${joinAnd(mayWarn.map((c) => c.short))} may already be above it. ${holds}`
+	};
+	return {
+		tier: "ok",
+		text: `${at}, every component is under the ${target}. It holds up to ${upTo}; ${first.short} ${verb([first], "is", "are")} the first limit${est(first)}.`
+	};
+}
+function measureText(m, components, first, th, searchMax) {
+	if (!m || !first) return null;
+	const k = components[m.component];
+	const then = components[m.firstLimit];
+	const holds = `the ${pct(th.target)} target holds up to ${multiples(m.target, searchMax)}`;
+	const text = then.id !== first.id ? `Measuring ${k.short} would change the answer: at its stated capacity, ${then.short} ${then.plural ? "are" : "is"} the first limit and ${holds}.` : `Measuring ${k.short} would narrow this most: at its stated capacity, ${holds}.`;
+	return {
+		component: k.id,
+		target: m.target,
+		firstLimit: then.id,
+		text
+	};
+}
+function presets(def, target, full, th, searchMax) {
+	const { min, max, step } = def.load;
+	const out = [];
+	if (min <= 1 && max >= 1) out.push({
+		label: "Today · 1×",
+		values: { load: 1 },
+		derived: false
+	});
+	for (const [label, values] of Object.entries(def.presets ?? {})) out.push({
+		label,
+		values,
+		derived: false
+	});
+	const at = (label, x) => {
+		if (x == null || !Number.isFinite(x) || x < min) return;
+		const load = Math.min(max, Math.floor(x / step) * step);
+		out.push({
+			label: `${label} · ${multiple(x, searchMax)}`,
+			values: { load },
+			derived: true
+		});
+	};
+	at(`${pct(th.target)} target`, target?.low);
+	at("Runs out", full?.low);
+	return out;
+}
+// ../core/src/check.ts
+/** Tests a model's expectations (or these) on the pessimistic edge. */
+function check$1(model, expectations = model.expectations) {
+	return expectations.map((e) => {
+		const scenario = e.scenario == null ? null : model.scenarios.find((s) => s.label === e.scenario);
+		if (e.scenario != null && !scenario) throw new Error(`loadmap: no scenario "${e.scenario}"`);
+		const ev = model.evaluate(scenario?.values);
+		const c = e.component == null ? null : ev.components[e.component];
+		if (e.component != null && !c) throw new Error(`loadmap: no component "${e.component}"`);
+		const where = scenario ? ` in ${scenario.label}` : "";
+		const range = (k) => c ? c[`${k}Range`] : ev[k];
+		const found = {
+			target: range("target"),
+			full: range("full")
+		};
+		if (c && c.util == null) return {
+			expectation: e,
+			ok: true,
+			...found,
+			message: `${c.short} is switched off${where}`
+		};
+		const claims = [];
+		const r = (x) => x ? multiples(x, model.searchMax) : "never";
+		const target = `the ${pct(model.thresholds.target)} target`;
+		if (e.target != null) {
+			const by = c ?? ev.firstLimit;
+			claims.push({
+				ok: (found.target?.low ?? Number.POSITIVE_INFINITY) >= e.target,
+				min: e.target,
+				text: c ? `${c.short} reaches ${target} at ${r(found.target)}${where}${sureness(c.capacity)}` : `${target} holds up to ${r(found.target)}${where}${by ? `, limited by ${by.short}${sureness(by.capacity)}` : ""}`
+			});
+		}
+		if (e.full != null) {
+			const by = c ?? ev.firstFull;
+			claims.push({
+				ok: (found.full?.low ?? Number.POSITIVE_INFINITY) >= e.full,
+				min: e.full,
+				text: by ? `${by.short} ${by.plural ? "run" : "runs"} out at ${r(found.full)}${where}${sureness(by.capacity)}` : `nothing runs out${where}`
+			});
+		}
+		const failed = claims.filter((x) => !x.ok);
+		const message = failed.length ? failed.map((x) => `expected at least ${fmt(x.min)}×, but ${x.text}`).join("; ") : claims.map((x) => x.text).join("; ");
+		return {
+			expectation: e,
+			ok: !failed.length,
+			...found,
+			message
+		};
+	});
+}
+// ../core/src/calibrate.ts
+/**
+* Ordinary least squares over `points[x]` → `points[y]`. Needs at least two distinct x values.
+* `through: 'origin'` fixes a at 0 (a cost with no idle part).
+*/
+function fitLinear(points, o) {
+	const xs = points.map((pt) => Number(pt[o.x]));
+	const ys = points.map((pt) => Number(pt[o.y]));
+	const n = xs.length;
+	if (xs.some((v) => !Number.isFinite(v)) || ys.some((v) => !Number.isFinite(v))) throw new Error(`loadmap: fitLinear(${o.x} → ${o.y}) got a non-numeric point`);
+	if (n < 2 || new Set(xs).size < 2) throw new Error(`loadmap: fitLinear(${o.x} → ${o.y}) needs two distinct x values`);
+	let a;
+	let b;
+	if (o.through === "origin") {
+		a = 0;
+		b = sum(xs.map((x, i) => x * ys[i])) / sum(xs.map((x) => x * x));
+	} else {
+		const mx = sum(xs) / n;
+		const my = sum(ys) / n;
+		b = sum(xs.map((x, i) => (x - mx) * (ys[i] - my))) / sum(xs.map((x) => (x - mx) ** 2));
+		a = my - b * mx;
+	}
+	const my = sum(ys) / n;
+	const ssTot = sum(ys.map((y) => (y - my) ** 2));
+	const ssRes = sum(xs.map((x, i) => (ys[i] - (a + b * x)) ** 2));
+	const r2 = ssTot === 0 ? 1 : Math.max(0, 1 - ssRes / ssTot);
+	const fit = ((x) => a + b * x);
+	return Object.assign(fit, {
+		a,
+		b,
+		r2,
+		n,
+		x: o.x,
+		y: o.y,
+		source: o.source,
+		provenance: "measured"
+	});
+}
+const sum = (v) => v.reduce((s, x) => s + x, 0);
+// ../layout/src/layout.ts
+/** The current text of every label. Cheap: call it on every change of values; the layout stays put. */
+function labelsAt(view, ev) {
+	const ctx = ev.ctx;
+	const nodes = {};
+	for (const [id, n] of Object.entries(view.def.nodes)) nodes[id] = {
+		title: text(n.label, ctx),
+		sub: n.sub == null ? void 0 : text(n.sub, ctx)
+	};
+	const edges = {};
+	visibleEdges(view, ctx).forEach(({ e, id }) => {
+		if (e.label != null) edges[id] = text(e.label, ctx);
+	});
+	return {
+		nodes,
+		edges
+	};
+}
+function visibleEdges(view, ctx) {
+	return view.def.edges.map((e, i) => ({
+		e,
+		id: `e${i}`
+	})).filter(({ e }) => e.when ? Boolean(e.when(ctx)) : true);
+}
+function text(l, ctx) {
+	return typeof l === "function" ? l(ctx) : l;
+}
+// ../layout/src/view.ts
+function defineView(model, def) {
+	const nodes = def.nodes;
+	for (const e of def.edges) for (const end of [e.from, e.to]) if (!(end in nodes)) throw new Error(`loadmap: edge to unknown node "${end}"`);
+	for (const [f, fv] of Object.entries(def.flows)) if (!(fv.from in nodes)) throw new Error(`loadmap: flow "${f}" starts at unknown node "${fv.from}"`);
+	const shows = (n, s) => Array.isArray(n.stage) ? n.stage.includes(s) : n.stage === s;
+	for (const s of model.stageIds) if (!Object.values(nodes).some((n) => shows(n, s))) throw new Error(`loadmap: no node shows stage "${s}"`);
+	return {
+		model,
+		def
+	};
+}
+/** 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];
+}
+// ../dsl/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"
+];
+// ../dsl/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;
+// ../dsl/src/lexer.ts
+const PUNCT = [
+	"===",
+	"!==",
+	"+/-",
+	"->",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"&&",
+	"||",
+	..."{}()[],;:.?+-*/%<>!=±"
+];
+/**
+* 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;
+}
+/** 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$1(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}"`;
+	}
+}
+/** 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$1(source, report).doc;
+		definition = c.run(doc);
+		if (definition) expectations = check$1(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;
+}
+// src/check.ts
+/**
+* `loadmap check`: compiles each definition and tests its expect lines. Resolves to the exit code: 1 when a
+* definition has an error or an expectation fails, 2 for a usage mistake, 0 when everything holds.
+*/
+async function check(argv, o = {}) {
+	const log = o.log ?? console.log;
+	let parsed;
+	try {
+		parsed = parse(argv, o.env ?? process.env);
+	} catch (err) {
+		log(err.message);
+		return 2;
+	}
+	let failed = false;
+	for (const file of parsed.files) {
+		let source;
+		try {
+			source = await readFile(file, "utf8");
+		} catch (err) {
+			log(`${file}: cannot read it (${err.code ?? err.message})`);
+			failed = true;
+			continue;
+		}
+		const r = compile(source);
+		const list = problems(r, "error");
+		if (parsed.format === "github") for (const d of list) log(github(d, file, source));
+		for (const d of list) log(formatDiagnostic(d, source, file));
+		if (list.some((d) => d.severity === "error")) failed = true;
+		const errors = r.diagnostics.filter((d) => d.severity === "error").length;
+		const n = r.expectations.length;
+		const bad = r.expectations.filter((e) => !e.result.ok).length;
+		const many = (k, one, more) => `${k} ${k === 1 ? one : more}`;
+		log(errors ? `${file}: does not compile (${many(errors, "error", "errors")})` : !n ? `${file}: compiles; it has no expect lines` : bad ? `${file}: ${bad} of ${many(n, "expectation", "expectations")} failed` : `${file}: ${many(n, "expectation holds", "expectations hold")}`);
+		for (const e of r.expectations) if (e.result.ok) log(`  ✓ ${e.result.expectation.label ?? `line ${e.line}`}: ${e.result.message}`);
+	}
+	return failed ? 1 : 0;
+}
+function parse(argv, env) {
+	const { values, positionals } = parseArgs({
+		args: argv,
+		allowPositionals: true,
+		options: { format: { type: "string" } }
+	});
+	const format = values.format ?? (env.GITHUB_ACTIONS === "true" ? "github" : "text");
+	if (format !== "text" && format !== "github") throw new Error(`--format is text or github, not "${format}"`);
+	if (!positionals.length) throw new Error("loadmap check needs one or more .loadmap files");
+	return {
+		files: positionals,
+		format
+	};
+}
+/**
+* A diagnostic as a GitHub Actions workflow command: an annotation on its line of the file in the pull request.
+* https://docs.github.com/actions/reference/workflow-commands-for-github-actions
+*/
+function github(d, file, source) {
+	const breaks = source.slice(d.from, Math.max(d.from, d.to)).split("\n");
+	const endLine = d.line + breaks.length - 1;
+	const endColumn = (breaks.length > 1 ? 1 : d.column) + breaks.at(-1).length;
+	const props = [
+		`file=${prop(file)}`,
+		`line=${d.line}`,
+		`col=${d.column}`,
+		`endLine=${endLine}`,
+		`endColumn=${endColumn}`,
+		`title=${prop("loadmap check")}`
+	];
+	const message = d.hint ? `${d.message} (${d.hint})` : d.message;
+	return `::${d.severity === "error" ? "error" : "warning"} ${props.join(",")}::${data(message)}`;
+}
+const data = (s) => s.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll("\n", "%0A");
+const prop = (s) => data(s).replaceAll(":", "%3A").replaceAll(",", "%2C");
+// src/index.ts
+const USAGE = `loadmap check <file.loadmap>… [--format text|github]
+loadmap record <url | file.loadmap> --out <file.gif|.webm|.mp4|.png|.svg> [options]
+
+check compiles each definition and tests its expect lines on the pessimistic edge (every capacity at its low
+bound). It exits 1 when a definition has an error or an expectation fails, 0 when everything holds.
+
+  --format <f>          text, or github to add annotations on the lines (the default under GitHub Actions)
+
+record opens the page in headless Chromium, finds the loadmap it exposes (expose() from @loadmap/export) and
+records it on a fixed clock, so the same options give the same file. A .loadmap file is drawn by the viewer that
+comes with the command.
+
+  --out <file>          the extension picks the format: gif, webm, mp4, png or svg
+  --script <file.json>  [{ "at": 0, "set": { "load": 5 } }, { "at": 3, "scenario": "Proposed" }, …]
+                        or { "seconds", "fps", "script": […] }
+  --scenario <label>    start from a scenario's values (--set goes on top)
+  --set <key=value>     a value before recording starts; repeatable (--set load=30 --set pods=6)
+  --caption             the title, scenario and load above the board, the verdict below it
+  --story               play the definition's story, a step at a time (with --caption, its text below the board)
+  --poster              with .png: the board, the verdict, the limits and the scenarios compared
+  --seconds <n>         length of a video or GIF (default 8, or the script's)
+  --fps <n>             frames per second (default 30; GIF 15, at most 50)
+  --scale <n>           pixels per diagram unit (default 1, PNG 2)
+  --seed <n>            the sim's seed (default 1)
+  --name <name>         which exposed loadmap, when the page has several (default "default")
+  --width <px>          the browser window (default 1280; below 640 the diagram runs top to bottom)
+  --color-scheme <s>    light or dark, for a page that follows the system theme (default light)`;
+/** Runs the command line; resolves to the exit code. */
+async function main(argv, log = console.log) {
+	const [command, ...rest] = argv;
+	if (command === "check") return check(rest, { log });
+	if (command !== "record") {
+		log(USAGE);
+		return command === "--help" || command === "-h" ? 0 : 2;
+	}
+	const args = await parseRecord(rest);
+	const bytes = await record(args);
+	await writeFile(args.out, bytes);
+	log(`${args.out}: ${(bytes.length / 1024).toFixed(0)} KB`);
+	return 0;
+}
+async function parseRecord(argv) {
+	const { values: v, positionals } = parseArgs({
+		args: argv,
+		allowPositionals: true,
+		options: {
+			out: { type: "string" },
+			script: { type: "string" },
+			set: {
+				type: "string",
+				multiple: true
+			},
+			scenario: { type: "string" },
+			caption: { type: "boolean" },
+			poster: { type: "boolean" },
+			story: { type: "boolean" },
+			seconds: { type: "string" },
+			fps: { type: "string" },
+			scale: { type: "string" },
+			seed: { type: "string" },
+			name: { type: "string" },
+			width: { type: "string" },
+			"color-scheme": { type: "string" }
+		}
+	});
+	const target = positionals[0];
+	if (!target || !v.out) throw new Error(`loadmap record needs a URL or a .loadmap file and --out\n\n${USAGE}`);
+	const file = !/^[a-z][a-z\d+.-]*:\/\//i.test(target) && extname(target).toLowerCase() === ".loadmap" ? target : void 0;
+	const num = (x, name) => {
+		if (x == null) return void 0;
+		const n = Number(x);
+		if (!x.trim() || !Number.isFinite(n) || n <= 0) throw new Error(`--${name} takes a positive number, not "${x}"`);
+		return n;
+	};
+	let script;
+	let fromFile = {};
+	if (v.script) {
+		const parsed = JSON.parse(await readFile(v.script, "utf8"));
+		script = Array.isArray(parsed) ? parsed : parsed.script;
+		fromFile = Array.isArray(parsed) ? {} : parsed;
+	}
+	const set = {};
+	for (const kv of v.set ?? []) {
+		const i = kv.indexOf("=");
+		if (i < 1) throw new Error(`--set takes key=value, not "${kv}"`);
+		const raw = kv.slice(i + 1).trim();
+		if (!raw) throw new Error(`--set ${kv.slice(0, i)}= has no value`);
+		const n = Number(raw);
+		set[kv.slice(0, i)] = raw === "true" ? true : raw === "false" ? false : Number.isFinite(n) ? n : raw;
+	}
+	const scheme = v["color-scheme"] ?? "light";
+	if (scheme !== "light" && scheme !== "dark") throw new Error("--color-scheme is light or dark");
+	if (v.poster && extname(v.out).toLowerCase() !== ".png") throw new Error("--poster writes a PNG: --out must end in .png");
+	if (v.story && ![
+		".gif",
+		".webm",
+		".mp4"
+	].includes(extname(v.out).toLowerCase())) throw new Error("--story plays a GIF or a video: --out must end in .gif, .webm or .mp4");
+	if (v.story && (v.script || v.seconds || v.scenario || v.set)) throw new Error("--story sets the values and the length itself: leave out --script, --seconds, --scenario and --set");
+	return {
+		url: file ? "" : target,
+		...file ? { file } : {},
+		out: v.out,
+		script,
+		scenario: v.scenario,
+		set,
+		caption: v.caption ?? false,
+		poster: v.poster ?? false,
+		story: v.story ?? false,
+		seconds: num(v.seconds, "seconds") ?? fromFile.seconds,
+		fps: num(v.fps, "fps") ?? fromFile.fps,
+		scale: num(v.scale, "scale"),
+		seed: num(v.seed, "seed"),
+		name: v.name ?? "default",
+		width: num(v.width, "width") ?? 1280,
+		colorScheme: scheme
+	};
+}
+/**
+* Records in a fresh headless Chromium and returns the file's bytes. A .loadmap file is compiled here first (its
+* errors are thrown, formatted), then drawn by the viewer in `o.viewer`: by default the one the build puts in
+* dist/viewer.
+*/
+async function record(a, o = {}) {
+	const format = extname(a.out).slice(1).toLowerCase();
+	if (![
+		"gif",
+		"webm",
+		"mp4",
+		"png",
+		"svg"
+	].includes(format)) throw new Error(`--out must end in .gif, .webm, .mp4, .png or .svg`);
+	if (!a.file) return recordPage(a, format);
+	const source = await readFile(a.file, "utf8");
+	const r = compile(source);
+	if (!r.ok) throw new Error(r.diagnostics.map((d) => formatDiagnostic(d, source, a.file)).join("\n"));
+	const server = await serve(source, o.viewer ?? join(import.meta.dirname, "../dist/viewer"));
+	try {
+		return await recordPage({
+			...a,
+			url: server.url
+		}, format);
+	} finally {
+		await server.close();
+	}
+}
+const TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".loadmap": "text/plain; charset=utf-8"
+};
+/** The viewer and the definition, on a port of 127.0.0.1 for as long as the recording takes. */
+async function serve(source, dir) {
+	try {
+		await readFile(join(dir, "index.html"));
+	} catch {
+		throw new Error(`no viewer in ${dir}: build the CLI first (pnpm --filter @loadmap/cli build)`);
+	}
+	const server = createServer(async (req, res) => {
+		try {
+			const path = normalize(decodeURIComponent(new URL(req.url ?? "/", "http://x").pathname)).replace(/^[/\\]+/, "");
+			if (path.split(/[/\\]/).includes("..")) throw new Error("outside the viewer");
+			const file = path || "index.html";
+			const body = file === "definition.loadmap" ? Buffer.from(source) : await readFile(join(dir, file));
+			res.writeHead(200, { "content-type": TYPES[extname(file)] ?? "application/octet-stream" });
+			res.end(body);
+		} catch {
+			res.writeHead(404).end();
+		}
+	});
+	await new Promise((done) => server.listen(0, "127.0.0.1", done));
+	const { port } = server.address();
+	return {
+		url: `http://127.0.0.1:${port}/`,
+		close: () => new Promise((done) => server.close(() => done()))
+	};
+}
+async function recordPage(a, format) {
+	const browser = await chromium.launch();
+	try {
+		const page = await browser.newPage({
+			viewport: {
+				width: a.width,
+				height: 900
+			},
+			colorScheme: a.colorScheme
+		});
+		await page.goto(a.url);
+		await page.waitForFunction((name) => Boolean(globalThis.__loadmap?.[name]), a.name, { timeout: 3e4 }).catch(() => {
+			throw new Error(`no loadmap "${a.name}" on ${a.url}: the page must call expose(handle${a.name === "default" ? "" : `, '${a.name}'`})`);
+		});
+		const out = await page.evaluate(async ({ a, format }) => {
+			const r = globalThis.__loadmap[a.name];
+			const still = {
+				scenario: a.scenario,
+				set: a.set,
+				scale: a.scale,
+				seed: a.seed,
+				caption: a.caption
+			};
+			if (format === "svg") return r.svg(still);
+			if (format === "png") return a.poster ? r.poster(still) : r.still(still);
+			if (a.story) return r.record({
+				format,
+				story: true,
+				fps: a.fps,
+				scale: a.scale,
+				seed: a.seed,
+				caption: a.caption
+			});
+			const script = [{
+				at: 0,
+				scenario: a.scenario,
+				set: a.set
+			}, ...a.script ?? []];
+			return r.record({
+				format,
+				seconds: a.seconds ?? 8,
+				fps: a.fps,
+				scale: a.scale,
+				seed: a.seed,
+				caption: a.caption,
+				script
+			});
+		}, {
+			a,
+			format
+		});
+		return format === "svg" ? Buffer.from(out, "utf8") : Buffer.from(out, "base64");
+	} finally {
+		await browser.close();
+	}
+}
+export { check as a, record as i, main as n, github as o, parseRecord as r, USAGE as t };