@mark1russell7/kind 0.0.0-stage → 0.1.1

package/build/judge-CDDCr1Z8.d.ts

@@ -0,0 +1,695 @@
+import { Extent, Quantity } from "@mark1russell7/quantity";
+import { z } from "zod";
+import { Coupling, Gate, Poll, Stage, Timing } from "@mark1russell7/service";
+import { RedisKnobs } from "@mark1russell7/service/redis";
+//#region src/scenario.d.ts
+/** A kube-proxy mode is the dataplane of each node: iptables (the default of kind), IPVS or nftables. */
+type KubeProxyMode = "iptables" | "ipvs" | "nftables";
+declare const KUBE_PROXY_MODES: readonly KubeProxyMode[];
+/** A node image is the kind node image of one Kubernetes version, pinned by digest. */
+interface NodeImage {
+  readonly kubernetes: string;
+  readonly image: string;
+}
+/**
+ * These are the node images of kind v0.33.0, from its release notes. The image of Kubernetes 1.37
+ * is v1.37.0. The research names v1.37.1 for some defaults, thus a default that changed in the
+ * patch release is a mismatch to record.
+ */
+declare const NODE_IMAGES: Readonly<Record<string, NodeImage>>;
+/**
+ * A scenario is one kind cluster as data. The lab generates the configuration of kind from it, and
+ * nothing comes from a default of kind. The scenario gives the node count, the version, the mode
+ * of kube-proxy and its sync periods, the CNI and the subnets.
+ */
+interface KindScenario {
+  /** This name names the cluster and its Docker network: lowercase letters, digits and dashes. */
+  readonly name: string;
+  /** This key selects the node image (`NODE_IMAGES`). */
+  readonly kubernetes: string;
+  /** This count is the number of workers. The cluster also has one control plane. */
+  readonly workers: number;
+  readonly kubeProxy: {
+    readonly mode: KubeProxyMode;
+    /** This time is the shortest interval between two syncs of the rules. */
+    readonly minSyncPeriod: Quantity;
+    /** This time is the interval of the full sync of the rules. */
+    readonly syncPeriod: Quantity;
+  };
+  /** This CNI is kindnet, the CNI of kind. Cilium comes later. */
+  readonly cni: "kindnet";
+  readonly podSubnet: string;
+  readonly serviceSubnet: string;
+}
+/** This function gives a scenario with the defaults of Kubernetes for kube-proxy, as explicit values. */
+declare const scenario: (name: string, mode: KubeProxyMode, workers: number, kubernetes?: string) => KindScenario;
+/** This function gives the problems of a scenario: a name that kind refuses, no image for the version, or a count out of range. */
+declare const scenarioProblems: (s: KindScenario) => string[];
+/** This function gives the names of the node containers, as kind names them: the control plane, then each worker. */
+declare const nodeNames: (s: KindScenario) => string[];
+/** This function gives a duration as kube-proxy reads it, in whole milliseconds: `1s`, `500ms`. */
+declare const goDuration: (amount: Quantity) => string;
+/** This function gives the KubeProxyConfiguration patch of a scenario, as kubeadm reads it. */
+declare const kubeProxyPatch: (s: KindScenario) => string;
+/** A kind configuration is the cluster file that `kind create cluster --config` reads. JSON is YAML, thus the lab writes it as JSON. */
+interface KindConfig {
+  readonly kind: "Cluster";
+  readonly apiVersion: "kind.x-k8s.io/v1alpha4";
+  readonly networking: {
+    readonly ipFamily: "ipv4";
+    readonly kubeProxyMode: KubeProxyMode;
+    readonly disableDefaultCNI: boolean;
+    readonly podSubnet: string;
+    readonly serviceSubnet: string;
+  };
+  readonly nodes: ReadonlyArray<{
+    readonly role: "control-plane" | "worker";
+    readonly image: string;
+    readonly labels: Readonly<Record<string, string>>;
+  }>;
+  readonly kubeadmConfigPatches: readonly string[];
+}
+/** This function generates the configuration of kind from a scenario. It refuses a scenario with a problem. */
+declare const kindConfig: (s: KindScenario) => KindConfig;
+/** This function gives the first and the last address of an IPv4 CIDR, as numbers. */
+declare const cidrRange: (cidr: string) => [number, number];
+/** This function tells if two IPv4 CIDRs share an address. */
+declare const cidrOverlap: (a: string, b: string) => boolean;
+//#endregion
+//#region src/cell.d.ts
+/** A template is the topology of a cell: T07, the endpoint lifecycle of a Service, or T18, a health-gated fleet. */
+type Template = "T07" | "T18";
+/**
+ * A trigger is the event or the fault of a cell, by the name of the plan:
+ * - `pod-deletion`, `rolling-update`, `node-drain` and `scale-in` stop a pod with its grace.
+ * - `crash` stops the process of the service with SIGKILL from the node.
+ * - `liveness-restart` fails the liveness check of one replica, and the kubelet restarts it.
+ * - `freeze-process` stops a process with SIGSTOP from the node: kube-proxy on one node (T07), or Redis (T18).
+ * - `rst` and `blackhole` are the rules of the injector of the harness in the namespace of Redis.
+ * - `peer-gone-without-close` drops the segments of Redis, and then Redis goes away.
+ * - `app-stall` blocks the event loop of one replica.
+ * - `rollout` is a rolling update while Redis is down.
+ * - `cpu-throttle` sets `cpu.max` in the cgroup of one replica.
+ * - `none` injects nothing: a calibration measures the path itself.
+ */
+type TriggerKind = "pod-deletion" | "rolling-update" | "node-drain" | "scale-in" | "crash" | "liveness-restart" | "freeze-process" | "rst" | "blackhole" | "peer-gone-without-close" | "app-stall" | "rollout" | "cpu-throttle";
+/**
+ * A trigger is its kind and the settings of its fault. The parameter `A` is the form of an amount:
+ * a quantity in the format `/2`, a number in the format `/1`.
+ */
+interface Trigger<A = Quantity> {
+  readonly kind: TriggerKind;
+  /** This time is how long a fault holds before it ends: a stall, a pause of kube-proxy, a black hole on Redis. */
+  readonly hold?: Quantity | undefined;
+  /** This time is how long before the deletion a pause of kube-proxy starts (T07 `freeze-process`). */
+  readonly lead?: Quantity | undefined;
+  /** This value is the `cpu.max` of a throttle: the quota and the period. The format `/1` gives each one in microseconds. */
+  readonly cpuMax?: {
+    readonly quota: A;
+    readonly period: A;
+  } | undefined;
+}
+/** A kubelet probe is the period, the failure threshold and the timeout of one probe of the pod. */
+interface KubeletProbe {
+  readonly period: Quantity;
+  readonly threshold: number;
+  readonly timeout: Quantity;
+}
+/** The pod settings are the part of the cell that the manifest of the Deployment holds. */
+interface PodSettings {
+  readonly replicas: number;
+  /** This time is `terminationGracePeriodSeconds`. */
+  readonly grace: Quantity;
+  /** This time is the preStop sleep, or zero for no preStop hook. */
+  readonly preStop: Quantity;
+  readonly readiness: KubeletProbe;
+  readonly liveness: KubeletProbe;
+  /** This probe is the startup probe, or null for none, the default of Kubernetes. */
+  readonly startup: KubeletProbe | null;
+}
+/** The Redis part of a declaration: the gate of the round trip of the client, its knobs and its watchdog. */
+interface RedisDeclaration {
+  /** This gate is the policy that the round-trip check controls, or null for a check that only reports. */
+  readonly gates: Gate | null;
+  readonly knobs: RedisKnobs;
+  readonly misses: number;
+}
+/**
+ * A declaration is the settings of the service in the image. The app composes its service from them
+ * with `@mark1russell7/service`, and `lint()` reads the same declaration.
+ */
+interface Declaration {
+  readonly poll: Poll;
+  readonly readiness: Timing;
+  readonly liveness: Timing;
+  readonly startup: Quantity;
+  /** These are the caps of each stage of the shutdown, in the sequence of the stages. */
+  readonly phases: ReadonlyArray<readonly [Stage, Quantity]>;
+  readonly cooperativeWindow: Extent;
+  readonly couplings: readonly Coupling[];
+  /** This part is null for a service without Redis. */
+  readonly redis: RedisDeclaration | null;
+  /** This gate is the policy of the check that a flag file fails, the seam of `liveness-restart`, or null for no such check. */
+  readonly flag: Gate | null;
+  /** This watchdog of the event loop gates liveness: a tick later than the threshold fails it. Null declares no watchdog. */
+  readonly watchdog: {
+    readonly tick: Quantity;
+    readonly threshold: Quantity;
+  } | null;
+}
+/** A workload is the clients: one pod on each node, each with requests on new connections to the ClusterIP. */
+interface Workload {
+  /** This time is the interval between two requests of one client. The clients do not wait for an answer. */
+  readonly every: Quantity;
+  /** This time is how long a client waits for an answer before the request is a timeout. */
+  readonly timeout: Quantity;
+}
+/**
+ * A band is a range of times after a reference event of the run. The format `/1` gives each end
+ * in seconds, as a number.
+ */
+interface Band<A = Quantity> {
+  readonly lo: A;
+  readonly hi: A;
+}
+/**
+ * A reference is the event of a run that a band counts from:
+ * - `deletion`: the first deletion timestamp of a target pod, as the watcher receives it.
+ * - `intake`: the stop of the intake of the target pod, as its service records it.
+ * - `fault`: the commit of the fault, as the injector or the agent stamps it.
+ * - `resume`: the end of a pause of kube-proxy, as the agent stamps it.
+ */
+type Reference = "deletion" | "intake" | "fault" | "resume";
+/**
+ * A prediction is what the cell expects:
+ * - `none`: no request fails in the run.
+ * - `window`: the requests that fail start in a window. The window starts at `start` and ends in
+ *   `end`. With `certain`, at least one request fails.
+ * - `removal`: the Service has no ready endpoint, and the rules of each node have no backend, in the band.
+ * - `leaves`: the target replica leaves the EndpointSlice and the rules of each node in the band.
+ * - `restarts`: each replica receives SIGTERM in the band, or no replica does.
+ * - `stays`: no endpoint leaves the Service, and no request is refused.
+ * - `stalls`: the rollout does not continue while Redis is down, and it ends after Redis is back.
+ * - `measured`: no document bounds the outcome. The run keeps the measurement.
+ */
+type Prediction<A = Quantity> = {
+  readonly kind: "none";
+  /** These outcomes are the failures that the prediction excludes. Without them, it excludes each outcome but `ok`. */
+  readonly outcomes?: readonly string[] | undefined;
+  readonly why: string;
+} | {
+  readonly kind: "window";
+  readonly nodes: "all" | "paused";
+  readonly start: {
+    readonly from: Reference;
+    readonly band: Band<A>;
+  };
+  readonly end: {
+    readonly from: Reference;
+    readonly band: Band<A>;
+  } | null;
+  readonly certain: boolean;
+  readonly why: string;
+} | {
+  readonly kind: "removal";
+  readonly band: Band<A>;
+  readonly why: string;
+} | {
+  readonly kind: "leaves";
+  readonly band: Band<A>;
+  readonly why: string;
+} | {
+  readonly kind: "restarts";
+  readonly band: Band<A> | null;
+  readonly why: string;
+} | {
+  readonly kind: "stays";
+  readonly why: string;
+} | {
+  readonly kind: "stalls";
+  readonly why: string;
+} | {
+  readonly kind: "measured";
+  readonly why: string;
+};
+/** A replica is one pod of the service at the start of a run. */
+interface Replica {
+  readonly pod: string;
+  readonly node: string;
+  readonly ip: string;
+  readonly version: string;
+}
+/**
+ * A kind run is one run of a cell: its lines, the stamps of its acts, and the replicas at its
+ * start. The judge derives each other reference from the lines, thus a holder of the raw record
+ * can judge it again.
+ *
+ * A stamp is a reading of CLOCK_MONOTONIC in milliseconds. It is a point on a clock, not an
+ * amount, thus it stays a number, as in each line.
+ */
+interface KindRun {
+  readonly env: number;
+  readonly index: number;
+  readonly warmup: boolean;
+  /** These stamps are the start and the end of the run. */
+  readonly start: number;
+  readonly end: number;
+  /** These are the stamps of the acts: the start of the fault, its heal, and the end of a pause of kube-proxy. */
+  readonly acts: {
+    readonly fault: number | null;
+    readonly heal: number | null;
+    readonly resume: number | null;
+  };
+  /** This replica is the target of the trigger, or null for a fault on Redis. */
+  readonly target: Replica | null;
+  /** This node is the node whose kube-proxy paused, or null. */
+  readonly paused: string | null;
+  readonly replicas: readonly Replica[];
+  readonly void: string | null;
+  readonly lines: ReadonlyArray<{
+    readonly ev: string;
+    readonly t: number;
+    readonly [field: string]: unknown;
+  }>;
+  /** These counts are the kernel records that the lab did not keep, by kind. */
+  readonly dropped: Readonly<Record<string, number>>;
+  /** These texts tell of an act of the heal or the restore that failed. */
+  readonly notes?: readonly string[] | undefined;
+}
+/** A kind cell is all that one measurement in kind needs, as data. The parameter `A` is the form of an amount. */
+interface KindCell<A = Quantity> {
+  /** This identifier is the cell of the plan that the cell stands for. */
+  readonly id: string;
+  readonly name: string;
+  readonly template: Template;
+  /** This text names a system of the plan that the cell replaces with the service of this repository, or null. */
+  readonly substitutes: string | null;
+  readonly mode: KubeProxyMode;
+  readonly workers: number;
+  readonly trigger: Trigger<A>;
+  readonly pod: PodSettings;
+  readonly declaration: Declaration;
+  readonly workload: Workload;
+  readonly prediction: Prediction<A>;
+  /** This flag marks a calibration: its runs measure the propagation of the endpoints, and nothing fails. */
+  readonly calibrates: boolean;
+  readonly runs: number;
+}
+//#endregion
+//#region src/bands.d.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. */
+declare const seconds: (value: number) => Quantity;
+/** This function gives a band from its two ends in seconds. */
+declare const bandOf: (lo: number, hi: number) => Band;
+/** This function gives the two ends of a band as numbers of seconds, for arithmetic. */
+declare const secondsOf: (band: Band) => {
+  readonly lo: number;
+  readonly hi: number;
+};
+/** This function gives a band in a short form for a name or a table: `[28, 49] s`. */
+declare const showBand: (band: Band) => string;
+//#endregion
+//#region src/names.d.ts
+/** These are the ports of the app: its server, and its health server for the probes. */
+declare const PORT = 8080;
+declare const HEALTH_PORT = 9e3;
+/** This label makes the watcher follow the log of a pod. */
+declare const LOG_LABEL = "lab.systems/log";
+/** These are the names of the objects of a cell. */
+declare const SERVER = "lab";
+declare const CLIENT = "client";
+declare const REDIS = "redis";
+//#endregion
+//#region src/observe.d.ts
+/**
+ * This module reads a run from its lines. Each time is in milliseconds on CLOCK_MONOTONIC. All the
+ * containers of the VM share that clock: the clients, the service, the agents, the injector, the
+ * watcher and the prober.
+ */
+/**
+ * A line is one JSON line of a source of a run, with its stamp `t` in milliseconds on
+ * CLOCK_MONOTONIC. It is a request of a client, a record of the service or a probe answer. It is
+ * also a pod, an EndpointSlice or an event of the API. Or it is the backends of the rules of a
+ * node, a kernel record, or an act of the lab. A record keeps each line as its source wrote it.
+ */
+interface Line {
+  readonly ev: string;
+  readonly t: number;
+  readonly [field: string]: unknown;
+}
+/** A request is one request of a client: its start, its duration in ms, its outcome, its client and the node of the client. */
+interface Request {
+  readonly t: number;
+  readonly d: number;
+  readonly o: string;
+  readonly p: string;
+  readonly n: string;
+  readonly b?: string;
+}
+/** A pod line is one state of a pod, as the watcher received it. */
+interface PodLine {
+  readonly t: number;
+  readonly type: string;
+  readonly name: string;
+  readonly node: string | null;
+  readonly ip: string | null;
+  readonly del: boolean;
+  readonly ready: boolean;
+  readonly phase: string | null;
+  readonly cs: ReadonlyArray<{
+    readonly n: string;
+    readonly r: boolean;
+    readonly rc: number;
+    readonly st: string;
+    readonly id: string | null;
+  }>;
+  readonly labels: Readonly<Record<string, string>>;
+}
+/** An endpoint is one endpoint of an EndpointSlice: its address, its conditions and its pod. */
+interface Endpoint {
+  readonly ip: string | null;
+  readonly r: boolean | null;
+  readonly s: boolean | null;
+  readonly x: boolean | null;
+  readonly pod: string | null;
+  readonly node: string | null;
+}
+/** A slice line is one state of an EndpointSlice. */
+interface SliceLine {
+  readonly t: number;
+  readonly type: string;
+  readonly name: string;
+  readonly svc: string | null;
+  readonly eps: readonly Endpoint[];
+}
+/** A rules line is the backends of the Service in the rules of one node, after a change. `prev` is the start of the poll before it. */
+interface RulesLine {
+  readonly t: number;
+  readonly prev: number | null;
+  readonly node: string;
+  readonly b: readonly string[];
+}
+/** A record line is one transition of a machine of the service, with its own stamp `at`. */
+interface RecordLine {
+  readonly t: number;
+  readonly at: number;
+  readonly p: string;
+  readonly m: string;
+  readonly i: string;
+  readonly from: string;
+  readonly to: string;
+  readonly on: string;
+  readonly d: string | null;
+}
+declare const requestsOf: (lines: readonly Line[]) => Request[];
+declare const podsOf: (lines: readonly Line[]) => PodLine[];
+declare const slicesOf: (lines: readonly Line[], svc: string) => SliceLine[];
+declare const rulesOf: (lines: readonly Line[]) => RulesLine[];
+declare const recordsOf: (lines: readonly Line[]) => RecordLine[];
+/** This function gives the requests that did not succeed, in sequence of their start. */
+declare const failuresOf: (lines: readonly Line[]) => Request[];
+/** This function counts the outcomes of the requests, by outcome. */
+declare const outcomesOf: (requests: readonly Request[]) => Record<string, number>;
+/** This function gives the requests of each node, by the name of the node. */
+declare const byNode: (requests: readonly Request[]) => Map<string, Request[]>;
+/** This function gives the time that the watcher first received a deletion timestamp of one of the pods, after a time. */
+declare const deletionOf: (lines: readonly Line[], pods: readonly string[], after: number) => number | 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. */
+declare const transitionOf: (lines: readonly Line[], pod: string, machine: string, match: (record: RecordLine) => boolean, after: number) => number | null;
+/** This function gives when the service of a pod stopped its intake: the start of the phase `stop intake`. */
+declare const intakeOf: (lines: readonly Line[], pod: string, after: number) => number | null;
+/** This function gives when the service of a pod received its exit signal. */
+declare const signalOf: (lines: readonly Line[], pod: string, after: number) => number | null;
+/**
+ * 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`.
+ */
+declare const dropOf: (lines: readonly Line[], node: string, backend: string, after: number) => RulesLine | null;
+/** This function gives when the rules of a node had no backend of the Service, after a time. */
+declare const emptyOf: (lines: readonly Line[], node: string, after: number) => RulesLine | null;
+/** This function gives when an EndpointSlice of the Service first had no ready endpoint, after a time. */
+declare const sliceEmptyOf: (lines: readonly Line[], svc: string, after: number) => number | null;
+/** This function gives when the endpoint of an address was first not ready in the EndpointSlice of the Service, after a time. */
+declare const sliceDropOf: (lines: readonly Line[], svc: string, ip: string, after: number) => number | null;
+/** This function gives the latest state of each pod at a time, by its name. A deleted pod is not in it. */
+declare const podsAt: (lines: readonly Line[], at: number) => Map<string, PodLine>;
+/** This function gives the latest backends of each node at a time, by node. */
+declare const backendsAt: (lines: readonly Line[], at: number) => Map<string, readonly string[]>;
+/** This function gives the kernel records of the kinds that the lab keeps, counted by kind. */
+declare const kernelCounts: (lines: readonly Line[]) => Record<string, number>;
+/** This function gives the SIGTERM of each pod in a set after a time, by pod. A pod without one is not in it. */
+declare const signalsOf: (lines: readonly Line[], pods: readonly string[], after: number) => Map<string, number>;
+/** This function gives the restart count of each container of each pod at a time, summed by pod. */
+declare const restartsAt: (lines: readonly Line[], at: number) => Map<string, number>;
+//#endregion
+//#region src/verdict.d.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.
+ */
+declare const KIND_NOISE: Quantity;
+/**
+ * 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.
+ */
+declare const LAST_SLACK: Quantity;
+/** A propagated change is when the rules of a node first had it: after the poll `after`, and by the poll `by`. */
+interface Propagated<A = Quantity> {
+  readonly after: A | null;
+  readonly by: A;
+}
+/**
+ * The facts of a run are what each table reads: its failures by outcome and node, and the times of
+ * its target. A count stays a number, and so does a stamp: `first`, `last` and `deletion` are
+ * readings of CLOCK_MONOTONIC in milliseconds. Each other time is an amount after a reference. The
+ * parameter `A` is the form of an amount: a quantity in the format `/2`, seconds in the format `/1`.
+ */
+interface RunFacts<A = Quantity> {
+  readonly failures: number;
+  readonly outcomes: Readonly<Record<string, number>>;
+  readonly byNode: Readonly<Record<string, number>>;
+  readonly first: number | null;
+  readonly last: number | null;
+  readonly deletion: number | null;
+  readonly intakeAfterDeletion: A | null;
+  readonly sliceAfter: A | null;
+  /** This record is the propagation of the target to the rules of each node, by node. */
+  readonly propagation: Readonly<Record<string, Propagated<A> | null>>;
+  /** This time is when the EndpointSlice had no ready endpoint, after the fault (`removal`). */
+  readonly sliceEmpty?: A | undefined;
+  /** These times are when the rules of each node had no backend, after the fault (`removal`). */
+  readonly rules?: Readonly<Record<string, A | null>> | undefined;
+  /** This time is when the target left the EndpointSlice, after the fault (`leaves`). */
+  readonly left?: A | undefined;
+  /** These times are the SIGTERM of each replica, after the fault (`restarts`). */
+  readonly signals?: ReadonlyArray<A | null> | undefined;
+}
+/**
+ * A run check is the judgement of one run: if it agrees with the prediction, why, its main value,
+ * and its facts. The main value is a time, or a count of requests or of replicas (`unitOf`).
+ */
+interface RunCheck<A = Quantity> {
+  readonly ok: boolean;
+  readonly why: string;
+  readonly value: A | null;
+  readonly facts: RunFacts<A>;
+}
+/** A kind decision is the result of a kind cell. */
+type KindDecision = "holds" | "fails" | "extend" | "measured" | "calibration" | "void";
+/** A kind verdict is the judgement of a cell on its counted runs. */
+interface KindVerdict<A = Quantity> {
+  readonly decision: KindDecision;
+  readonly counted: number;
+  readonly voided: number;
+  readonly failed: number;
+  /** This amount is the median of the main value of the counted runs, or null. */
+  readonly median: A | null;
+  readonly why: string;
+  readonly checks: ReadonlyArray<RunCheck<A>>;
+}
+/**
+ * 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.
+ */
+declare const unitOf: (prediction: {
+  readonly kind: Prediction["kind"];
+  readonly band?: unknown;
+}) => string;
+/** This function gives a reference event of a run, as a stamp, or null when the run does not have it. */
+declare const referenceOf: (run: KindRun, from: Reference) => number | null;
+/**
+ * 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`).
+ */
+declare const propagationOf: (run: KindRun, from: number | null) => Record<string, Propagated | null>;
+/** This function gives the facts of a run that each table reads: its failures by outcome and node, and the times of its target. */
+declare const factsOf: (cell: KindCell, run: KindRun) => RunFacts;
+/** This function judges one run against the prediction of its cell. */
+declare const checkRun: (cell: KindCell, run: KindRun) => RunCheck;
+/** This function judges a cell on its runs: each counted run must agree, and a median in a band must be equivalent to it. */
+declare const judgeKind: (cell: KindCell, runs: readonly KindRun[]) => KindVerdict;
+//#endregion
+//#region src/record.d.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. */
+declare const FORMAT = "systems.kind-cell-record/2";
+/** This format is the first format. Its bands, its medians and its times are numbers. */
+declare const FORMAT_V1 = "systems.kind-cell-record/1";
+/** A load sample is what the VM did in 4 s before a run: when (a stamp of the wall clock in milliseconds), its idle share, and its busiest processes. */
+interface LoadSample {
+  readonly t: number;
+  readonly idle: number;
+  readonly top: readonly string[];
+  readonly foreign: readonly string[];
+}
+/** A cluster manifest is what a run records about its cluster: the versions, the images, the nodes and the mode as read back. */
+interface ClusterManifest {
+  readonly kind: string;
+  readonly nodeImage: string;
+  readonly server: string;
+  readonly mode: string;
+  readonly docker: string;
+  readonly nodes: ReadonlyArray<{
+    readonly name: string;
+    readonly kubelet: string;
+    readonly kernel: string;
+    readonly runtime: string;
+    readonly os: string;
+  }>;
+}
+/** An environment manifest is one cluster of a cell: its scenario, what the cluster was, and the images of the lab. */
+interface EnvironmentManifest {
+  readonly env: number;
+  readonly scenario: KindScenario;
+  readonly cluster: ClusterManifest;
+  readonly images: Readonly<Record<string, string>>;
+}
+/**
+ * A kind cell result is a cell, its runs over its environments, the manifest of each environment,
+ * and its verdict. The parameter `A` is the form of an amount.
+ */
+interface KindCellResult<A = Quantity> {
+  readonly cell: KindCell<A>;
+  readonly runs: readonly KindRun[];
+  readonly manifests: readonly EnvironmentManifest[];
+  readonly loads: readonly LoadSample[];
+  readonly verdict: KindVerdict<A>;
+  /** This text is the time of the verdict, in ISO 8601. */
+  readonly at: string;
+}
+/** A kind cell record is the raw record of a cell in the format `/2`: a result with its format. */
+interface KindCellRecord extends KindCellResult {
+  readonly format: typeof FORMAT;
+}
+/** A kind cell record of the format `/1` gives each band, median, main value and time of a fact as a number. */
+interface KindCellRecordV1 extends KindCellResult<number> {
+  readonly format: typeof FORMAT_V1;
+}
+/** These are the parts of the format `/1`, with numbers for amounts. */
+type BandV1 = Band<number>;
+type PredictionV1 = Prediction<number>;
+type TriggerV1 = Trigger<number>;
+type KindCellV1 = KindCell<number>;
+type KindVerdictV1 = KindVerdict<number>;
+type RunCheckV1 = RunCheck<number>;
+type RunFactsV1 = RunFacts<number>;
+/** This function gives a cell of the format `/1` in the format `/2`: its bands in seconds, and its `cpu.max` in microseconds. */
+declare const upgradeCell: (cell: KindCellV1) => KindCell;
+/**
+ * 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}`).
+ */
+declare const upgrade: (record: KindCellRecordV1 | KindCellRecord) => KindCellRecord;
+/**
+ * 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`.
+ */
+declare const judge: (record: KindCellRecordV1 | KindCellRecord) => KindVerdict;
+//#endregion
+//#region src/report.d.ts
+/** A judged cell is a cell, its runs and its verdict: the part of a result that a report reads. */
+interface Judged {
+  readonly cell: KindCell;
+  readonly runs: readonly KindRun[];
+  readonly verdict: KindVerdict;
+}
+/** A spread is the count, the extremes, the median and the 99th percentile of a set of times. */
+interface TimeSpread {
+  readonly count: number;
+  readonly min: Quantity;
+  readonly median: Quantity;
+  readonly p99: Quantity;
+  readonly max: Quantity;
+}
+/** This function gives the spread of a set of times, or null for none. The percentile is by nearest rank. */
+declare const timeSpread: (times: readonly Quantity[]) => TimeSpread | null;
+/** This function gives the prediction of a cell in a short form for a table. */
+declare const predictionText: (prediction: Prediction) => string;
+/**
+ * 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.
+ */
+declare const medianText: (judged: Judged) => string;
+/** 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. */
+declare const cellsTable: (judged: readonly Judged[]) => string;
+/**
+ * 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.
+ */
+declare const calibrationOf: (judged: Judged) => {
+  readonly nodes: Readonly<Record<string, TimeSpread | null>>;
+  readonly all: TimeSpread | null;
+  readonly slice: TimeSpread | null;
+  readonly intake: TimeSpread | null;
+};
+//#endregion
+//#region src/schema.d.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. */
+declare const STAGES: readonly [Stage, ...Stage[]];
+/**
+ * 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`).
+ */
+declare const kindCellRecordSchema: z.ZodType<KindCellRecord>;
+/** This schema accepts a record in the format `/1`. */
+declare const kindCellRecordV1Schema: z.ZodType<KindCellRecordV1>;
+/** This function reads a record of either format from parsed JSON, and gives it in the format `/2`. */
+declare const readRecord: (data: unknown) => KindCellRecord;
+//#endregion
+//#region src/stats.d.ts
+/** This fraction, δ_rel, is how far the median of a cell can be outside its band and stay equivalent. */
+declare const RELATIVE = .05;
+/** This function gives the median of sorted values: the middle value, or the mean of the two middle values. */
+declare const middle: (sorted: readonly number[]) => number;
+/** This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). */
+declare const quantileOf: (sorted: readonly number[], p: number) => number;
+/**
+ * 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 %.
+ */
+declare const medianInterval: (sorted: readonly number[]) => [number, number];
+//#endregion
+export { SliceLine as $, goDuration as $t, TriggerV1 as A, showBand as At, RunFacts as B, Replica as Bt, KindCellResult as C, LOG_LABEL as Ct, PredictionV1 as D, bandOf as Dt, LoadSample as E, SERVER as Et, KindDecision as F, KubeletProbe as Ft, referenceOf as G, KUBE_PROXY_MODES as Gt, factsOf as H, Trigger as Ht, KindVerdict as I, PodSettings as It, Line as J, KubeProxyMode as Jt, unitOf as K, KindConfig as Kt, LAST_SLACK as L, Prediction as Lt, upgrade as M, Declaration as Mt, upgradeCell as N, KindCell as Nt, RunCheckV1 as O, seconds as Ot, KIND_NOISE as P, KindRun as Pt, RulesLine as Q, cidrRange as Qt, Propagated as R, RedisDeclaration as Rt, KindCellRecordV1 as S, HEALTH_PORT as St, KindVerdictV1 as T, REDIS as Tt, judgeKind as U, TriggerKind as Ut, checkRun as V, Template as Vt, propagationOf as W, Workload as Wt, RecordLine as X, NodeImage as Xt, PodLine as Y, NODE_IMAGES as Yt, Request as Z, cidrOverlap as Zt, ClusterManifest as _, sliceDropOf as _t, STAGES as a, failuresOf as at, FORMAT_V1 as b, transitionOf as bt, readRecord as c, outcomesOf as ct, calibrationOf as d, recordsOf as dt, kindConfig as en, backendsAt as et, cellsTable as f, requestsOf as ft, BandV1 as g, signalsOf as gt, timeSpread as h, signalOf as ht, quantileOf as i, scenarioProblems as in, emptyOf as it, judge as j, Band as jt, RunFactsV1 as k, secondsOf as kt, Judged as l, podsAt as lt, predictionText as m, rulesOf as mt, medianInterval as n, nodeNames as nn, deletionOf as nt, kindCellRecordSchema as o, intakeOf as ot, medianText as p, restartsAt as pt, Endpoint as q, KindScenario as qt, middle as r, scenario as rn, dropOf as rt, kindCellRecordV1Schema as s, kernelCounts as st, RELATIVE as t, kubeProxyPatch as tn, byNode as tt, TimeSpread as u, podsOf as ut, EnvironmentManifest as v, sliceEmptyOf as vt, KindCellV1 as w, PORT as wt, KindCellRecord as x, CLIENT as xt, FORMAT as y, slicesOf as yt, RunCheck as z, Reference as zt };
+//# sourceMappingURL=judge-CDDCr1Z8.d.ts.map