@mark1russell7/harness 0.14.3 → 0.15.0

package/build/index.d.ts

@@ -1,5 +1,6 @@
-import { $ as RunRoute, A as MiddleboxExpectation, B as Reference, C as HopWrite, D as KernelRecord, E as Jitter, F as ProbeEvent, G as RouterHop, H as ReplicaSetStage, I as ProxyHop, J as RunBackup, K as RttRange, L as ProxyTime, M as Observer, N as PinnedImage, O as LineMatch, P as Prediction, Q as RunPart, R as Reconnects, S as HopSignal, T as ImageSource, U as Replies, V as ReplicaSet, W as RequestPrediction, X as RunFabric, Y as RunDrill, Z as RunGroup, _ as GroupPrediction, a as Cluster, at as Stage, b as HopEvent, c as Drill, ct as Target, d as Fabric, dt as WsProbe, et as RunTopology, f as FabricManifest, ft as isHopPlace, g as GroupPlace, h as Group, i as ClientImage, it as ShippedImage, j as MiddleboxForm, k as MiddleboxEvent, l as DriverBand, lt as Topology, m as FaultPlace, n as Cell, nt as SentinelStage, o as ClusterClientAt, ot as StageBand, p as Fault, pt as latestEndOf, q as Run, r as Client, rt as Shipped, s as ClusterStage, st as Subject, t as BuildImage, tt as SentinelEvent, u as DriverStep, ut as Toxic, v as GroupRole, w as HttpProbe, x as HopPlace, y as Hop, z as Recovers } from "./cell-B3-BSTit.js";
+import { $ as ProxyHop, A as ImageSource, At as Subject, B as LoadStream, C as Hop, Ct as RunTopology, D as HopWrite, Dt as ShippedImage, E as HopSignal, Et as Shipped, F as LineCount, Ft as isHopPlace, G as Outcomes, H as MiddleboxExpectation, I as LineMatch, It as latestEndOf, J as PausePrediction, K as Pair, L as LoadBand, M as Kafka, Mt as Topology, N as KafkaPause, Nt as Toxic, O as HostSysctl, Ot as Stage, P as KernelRecord, Pt as WsProbe, Q as ProbeEvent, R as LoadPlan, S as GroupRole, St as RunStream, T as HopPlace, Tt as SentinelStage, U as MiddleboxForm, V as MiddleboxEvent, W as Observer, X as PortsPrediction, Y as PinnedImage, Z as Prediction, _ as Fault, _t as RunFabric, a as ClientCapability, at as Reconnects, b as GroupPlace, bt as RunPause, c as ClusterClientAt, ct as ReplicaSet, d as CountBand, dt as RequestPrediction, et as ProxyTime, f as Drill, ft as RouterHop, g as FabricManifest, gt as RunDrill, h as Fabric, ht as RunBackup, i as Client, it as QueuePrediction, j as Jitter, jt as Target, k as HttpProbe, kt as StageBand, l as ClusterStage, lt as ReplicaSetStage, m as DriverStep, mt as Run, n as CLIENT_CAPABILITIES, nt as QueueConnection, o as ClientImage, ot as Recovers, p as DriverBand, pt as RttRange, q as PauseBand, r as Cell, rt as QueueEnd, s as Cluster, st as Reference, t as BuildImage, tt as QueueBand, u as ConntrackPrediction, ut as Replies, v as FaultPlace, vt as RunGroup, w as HopEvent, wt as SentinelEvent, x as GroupPrediction, xt as RunRoute, y as Group, yt as RunPart, z as LoadPrediction } from "./cell-biffSiEJ.js";
 import { Quantity } from "@mark1russell7/quantity";
+import { LoadMeasure, Schedule } from "@mark1russell7/rigor-chaos";
 import { StartedTestContainer } from "testcontainers";
 //#region src/application.d.ts
 /**
@@ -135,6 +136,95 @@ interface CallReading {
 /** This function reads the call that the client sent into the fault: its `call-error` or `data` line after the request. */
 export declare const callOf: (events: readonly ProbeEvent[], request: ProbeEvent, detected: number | undefined) => CallReading;
 //#endregion
+//#region src/load.d.ts
+/**
+ * The measure and the verdict of an open-loop cell (SYS-68). A client on a schedule sends each
+ * arrival at its time, thus a stall counts in each arrival that it delayed. The package rigor-chaos
+ * counts each latency from the planned time. The package rigor-bench judges a quantile by a
+ * distribution-free interval.
+ */
+/** This path is where the client of an open-loop cell finds its schedule. */
+export declare const SCHEDULE_PATH = "/tmp/schedule.json";
+/**
+ * This function gives the measure of one run of a schedule from the lines of its client. It gives
+ * null when the client did not start the schedule. The first `sent` line of a client is its request
+ * before `ready`, and it names no arrival. The end of the run is its last line.
+ */
+export declare const loadOf: (events: readonly ProbeEvent[], plan: Schedule) => RunLoad | null;
+/**
+ * A run load is the measure of one run of a schedule. `failed` counts the replies with a status
+ * outside 200 to 299. Such a reply is a completion, thus its time is in `latency`. The client
+ * `schedule` gives no status, and a record from before this field has none: both read as 0.
+ */
+type RunLoad = LoadMeasure & {
+  readonly failed?: number;
+};
+/** This path is where the client `load` finds its plan. */
+export declare const LOAD_PATH = "/tmp/load.json";
+/** This text is the format of the plan of the client `load`. */
+export declare const LOAD_FORMAT = "systems-load/1";
+/**
+ * This function gives the schedule of each stream of a cell, and the text of the plan of the client
+ * `load`. It throws for no stream, for two streams with one key and for a stream with no request.
+ */
+export declare const loadPlanOf: (streams: readonly LoadStream[]) => {
+  readonly streams: readonly RunStream[];
+  readonly content: string;
+};
+/**
+ * This function gives the measure of each stream of a run of the client `load`, and their pool. Each
+ * stream counts its arrivals from 0, thus the lines of a stream are the lines with its key. The pool
+ * sums the counts and joins the times, in the order of the streams. It gives null when the client did
+ * not start its schedule.
+ */
+export declare const streamsLoadOf: (events: readonly ProbeEvent[], streams: readonly RunStream[]) => {
+  readonly pool: RunLoad;
+  readonly streams: Readonly<Record<string, RunLoad>>;
+} | null;
+/** A load spread is a part of the distribution of one measure of an open-loop cell, over its counted runs. */
+interface LoadSpread {
+  readonly p50: Quantity;
+  readonly p99: Quantity;
+  readonly max: Quantity;
+}
+/**
+ * A load verdict sums the schedule of an open-loop cell over its counted runs. `latency` counts from
+ * the planned time, and `service` counts from the send: the measure of a closed-loop driver. Each
+ * arrival with no reply counts in `latency` at its age at the end of its run, a lower bound.
+ */
+interface LoadVerdict {
+  readonly planned: number;
+  readonly unsent: number;
+  readonly unfinished: number;
+  /** This count is the replies with a status of a failure, over the counted runs. */
+  readonly failed: number;
+  readonly latency: LoadSpread | null;
+  readonly service: LoadSpread | null;
+  readonly lag: LoadSpread | null;
+  /** This text is the verdict of each band, in the order of the prediction. */
+  readonly bands: readonly string[];
+  /** This text is the verdict of the share of failed arrivals, when the prediction has a limit on it. */
+  readonly failures?: string;
+}
+/** This record is what the verdict of a cell takes from its load: the runs that broke the schedule, and the sum. */
+interface LoadJudgement {
+  readonly holds: boolean;
+  readonly outside: ReadonlyArray<{
+    readonly run: string;
+    readonly why: string;
+  }>;
+  readonly load: LoadVerdict;
+}
+/**
+ * This function judges the load of an open-loop cell over its counted runs. A run that did not keep
+ * its schedule measures its driver, not the target, thus it is a finding of that run. Each
+ * band reads all the arrivals of the counted runs.
+ */
+export declare const loadVerdict: (prediction: LoadPrediction, runs: ReadonlyArray<{
+  readonly name: string;
+  readonly load: RunLoad | undefined;
+}>) => LoadJudgement;
+//#endregion
 //#region src/driver.d.ts
 /**
  * This module measures a run of a cell whose client is a driver with more than one socket, for
@@ -204,6 +294,103 @@ export declare const referenceOf: (run: Run, from: Reference, role: string, data
  */
 export declare const measureDriver: (cell: Cell, run: Run) => Measured;
 //#endregion
+//#region src/conntrack.d.ts
+/** This record is the end of a connect that found no entry at its start. */
+interface StallReading {
+  readonly errno: string;
+  readonly time: Quantity;
+  /** This count is the rise of the field `drop` of the conntrack statistics during the connect. */
+  readonly drops: number;
+  /** This count is the rise of `TCPRetransFail` during the connect. */
+  readonly retransFail: number;
+}
+/** This record is what a run of a conntrack cell measured. */
+interface ConntrackReading {
+  /** This count is the flows that the client holds at its `full` line. */
+  readonly flows: number;
+  /** This count is what the namespace of the client reads at that line. */
+  readonly count: number;
+  /** This count is what the namespace of the target reads while the client holds its flows. */
+  readonly neighbor: number | null;
+  readonly stall: StallReading | null;
+  /** This time is from the `closing` line to the first fall of the count. */
+  readonly firstFall: Quantity | null;
+  /** This time is from the `closing` line to the zero of the count. */
+  readonly zero: Quantity | null;
+  /** This count is what the namespace reads after each side closes. */
+  readonly closed: number | null;
+  /** This count is the lowest that the poll of the count read. */
+  readonly lowest: number | null;
+  /** This count is what the namespace reads after a connect that got a slot. */
+  readonly after: number | null;
+}
+/**
+ * This function reads one run of a conntrack cell from the lines of its client and its target. An
+ * `unsettled` line makes the run void. The entries of the run before it were still in the table, thus
+ * the run did not start from an empty table.
+ */
+export declare const measureConntrack: (run: Run, expected: ConntrackPrediction) => Measured;
+//#endregion
+//#region src/pause.d.ts
+/**
+ * This module reads one run of a paused consumer against its law. Two members of a group each hold
+ * one partition. A SIGSTOP stops the first member while it holds a batch, and a SIGCONT ends that
+ * stop. Three sources give the reading: the lines of each member, the log lines of the brokers, and
+ * the stamps of the injector.
+ *
+ * The broker writes its log on the clock of the wall, and the members and the injector use the
+ * monotonic clock. The `start` line of a member has both clocks, thus it converts a log line.
+ */
+/** A commit reading is the first commit of the stopped member after the stop. */
+interface PauseCommit {
+  readonly acked: boolean;
+  /** This name is the class of the error of the commit. It is null for a commit that the broker acknowledged. */
+  readonly name: string | null;
+  readonly message: string | null;
+  /** This number is the epoch that the member held at the commit. */
+  readonly epoch: number | null;
+}
+/** A pause reading is what one run of a paused consumer measured. Each offset is the next offset to read, as a commit names it. */
+interface PauseReading {
+  /** This number is the partition of the stopped member before the stop. */
+  readonly partition: number;
+  /** This time is from the stop to the log line of the broker that removes the member. It is null when no such line came. */
+  readonly fence: Quantity | null;
+  /** This time is from the stop to the first report of the partition by the other member. It is null when no report came. */
+  readonly takeover: Quantity | null;
+  readonly commit: PauseCommit | null;
+  /** This number is the epoch at the last acknowledged commit before the stop. */
+  readonly epochBefore: number | null;
+  /** This offset is the last acknowledged commit of the stopped member before the stop. */
+  readonly lastAck: number;
+  /** This offset is the first offset of the partition that the other member read after the stop. */
+  readonly otherFirst: number | null;
+  /** This offset is the last acknowledged commit of the other member on the partition, before the commit of the stopped member. */
+  readonly otherLast: number | null;
+  /** This time is from the end of the stop to the new epoch of the member. It is null when no new epoch came. */
+  readonly rejoin: Quantity | null;
+  /** This value tells if the stopped member reported the partition again between the end of the stop and its commit. */
+  readonly reassigned: boolean;
+  /** This offset is the committed offset that the member read after its commit. */
+  readonly committed: number | null;
+  /** This offset is what the first commit after the stop names for the partition. */
+  readonly stale: number | null;
+}
+/** This function gives the time of a log line on the monotonic clock of a member, in ns, from the `start` line of that member. It is null for a line with no stamp. */
+export declare const logTimeOf: (line: string, start: ProbeEvent) => number | null;
+/**
+ * This function tells if the two members can take the fault. Each member holds one partition, the
+ * two partitions differ, and the first member has two acknowledged commits on its partition after its
+ * last change. Thus the first member reads and commits at a steady rate.
+ */
+export declare const pauseReady: (first: readonly ProbeEvent[], other: readonly ProbeEvent[]) => boolean;
+/** This function tells if a log line of a broker tells that a member left a group, under either protocol. */
+export declare const isFenceLine: (line: string) => boolean;
+/** This function tells if a fence line names a group. The two protocols write the name in different words. */
+export declare const namesGroup: (line: string, group: string) => boolean;
+/** This function reads one run of a paused consumer against its law. */
+export declare const measurePause: (run: Run, prediction: PausePrediction) => Measured;
+//#endregion
 //#region src/recovery.d.ts
 /**
  * This module holds the pure parts of a recovery drill. These are the scripts of the shell, the reader
@@ -295,6 +482,9 @@ interface ErrorOnTheWay {
  *   of a split brain. It is null when the group did not converge after the run.
  * - `unknown` are the writes that the client sent and did not see accepted: an error, or no answer.
  *   `held` tells if the group kept each one, or null when it did not converge.
+ * - `duplicates` has one entry for each extra copy that the group holds: a write held three times
+ *   has two entries. It is null when the group did not converge. A key holds one copy by
+ *   construction, thus only a list can show a copy.
  */
 interface Writes {
   readonly sent: number;
@@ -305,6 +495,18 @@ interface Writes {
     readonly n: number;
     readonly held: boolean | null;
   }>;
+  readonly duplicates?: readonly number[] | null;
+  /** These are the counts of a pair (`Cell.pair`), from its two final reads. */
+  readonly sets?: PairSets;
+}
+/** These are the counts that the bands of `Outcomes` judge: each one has the same name there. */
+interface PairSets {
+  readonly unknown: number;
+  readonly kept: number;
+  readonly stranded: number;
+  readonly absent: number;
+  readonly missing: number;
+  readonly warnings: number;
 }
 /** A group measurement is what one run of a group cell measured, beside its time. */
 interface GroupMeasured {
@@ -406,6 +608,78 @@ interface GroupReading {
  */
 export declare const measureGroup: (cell: Cell, run: Run) => GroupReading;
 //#endregion
+//#region src/ports.d.ts
+/** This record is what a run of a port cell measured. */
+interface PortsReading {
+  /** This count is the rounds of the run, each destination once. */
+  readonly rounds: number;
+  /** This record gives the count of searches for each count of connects, by that count. */
+  readonly counts: Readonly<Record<string, number>>;
+  /** These offsets from the low port are the ports that the run used, in rising order. */
+  readonly seen: readonly number[];
+  /** These errnos ended the searches of the run, each one time. */
+  readonly errnos: readonly string[];
+  /** This time is the longest connect that failed. */
+  readonly refusal: Quantity;
+  /** This time is from the `closing` line to the first `freed` line. */
+  readonly firstFreed: Quantity | null;
+  /** This time is from the `closing` line to the last `freed` line. */
+  readonly lastFreed: Quantity | null;
+  /** This count is the `freed` lines of the run. */
+  readonly freed: number;
+  /** This count is the connects that failed before the last `freed` line. */
+  readonly tries: number;
+}
+/**
+ * This function reads one run of a port cell. The `round` lines give each search. The `closing` and
+ * `freed` lines give when each held port comes back. The records of the prober give the
+ * retransmissions.
+ */
+export declare const measurePorts: (run: Run, expected: PortsPrediction) => Measured;
+//#endregion
+//#region src/queue.d.ts
+/** This record is what one connection of a queue cell did, from its lines and the records of its socket. */
+interface QueueConnectionReading {
+  readonly name: string;
+  readonly connected: boolean;
+  /** These times are the waits of the SYN. The first one counts from the dial. */
+  readonly syns: readonly Quantity[];
+  /** These times are the waits of each SYN-ACK sent again. The first one counts from the dial. */
+  readonly synAcks: readonly Quantity[];
+  /** This count is the segments that the socket sent again. */
+  readonly retransmissions: number;
+  readonly errno: string | null;
+  /** This time is from the line of the prediction to the end of the connection. It is null for a live connection, or with no prediction. */
+  readonly ended: Quantity | null;
+  /** This time is from the last retransmission to the end of the connection. */
+  readonly afterLast: Quantity | null;
+  /** This count is the segments of the socket with no acknowledgment at the end of the run. */
+  readonly unacked: number | null;
+}
+/** This record is what a run of a queue cell measured. The counts are the changes in the run. */
+interface QueueReading {
+  readonly max: number;
+  readonly held: number;
+  readonly connected: number;
+  readonly overflows: number;
+  readonly drops: number;
+  readonly cookies: number;
+  readonly timeouts: number;
+  readonly resets: number;
+  readonly drained: number;
+  /** This time is from the first dial of the burst to the last `TCPTimeouts` of the prediction. */
+  readonly expiry: Quantity | null;
+  /** This time is from the first dial of the burst to the rise of the count of the queue. */
+  readonly rise: Quantity | null;
+  readonly connections: readonly QueueConnectionReading[];
+}
+/**
+ * This function reads one run of a queue cell. The client lines give the connections and the
+ * counters at the two ends of the run. The target lines give the count of the queue. The records of
+ * the prober give the waits of each socket.
+ */
+export declare const measureQueue: (run: Run, expected: QueuePrediction) => Measured;
+//#endregion
 //#region src/verdict.d.ts
 /** This function gives the words of the outcome of a second request: its connection, a retry, and its end. */
 export declare const requestWords: (outcome: {
@@ -509,6 +783,8 @@ interface Verdict {
   readonly slowest?: Quantity;
   /** This record is the sum of what reordering did in each counted run of a measurement-only cell. */
   readonly reordering?: Reordering;
+  /** This record is the load of an open-loop cell over its counted runs. */
+  readonly load?: LoadVerdict;
   /** This record is the time of the proxy of a calibration cell, in each direction. */
   readonly proxy?: {
     readonly hop: string;
@@ -577,6 +853,8 @@ interface StageVerdict {
  * - `unknown` counts the writes whose outcome the client did not see, and how many the group kept.
  * - `errors` are the errors on the way: the runs that met each, and the median of its first time.
  * - `lags` is the spread of the delays of the stamps, for a calibration.
+ * - `duplicates` counts the extra copies that the group holds, in each run. A cell with no band of
+ *   copies has no such count.
  */
 interface GroupVerdict {
   readonly stages: readonly StageVerdict[];
@@ -601,6 +879,12 @@ interface GroupVerdict {
     readonly first: Quantity;
   }>;
   readonly lags?: Spread | null;
+  readonly duplicates?: {
+    readonly runs: number;
+    readonly total: number;
+    readonly median: number | null;
+    readonly max: number | null;
+  };
 }
 /**
  * This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). It is
@@ -688,6 +972,8 @@ interface Measured {
    * sample is the time from its send to the first data after it.
    */
   readonly samples?: readonly Quantity[];
+  /** This measure is the run of an open-loop cell against its schedule (`Run.schedule`), with its failed replies. Its times are in ms. */
+  readonly load?: RunLoad;
   /** This count is the number of keepalive probes that the kernel sent. */
   readonly probes: number;
   /** This count is the number of segments that the kernel sent again. */
@@ -712,6 +998,12 @@ interface Measured {
   readonly crossings?: Crossings;
   /** This record is what a run of a group cell measured: the stages of its timeline, and what became of each write. */
   readonly group?: GroupMeasured;
+  /** This record is what a run of a queue cell measured: the count of the queue, its counters, and each connection. */
+  readonly queue?: QueueReading;
+  /** This record is what a run of a port cell measured: the count of each search, and when each port came back. */
+  readonly ports?: PortsReading;
+  /** This record is what a run of a conntrack cell measured: the flows, the count, and when a slot came back. */
+  readonly conntrack?: ConntrackReading;
   /** This record is what the second request of an HTTP client met, for a cell whose prediction says it. */
   readonly request?: RequestReading | null;
   /** This record is the time of each later band of a driver cell (`DriverBand.then`). */
@@ -740,6 +1032,8 @@ interface Measured {
    * reader can check each pairing of the run again.
    */
   readonly pairing?: Pairing;
+  /** This record is what a run of a paused consumer measured. */
+  readonly pause?: PauseReading;
   /** This text is the reason that the run cannot count, or null. A void run is not a pass and not a finding. */
   readonly void: string | null;
   /** This text tells what in the run disagrees with the prediction, other than its timing, or null. */
@@ -1102,6 +1396,8 @@ export declare const pgClientImage: () => Promise<string>;
 export declare const hikariClientImage: () => Promise<string>;
 /** This function gives the image of the RabbitMQ client: amqplib, with the client and the admin of a cluster cell. */
 export declare const amqpClientImage: () => Promise<string>;
+/** This function gives the image of the Kafka client: kafka-clients on Java, with the client and the admin of a Kafka cell. */
+export declare const kafkaClientImage: () => Promise<string>;
 /** This function gives the image of the gRPC client of the harness: grpc-js 1.14.6 on Node 24.21.0, with its client. */
 export declare const grpcClientImage: () => Promise<string>;
 /**
@@ -1239,6 +1535,8 @@ interface FaultOptions {
   readonly code?: "host" | "net" | "port" | "admin";
   /** This length is the longest segment in bytes that an MTU drop lets through. */
   readonly above?: number;
+  /** These are the addresses that the rule faces, in place of the peer of its place. */
+  readonly peers?: readonly string[];
 }
 /**
  * A fault side is the namespace that gets the rules of a fault: the namespace of the peer of the
@@ -1260,6 +1558,14 @@ interface ManifestHop {
   /** These are the sysctls of the namespace of the hop, as read back after the harness set them. */
   readonly sysctls: Readonly<Record<string, string>>;
 }
+/** This record is one sysctl of the host for one environment, as the harness read it. */
+interface HostSetting {
+  readonly name: string;
+  readonly before: string;
+  readonly set: string;
+  /** This value is the read after the restore. It is null until the restore. */
+  readonly restored: string | null;
+}
 /** A manifest is what a lab records about its machine, its images and its settings. */
 interface Manifest {
   readonly kernel: string;
@@ -1313,6 +1619,7 @@ interface Manifest {
   readonly client: {
     readonly kind: Client | "image";
     readonly image: string;
+    readonly capabilities?: readonly ClientCapability[];
     readonly source?: ImageSource;
     readonly build?: BuildRecord;
   };
@@ -1324,6 +1631,8 @@ interface Manifest {
   };
   /** These are the sysctls of the client namespace, as read back after the harness set them. */
   readonly sysctls: Readonly<Record<string, string>>;
+  /** These are the sysctls of the host that the cell set: each value before, as set, and as restored. */
+  readonly host?: readonly HostSetting[];
   /** These are the hops of a topology, in sequence from the client. */
   readonly hops?: readonly ManifestHop[];
   /** These are the parts of a group, with their settings as each part read them back. */
@@ -1380,8 +1689,17 @@ interface Agent {
   exec(argv: readonly string[]): Promise<string>;
   stop(): Promise<void>;
 }
+/** A sibling is a server that a lab starts on the network of the target, for example a standby. */
+interface Sibling {
+  readonly ip: string;
+  readonly netns: number;
+  /** This method starts a command in the sibling, and gives its standard output. */
+  exec(argv: readonly string[]): Promise<string>;
+}
 /** A lab is one environment: the target, the client, the hops of a topology, the injectors and the prober. */
 interface Lab {
+  /** This address is the address of the target on its own network. */
+  readonly serverIp: string;
   /** This address is the address that the client connects to: the target, or the first proxy of a topology. */
   readonly targetIp: string;
   /** This port is the port that the client connects to. */
@@ -1412,6 +1730,10 @@ interface Lab {
   agent(image: string, command: readonly string[], options?: {
     readonly pid?: boolean;
   }): Promise<Agent>;
+  /** This method starts a sibling, and waits for a line of its log. */
+  sibling(image: string, command: readonly string[], ready: string): Promise<Sibling>;
+  /** This method starts a command in the target, and gives its standard output. */
+  exec(argv: readonly string[]): Promise<string>;
   /** These are all the records that the prober wrote, in sequence. */
   readonly kernel: readonly KernelRecord[];
   /** This method sets the sysctls of the client namespace through its privileged sidecar, and reads them back. */
@@ -1420,6 +1742,12 @@ interface Lab {
   configure(values: Readonly<Record<string, string>>): Promise<Record<string, string>>;
   /** This method sets the sysctls of the target namespace through a privileged sidecar there, and reads them back. */
   targetSysctl(values: Readonly<Record<string, string>>): Promise<Record<string, string>>;
+  /** This method runs each command in the namespace of the client and in the namespace of the target. */
+  namespaceSetup(commands: readonly (readonly string[])[]): Promise<void>;
+  /** This method sets sysctls of the host through a privileged sidecar on the network of the host, and reads them back. */
+  hostSysctl(settings: readonly HostSysctl[]): Promise<void>;
+  /** This method puts back each value that `hostSysctl` changed, once, and gives the record of each. Closing the lab also does it. */
+  restoreHost(): Promise<readonly HostSetting[]>;
   /**
    * This method applies a fault between the client and the target, by default from the namespace
    * of the target. The fault is a black hole, or a reset that answers the next segment of the
@@ -1497,7 +1825,11 @@ interface Lab {
     t0: number;
     t1: number;
   } | null>;
-  probe(args: readonly string[]): Promise<Probe>;
+  /** This method starts the client with `args`. Each file is in its container before it starts. */
+  probe(args: readonly string[], files?: ReadonlyArray<{
+    readonly content: string;
+    readonly target: string;
+  }>): Promise<Probe>;
   /**
    * This method waits for the next clock line of the prober, which gives the count of lost
    * records. It gives null when no clock line comes in 5 s, because then nothing tells the count.
@@ -1578,6 +1910,32 @@ export declare const deviceOf: (route: string) => string;
  */
 export declare const openLab: (target: Target, kind?: Client | ClientImage, topology?: Topology) => Promise<Lab>;
 //#endregion
+//#region src/standby.d.ts
+/** This text is the line of the log of a standby that serves reads (src/backend/postmaster/postmaster.c:3740). */
+export declare const STANDBY_READY: string;
+/** This text is the write of the client, with its sequence number. */
+export declare const INSERT: string;
+/** This function gives the command of a standby: a base backup of the primary, then the server in recovery. */
+export declare const standbyCommand: (primary: string) => string[];
+/** This command starts the old primary again, after the stop of each of its processes. Its crash recovery runs before the wait ends. */
+export declare const RESTART: readonly string[];
+/** This function reads the output of a query for sequence numbers into a sorted list. */
+export declare const numbersOf: (text: string) => number[];
+/** This function gives the arguments of the client of a run. */
+export declare const pairArgs: (cell: Cell, lab: Pick<Lab, "targetIp" | "targetPort">) => string[];
+/** This function gives the instants of the cancels of a hold, in ns from the fault: equal parts of the hold. */
+export declare const cancelsOf: (pair: Pair, holdNs: number) => number[];
+/**
+ * This function opens the pair of an environment. The table comes first and the standby next: the
+ * base backup has it. A synchronous standby is named last, thus no setup step waits for it.
+ */
+export declare const openStandby: (lab: Lab, cell: Cell) => Promise<Sibling>;
+/**
+ * This function does one run of a pair. A dry run writes and stops, with no fault: the warm-up of the
+ * environment. It removes its rows, thus the numbers of the run start on an empty table.
+ */
+export declare const pairOnce: (lab: Lab, standby: Sibling, cell: Cell, environment: number, index: number, dry?: boolean) => Promise<Run>;
+//#endregion
 //#region src/locks.d.ts
 /**
  * This module reads the lockfiles of a build context for the manifest of a run. A lockfile pins each
@@ -1632,6 +1990,28 @@ export declare const versionsOf: (files: readonly ContextFile[]) => Record<strin
 export declare const manifestProblems: (manifest: Manifest) => string[];
 /** This function gives the problem of the commit of a record: no commit, or a text that is not a commit of git. */
 export declare const commitProblems: (commit: string | undefined) => string[];
+/** The code of a record is the commit of the checkout that operated, and if its tracked files had changes. */
+interface RecordCode {
+  readonly commit: string;
+  readonly dirty: boolean;
+}
+/** These are the parts of a record that tell if it pins the programs of its runs. */
+interface Pinnable {
+  readonly code?: RecordCode | undefined;
+  readonly manifests: readonly Manifest[];
+  /** A local debug run marks its record so. No page reads such a record. */
+  readonly debug?: boolean | undefined;
+}
+/** This problem is the problem of a checkout with changes: its commit does not hold the code that operated. */
+export declare const DIRTY = "the checkout has changes to tracked files that no commit holds";
+/** This problem is the problem of a record of a local debug run. */
+export declare const DEBUG = "the record is of a local debug run, and no page reads it";
+/**
+ * This function gives each problem that stops a record from pinning the programs of its runs. A
+ * record with a problem is not a record (SYS-101). The writer of the cells refuses it, and the read
+ * of a schedule refuses it. A commit with changes to tracked files is not a pin.
+ */
+export declare const recordProblems: (record: Pinnable) => string[];
 //#endregion
 //#region src/group.d.ts
 /**
@@ -1708,8 +2088,8 @@ export declare const memberConfig: (group: Group, primary: string | null) => str
 export declare const sentinelConfig: (group: Group, primary: string) => string;
 /**
  * This function gives the peers that a fault on a part cuts it from, by their addresses. `all` is
- * each other part and the client, `group` is the other parts, and `clients` is the client. `one`
- * and `one-way` are the first other member. The observer is not a peer, thus the timeline of the
+ * each other part and the client, `group` is the other parts, and `clients` and `to-clients` are
+ * the client. `one` and `one-way` are the first other member. The observer is not a peer, thus the timeline of the
  * group stays whole.
  */
 export declare const peersOf: (parts: {
@@ -2009,6 +2389,7 @@ export declare const clusterViewOf: (cluster: Cluster, rows: readonly StatusRow[
  * This function gives the peers that a fault on a node cuts it from. `all` is each other node and the
  * client, `group` is the other nodes, and `clients` is the client. `one` is the first other node in
  * the sequence of the cluster, and `one-way` is the same node for the segments from the part only.
+ * `to-clients` is the client, for the segments from the part only.
  */
 export declare const clusterCutOf: (cluster: Cluster, members: Readonly<Record<string, RunPart>>, client: string, part: string, cuts: NonNullable<GroupPlace["cuts"]>) => Cut;
 /** A wall stamp is the wall clock in ns around a command of a node: the run puts it on the monotonic clock. */
@@ -2109,6 +2490,129 @@ export declare const restamped: (line: NodeLine, events: readonly ProbeEvent[])
  */
 export declare const clusterOnce: (lab: ClusterLab, cell: Cell, environment: number, index: number) => Promise<Run>;
 //#endregion
+//#region src/kafka.d.ts
+/** This function gives the node id of a name. A broker has its place in the list from 1, and the controller has the id after them. */
+export declare const nodeIdOf: (kafka: Kafka, name: string) => number;
+/**
+ * This function gives the variable of a server property for the image. The wrapper of the image
+ * reverses this map (KafkaDockerWrapper.scala:188-203). After the prefix `KAFKA_`, `___` is a
+ * hyphen, `__` is an underscore and `_` is a dot.
+ */
+export declare const envOf: (property: string) => string;
+/** This function gives the environment of a broker. */
+export declare const brokerEnv: (kafka: Kafka, name: string) => Record<string, string>;
+/** This function gives the environment of the controller. The start script of the image stops on an advertised listener here (configure:43-48). */
+export declare const controllerEnv: (kafka: Kafka) => Record<string, string>;
+/** A partition view is the output of the command `view` of the admin. Without a topic it has only the brokers. */
+interface PartitionView {
+  readonly brokers: readonly number[];
+  readonly leader?: number | null;
+  readonly isr?: readonly number[];
+  readonly replicas?: readonly number[];
+}
+/**
+ * This function judges a view of a partition: its leader, and if the group is healthy. A healthy
+ * group has each broker not fenced, one leader, and each broker in the in-sync replicas.
+ */
+export declare const kafkaViewOf: (kafka: Kafka, view: PartitionView) => GroupView;
+/**
+ * This function gives the peers that a fault on a broker cuts it from. Only `group` has a law: the
+ * other brokers and the controller, and the client keeps its route to the broker.
+ */
+export declare const kafkaCutOf: (kafka: Kafka, members: Readonly<Record<string, RunPart>>, controller: RunPart, part: string, cuts: NonNullable<GroupPlace["cuts"]>) => Cut;
+/** This function gives the addresses that the client and the admin bootstrap from. */
+export declare const bootstrapOf: (kafka: Kafka) => string;
+/** This function gives the name of the topic of a run. A warm-up has the index -1. */
+export declare const topicOf: (environment: number, index: number) => string;
+/** A Kafka member is one member of a consumer group. A signal goes from a sidecar in its process namespace. */
+interface KafkaMember extends GroupClient {
+  /** This method sends a signal to the process of the member, at once or at an instant of the VM. The injector stamps it. */
+  signal(signal: "STOP" | "CONT", at?: number): Promise<Stamp>;
+}
+/** A Kafka lab is one environment of a Kafka cell. */
+interface KafkaLab {
+  readonly kafka: Kafka;
+  readonly clientIp: string;
+  readonly members: Readonly<Record<string, RunPart>>;
+  readonly controller: RunPart;
+  readonly netns: {
+    readonly client: number;
+  };
+  /** These are all the records that the prober wrote, in sequence. */
+  readonly kernel: readonly KernelRecord[];
+  /** These are the last raw lines of the console of each node, for the diagnosis of a lab: at most RAW_TAIL of each. */
+  readonly raw: Readonly<Record<string, readonly string[]>>;
+  /** This method sets the sysctls of the client namespace through its privileged sidecar, and reads them back. */
+  sysctl(values: Readonly<Record<string, string>>): Promise<Record<string, string>>;
+  /** This method waits until each broker is not fenced. */
+  brokersUp(within?: number): Promise<void>;
+  /** These are the log lines of the brokers that tell that a member left a group (`isFenceLine`), in sequence. */
+  readonly fences: readonly string[];
+  /** This method makes the topic of a run, with one partition or more. */
+  create(topic: string, partitions?: number): Promise<void>;
+  /** This method writes `count` records in each partition of a topic, each acknowledged by each in-sync replica. */
+  fill(topic: string, partitions: number, count: number): Promise<void>;
+  /** This method starts one member of a consumer group, with the arguments of `ConsumerKafka` after the bootstrap. */
+  consumer(args: readonly string[]): Promise<KafkaMember>;
+  /** This method waits until the partition is whole and calm, and gives the name of the broker of its leader. */
+  converge(topic: string, within?: number): Promise<string>;
+  /** This method gives the sequence numbers that the partition holds, one entry for each copy. */
+  holds(topic: string): Promise<number[]>;
+  /** This method starts the client of a run, with the arguments of `ClientKafka`. */
+  client(args: readonly string[]): Promise<GroupClient>;
+  /** This method applies a network fault between a broker and some of its peers, at once or at an instant of the VM. */
+  fault(kind: GroupNetworkFault, part: string, cuts: NonNullable<GroupPlace["cuts"]>, at?: number): Promise<Stamp>;
+  /** This method removes a network fault, at once or at an instant of the VM. */
+  lift(kind: GroupNetworkFault, part: string, cuts: NonNullable<GroupPlace["cuts"]>, at?: number): Promise<Stamp>;
+  /** This method removes the TCP metrics of the client namespace: each run starts from a kernel that keeps nothing. */
+  forget(): Promise<void>;
+  /** This method waits for the next clock line of the prober, which gives the count of lost records. */
+  settle(): Promise<number | null>;
+  manifest(sysctls: Readonly<Record<string, string>>): Promise<Manifest>;
+  close(): Promise<void>;
+}
+/**
+ * This function opens one environment of a Kafka cell:
+ * - one new network, with each node, the client and the commander on it.
+ * - the controller first, then each broker: the stock image with its own command. The brokers
+ *   register with the controller, thus they need it first.
+ * - an injector sidecar for each node, in its network and process namespaces.
+ * - a client that holds its own network namespace, with a privileged sidecar for its sysctls.
+ * - the prober, which watches the namespace of the client.
+ */
+export declare const openKafkaLab: (kafka: Kafka) => Promise<KafkaLab>;
+/**
+ * This time is how long a run continues after its lift. The record then shows the step-down of the
+ * leader and the writes after it. It has no source. It is above the largest step-down of the
+ * law, which is approximately 2 s after the lift.
+ */
+export declare const KAFKA_TAIL_MS = 1e4;
+/** This function gives the arguments of the client of a Kafka cell: the topic, the writers, the stream of writes and the settings. */
+export declare const kafkaArgs: (cell: Cell, topic: string) => string[];
+/**
+ * This function does one run of a Kafka cell:
+ * - Each broker is up, the topic of the run exists, and its partition is whole. The client starts,
+ *   and its stream of writes gets steady.
+ * - The fault cuts the leader from the other brokers and the controller, and it lifts at its instant
+ *   in the VM. The client keeps its route to the leader, thus only the group knows of the cut.
+ * - The run waits for the lift and for the tail after it.
+ * - Each fault goes, the client stops, and the partition converges again. The admin then reads
+ *   the whole partition, thus the record tells which writes the group kept.
+ */
+export declare const kafkaOnce: (lab: KafkaLab, cell: Cell, environment: number, index: number) => Promise<Run>;
+/**
+ * This function does one run of a paused consumer:
+ * - The topic of the run has two partitions, each with records that a run does not finish.
+ * - Two members join one group, and the run waits until each member holds one partition and the
+ *   first member has two commits on its partition.
+ * - A SIGSTOP stops the first member while it holds its next batch, and a SIGCONT ends the stop
+ *   after the hold of the cell. The run then waits for the tail.
+ *
+ * The fault is null when the members did not get one partition each. The measure then voids the run.
+ * The law reads no kernel record, thus a lost record does not void this run.
+ */
+export declare const kafkaPauseOnce: (lab: KafkaLab, cell: Cell, environment: number, index: number) => Promise<Run>;
+//#endregion
 //#region src/run.d.ts
 /** A cell result is a cell with its manifests, its runs, their measurements and its verdict. */
 interface CellResult {
@@ -2157,5 +2661,5 @@ export declare const spread: (runs: number, environments: number) => number[];
  */
 export declare const runCell: (cell: Cell, say?: (line: string) => void) => Promise<CellResult>;
 //#endregion
-export { type Agent, type BuildImage, type BuildRecord, type CallReading, type Cell, type CellResult, type Client, type ClientImage, type ClockPair, type Cloud, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type ContextFile, type Crossings, type Cut, type Decision, type Drill, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, type Fabric, type FabricLab, type FabricManifest, type FabricParts, type Fault, type FaultPlace, type FaultSide, type Group, type GroupClient, type GroupLab, type GroupMeasured, type GroupNetworkFault, type GroupPlace, type GroupPrediction, type GroupReading, type GroupRole, type GroupVerdict, type GroupView, type Hop, type HopEvent, type HopPlace, type HopSignal, type HopWrite, type Host, type HttpProbe, type ImagePlan, type ImageSource, type Interval, type Jitter, type KernelRecord, type Lab, type Layer, type LeafViews, type LineMatch, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, type OplogRead, type OplogTime, type Outcome, type Pairing, type PinnedImage, type Prediction, type Probe, type ProbeEvent, type ProgramEvent, type ProxyHop, type ProxyTime, type ReconnectReading, type ReconnectVerdict, type Reconnects, type Recovers, type RecoveryMeasured, type Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouteLine, type RouterHop, type RttRange, type Run, type RunBackup, type RunDrill, type RunFabric, type RunGroup, type RunPart, type RunRoute, type RunTopology, type SentinelEvent, type SentinelStage, type Shipped, type ShippedImage, type SocketPlace, type Spread, type Stage, type StageBand, type StageVerdict, type Stamp, type Status, type StatusRow, type Subject, type Substrate, type SubstrateSource, type Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, isHopPlace, latestEndOf };
+export { type Agent, type BuildImage, type BuildRecord, CLIENT_CAPABILITIES, type CallReading, type Cell, type CellResult, type Client, type ClientCapability, type ClientImage, type ClockPair, type Cloud, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type ConntrackPrediction, type ConntrackReading, type ContextFile, type CountBand, type Crossings, type Cut, type Decision, type Drill, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, type Fabric, type FabricLab, type FabricManifest, type FabricParts, type Fault, type FaultPlace, type FaultSide, type Group, type GroupClient, type GroupLab, type GroupMeasured, type GroupNetworkFault, type GroupPlace, type GroupPrediction, type GroupReading, type GroupRole, type GroupVerdict, type GroupView, type Hop, type HopEvent, type HopPlace, type HopSignal, type HopWrite, type Host, type HostSetting, type HostSysctl, type HttpProbe, type ImagePlan, type ImageSource, type Interval, type Jitter, type Kafka, type KafkaLab, type KafkaMember, type KafkaPause, type KernelRecord, type Lab, type Layer, type LeafViews, type LineCount, type LineMatch, type LoadBand, type LoadJudgement, type LoadPlan, type LoadPrediction, type LoadSpread, type LoadStream, type LoadVerdict, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, type OplogRead, type OplogTime, type Outcome, type Outcomes, type Pair, type PairSets, type Pairing, type PartitionView, type PauseBand, type PauseCommit, type PausePrediction, type PauseReading, type Pinnable, type PinnedImage, type PortsPrediction, type PortsReading, type Prediction, type Probe, type ProbeEvent, type ProgramEvent, type ProxyHop, type ProxyTime, type QueueBand, type QueueConnection, type QueueConnectionReading, type QueueEnd, type QueuePrediction, type QueueReading, type ReconnectReading, type ReconnectVerdict, type Reconnects, type RecordCode, type Recovers, type RecoveryMeasured, type Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouteLine, type RouterHop, type RttRange, type Run, type RunBackup, type RunDrill, type RunFabric, type RunGroup, type RunLoad, type RunPart, type RunPause, type RunRoute, type RunStream, type RunTopology, type SentinelEvent, type SentinelStage, type Shipped, type ShippedImage, type Sibling, type SocketPlace, type Spread, type Stage, type StageBand, type StageVerdict, type StallReading, type Stamp, type Status, type StatusRow, type Subject, type Substrate, type SubstrateSource, type Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, isHopPlace, latestEndOf };
 //# sourceMappingURL=index.d.ts.map