@mark1russell7/kind 0.0.0-stage → 0.1.0

package/build/judge-CW1IX2zP.js

@@ -0,0 +1,1018 @@
+import { format, valueIn } from "@mark1russell7/quantity";
+import { extentSchema, quantitySchema } from "@mark1russell7/quantity/schema";
+import { z } from "zod";
+//#region src/bands.ts
+/** This module makes and prints the bands of the predictions. It imports only the amounts. */
+/** This function gives a time in seconds as a quantity. */
+const seconds = (value) => ({
+	value,
+	unit: "s"
+});
+/** This function gives a band from its two ends in seconds. */
+const bandOf = (lo, hi) => ({
+	lo: seconds(lo),
+	hi: seconds(hi)
+});
+/** This function gives the two ends of a band as numbers of seconds, for arithmetic. */
+const secondsOf = (band) => ({
+	lo: valueIn(band.lo, "s"),
+	hi: valueIn(band.hi, "s")
+});
+/** This function gives a band in a short form for a name or a table: `[28, 49] s`. */
+const showBand = (band) => {
+	const { lo, hi } = secondsOf(band);
+	return `[${lo}, ${hi}] s`;
+};
+//#endregion
+//#region src/names.ts
+/** These are the ports of the app: its server, and its health server for the probes. */
+const PORT = 8080;
+const HEALTH_PORT = 9e3;
+/** This label makes the watcher follow the log of a pod. */
+const LOG_LABEL = "lab.systems/log";
+/** These are the names of the objects of a cell. */
+const SERVER = "lab";
+const CLIENT = "client";
+const REDIS = "redis";
+//#endregion
+//#region src/observe.ts
+const of = (lines, ev) => lines.filter((line) => line.ev === ev);
+const requestsOf = (lines) => of(lines, "req");
+const podsOf = (lines) => of(lines, "pod").sort((a, b) => a.t - b.t);
+const slicesOf = (lines, svc) => of(lines, "slice").filter((line) => line.svc === svc);
+const rulesOf = (lines) => of(lines, "rules").sort((a, b) => a.t - b.t);
+const recordsOf = (lines) => of(lines, "rec");
+/** This function gives the requests that did not succeed, in sequence of their start. */
+const failuresOf = (lines) => requestsOf(lines).filter((request) => request.o !== "ok").sort((a, b) => a.t - b.t);
+/** This function counts the outcomes of the requests, by outcome. */
+const outcomesOf = (requests) => {
+	const out = {};
+	for (const request of requests) out[request.o] = (out[request.o] ?? 0) + 1;
+	return out;
+};
+/** This function gives the requests of each node, by the name of the node. */
+const byNode = (requests) => {
+	const out = /* @__PURE__ */ new Map();
+	for (const request of requests) out.set(request.n, [...out.get(request.n) ?? [], request]);
+	return out;
+};
+/** This function gives the time that the watcher first received a deletion timestamp of one of the pods, after a time. */
+const deletionOf = (lines, pods, after) => podsOf(lines).find((pod) => pods.includes(pod.name) && pod.del && pod.t >= after)?.t ?? null;
+/** This function gives the stamp of a transition of the service in a pod: the first matching record of a machine, after a time. */
+const transitionOf = (lines, pod, machine, match, after) => recordsOf(lines).find((record) => record.p === pod && record.m === machine && record.at >= after && match(record))?.at ?? null;
+/** This function gives when the service of a pod stopped its intake: the start of the phase `stop intake`. */
+const intakeOf = (lines, pod, after) => transitionOf(lines, pod, "drain", (record) => record.to === "stop intake", after);
+/** This function gives when the service of a pod received its exit signal. */
+const signalOf = (lines, pod, after) => transitionOf(lines, pod, "exit", (record) => record.on === "exit.request", after);
+/**
+* This function gives when the rules of a node stopped the selection of a backend: the first poll
+* after a time without it. The change came after `prev`, the poll before it, and at the latest at `t`.
+*/
+const dropOf = (lines, node, backend, after) => rulesOf(lines).find((line) => line.node === node && line.t >= after && !line.b.includes(backend)) ?? null;
+/** This function gives when the rules of a node had no backend of the Service, after a time. */
+const emptyOf = (lines, node, after) => rulesOf(lines).find((line) => line.node === node && line.t >= after && line.b.length === 0) ?? null;
+/** This function gives when an EndpointSlice of the Service first had no ready endpoint, after a time. */
+const sliceEmptyOf = (lines, svc, after) => slicesOf(lines, svc).find((slice) => slice.t >= after && !slice.eps.some((endpoint) => endpoint.r === true))?.t ?? null;
+/** This function gives when the endpoint of an address was first not ready in the EndpointSlice of the Service, after a time. */
+const sliceDropOf = (lines, svc, ip, after) => slicesOf(lines, svc).find((slice) => slice.t >= after && !slice.eps.some((endpoint) => endpoint.ip === ip && endpoint.r === true))?.t ?? null;
+/** This function gives the latest state of each pod at a time, by its name. A deleted pod is not in it. */
+const podsAt = (lines, at) => {
+	const out = /* @__PURE__ */ new Map();
+	for (const pod of podsOf(lines)) {
+		if (pod.t > at) break;
+		if (pod.type === "DELETED") out.delete(pod.name);
+		else out.set(pod.name, pod);
+	}
+	return out;
+};
+/** This function gives the latest backends of each node at a time, by node. */
+const backendsAt = (lines, at) => {
+	const out = /* @__PURE__ */ new Map();
+	for (const line of rulesOf(lines)) {
+		if (line.t > at) break;
+		out.set(line.node, line.b);
+	}
+	return out;
+};
+/** This function gives the kernel records of the kinds that the lab keeps, counted by kind. */
+const kernelCounts = (lines) => {
+	const out = {};
+	for (const line of lines) if (line.ev.startsWith("kernel.")) out[line.ev.slice(7)] = (out[line.ev.slice(7)] ?? 0) + 1;
+	return out;
+};
+/** This function gives the SIGTERM of each pod in a set after a time, by pod. A pod without one is not in it. */
+const signalsOf = (lines, pods, after) => {
+	const out = /* @__PURE__ */ new Map();
+	for (const pod of pods) {
+		const at = signalOf(lines, pod, after);
+		if (at !== null) out.set(pod, at);
+	}
+	return out;
+};
+/** This function gives the restart count of each container of each pod at a time, summed by pod. */
+const restartsAt = (lines, at) => {
+	const out = /* @__PURE__ */ new Map();
+	for (const [name, pod] of podsAt(lines, at)) out.set(name, pod.cs.reduce((sum, status) => sum + status.rc, 0));
+	return out;
+};
+//#endregion
+//#region src/stats.ts
+/** This fraction, δ_rel, is how far the median of a cell can be outside its band and stay equivalent. */
+const RELATIVE = .05;
+/** This function gives the median of sorted values: the middle value, or the mean of the two middle values. */
+const middle = (sorted) => {
+	const half = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 1 ? sorted[half] : (sorted[half - 1] + sorted[half]) / 2;
+};
+/** This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). */
+const quantileOf = (sorted, p) => sorted[Math.min(sorted.length, Math.max(1, Math.ceil(p * sorted.length))) - 1];
+/** This function gives P(X ≤ j) for X ~ Binomial(n, 1/2), exactly. */
+const below = (n, j) => {
+	let term = 1;
+	let sum = 0;
+	for (let i = 0; i <= j; i += 1) {
+		sum += term;
+		term = term * (n - i) / (i + 1);
+	}
+	return sum / 2 ** n;
+};
+/**
+* This function gives the distribution-free interval of a median: [x_(k), x_(n+1−k)], for the
+* largest k whose two tails each hold 2.5 % or less. For eleven runs, it gives [x_(2), x_(10)],
+* at 98.8 %.
+*/
+const medianInterval = (sorted) => {
+	const n = sorted.length;
+	let k = 0;
+	while (k + 1 <= n / 2 && below(n, k) <= .025) k += 1;
+	return k === 0 ? [sorted[0], sorted[n - 1]] : [sorted[k - 1], sorted[n - k]];
+};
+//#endregion
+//#region src/verdict.ts
+/**
+* This time is δ for kind: each time of a run lands in its band ± δ. Its parts are the interval of
+* the poll of the rules (50 ms) and the delay of the watcher. The watcher receives each change after
+* the API server writes it.
+*/
+const KIND_NOISE = {
+	value: 100,
+	unit: "ms"
+};
+/**
+* This time is how much earlier than the end of its window the last failed request can start. A
+* request goes to the closed pod by the choice of the rules, thus the last ones before the end can
+* go to another pod. At 50 requests a second and two pods, 12 requests in sequence miss the closed
+* pod with a chance of 1 in 4096.
+*/
+const LAST_SLACK = {
+	value: 250,
+	unit: "ms"
+};
+/** These are δ and the slack in milliseconds, the unit of the stamps. */
+const NOISE = valueIn(KIND_NOISE, "ms");
+const SLACK = valueIn(LAST_SLACK, "ms");
+/**
+* This function gives the unit of the main value of a cell, from its prediction:
+* - `s` for a time: the removal, the departure or the restart of a band, and the end of a stall.
+* - `{request}` for the failed requests: no failure, a window, a fleet that stays, and a measurement.
+* - `{replica}` for the replicas that received SIGTERM, when no replica must restart.
+*/
+const unitOf = (prediction) => {
+	switch (prediction.kind) {
+		case "removal":
+		case "leaves":
+		case "stalls": return "s";
+		case "restarts": return prediction.band === null ? "{replica}" : "s";
+		default: return "{request}";
+	}
+};
+const sec = (ms) => Math.round(ms) / 1e3;
+const inBand = (value, band) => value >= band.lo - NOISE / 1e3 && value <= band.hi + NOISE / 1e3;
+const time$2 = (value) => value === null ? null : seconds(value);
+/** This function gives a reference event of a run, as a stamp, or null when the run does not have it. */
+const referenceOf = (run, from) => {
+	const lines = run.lines;
+	if (from === "fault") return run.acts.fault;
+	if (from === "resume") return run.acts.resume;
+	if (run.target === null) return null;
+	const deletion = deletionOf(lines, [run.target.pod], run.start);
+	if (from === "deletion") return deletion;
+	return intakeOf(lines, run.target.pod, run.start);
+};
+/**
+* This function gives the propagation of each node for the target of a run. It is the time from
+* its deletion (or its crash) to the first poll of the rules of the node without it. The change
+* came between the poll before (`after`) and that poll (`by`).
+*/
+const propagationOf = (run, from) => {
+	const out = {};
+	if (run.target === null || from === null) return out;
+	const nodes = [...new Set(run.lines.filter((line) => line.ev === "rules").map((line) => String(line["node"])))].sort();
+	for (const node of nodes) {
+		const drop = dropOf(run.lines, node, `${run.target.ip}:${PORT}`, from);
+		out[node] = drop === null ? null : {
+			after: drop.prev === null ? null : seconds(sec(Math.max(0, drop.prev - from))),
+			by: seconds(sec(drop.t - from))
+		};
+	}
+	return out;
+};
+/** This function gives the facts of a run that each table reads: its failures by outcome and node, and the times of its target. */
+const factsOf = (cell, run) => {
+	const lines = run.lines;
+	const failures = failuresOf(lines).filter((request) => request.t >= run.start && request.t <= run.end);
+	const deletion = referenceOf(run, "deletion");
+	const intake = referenceOf(run, "intake");
+	const crash = cell.trigger.kind === "crash" ? run.acts.fault : null;
+	const from = deletion ?? crash;
+	return {
+		failures: failures.length,
+		outcomes: outcomesOf(failures),
+		byNode: Object.fromEntries([...byNode(failures)].map(([node, list]) => [node, list.length])),
+		first: failures.length === 0 ? null : failures[0].t,
+		last: failures.length === 0 ? null : failures.at(-1).t,
+		deletion,
+		intakeAfterDeletion: deletion === null || intake === null ? null : seconds(sec(intake - deletion)),
+		sliceAfter: run.target === null || from === null ? null : time$2((() => {
+			const at = sliceDropOf(lines, "lab", run.target.ip, from);
+			return at === null ? null : sec(at - from);
+		})()),
+		propagation: propagationOf(run, from)
+	};
+};
+/** This function judges one run against the prediction of its cell. */
+const checkRun = (cell, run) => {
+	const lines = run.lines;
+	const facts = factsOf(cell, run);
+	const failures = failuresOf(lines).filter((request) => request.t >= run.start && request.t <= run.end);
+	const prediction = cell.prediction;
+	const unit = unitOf(prediction);
+	const done = (ok, why, value, more = {}) => ({
+		ok,
+		why,
+		value: value === null ? null : {
+			value,
+			unit
+		},
+		facts: {
+			...facts,
+			...more
+		}
+	});
+	switch (prediction.kind) {
+		case "none": {
+			const excluded = prediction.outcomes;
+			const counted = excluded === void 0 ? failures : failures.filter((request) => excluded.includes(request.o));
+			const what = excluded === void 0 ? "requests failed" : `requests ended ${excluded.join(", ")}`;
+			return done(counted.length === 0, counted.length === 0 ? `no ${excluded === void 0 ? "request failed" : `request ended ${excluded.join(", ")}`}` : `${counted.length} ${what}: ${JSON.stringify(facts.outcomes)}`, counted.length);
+		}
+		case "window": {
+			const start = referenceOf(run, prediction.start.from);
+			const end = prediction.end === null ? null : referenceOf(run, prediction.end.from);
+			if (start === null || prediction.end !== null && end === null) return done(false, `the run has no ${start === null ? prediction.start.from : prediction.end.from} reference`, null);
+			const opens = secondsOf(prediction.start.band);
+			const closes = prediction.end === null ? null : secondsOf(prediction.end.band);
+			const lo = start + opens.lo * 1e3 - NOISE;
+			const hi = end === null ? Number.POSITIVE_INFINITY : end + closes.hi * 1e3 + NOISE;
+			const relevant = prediction.nodes === "paused" ? failures.filter((request) => request.n === run.paused) : failures;
+			const others = prediction.nodes === "paused" ? failures.filter((request) => request.n !== run.paused) : [];
+			const outside = relevant.filter((request) => request.t < lo || request.t > hi);
+			const problems = [];
+			if (outside.length > 0) problems.push(`${outside.length} failed requests outside [${sec(lo - start)}, ${sec(hi - start)}] s after ${prediction.start.from}`);
+			if (others.length > 0) problems.push(`${others.length} failed requests on nodes whose kube-proxy did not pause`);
+			if (prediction.certain && relevant.length === 0) problems.push("no request failed in a window that the law opens");
+			if (prediction.certain && end !== null && relevant.length > 0) {
+				const last = relevant.at(-1).t;
+				const earliest = end + closes.lo * 1e3 - NOISE - SLACK;
+				if (last < earliest) problems.push(`the last failed request started ${sec(earliest - last)} s before the window can end`);
+			}
+			const span = relevant.length === 0 ? 0 : sec(relevant.at(-1).t - relevant[0].t);
+			return done(problems.length === 0, problems.length === 0 ? `${relevant.length} failed requests, all in the window (span ${span} s)` : problems.join("; "), relevant.length);
+		}
+		case "removal": {
+			const fault = run.acts.fault;
+			if (fault === null) return done(false, "the run has no fault stamp", null);
+			const empty = sliceEmptyOf(lines, "lab", fault);
+			if (empty === null) return done(false, "the Service kept a ready endpoint", null);
+			const value = sec(empty - fault);
+			const band = secondsOf(prediction.band);
+			const problems = [];
+			if (!inBand(value, band)) problems.push(`the EndpointSlice had no ready endpoint at ${value} s`);
+			const nodes = [...new Set(lines.filter((line) => line.ev === "rules").map((line) => String(line["node"])))].sort();
+			const rules = {};
+			for (const node of nodes) {
+				const drop = emptyOf(lines, node, fault);
+				rules[node] = drop === null ? null : seconds(sec(drop.t - fault));
+				if (drop === null) problems.push(`the rules of ${node} kept a backend`);
+				else if (!inBand(sec(drop.t - fault), {
+					lo: band.lo,
+					hi: band.hi + .05
+				})) problems.push(`the rules of ${node} had no backend at ${sec(drop.t - fault)} s`);
+			}
+			return done(problems.length === 0, problems.length === 0 ? `the Service was empty at ${value} s` : problems.join("; "), value, {
+				sliceEmpty: seconds(value),
+				rules
+			});
+		}
+		case "leaves": {
+			const fault = run.acts.fault;
+			if (fault === null || run.target === null) return done(false, "the run has no fault stamp or no target", null);
+			const at = sliceDropOf(lines, "lab", run.target.ip, fault);
+			if (at === null) return done(false, `${run.target.pod} stayed ready in the EndpointSlice`, null);
+			const value = sec(at - fault);
+			const band = secondsOf(prediction.band);
+			const problems = [];
+			if (!inBand(value, band)) problems.push(`${run.target.pod} left the EndpointSlice at ${value} s`);
+			const propagation = propagationOf(run, fault);
+			for (const [node, drop] of Object.entries(propagation)) {
+				const by = drop === null ? null : valueIn(drop.by, "s");
+				if (by === null) problems.push(`the rules of ${node} kept ${run.target.pod}`);
+				else if (!inBand(by, {
+					lo: band.lo,
+					hi: band.hi + .05
+				})) problems.push(`the rules of ${node} dropped it at ${by} s`);
+			}
+			return done(problems.length === 0, problems.length === 0 ? `${run.target.pod} left at ${value} s` : problems.join("; "), value, {
+				left: seconds(value),
+				propagation
+			});
+		}
+		case "restarts": {
+			const fault = run.acts.fault;
+			if (fault === null) return done(false, "the run has no fault stamp", null);
+			const until = run.acts.heal ?? run.end;
+			const pods = run.replicas.map((replica) => replica.pod);
+			const signals = signalsOf(lines, pods, fault);
+			const inside = [...signals].filter(([, at]) => at <= until);
+			if (prediction.band === null) return done(inside.length === 0, inside.length === 0 ? "no replica received SIGTERM" : `${inside.length} replicas received SIGTERM`, inside.length);
+			const band = secondsOf(prediction.band);
+			const times = pods.map((pod) => {
+				const at = signals.get(pod);
+				return at === void 0 ? null : sec(at - fault);
+			});
+			const missing = times.filter((each) => each === null).length;
+			const off = times.filter((each) => each !== null && !inBand(each, band));
+			const known = times.filter((each) => each !== null).sort((a, b) => a - b);
+			const ok = missing === 0 && off.length === 0;
+			return done(ok, ok ? `each replica received SIGTERM, at ${known.join(", ")} s` : `${missing} replicas without SIGTERM, ${off.length} outside the band (${known.join(", ")} s)`, known.length === 0 ? null : middle(known), { signals: times.map(time$2) });
+		}
+		case "stays": {
+			const fault = run.acts.fault;
+			if (fault === null) return done(false, "the run has no fault stamp", null);
+			const until = run.end;
+			const dropped = run.replicas.filter((replica) => {
+				const at = sliceDropOf(lines, "lab", replica.ip, fault);
+				return at !== null && at <= until;
+			});
+			const refused = failures.filter((request) => request.o === "refused" && request.t >= fault);
+			const problems = [];
+			if (dropped.length > 0) problems.push(`${dropped.length} replicas left the EndpointSlice`);
+			if (refused.length > 0) problems.push(`${refused.length} requests were refused`);
+			return done(problems.length === 0, problems.length === 0 ? `the replicas stayed ready, ${failures.length} requests failed by their dependency` : problems.join("; "), failures.length);
+		}
+		case "stalls": {
+			const fault = run.acts.fault;
+			const heal = run.acts.heal;
+			if (fault === null || heal === null) return done(false, "the run has no fault or heal stamp", null);
+			const old = new Set(run.replicas.map((replica) => replica.pod));
+			const servers = podsOf(lines).filter((pod) => pod.labels["app"] === "lab");
+			const pods = servers.filter((pod) => pod.t >= fault && pod.t <= heal);
+			const deleted = pods.filter((pod) => old.has(pod.name) && pod.del);
+			const newReady = pods.filter((pod) => !old.has(pod.name) && pod.ready);
+			const after = servers.filter((pod) => pod.t > heal);
+			const firstReady = after.find((pod) => !old.has(pod.name) && pod.ready);
+			const finished = firstReady !== void 0 && after.some((pod) => old.has(pod.name) && pod.type === "DELETED");
+			const problems = [];
+			if (deleted.length > 0) problems.push(`${new Set(deleted.map((pod) => pod.name)).size} old pods were deleted while Redis was down`);
+			if (newReady.length > 0) problems.push("a new pod became ready while Redis was down");
+			if (!finished) problems.push("the rollout did not continue after Redis came back");
+			if (problems.length === 0) return done(true, `the rollout waited for Redis, and its first new pod was ready ${sec(firstReady.t - heal)} s after Redis came back`, sec(firstReady.t - heal));
+			return done(false, problems.join("; "), null);
+		}
+		case "measured": return done(true, "measured", facts.failures);
+	}
+};
+/** This function judges a cell on its runs: each counted run must agree, and a median in a band must be equivalent to it. */
+const judgeKind = (cell, runs) => {
+	const counted = runs.filter((run) => !run.warmup && run.void === null);
+	const voided = runs.filter((run) => !run.warmup && run.void !== null).length;
+	const checks = counted.map((run) => checkRun(cell, run));
+	const values = checks.flatMap((check) => check.value === null ? [] : [check.value.value]).sort((a, b) => a - b);
+	const median = values.length === 0 ? null : {
+		value: middle(values),
+		unit: unitOf(cell.prediction)
+	};
+	const failed = checks.filter((check) => !check.ok).length;
+	if (counted.length === 0) return {
+		decision: "void",
+		counted: 0,
+		voided,
+		failed: 0,
+		median: null,
+		why: "no counted run",
+		checks
+	};
+	if (cell.calibrates) return {
+		decision: "calibration",
+		counted: counted.length,
+		voided,
+		failed,
+		median,
+		why: "a calibration of the propagation",
+		checks
+	};
+	if (cell.prediction.kind === "measured") return {
+		decision: "measured",
+		counted: counted.length,
+		voided,
+		failed: 0,
+		median,
+		why: cell.prediction.why,
+		checks
+	};
+	const prediction = cell.prediction;
+	const band = prediction.kind === "removal" || prediction.kind === "leaves" || prediction.kind === "restarts" ? prediction.band : null;
+	if (failed > 0) {
+		const first = checks.find((check) => !check.ok);
+		return {
+			decision: "fails",
+			counted: counted.length,
+			voided,
+			failed,
+			median,
+			why: `${failed} of ${counted.length} runs disagree, the first: ${first.why}`,
+			checks
+		};
+	}
+	if (band !== null && values.length > 0) {
+		const ends = secondsOf(band);
+		const [from, to] = medianInterval(values);
+		const wide = {
+			lo: ends.lo * .95,
+			hi: ends.hi * 1.05
+		};
+		if (to < wide.lo || from > wide.hi) return {
+			decision: "fails",
+			counted: counted.length,
+			voided,
+			failed,
+			median,
+			why: `the median interval [${from}, ${to}] s is outside the band`,
+			checks
+		};
+		if (from < wide.lo || to > wide.hi) return {
+			decision: "extend",
+			counted: counted.length,
+			voided,
+			failed,
+			median,
+			why: `the median interval [${from}, ${to}] s crosses the edge of the band`,
+			checks
+		};
+	}
+	return {
+		decision: "holds",
+		counted: counted.length,
+		voided,
+		failed,
+		median,
+		why: `${counted.length} of ${counted.length} runs agree`,
+		checks
+	};
+};
+//#endregion
+//#region src/record.ts
+/**
+* This module is the raw record of a kind cell: its formats, and the upgrade from the format `/1`
+* to the format `/2`. The lab writes `/2`, and it does not write `/1` again. A reader reads a record
+* of `/1` through `upgrade`, and the meaning of each value stays the same.
+*/
+/** This format is the format that the lab writes. Each amount in it is a quantity. */
+const FORMAT = "systems.kind-cell-record/2";
+/** This format is the first format. Its bands, its medians and its times are numbers. */
+const FORMAT_V1 = "systems.kind-cell-record/1";
+const time$1 = (value) => value === null ? null : seconds(value);
+const band = (old) => ({
+	lo: seconds(old.lo),
+	hi: seconds(old.hi)
+});
+/** The format `/1` gives each part of `cpu.max` in microseconds. */
+const microseconds = (value) => ({
+	value,
+	unit: "us"
+});
+const upgradeTrigger = (trigger) => {
+	const { cpuMax, ...rest } = trigger;
+	return cpuMax === void 0 ? rest : {
+		...rest,
+		cpuMax: {
+			quota: microseconds(cpuMax.quota),
+			period: microseconds(cpuMax.period)
+		}
+	};
+};
+const upgradePrediction = (prediction) => {
+	switch (prediction.kind) {
+		case "window": return {
+			...prediction,
+			start: {
+				from: prediction.start.from,
+				band: band(prediction.start.band)
+			},
+			end: prediction.end === null ? null : {
+				from: prediction.end.from,
+				band: band(prediction.end.band)
+			}
+		};
+		case "removal":
+		case "leaves": return {
+			...prediction,
+			band: band(prediction.band)
+		};
+		case "restarts": return {
+			...prediction,
+			band: prediction.band === null ? null : band(prediction.band)
+		};
+		default: return prediction;
+	}
+};
+/** This function gives a cell of the format `/1` in the format `/2`: its bands in seconds, and its `cpu.max` in microseconds. */
+const upgradeCell = (cell) => ({
+	...cell,
+	trigger: upgradeTrigger(cell.trigger),
+	prediction: upgradePrediction(cell.prediction)
+});
+const upgradeFacts = (facts) => {
+	const propagated = (old) => old === null ? null : {
+		after: time$1(old.after),
+		by: seconds(old.by)
+	};
+	const { sliceEmpty, rules, left, signals, ...rest } = facts;
+	return {
+		...rest,
+		intakeAfterDeletion: time$1(facts.intakeAfterDeletion),
+		sliceAfter: time$1(facts.sliceAfter),
+		propagation: Object.fromEntries(Object.entries(facts.propagation).map(([node, old]) => [node, propagated(old)])),
+		...sliceEmpty === void 0 ? {} : { sliceEmpty: seconds(sliceEmpty) },
+		...rules === void 0 ? {} : { rules: Object.fromEntries(Object.entries(rules).map(([node, old]) => [node, time$1(old)])) },
+		...left === void 0 ? {} : { left: seconds(left) },
+		...signals === void 0 ? {} : { signals: signals.map((old) => time$1(old)) }
+	};
+};
+/**
+* This function gives a record in the format `/2`. A record of `/2` comes back as it is. A record
+* of `/1` gets each amount as a quantity, and each value stays the same:
+* - Each band and each time of a fact is in seconds, as `/1` gives it.
+* - The `cpu.max` of a throttle is in microseconds, as `/1` gives it.
+* - The median and the main value of each run get the unit of the prediction (`unitOf`): seconds,
+*   failed requests (`{request}`) or replicas (`{replica}`).
+*/
+const upgrade = (record) => {
+	if (record.format === "systems.kind-cell-record/2") return record;
+	const unit = unitOf(record.cell.prediction);
+	const amount = (value) => value === null ? null : {
+		value,
+		unit
+	};
+	const verdict = record.verdict;
+	return {
+		format: FORMAT,
+		cell: upgradeCell(record.cell),
+		runs: record.runs,
+		manifests: record.manifests,
+		loads: record.loads,
+		verdict: {
+			...verdict,
+			median: amount(verdict.median),
+			checks: verdict.checks.map((check) => ({
+				...check,
+				value: amount(check.value),
+				facts: upgradeFacts(check.facts)
+			}))
+		},
+		at: record.at
+	};
+};
+/**
+* This function judges a record again, from its cell and its runs, with the judge of this version.
+* It reads a record of `/1` through `upgrade`. The verdict is in the format `/2`.
+*/
+const judge = (record) => {
+	const current = upgrade(record);
+	return judgeKind(current.cell, current.runs);
+};
+//#endregion
+//#region src/report.ts
+/** This function gives the spread of a set of times, or null for none. The percentile is by nearest rank. */
+const timeSpread = (times) => {
+	if (times.length === 0) return null;
+	const sorted = times.map((each) => valueIn(each, "s")).sort((a, b) => a - b);
+	const half = Math.floor(sorted.length / 2);
+	const median = sorted.length % 2 === 1 ? sorted[half] : (sorted[half - 1] + sorted[half]) / 2;
+	return {
+		count: sorted.length,
+		min: seconds(sorted[0]),
+		median: seconds(Math.round(median * 1e3) / 1e3),
+		p99: seconds(quantileOf(sorted, .99)),
+		max: seconds(sorted.at(-1))
+	};
+};
+/** This function gives the prediction of a cell in a short form for a table. */
+const predictionText = (prediction) => {
+	switch (prediction.kind) {
+		case "none": return prediction.outcomes === void 0 ? "no failure" : `no ${prediction.outcomes.join(", ")}`;
+		case "window": return `failures only from the ${prediction.start.from}${prediction.end === null ? "" : ` to the ${prediction.end.from} + ${showBand(prediction.end.band)}`}${prediction.nodes === "paused" ? ", on the paused node" : ""}${prediction.certain ? ", at least one" : ""}`;
+		case "removal": return `Service empty in ${showBand(prediction.band)}`;
+		case "leaves": return `the replica leaves in ${showBand(prediction.band)}`;
+		case "restarts": return prediction.band === null ? "no restart" : `each replica SIGTERM in ${showBand(prediction.band)}`;
+		case "stays": return "stays ready, no refusal";
+		case "stalls": return "the rollout waits for Redis";
+		case "measured": return "measured";
+	}
+};
+/**
+* This function gives the main measurement of a cell in a short form: its median and what it
+* counts. For failed requests, it is the middle count of the counted runs.
+*/
+const medianText = (judged) => {
+	const { cell, verdict } = judged;
+	if (verdict.median === null) return "";
+	if (verdict.median.unit === "{request}") {
+		const failures = judged.runs.filter((run) => !run.warmup && run.void === null).map((run) => factsOf(cell, run).failures).sort((a, b) => a - b);
+		return `${failures.length === 0 ? 0 : failures[Math.floor(failures.length / 2)]} failed requests`;
+	}
+	return format(verdict.median, { digits: 4 });
+};
+/** This function gives the table of the cells in Markdown. Each row has the cell, its plan cell, its mode, its trigger, the prediction, the verdict, its runs and its median. */
+const cellsTable = (judged) => [
+	"| Cell | Plan id | Mode | Trigger | Prediction | Verdict | Runs | Median |",
+	"| --- | --- | --- | --- | --- | --- | --- | --- |",
+	...judged.map((each) => {
+		const { cell, verdict } = each;
+		const runs = verdict.voided === 0 ? `${verdict.counted}` : `${verdict.counted} (+${verdict.voided} void)`;
+		return `| ${cell.name} | ${cell.id} | ${cell.mode} | ${cell.trigger.kind} | ${predictionText(cell.prediction)} | ${verdict.decision} | ${runs} | ${medianText(each)} |`;
+	})
+].join("\n");
+/**
+* This function gives the propagation of each calibration, by node. It is the time from the
+* deletion to the poll of the rules of each node without the pod. It also gives the time to the
+* EndpointSlice and to the stop of the intake.
+*/
+const calibrationOf = (judged) => {
+	const byNode = {};
+	const slice = [];
+	const intake = [];
+	for (const run of judged.runs.filter((each) => !each.warmup && each.void === null)) {
+		const deletion = referenceOf(run, "deletion");
+		for (const [node, drop] of Object.entries(propagationOf(run, deletion))) if (drop !== null) (byNode[node] ??= []).push(drop.by);
+		const facts = factsOf(judged.cell, run);
+		if (facts.sliceAfter !== null) slice.push(facts.sliceAfter);
+		if (facts.intakeAfterDeletion !== null) intake.push(facts.intakeAfterDeletion);
+	}
+	return {
+		nodes: Object.fromEntries(Object.entries(byNode).map(([node, values]) => [node, timeSpread(values)])),
+		all: timeSpread(Object.values(byNode).flat()),
+		slice: timeSpread(slice),
+		intake: timeSpread(intake)
+	};
+};
+//#endregion
+//#region src/schema.ts
+/**
+* This module holds the zod schemas of a kind cell record, in the formats `/1` and `/2`. It names
+* the stages of the shutdown itself, thus it does not load the service. A test holds the names to
+* the service.
+*/
+/** These are the stages of the shutdown of the service, in their sequence. */
+const STAGES = [
+	"fail readiness",
+	"stop intake",
+	"drain",
+	"close transports",
+	"stop the poller",
+	"tear down dependencies",
+	"close the health server"
+];
+const TRIGGERS = [
+	"pod-deletion",
+	"rolling-update",
+	"node-drain",
+	"scale-in",
+	"crash",
+	"liveness-restart",
+	"freeze-process",
+	"rst",
+	"blackhole",
+	"peer-gone-without-close",
+	"app-stall",
+	"rollout",
+	"cpu-throttle"
+];
+const MODES = [
+	"iptables",
+	"ipvs",
+	"nftables"
+];
+const time = quantitySchema("time");
+const extent = extentSchema("time");
+const count = z.number().int().nonnegative();
+const gate = z.enum(["readiness", "liveness"]);
+const reference = z.enum([
+	"deletion",
+	"intake",
+	"fault",
+	"resume"
+]);
+const probe = z.object({
+	period: time,
+	threshold: count,
+	timeout: time
+});
+const timing = z.discriminatedUnion("type", [z.object({
+	type: z.literal("debounce"),
+	interval: time,
+	failAfter: count,
+	recoverAfter: count
+}), z.object({
+	type: z.literal("window"),
+	failAfter: time,
+	recoverAfter: time.optional()
+})]);
+const knobs = z.object({
+	connect_bound: time,
+	request_timeout: time,
+	driver_writeoff_time: extent,
+	keepalive_idle: extent,
+	heartbeat_interval: extent,
+	heartbeat_timeout: time,
+	client_retry_window: extent,
+	retry_base: time,
+	retry_cap: time,
+	close_bound: time,
+	max_connection_age: extent,
+	retrans_giveup_time: extent
+});
+const declaration = z.object({
+	poll: z.object({
+		interval: time,
+		jitter: z.number().min(0).lt(1),
+		timeout: time
+	}),
+	readiness: timing,
+	liveness: timing,
+	startup: time,
+	phases: z.array(z.tuple([z.enum(STAGES), time])),
+	cooperativeWindow: extent,
+	couplings: z.array(z.object({
+		from: gate,
+		to: gate,
+		effect: z.literal("fails")
+	})),
+	redis: z.object({
+		gates: gate.nullable(),
+		knobs,
+		misses: count
+	}).nullable(),
+	flag: gate.nullable(),
+	watchdog: z.object({
+		tick: time,
+		threshold: time
+	}).nullable()
+});
+const replica = z.object({
+	pod: z.string(),
+	node: z.string(),
+	ip: z.string(),
+	version: z.string()
+});
+/** A line keeps each field that its source wrote. The judge reads `ev`, `t` and the fields of its kind. */
+const line = z.object({
+	ev: z.string(),
+	t: z.number()
+}).catchall(z.unknown());
+const run = z.object({
+	env: count,
+	index: z.number().int(),
+	warmup: z.boolean(),
+	start: z.number(),
+	end: z.number(),
+	acts: z.object({
+		fault: z.number().nullable(),
+		heal: z.number().nullable(),
+		resume: z.number().nullable()
+	}),
+	target: replica.nullable(),
+	paused: z.string().nullable(),
+	replicas: z.array(replica),
+	void: z.string().nullable(),
+	lines: z.array(line),
+	dropped: z.record(z.string(), count),
+	notes: z.array(z.string()).optional()
+});
+const manifest = z.object({
+	env: count,
+	scenario: z.object({
+		name: z.string(),
+		kubernetes: z.string(),
+		workers: count,
+		kubeProxy: z.object({
+			mode: z.enum(MODES),
+			minSyncPeriod: time,
+			syncPeriod: time
+		}),
+		cni: z.literal("kindnet"),
+		podSubnet: z.string(),
+		serviceSubnet: z.string()
+	}),
+	cluster: z.object({
+		kind: z.string(),
+		nodeImage: z.string(),
+		server: z.string(),
+		mode: z.string(),
+		docker: z.string(),
+		nodes: z.array(z.object({
+			name: z.string(),
+			kubelet: z.string(),
+			kernel: z.string(),
+			runtime: z.string(),
+			os: z.string()
+		}))
+	}),
+	images: z.record(z.string(), z.string())
+});
+const load = z.object({
+	t: z.number(),
+	idle: z.number(),
+	top: z.array(z.string()),
+	foreign: z.array(z.string())
+});
+/**
+* This function gives the schema of a record whose amounts have one form. The schema `a` is for a
+* time. The schema `main` is for the main value of a run: a time or a count.
+*/
+const recordOf = (a, main) => {
+	const band = z.object({
+		lo: a,
+		hi: a
+	});
+	const prediction = z.discriminatedUnion("kind", [
+		z.object({
+			kind: z.literal("none"),
+			outcomes: z.array(z.string()).optional(),
+			why: z.string()
+		}),
+		z.object({
+			kind: z.literal("window"),
+			nodes: z.enum(["all", "paused"]),
+			start: z.object({
+				from: reference,
+				band
+			}),
+			end: z.object({
+				from: reference,
+				band
+			}).nullable(),
+			certain: z.boolean(),
+			why: z.string()
+		}),
+		z.object({
+			kind: z.literal("removal"),
+			band,
+			why: z.string()
+		}),
+		z.object({
+			kind: z.literal("leaves"),
+			band,
+			why: z.string()
+		}),
+		z.object({
+			kind: z.literal("restarts"),
+			band: band.nullable(),
+			why: z.string()
+		}),
+		z.object({
+			kind: z.literal("stays"),
+			why: z.string()
+		}),
+		z.object({
+			kind: z.literal("stalls"),
+			why: z.string()
+		}),
+		z.object({
+			kind: z.literal("measured"),
+			why: z.string()
+		})
+	]);
+	const cell = z.object({
+		id: z.string(),
+		name: z.string(),
+		template: z.enum(["T07", "T18"]),
+		substitutes: z.string().nullable(),
+		mode: z.enum(MODES),
+		workers: count,
+		trigger: z.object({
+			kind: z.enum(TRIGGERS),
+			hold: time.optional(),
+			lead: time.optional(),
+			cpuMax: z.object({
+				quota: a,
+				period: a
+			}).optional()
+		}),
+		pod: z.object({
+			replicas: count,
+			grace: time,
+			preStop: time,
+			readiness: probe,
+			liveness: probe,
+			startup: probe.nullable()
+		}),
+		declaration,
+		workload: z.object({
+			every: time,
+			timeout: time
+		}),
+		prediction,
+		calibrates: z.boolean(),
+		runs: count
+	});
+	const facts = z.object({
+		failures: count,
+		outcomes: z.record(z.string(), count),
+		byNode: z.record(z.string(), count),
+		first: z.number().nullable(),
+		last: z.number().nullable(),
+		deletion: z.number().nullable(),
+		intakeAfterDeletion: a.nullable(),
+		sliceAfter: a.nullable(),
+		propagation: z.record(z.string(), z.object({
+			after: a.nullable(),
+			by: a
+		}).nullable()),
+		sliceEmpty: a.optional(),
+		rules: z.record(z.string(), a.nullable()).optional(),
+		left: a.optional(),
+		signals: z.array(a.nullable()).optional()
+	});
+	return {
+		cell,
+		verdict: z.object({
+			decision: z.enum([
+				"holds",
+				"fails",
+				"extend",
+				"measured",
+				"calibration",
+				"void"
+			]),
+			counted: count,
+			voided: count,
+			failed: count,
+			median: main.nullable(),
+			why: z.string(),
+			checks: z.array(z.object({
+				ok: z.boolean(),
+				why: z.string(),
+				value: main.nullable(),
+				facts
+			}))
+		}),
+		runs: z.array(run),
+		manifests: z.array(manifest),
+		loads: z.array(load),
+		at: z.string()
+	};
+};
+const v2 = recordOf(time, quantitySchema(["time", "count"]));
+const v1 = recordOf(z.number(), z.number());
+/**
+* This schema accepts a record in the format `/2`. The median and the main value of each run must
+* have the unit of the prediction of the cell (`unitOf`).
+*/
+const kindCellRecordSchema = z.object({
+	format: z.literal(FORMAT),
+	...v2
+}).superRefine((record, ctx) => {
+	const unit = unitOf(record.cell.prediction);
+	const values = [record.verdict.median, ...record.verdict.checks.map((check) => check.value)];
+	for (const value of values) if (value !== null && value.unit !== unit) ctx.addIssue({
+		code: "custom",
+		message: `the main value is in ${value.unit}, and the prediction ${record.cell.prediction.kind} gives ${unit}`
+	});
+});
+/** This schema accepts a record in the format `/1`. */
+const kindCellRecordV1Schema = z.object({
+	format: z.literal(FORMAT_V1),
+	...v1
+});
+/** This function reads a record of either format from parsed JSON, and gives it in the format `/2`. */
+const readRecord = (data) => {
+	const format = typeof data === "object" && data !== null ? data.format : void 0;
+	if (format === "systems.kind-cell-record/1") return upgrade(kindCellRecordV1Schema.parse(data));
+	if (format === "systems.kind-cell-record/2") return kindCellRecordSchema.parse(data);
+	throw new Error(`a kind cell record has the format ${FORMAT} or ${FORMAT_V1}, not ${String(format)}`);
+};
+//#endregion
+export { SERVER as $, dropOf as A, restartsAt as B, RELATIVE as C, backendsAt as D, quantileOf as E, outcomesOf as F, sliceEmptyOf as G, signalOf as H, podsAt as I, CLIENT as J, slicesOf as K, podsOf as L, failuresOf as M, intakeOf as N, byNode as O, kernelCounts as P, REDIS as Q, recordsOf as R, unitOf as S, middle as T, signalsOf as U, rulesOf as V, sliceDropOf as W, LOG_LABEL as X, HEALTH_PORT as Y, PORT as Z, checkRun as _, calibrationOf as a, propagationOf as b, predictionText as c, FORMAT_V1 as d, bandOf as et, judge as f, LAST_SLACK as g, KIND_NOISE as h, readRecord as i, emptyOf as j, deletionOf as k, timeSpread as l, upgradeCell as m, kindCellRecordSchema as n, secondsOf as nt, cellsTable as o, upgrade as p, transitionOf as q, kindCellRecordV1Schema as r, showBand as rt, medianText as s, STAGES as t, seconds as tt, FORMAT as u, factsOf as v, medianInterval as w, referenceOf as x, judgeKind as y, requestsOf as z };
+
+//# sourceMappingURL=judge-CW1IX2zP.js.map