@loadmap/cli 0.1.1 → 0.2.0

package/dist/{src-B81_QU8o.js → src-IlCf12IX.js}

@@ -12,6 +12,10 @@ function measured(value, unit, o) {
 function estimated(value, unit, o) {
 	return capacity(value, unit, "estimated", o);
 }
+/** A limit someone set, such as a rate limiter's: exact, so it takes no ±. */
+function configured(value, unit, source) {
+	return capacity(value, unit, "configured", source);
+}
 function capacity(value, unit, provenance, o) {
 	const { source, within } = typeof o === "string" ? {
 		source: o,
@@ -210,6 +214,19 @@ function workers(component, o) {
 		fill: o.fill ?? "round-robin"
 	};
 }
+function cache(o) {
+	return {
+		kind: "cache",
+		...o
+	};
+}
+function limit(component, o = {}) {
+	return {
+		kind: "limit",
+		component,
+		...o
+	};
+}
 function store(component, o = {}) {
 	return {
 		kind: "store",
@@ -229,11 +246,17 @@ function fanout(o) {
 		...o
 	};
 }
+/** The share a stage turns away when its component is past `full`: what is above it. */
+function rejectShare(util, full) {
+	return util != null && util > full ? 1 - full / util : 0;
+}
 function dyn(v, ctx) {
 	return typeof v === "function" ? v(ctx) : v;
 }
-function resolveStage(id, s, ctx, flowIds) {
+function resolveStage(id, s, ctx, flowIds, full) {
 	const label = s.label ?? id;
+	const util = (c) => c ? ctx.util[c] : null;
+	const rejects = rejectShare(util(s.kind === "sink" ? void 0 : s.component), full);
 	switch (s.kind) {
 		case "queue": return {
 			id,
@@ -242,15 +265,32 @@ function resolveStage(id, s, ctx, flowIds) {
 			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 "workers": {
+			const perPod = dyn(s.perPod, ctx);
+			const base = {
+				id,
+				label,
+				kind: "workers",
+				component: s.component,
+				perPod,
+				fill: s.fill
+			};
+			if (!s.autoscale) {
+				const pods = dyn(s.pods ?? 0, ctx);
+				return {
+					...base,
+					pods,
+					running: pods
+				};
+			}
+			const a = autoscaleOf(id, s.autoscale, ctx);
+			return {
+				...base,
+				pods: a.max,
+				running: running(a, util(s.component)),
+				autoscale: a
+			};
+		}
 		case "fanout": {
 			const to = dyn(s.to, ctx);
 			const perFlow = {};
@@ -260,26 +300,72 @@ function resolveStage(id, s, ctx, flowIds) {
 				label,
 				kind: "fanout",
 				component: s.component,
-				to: perFlow
+				to: perFlow,
+				rejects,
+				shed: rejects
 			};
 		}
+		case "cache": return {
+			id,
+			label,
+			kind: "cache",
+			component: s.component,
+			hit: hitOf(id, s, ctx),
+			rejects,
+			shed: rejects
+		};
 		case "sink": return {
 			id,
 			label,
 			kind: "sink"
 		};
+		case "store": return {
+			id,
+			label,
+			kind: "store",
+			component: s.component
+		};
 		default: return {
 			id,
 			label,
 			kind: s.kind,
-			component: s.component
+			component: s.component,
+			rejects,
+			shed: rejects
 		};
 	}
 }
+/** A cache's hit share, checked: a share outside 0 to 1 is a mistake, not a rate. */
+function hitOf(id, s, ctx) {
+	const hit = dyn(s.hit, ctx);
+	if (!(hit >= 0 && hit <= 1)) throw new Error(`loadmap: cache "${id}" needs a hit share from 0 to 1, not ${hit}`);
+	return hit;
+}
+function autoscaleOf(id, a, ctx) {
+	const min = dyn(a.min, ctx);
+	const max = dyn(a.max, ctx);
+	const target = dyn(a.target, ctx);
+	if (!(Number.isInteger(min) && Number.isInteger(max) && min >= 1 && max >= min)) throw new Error(`loadmap: workers "${id}" autoscale needs whole numbers with 1 ≤ min ≤ max, not ${min} and ${max}`);
+	if (!(target > 0 && target <= 1)) throw new Error(`loadmap: workers "${id}" autoscale needs a target above 0 and at most 1, not ${target}`);
+	return {
+		min,
+		max,
+		target
+	};
+}
+/**
+* The pods an autoscaler runs: enough to hold each near its target. `util` is against the pool at max pods, so
+* util × max is the work in pods' worth of capacity.
+*/
+function running(a, util) {
+	const need = Math.ceil((util ?? 0) * a.max / a.target - 1e-9);
+	return Math.min(a.max, Math.max(a.min, need));
+}
 // ../core/src/model.ts
 const RESERVED$1 = [
 	"load",
 	"flows",
+	"at",
 	"demand",
 	"util",
 	"derived"
@@ -299,6 +385,11 @@ function defineModel(def) {
 			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}"`);
 		});
 	}
+	for (const c of componentIds) if (!def.components[c].demand && !stageIds.some((s) => def.stages[s].component === c)) throw new Error(`loadmap: component "${c}" needs a demand: no stage uses it`);
+	for (const s of stageIds) {
+		const st = def.stages[s];
+		if (st.kind === "workers" && st.pods == null === (st.autoscale == null)) throw new Error(`loadmap: workers "${s}" needs pods or autoscale, one of them`);
+	}
 	const thresholds = {
 		target: def.thresholds?.target ?? .5,
 		full: def.thresholds?.full ?? 1
@@ -397,8 +488,17 @@ function defineModel(def) {
 		const stated = context(def, values);
 		const uncertain = componentIds.filter((c) => (stated.capacity(c).within ?? 0) > 0);
 		const components = {};
+		const seen = /* @__PURE__ */ new Map();
+		const utilOf = (bound, load) => {
+			const k = `${bound}|${load}`;
+			const hit = seen.get(k);
+			if (hit) return hit;
+			const u = utilAt(values, bound)(load);
+			seen.set(k, u);
+			return u;
+		};
 		for (const c of componentIds) {
-			const at = (bound) => (load) => utilAt(values, bound)(load)[c];
+			const at = (bound) => (load) => utilOf(bound, load)[c];
 			const both = (th) => {
 				const x = crossing(at(), th, searchMax);
 				if (x == null) return {
@@ -485,7 +585,7 @@ function defineModel(def) {
 			...defaults(),
 			...partial
 		};
-		const { ctx, capacity, over, describe } = context(def, values);
+		const { ctx, capacity, over, describe, overload: overloadOf, retries, shed } = context(def, values);
 		const crossings = crossingsFor(values);
 		const components = {};
 		for (const c of componentIds) {
@@ -525,15 +625,24 @@ function defineModel(def) {
 		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 s of stageIds) {
+			const st = resolveStage(s, def.stages[s], ctx, flowIds, thresholds.full);
+			stages[s] = st.kind === "pass" || st.kind === "limit" || st.kind === "cache" ? {
+				...st,
+				shed: shed(s)
+			} : st;
+		}
 		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) ?? {};
+		for (const f of flowIds) overload[f] = overloadOf(f);
+		const at = {};
+		for (const s of stageIds) {
+			const row = {};
+			for (const f of flowIds) row[f] = ctx.at[s][f];
+			at[s] = row;
 		}
 		const assumptions = [];
 		for (const c of componentIds) {
@@ -567,7 +676,9 @@ function defineModel(def) {
 			assumptions,
 			stages,
 			routes: def.routes,
+			at,
 			overload,
+			retry: retries(),
 			ctx
 		};
 	};
@@ -604,9 +715,10 @@ function defineModel(def) {
 }
 /**
 * 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.
+* may read any other; a value that needs itself throws, naming the loop. Retries are the one loop that is solved:
+* a retrying flow's attempts settle where the share its route turns away gives back the same attempts.
 */
-function context(def, values, bound, pinned) {
+function context(def, values, bound, pinned, fixed) {
 	const cache = /* @__PURE__ */ new Map();
 	const stack = [];
 	const memo = (key, f) => {
@@ -630,15 +742,205 @@ function context(def, values, bound, pinned) {
 		return Object.freeze(t);
 	};
 	const ctx = { ...values };
+	const full = def.thresholds?.full ?? 1;
 	const flowIds = Object.keys(def.flows);
 	const componentIds = Object.keys(def.components);
+	const stages = def.stages;
+	const stageIds = Object.keys(stages);
+	const routes = def.routes;
 	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)));
+	const overload = (f) => memo(`overload of ${f}`, () => {
+		const o = def.flows[f].overload;
+		return (typeof o === "function" ? o(ctx) : o) ?? {};
+	});
+	const retryOf = (f) => {
+		const rule = def.flows[f].retry;
+		const r = typeof rule === "function" ? rule(values) : rule;
+		if (!r) return void 0;
+		if (!(Number.isInteger(r.times) && r.times >= 0)) throw new Error(`loadmap: flow "${f}" retries a whole number of times, not ${r.times}`);
+		if (r.budget != null && !(r.budget >= 0 && Number.isFinite(r.budget))) throw new Error(`loadmap: flow "${f}" needs a retry budget of 0 or more, not ${r.budget}`);
+		return r.times > 0 && r.budget !== 0 ? r : void 0;
+	};
+	const rate = (f) => memo(`rate of ${f}`, () => def.flows[f].rate(ctx));
+	ctx.flows = table(flowIds, (f) => memo(`flow ${f}`, () => {
+		if (fixed && Object.hasOwn(fixed, f)) return fixed[f];
+		return retryOf(f) ? retries()[f].attempts : def.flows[f].rate(ctx);
+	}));
+	/** The share a stage turns away: past its component's `full`, what is above it. */
+	const rejects = (s) => memo(`rejects at ${s}`, () => {
+		const st = stages[s];
+		if (!(st.kind === "pass" || st.kind === "limit" || st.kind === "cache" || st.kind === "fanout") || !st.component) return 0;
+		return rejectShare(ctx.util[st.component], full);
+	});
+	const hit = (s) => memo(`hit at ${s}`, () => hitOf(s, stages[s], ctx));
+	/** The share of a flow's units that go on past a stage: cache hits stay, and what a limiter turns away. */
+	const onward = (s) => {
+		const st = stages[s];
+		return st.kind === "cache" ? 1 - hit(s) : st.kind === "limit" ? 1 - rejects(s) : 1;
+	};
+	/** Copies per unit of a flow that a fan-out at t sends to s: 0 unless t is a fan-out with a branch there. */
+	const copies = (t, f, s) => {
+		const st = stages[t];
+		if (st.kind !== "fanout") return 0;
+		const to = memo(`branches of ${t}`, () => dyn(st.to, ctx));
+		let n = 0;
+		for (const b of Array.isArray(to) ? to : to[f] ?? []) if (b.stage === s) n += b.share;
+		return n;
+	};
+	const arriving = (s, f) => memo(`${f} at ${s}`, () => {
+		const route = routes[f] ?? [];
+		const last = route.findLastIndex((t) => t === s || copies(t, f, s) > 0);
+		let total = 0;
+		let r = ctx.flows[f];
+		for (const [i, t] of route.entries()) {
+			if (t === s) total += r;
+			total += r * copies(t, f, s);
+			if (i >= last) break;
+			r *= onward(t);
+		}
+		return total;
+	});
+	const inner = /* @__PURE__ */ new Map();
+	ctx.at = table(stageIds, (s) => {
+		const known = inner.get(s);
+		if (known) return known;
+		const t = table(flowIds, (f) => arriving(s, f));
+		inner.set(s, t);
+		return t;
+	});
+	/**
+	* The share of a flow's attempts turned away somewhere on its route; a cache hit is an answer, not a failure. A
+	* stage's rejections are counted against what is offered to it, so behind another stage that turns work away it
+	* passes at most what it can take (offered × (1 − rejects)), not a share of a share: the bottleneck decides.
+	*/
+	const failure = (f) => memo(`failures of ${f}`, () => {
+		let offered = 1;
+		let actual = 1;
+		let answered = 0;
+		for (const s of routes[f] ?? []) {
+			const r = stages[s].kind === "fanout" ? 0 : rejects(s);
+			if (r > 0) actual = Math.min(actual, offered * (1 - r));
+			if (stages[s].kind === "cache") {
+				answered += actual * hit(s);
+				actual *= 1 - hit(s);
+			}
+			offered *= onward(s);
+		}
+		return Math.max(0, 1 - answered - actual);
+	});
+	/**
+	* What actually reaches a stage, per second: like `at`, less what stages before it turned away. A stage takes up to
+	* what is offered to it × (1 − rejects), so behind another stage that turns work away the bottleneck decides.
+	*/
+	const actual = (s, f) => memo(`${f} reaching ${s}`, () => {
+		const route = routes[f] ?? [];
+		const last = route.findLastIndex((t) => t === s || copies(t, f, s) > 0);
+		let total = 0;
+		let r = ctx.flows[f];
+		for (const [i, t] of route.entries()) {
+			if (t === s) total += r;
+			total += r * copies(t, f, s) * (1 - rejects(t));
+			if (i >= last) break;
+			const cut = rejects(t);
+			if (cut > 0) r = Math.min(r, arriving(t, f) * (1 - cut));
+			if (stages[t].kind === "cache") r *= 1 - hit(t);
+		}
+		return total;
+	});
+	/** The share of what actually reaches a stage that it turns away: the one number the sim and the meters show. */
+	const shed = (s) => memo(`shed at ${s}`, () => {
+		const r = rejects(s);
+		if (!r) return 0;
+		let offered = 0;
+		let reaching = 0;
+		for (const f of flowIds) {
+			offered += arriving(s, f);
+			reaching += actual(s, f);
+		}
+		return reaching > 0 ? Math.max(0, 1 - offered * (1 - r) / reaching) : 0;
+	});
+	const retries = () => memo("retries", () => {
+		const ids = flowIds.filter((f) => retryOf(f));
+		const lam = {};
+		for (const f of ids) lam[f] = rate(f);
+		const most = (f) => {
+			const r = retryOf(f);
+			return Math.min(r.times, r.budget ?? Number.POSITIVE_INFINITY);
+		};
+		const attempts = (e) => {
+			const a = {};
+			for (const f of ids) a[f] = lam[f] * (1 + e[f]);
+			return a;
+		};
+		const wanted = (e) => {
+			const sub = context(def, values, bound, pinned, attempts(e));
+			const w = {};
+			const p = {};
+			for (const f of ids) {
+				p[f] = sub.failure(f);
+				w[f] = Math.min(excess(p[f], retryOf(f).times), most(f));
+			}
+			return {
+				w,
+				p
+			};
+		};
+		let e = Object.fromEntries(ids.map((f) => [f, 0]));
+		for (let step = 0; step < 100; step++) {
+			const { w, p: failed } = wanted(e);
+			const d = {};
+			for (const f of ids) d[f] = Math.max(0, w[f] - e[f]);
+			const live = ids.filter((f) => lam[f] > 0 && d[f] > (step ? 1e-10 * (1 + e[f]) : 0));
+			if (!live.length) {
+				const a = attempts(e);
+				const out = {};
+				for (const f of ids) {
+					const l = lam[f];
+					const p = failed[f];
+					const times = retryOf(f).times;
+					const retried = p > 0 && excess(p, times) > e[f] * (1 + 1e-12) ? root((y) => excess(y, times), e[f], p) / p : 1;
+					out[f] = {
+						times,
+						rate: l,
+						attempts: a[f],
+						rejected: p,
+						retried,
+						failed: l > 0 ? 1 - (1 - p) * (1 + e[f]) : 0
+					};
+				}
+				return out;
+			}
+			const along = (t) => {
+				const y = { ...e };
+				for (const f of live) y[f] = e[f] + t * d[f];
+				return y;
+			};
+			const holds = (t) => {
+				const y = along(t);
+				const wy = wanted(y).w;
+				return Math.min(...live.map((f) => (wy[f] - y[f]) / d[f]));
+			};
+			const far = Math.min(...live.map((f) => (most(f) - e[f]) / d[f]));
+			if (far <= 1) e = along(far);
+			else {
+				const h1 = holds(1);
+				e = along(h1 > 0 ? settle(holds, 1, far, h1) : 1);
+			}
+		}
+		throw new Error(`loadmap: the retries of ${joinAnd(ids.map((f) => `"${f}"`))} do not settle`);
+	});
+	const usedBy = (c) => stageIds.filter((s) => stages[s].component === c);
+	ctx.demand = table(componentIds, (c) => memo(`demand of ${c}`, () => {
+		const d = def.components[c].demand;
+		if (d) return d(ctx);
+		let total = 0;
+		for (const s of usedBy(c)) for (const f of flowIds) total += arriving(s, f);
+		return total;
+	}));
 	ctx.util = table(componentIds, (c) => memo(`utilization of ${c}`, () => {
 		if (!enabled(c)) return null;
 		const cap = boundOf(capacity(c), c === pinned ? void 0 : bound);
@@ -650,10 +952,55 @@ function context(def, values, bound, pinned) {
 	return {
 		ctx: Object.freeze(ctx),
 		capacity,
+		overload,
+		failure,
+		shed,
+		retries: () => flowIds.some((f) => retryOf(f)) ? retries() : {},
 		over: (c) => text(def.components[c].over) ?? "",
 		describe: (c) => text(def.components[c].describe)
 	};
 }
+/** y + y² + … + yⁿ: the retries per unit when each attempt fails with share y and n retries may follow. */
+function excess(y, n) {
+	return y >= 1 ? n : y * (1 - y ** n) / (1 - y);
+}
+/**
+* Where h, above 0 at lo and at most 0 at hi, reaches 0: regula falsi with the Illinois step, a few evaluations where
+* bisection takes forty, and still bracketed when h has a kink (the knee where rejections start).
+*/
+function settle(h, lo, hi, hl = h(lo)) {
+	let hh = h(hi);
+	if (hh >= 0) return hi;
+	let side = 0;
+	let x = lo;
+	for (let k = 0; k < 100 && hi - lo > 1e-13 * hi; k++) {
+		x = (lo * hh - hi * hl) / (hh - hl);
+		const hx = h(x);
+		if (hx === 0) break;
+		if (hx > 0) {
+			lo = x;
+			hl = hx;
+			if (side === 1) hh /= 2;
+			side = 1;
+		} else {
+			hi = x;
+			hh = hx;
+			if (side === -1) hl /= 2;
+			side = -1;
+		}
+	}
+	return x;
+}
+/** The y in [0, hi] where a rising f(y) reaches `goal`. */
+function root(f, goal, hi) {
+	let lo = 0;
+	for (let k = 0; k < 200 && hi - lo > 1e-15; k++) {
+		const mid = (lo + hi) / 2;
+		if (f(mid) < goal) lo = mid;
+		else hi = mid;
+	}
+	return (lo + hi) / 2;
+}
 /**
 * 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.
@@ -688,9 +1035,9 @@ 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 ±. */
+/** " (capacity estimated ±30 %)"; nothing for a measured capacity without a ± or a configured one. */
 function sureness(c) {
-	if (!c || c.provenance === "measured" && !c.within) return "";
+	if (!c || c.provenance !== "estimated" && !c.within) return "";
 	return ` (capacity ${c.provenance}${c.within ? ` ±${pct(c.within)}` : ""})`;
 }
 function verdict(load, live, first, range, th, searchMax, when) {
@@ -1048,12 +1395,12 @@ const COMPONENT_PROPS = {
 	demand: {
 		value: "number",
 		scope: "ctx",
-		doc: "What the component must handle, in its capacity's unit."
+		doc: "What the component must handle, in its capacity's unit. Without one: the units per second reaching its stages."
 	},
 	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."
+		doc: "What it can handle: measured(value, unit, source) or estimated(value, unit, source), `value ± 30%` saying how sure it is; configured(value, unit, source) for a limit someone set."
 	},
 	when: {
 		value: "boolean",
@@ -1492,7 +1839,11 @@ const SCHEMA = {
 				doc: "A theme colour (accent, alt, ok, warn, drop, muted) or a CSS colour in quotes."
 			}
 		},
-		children: ["drop", "merge"]
+		children: [
+			"drop",
+			"merge",
+			"retry"
+		]
 	},
 	drop: {
 		doc: "Units older than olderThan simulated seconds are dropped before they are handled.",
@@ -1534,6 +1885,30 @@ const SCHEMA = {
 		},
 		children: []
 	},
+	retry: {
+		doc: "A unit turned away on the route (by a pass, limit or cache stage past capacity) is sent again, up to times more times. The attempts settle where the retries they cause are the ones assumed.",
+		example: "retry { times: 3; budget: 0.1 }",
+		args: [],
+		props: {
+			times: {
+				value: "number",
+				scope: "values",
+				doc: "Retries after the first attempt: a whole number. Reads only the parameters.",
+				required: true
+			},
+			budget: {
+				value: "number",
+				scope: "values",
+				doc: "At most this share of the flow is added as retries: 0.1 adds at most 10 %. Without one, every retry is sent."
+			},
+			when: {
+				value: "boolean",
+				scope: "values",
+				doc: "The rule applies only while this is true; it reads only parameters."
+			}
+		},
+		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\") }",
@@ -1568,6 +1943,8 @@ const SCHEMA = {
 			"store",
 			"sink",
 			"fanout",
+			"cache",
+			"limit",
 			"component"
 		]
 	},
@@ -1614,6 +1991,28 @@ const SCHEMA = {
 		props: { component: STAGE_COMPONENT },
 		children: []
 	},
+	cache: {
+		doc: "A share of the units (hit) is answered here and goes no further; the rest carry on to the next stage. Past capacity the share above 100 % is rejected.",
+		example: "cache { hit: 0.8 }",
+		args: STAGE_LABEL,
+		props: {
+			hit: {
+				value: "number",
+				scope: "ctx",
+				doc: "The share answered here, 0 to 1.",
+				required: true
+			},
+			component: STAGE_COMPONENT
+		},
+		children: []
+	},
+	limit: {
+		doc: "A rate limiter: its component's capacity is the limit. Above it the share over is turned away, and the stages after it see only what got through.",
+		example: "limit",
+		args: STAGE_LABEL,
+		props: { component: STAGE_COMPONENT },
+		children: []
+	},
 	store: {
 		doc: "Where a flow ends: written to its component.",
 		example: "store",
@@ -1658,8 +2057,7 @@ const SCHEMA = {
 			pods: {
 				value: "number",
 				scope: "ctx",
-				doc: "How many pods.",
-				required: true
+				doc: "How many pods; an autoscaled pool has autoscale instead."
 			},
 			perPod: {
 				value: "number",
@@ -1675,6 +2073,32 @@ const SCHEMA = {
 			},
 			component: STAGE_COMPONENT
 		},
+		children: ["autoscale"]
+	},
+	autoscale: {
+		doc: "Pods are added and removed to hold each running pod near target, between min and max. The component's capacity is the pool at max pods: it runs out when the pool cannot grow further.",
+		example: "autoscale { min: 2; max: 10; target: 0.7 }",
+		args: [],
+		props: {
+			min: {
+				value: "number",
+				scope: "ctx",
+				doc: "The fewest pods, at least 1.",
+				required: true
+			},
+			max: {
+				value: "number",
+				scope: "ctx",
+				doc: "The most pods.",
+				required: true
+			},
+			target: {
+				value: "number",
+				scope: "ctx",
+				doc: "The utilization each running pod is held at, above 0 and at most 1: 0.7 scales out above 70 %.",
+				required: true
+			}
+		},
 		children: []
 	},
 	fanout: {
@@ -1728,7 +2152,9 @@ const STAGES = [
 	"sink",
 	"queue",
 	"workers",
-	"fanout"
+	"fanout",
+	"cache",
+	"limit"
 ];
 // ../dsl/src/expr.ts
 /** A formula failed while the model ran: where, and why. */
@@ -1836,11 +2262,22 @@ const BUILTINS = {
 		min: 2,
 		result: "capacity",
 		fn: estimated
+	},
+	configured: {
+		args: [
+			"number",
+			"string",
+			"string"
+		],
+		min: 2,
+		result: "capacity",
+		fn: configured
 	}
 };
-/** The tables a formula may read with a ".": flows.orders, demand.db, util.db, derived.x. */
+/** The tables a formula may read with a ".": flows.orders, at.db.orders, demand.db, util.db, derived.x. */
 const TABLES = [
 	"flows",
+	"at",
 	"demand",
 	"util",
 	"derived"
@@ -2005,14 +2442,15 @@ var Compiler$1 = class {
 		return bad;
 	}
 	example(table) {
-		return [...table === "flows" ? this.names.flows : table === "derived" ? this.names.lets.keys() : this.names.components][0] ?? "x";
+		return [...table === "flows" ? this.names.flows : table === "at" ? this.names.stages : table === "derived" ? this.names.lets.keys() : this.names.components][0] ?? "x";
 	}
 	member(e) {
 		const table = e.object.name;
 		const key = e.prop.name;
+		if (table === "at") return this.at(e);
 		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`);
+			this.report.error(e.object, `"${table}" has no entries: only flows., at., demand., util. and derived. do`);
 			return bad;
 		}
 		if (!(table === "derived" ? this.names.lets.has(key) : pool.has(key))) {
@@ -2027,6 +2465,26 @@ var Compiler$1 = class {
 			run: (c) => c[table][key]
 		};
 	}
+	/** at.db: every flow reaching the stage, per second; at.db.orders: one flow. */
+	at(e) {
+		const stage = e.prop.name;
+		if (!this.names.stages.has(stage)) {
+			this.report.error(e.prop, `unknown stage "${stage}"`, didYouMean(stage, this.names.stages));
+			return bad;
+		}
+		const flow = e.flow?.name;
+		if (flow != null && !this.names.flows.has(flow)) {
+			this.report.error(e.flow, `unknown flow "${flow}"`, didYouMean(flow, this.names.flows));
+			return bad;
+		}
+		if (!this.canRead(e, flow == null ? `at.${stage}` : `at.${stage}.${flow}`)) return bad;
+		const flows = [...this.names.flows];
+		return {
+			type: "number",
+			constant: false,
+			run: flow == null ? (c) => flows.reduce((a, f) => a + c.at[stage][f], 0) : (c) => c.at[stage][flow]
+		};
+	}
 	call(e) {
 		const name = e.callee.name;
 		const pm = e.args[0]?.t === "pm" ? e.args[0] : null;
@@ -2771,6 +3229,19 @@ var Parser = class {
 					this.next();
 					const prop = this.ident("a name after \".\"");
 					if (!this.is("(")) {
+						if (callee.name === "at" && this.is(".")) {
+							this.next();
+							const flow = this.ident("a flow after \"at.<stage>.\"");
+							if (this.is(".")) this.fail(this.peek(), "at takes two names: at.db.orders");
+							return {
+								t: "member",
+								object: callee,
+								prop,
+								flow,
+								from: t.from,
+								to: flow.to
+							};
+						}
 						if (this.is(".")) this.fail(this.peek(), "only one \".\" is allowed: flows.orders, util.db");
 						return {
 							t: "member",
@@ -2989,6 +3460,7 @@ var Compiler = class {
 			params: paramTypes,
 			lets: this.lets,
 			flows: new Set(flowNames.keys()),
+			stages: new Set(stageNames.keys()),
 			components: new Set(componentNames.keys()),
 			fits: this.fits,
 			functions: this.functions
@@ -3074,6 +3546,8 @@ var Compiler = class {
 			if (priority != null) def.priority = priority;
 			const overload = this.overload(b);
 			if (overload) def.overload = overload;
+			const retry = this.retry(b);
+			if (retry) def.retry = retry;
 			flowDefs[id.name] = def;
 			const route = this.prop(b, "route");
 			const stages = [];
@@ -3109,6 +3583,8 @@ var Compiler = class {
 			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 used = new Set(Object.values(stageDefs).map((d) => d.component));
+		for (const [id, c] of Object.entries(componentDefs)) if (!c.demand && !used.has(id)) this.report.error(componentNames.get(id), `the component "${id}" needs "demand: …": no stage uses it`, COMPONENT_PROPS.demand.doc);
 		const calibration = {};
 		for (const f of fits) {
 			const fit = f.args.id && this.fits.get(f.args.id.name);
@@ -3706,13 +4182,16 @@ var Compiler = class {
 		if (!rules.length) return void 0;
 		const seen = /* @__PURE__ */ new Set();
 		const parts = [];
+		const props = {
+			drop: ["olderThan", "reason"],
+			merge: ["share", "reason"]
+		};
 		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"]) {
+			for (const k of props[key]) {
 				const v = this.dynProp(r, k, k === "reason" ? "string" : "number");
 				if (v !== void 0) fields.push([k, v]);
 			}
@@ -3736,6 +4215,24 @@ var Compiler = class {
 		};
 		return fixed ? at(void 0) : at;
 	}
+	/** A flow's retry rule: it reads only the load and the parameters, since retries change every other number. */
+	retry(b) {
+		const r = b.children.filter((c) => c.keyword === "retry");
+		if (!r.length) return void 0;
+		if (r.length > 1) this.report.error(r[1].at, "\"retry\" is set twice in this flow");
+		const rule = r[0];
+		const times = this.dynProp(rule, "times", "number");
+		const budget = this.dynProp(rule, "budget", "number");
+		const w = this.prop(rule, "when");
+		const when = w && placed(w.value, this.formula(w.value, "values").run);
+		const at = (v) => {
+			if (when && !when(v)) return void 0;
+			const out = { times: (typeof times === "function" ? times(v) : times) ?? 0 };
+			if (budget !== void 0) out.budget = typeof budget === "function" ? budget(v) : budget;
+			return out;
+		};
+		return !when && typeof times !== "function" && typeof budget !== "function" ? 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);
@@ -3758,16 +4255,12 @@ var Compiler = class {
 			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(…)");
+				if (!isCapacity(v)) throw new Error("a capacity comes from measured(…), estimated(…) or configured(…)");
 			} : 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);
+		for (const k of ["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) {
@@ -3785,18 +4278,46 @@ var Compiler = class {
 		};
 		switch (b.keyword) {
 			case "pass": return component ? pass(component, base) : needs();
+			case "limit": return component ? limit(component, base) : needs();
+			case "cache": {
+				const hit = this.dynProp(b, "hit", "number");
+				return cache({
+					...base,
+					hit: hit ?? 0,
+					...component ? { component } : {}
+				});
+			}
 			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, {
+				const rest = {
 					...base,
-					pods: pods ?? 0,
 					perPod: perPod ?? 0,
 					...fill ? { fill } : {}
+				};
+				const scale = b.children.find((c) => c.keyword === "autoscale");
+				if (scale) {
+					if (this.prop(b, "pods")) this.report.error(this.prop(b, "pods").key, "an autoscaled pool has no fixed pods", "leave out pods");
+					const min = this.dynProp(scale, "min", "number") ?? 1;
+					const max = this.dynProp(scale, "max", "number", this.count("pods")) ?? 1;
+					const target = this.dynProp(scale, "target", "number") ?? 1;
+					return workers(component, {
+						...rest,
+						autoscale: {
+							min,
+							max,
+							target
+						}
+					});
+				}
+				const pods = this.dynProp(b, "pods", "number", this.count("pods"));
+				if (!this.prop(b, "pods")) this.report.error(b.at, "a workers stage needs pods, or autoscale", "pods: 3, or autoscale { min: 2; max: 10; target: 0.7 }");
+				return workers(component, {
+					...rest,
+					pods: pods ?? 0
 				});
 			}
 			case "queue": {