@mark1russell7/harness 0.5.0 → 0.6.0

package/README.md

@@ -82,11 +82,16 @@ A Sentinel that aborted a failover does not try again for 2 × `failover-timeout
 ## The clients and the agents
 
 - **A client image** (`ClientImage`, `Cell.client`) replaces the TCP client of the harness in each run. It operates in the namespace of the client. Its command gets the arguments of the TCP client, and it prints the same JSON lines.
+- **An HTTP client** (`Cell.client`: `go-http`, `http-agent` or `undici`) is a client of the harness from its own image. It sends a GET of the root, then a second request (`probe.http`):
+  - after the signal (`inflight`), into the fault
+  - or by itself, a gap after its first reply (`gap`), for the keep-alive race.
+- **The lines of an HTTP client.** It writes the lines of the TCP client, with the number `i` of the request on each line of a request. It also writes the connection of each try of a request (`request`, then `retry`), with its local address and a flag for a reused connection. Each connection gets a `conn` line, and each end of a connection a line (`eof`, `conn-error`, `closed`). The end of the second request is a `done` line.
+- **A target with a script.** A target can take files before it starts (`Target.files`), for example the script of a Node server on the stock Node image. A target that writes JSON lines (`Target.lines`) gives them to each run (`Run.server`). The manifest holds the sha256 of each file and the first line of the target.
 - **An agent** (`lab.agent(image, command, { pid })`) is a container in the network namespace of the target. With `pid`, it also shares the process namespace of the target, thus it can signal the server process. Its JSON lines and its `exec` stay available to the caller.
 
 ## The images
 
-The harness builds three images. The tag of each image comes from the content of all the files that its Dockerfile reads. The harness copies these files into a new build context, from its own package and from the prober package. Thus the build works in a workspace and from npm.
+The harness builds five images. The tag of each image comes from the content of all the files that its Dockerfile reads. The harness copies these files into a new build context, from its own package and from the prober package. Thus the build works in a workspace and from npm.
 
 - **The harness image** (`image/Dockerfile`) has two stages, each a digest-pinned Alpine. `Cargo.lock` pins the crates. The image holds:
   - the kernel program of the prober, compiled against the BTF of the kernel that builds it, and its Rust collector.
@@ -95,6 +100,8 @@ The harness builds three images. The tag of each image comes from the content of
   - `inject`, which applies a fault in one `iptables-restore` commit, with monotonic stamps around the commit. Thus the start of a fault is known in the VM. A `docker exec` from Windows comes 190 ms late at the median. With `--via DEV`, the rules go in the FORWARD chain, on the device toward one side.
   - `inject` also sends a signal to a process by its name (`signal`), and one command to a server of the Redis protocol (`resp`). Stamps bracket each.
 - **The Node client image** (`image/node`) is a driver client: ioredis 6.0.0 on Node 24.21.0. The digest of the image and an npm lockfile pin them. `client-ioredis.mjs` prints the lines of the TCP client on the same clock, and it adds the status changes of ioredis as `status` lines. The same image holds the client of a group in Sentinel mode (`client-sentinel.mjs`) and the observer of its Sentinels (`observer.mjs`).
+- **The Go HTTP image** (`image/go-http`) is the `http.Transport` of Go 1.27.2 at its defaults (`client-go`). The program uses the standard library only, thus the digest of the Go builder pins all of its code. The build does `gofmt` and `go vet` first. A wrapper on each connection writes what the read loop of the transport reads. The trace of the transport writes each try of a request.
+- **The Node HTTP image** (`image/node-http`) holds the `http.Agent` of Node 24.21.0 (`client-agent.mjs`) and an HTTP/1.1 `Client` of undici 8.12.2 (`client-undici.mjs`). The digest of the image and an npm lockfile pin them. It is apart from the image of ioredis, thus the cells of ioredis keep their image.
 - **The router image** (`image/router`) is a digest-pinned Alpine with conntrack-tools, nftables, iproute2 and Python. `mbx.sh` sets the form of the router in one nftables table, `ctwatch.py` writes the conntrack events, and `resetter.py` sends the resets of the `reset-both` form. Each run records its packages in the manifest.
 
 The build does the `cargo test` of the two crates. Thus the record decoder passes its tests before an image exists. Each amount that the native programs print is a quantity in a canonical unit. For example, an RTO is in `jiffy`, a round trip in `us`, and a segment in `B`.
@@ -110,7 +117,7 @@ ioredis sets the keepalive of its socket itself, after it connects. Thus a cell
 - **An ICMP unreachable** (`unreachable`, `Cell.icmp`) answers each segment from the observer with host, net or port unreachable, or admin prohibited. Linux keeps it as a soft error, continues to retransmit, and gives the errno of the ICMP at the timeout. Host and net unreachable also revert the backoff (RFC 6069).
 - **A simplex partition** (`simplex`, `Cell.drops`) drops the segments to the server, or the segments to the client, but not both.
 - **A FIN** (`fin`) stops the process of the peer with SIGKILL while its kernel stays up. For the client, the target starts its server as the child of a shell (`Target.command`), and `Target.kill` stops it. For the server, the harness stops the container of the client.
-- **An MTU black hole** (`mtu-blackhole`, `Cell.mtu`) drops each segment longer than the length, in the namespace that receives it.
+- **An MTU black hole** (`mtu-blackhole`, `Cell.mtu`) drops each segment longer than the length, in the namespace that receives it. At a router (`Cell.faultAt`), it drops what the router forwards from one side.
 - **netem** (`netem`, `Cell.netem`) is tc netem on the egress of the target: loss, duplication, reordering or corruption. The outcome is a distribution. At a hop, netem is on the egress of the device of the hop toward one side.
 - **A latency** (`Cell.latency`) is tc netem delay on the egress of the target before the client connects. Thus the round trip and the RTO include it.
 - **A fault at a proxy** (`Cell.faultAt`) puts the rules of a fault in the namespace of the proxy, toward the client or toward the target. The rules act on the sockets of the proxy.
@@ -125,6 +132,7 @@ ioredis sets the keepalive of its socket itself, after it connects. Thus a cell
 - **An idle proxy** (`proxy-idle`) injects nothing. The proxy closes an idle connection at its own timeout.
 - **A toxic** (`toxic`, `Cell.toxic`) is one toxic of Toxiproxy, added through its HTTP API by `inject http`, with monotonic stamps around the request. Its name is `fault`, and the harness removes it after the run. A cell whose fault is another one adds its toxic first: a slow close, then the close of the server.
 - **A close of the server** (`server-close`) makes the server close the connection of each client, with `Target.close`: `CLIENT KILL` for Redis.
+- **A stall of the application** (`app-stall`) injects nothing. The server process holds the reply, because the request asks for it (`HttpProbe.hold`), and its kernel stays up.
 - **A fault on a group** acts on the part that `Cell.faultAt` names by its role:
   - A black hole (`blackhole`) drops each segment between the part and each peer. A reset (`rst`) answers each segment from a peer with a reset, thus the part refuses each connection.
   - A partial partition (`partition`) is a black hole between the part and some of its peers (`GroupPlace.cuts`). `group` cuts the part from the other members and the Sentinels, and `clients` cuts it from the client.
@@ -156,6 +164,11 @@ Each run starts from kernels that keep nothing from the run before it (`lab.forg
 - **Reordering.** A measurement-only run also gives what reordering, duplicates and losses did (`reordering`). At the client, it counts the arrivals beyond a hole and the arrivals of data that it had already, against `rcv_nxt`. From the sender, it gives the most SACKed and lost segments, the DSACKs, the fast retransmissions, and the reordering degree and count of the kernel.
 - **An arrival is not always one segment.** The segments that arrive while the owner holds the socket wait in its backlog, and the kernel joins the contiguous ones. Thus the kernel counts out-of-order segments (`rcv_ooopack`), and the prober counts arrivals.
 - **A proxy's own time.** A calibration cell (`Cell.calibrates`) gives the time of its proxy for each request and its reply (`crossings`). Each time goes from an arrival on one socket of the proxy to its next write on the other socket (a `tx` record).
+- **An HTTP client** (`requestOf`). The run gives what the second request met (`request`): the connection of its first try, a new try, and its error or its reply. The prediction gives the same (`Prediction.request`), and another outcome is a finding.
+  - In a gap, the idle connection counts from the first reply, and the run gives the gap from the lines of the client.
+  - A new try that gets no connection writes only its failed dial (`dial-error`). That line counts as a new try.
+  - A close of the observer itself (errno `CLOSED`) is the change of its socket from ESTABLISHED to FIN_WAIT1: its pool closed an idle connection.
+  - A timer of the client or the server is not a timer of the kernel. Thus a delayed keepalive timer of the socket does not make such a run void.
 - **A router that forgets in silence.** A silent prediction can say that the router forgets the flow in a band after the last segment (`Prediction.middlebox`). The run then holds when the forget is in that band and nothing detects it. A missing forget, or one outside its band, is a finding. Without it, the router must keep the flow.
 - **A group** (`measureGroup`, `timeline.ts`). The time counts from the start of the commit of the fault, or from the first write into a stall.
   - It ends at the first write that a primary accepted after the fault. That primary is a new one, or the same one after the lift, as the prediction says (`GroupPrediction.lands`).
@@ -184,6 +197,8 @@ Each run starts from kernels that keep nothing from the run before it (`lab.forg
   - A run that did not announce the stage is outside too. A stage outside its band fails that stage. The decision of the cell stays the decision of its band.
   - The verdict also gives the median of each stage, the lost writes of each run, and the errors on the way.
 
+- **An HTTP client** (`Verdict.requests`). The verdict counts each outcome of the second request over the counted runs. A measurement-only cell also gives them in its reason.
+
 The distribution test needs a simulator, which does not exist at this time.
 
 ## Runs
@@ -200,6 +215,8 @@ The distribution test needs a simulator, which does not exist at this time.
   - Its in-flight data is the reply of the server. Thus the client sends `probe.request` first, for example a BLPOP with a timeout, and the fault occurs while the server holds it.
 - **The pause before the fault.** In every other run, the fault comes 250 ms after the client's first reply (`QUIET_MS`). That is more than Linux's longest delayed ACK, 200 ms. A fault that comes earlier meets the client's delayed ACK of the reply, not the request or the idle time that the cell measures. On a fast host the fault came 35 ms after the reply, and the ACK met a reset first.
   - A run of a group has no such pause. Its fault comes after the 20th accepted write of its stream, and each band of a group counts from the fault.
+  - An HTTP client in a gap counts its gap from its own first reply, thus the pause does not change it. Its run ends at the end of its second request (`done`).
+- **An HTTP client.** A run of an HTTP client in flight ends at the end of its second request, after a new try of the client. The client waits one second after it (`LINGER_MS`), thus its own close comes after the window.
 - **`judge(cell, runs)`** (`run.ts`) measures and judges the raw records of a cell with the code at this time. `runCell` uses it during a cell. A holder of raw records can judge them again after a change to `observe.ts` or to the verdict.
 - **Testcontainers loads when a lab first opens.** Code that only measures and judges does not load it.
 
@@ -217,6 +234,6 @@ A run needs Docker, and privileged containers for the prober and the sidecars. T
 
 The tests also measure a group run from test lines. They find the first accepted write, the stages, the writes that the group kept, and the void runs. They test the views that make a group healthy, and the peers that a fault on a part cuts.
 
-The cells themselves need Docker and privileged containers. CI does not start them. `HARNESS_LAB=1` starts the lab tests on Docker. They start a client image and an agent, and they put a reset and netem at a router. They also fail a group of Valkey 9.1 over with a planned failover.
+The cells themselves need Docker and privileged containers. CI does not start them. `HARNESS_LAB=1` starts the lab tests on Docker. They start a client image and an agent, and they put a reset and netem at a router. They also fail a group of Valkey 9.1 over with a planned failover. Each HTTP client sends two requests on one connection to a Node server, from a script in the stock Node image.
 
 `pnpm --filter @mark1russell7/harness build` writes the package for npm into `build/`.

package/build/index.d.ts

@@ -43,8 +43,12 @@ import "testcontainers";
  * - `freeze-process` stops the server process of the part with SIGSTOP, and SIGCONT thaws it. Its
  *   kernel stays up. `fin` stops the process with SIGKILL.
  * - `planned-failover` asks a Sentinel for a failover: `SENTINEL FAILOVER <group>`.
+ *
+ * This fault is of an HTTP server:
+ * - `app-stall` injects nothing. The server process holds the reply to the request, because the
+ *   request asks for that (`HttpProbe.hold`), while its kernel stays up.
  */
-type Fault = "blackhole" | "freeze-process" | "rst" | "stall" | "fin" | "unreachable" | "simplex" | "mtu-blackhole" | "netem" | "middlebox-forget" | "proxy-idle" | "toxic" | "server-close" | "partition" | "planned-failover" | "none";
+type Fault = "blackhole" | "freeze-process" | "rst" | "stall" | "fin" | "unreachable" | "simplex" | "mtu-blackhole" | "netem" | "middlebox-forget" | "proxy-idle" | "toxic" | "server-close" | "partition" | "planned-failover" | "app-stall" | "none";
 /**
  * A middlebox form tells what a router does with a flow that it forgot, when a late packet comes:
  * - `reset-both` sends a reset to the two ends when it forgets the flow.
@@ -279,6 +283,21 @@ interface MiddleboxExpectation {
     readonly high: Quantity;
   };
 }
+/**
+ * A request prediction tells what the second request of an HTTP client meets, beside the band of
+ * its cell. The client writes it in its lines: the connection of each try, and the outcome.
+ * - `connection` is the connection of its first try: the one that the first request used
+ *   (`reused`), or a new one.
+ * - `retried` tells that the client sent it again on a new connection by itself.
+ * - `error` is the error that reaches the caller, or null for a reply.
+ * - `pending` tells that nothing ends the request in the window of the cell.
+ */
+interface RequestPrediction {
+  readonly connection: "reused" | "new";
+  readonly retried: boolean;
+  readonly error: string | null;
+  readonly pending?: true;
+}
 /**
  * A prediction is what a cell predicts. Either a detection occurs in an interval [T_lo, T_hi]
  * after the reference event, or nothing detects the fault in a window. Nothing detects a stall
@@ -296,12 +315,18 @@ interface MiddleboxExpectation {
  *
  * For a group cell, the band is the first write that a primary accepts after the fault, and its
  * errno is `OK`. `group` tells which primary, and the stages of the group on the way.
+ *
+ * For an HTTP cell, `request` tells what the second request meets. The errno `CLOSED` is a close
+ * of the observer itself: its pool closes an idle connection, a FIN that it sends.
  */
 type Prediction = {
   readonly detects: true;
   /** This name is the timer of the machine that fires first, or the event that detects the fault, with its errno. */
   readonly timer: string;
-  /** This name is the errno of the detection, or EOF for an end of file without an error. It is OK for a write that a primary accepts. */
+  /**
+   * This name is the errno of the detection, or EOF for an end of file without an error. It is
+   * OK for a write that a primary accepts, and CLOSED for a close of the observer itself.
+   */
   readonly errno: string;
   readonly from: Reference;
   /** This time is the closed form, less the most that the timer can fire early. */
@@ -311,6 +336,7 @@ type Prediction = {
   readonly rtt?: RttRange;
   readonly through?: readonly ProxyTime[];
   readonly group?: GroupPrediction;
+  readonly request?: RequestPrediction;
 } | {
   readonly detects: false;
   readonly window: Quantity;
@@ -320,12 +346,14 @@ type Prediction = {
   readonly rtt?: RttRange;
   readonly through?: readonly ProxyTime[];
   readonly group?: GroupPrediction;
+  readonly request?: RequestPrediction;
 } | {
   readonly detects: null;
   readonly window: Quantity;
   readonly why: string;
   readonly from?: Reference;
   readonly group?: GroupPrediction;
+  readonly request?: RequestPrediction;
 };
 /** A target is the server that a cell connects to: a stock image. */
 interface Target {
@@ -352,9 +380,40 @@ interface Target {
   readonly kill?: readonly string[];
   /** This command makes the server close the connection of each client, as argv, for a `server-close` fault. */
   readonly close?: readonly string[];
+  /**
+   * These files go into the target before it starts, by their path, for example the script of a
+   * server on a stock Node image. The image stays stock.
+   */
+  readonly files?: Readonly<Record<string, string>>;
+  /**
+   * This flag tells that the target writes JSON lines with an `ev` and a `t` on its standard
+   * output, on CLOCK_MONOTONIC. Each run then keeps its lines (`Run.server`).
+   */
+  readonly lines?: true;
+}
+/**
+ * A client is what the runs of a cell use: the TCP client of the harness, or a driver on its
+ * socket. The HTTP clients are the `http.Transport` of Go (`go-http`), the `http.Agent` of Node
+ * (`http-agent`) and an HTTP/1.1 `Client` of undici (`undici`).
+ */
+type Client = "tcp" | "ioredis" | "go-http" | "http-agent" | "undici";
+/**
+ * An HTTP probe is the workload of an HTTP client. The first request is a GET of the root. The
+ * second request follows the mode of the probe: after the signal (`inflight`), or after a gap
+ * (`gap`).
+ */
+interface HttpProbe {
+  /** This method is the method of the second request. */
+  readonly method: "GET" | "POST";
+  /** This time is the gap of a `gap` workload: from the end of the first reply to the second request. */
+  readonly gap?: Quantity;
+  /** This time is how long the server holds the reply to the second request (`/hold?ms=`). */
+  readonly hold?: Quantity;
+  /** This length is the length of the body of the reply to the second request, in bytes (`/big?bytes=`). */
+  readonly bytes?: number;
+  /** These are settings of the client over its defaults, by the names of its flags: for example `idle-conn-timeout-ms`. */
+  readonly options?: Readonly<Record<string, number>>;
 }
-/** A client is what the runs of a cell use: the TCP client of the harness, or a driver on its socket. */
-type Client = "tcp" | "ioredis";
 /**
  * A client image is a process that a lab starts as the client of each run, in the network
  * namespace of the client. An example is an agent of an application on Node. Its command gets the
@@ -389,8 +448,9 @@ interface Cell {
     /**
      * This mode tells if the client is idle after its first reply, or sends a request into the
      * fault. In a stream, it sends `count` requests into it, each `interval` after the reply before.
+     * An HTTP client in a `gap` sends its second request a gap after its first reply, by itself.
      */
-    readonly mode: "idle" | "inflight" | "stream";
+    readonly mode: "idle" | "inflight" | "stream" | "gap";
     /** This count is the number of requests of a stream. */
     readonly count?: number;
     /** This time is the pause after each reply of a stream, before the next request. */
@@ -414,6 +474,8 @@ interface Cell {
       readonly name: "ioredis";
       readonly keepAlive: Quantity;
     };
+    /** This workload is the workload of an HTTP client (`Cell.client` is an HTTP client). The client then ignores `keepalive` and `userTimeout`. */
+    readonly http?: HttpProbe;
   };
   readonly fault: Fault;
   /** This time is the length of a stall, from the send of the request. */
@@ -451,8 +513,8 @@ interface Cell {
   readonly idleBefore?: Quantity;
   /** This toxic is the toxic of a `toxic` fault, which the Toxiproxy hop gets. */
   readonly toxic?: Toxic;
-  /** This image replaces the TCP client of the harness for each run. */
-  readonly client?: ClientImage;
+  /** This image, or this client of the harness, replaces the TCP client of the harness for each run. An HTTP client is one. */
+  readonly client?: ClientImage | Client;
   /**
    * This name is the proxy hop whose own time a calibration cell measures. The time of a request
    * (`up`) starts at its arrival on the socket of the proxy toward the client. It stops at the
@@ -549,6 +611,8 @@ interface Run {
   readonly middlebox?: readonly MiddleboxEvent[];
   /** This record is the group of a group cell: its parts, and what it did in the run. */
   readonly group?: RunGroup;
+  /** These are the lines of a target that writes them (`Target.lines`), from the start to the end of the run. */
+  readonly server?: readonly ProbeEvent[];
 }
 /** A Sentinel event is one line of the observer of a group: an event that a Sentinel published, on the clock of the VM. */
 interface SentinelEvent {
@@ -697,7 +761,21 @@ type Outcome = {
   readonly kind: "silent";
 } | {
   readonly kind: "answered";
+} | {
+  readonly kind: "closed";
 };
+/**
+ * A request reading is what the second request of an HTTP client met, from the lines of the
+ * client. It holds the connection of its first try, a new try, and its outcome. `gap` is the time
+ * from the end of the first reply to the send of the second request.
+ */
+interface RequestReading {
+  readonly connection: "reused" | "new";
+  readonly retried: boolean;
+  readonly error: string | null;
+  readonly pending: boolean;
+  readonly gap: Quantity | null;
+}
 /** A measurement is what one run measured, against the prediction of its cell. */
 interface Measured {
   readonly environment: number;
@@ -746,6 +824,8 @@ 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 the second request of an HTTP client met, for a cell whose prediction says it. */
+  readonly request?: RequestReading | null;
   /** 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. */
@@ -818,10 +898,28 @@ export declare const crossingsOf: (run: Run, hop: string, toClient: SocketPlace
  *   it, and before the first keepalive probe. A live peer answers that probe, and the answer
  *   starts the idle time again. A run where the fault was late is void. A run whose records the
  *   prober lost is also void.
+ * - For an HTTP client, it also reads what the second request met (`requestOf`). An outcome other
+ *   than the one that the prediction gives is a finding.
  */
 export declare const measure: (cell: Cell, run: Run) => Measured;
+/**
+ * This function reads the second request of an HTTP client from its lines. Its first try is its
+ * first `request` line, and each `retry` line is a new try. Its end is its `error` line, or its
+ * `replied` line. A request with neither is pending. It gives null when the client wrote no try.
+ *
+ * A new try that gets no connection writes no `retry` line. Its dial writes a `dial-error` line.
+ * Thus a `dial-error` line after the first try and before the end is also a new try.
+ */
+export declare const requestOf: (events: readonly ProbeEvent[]) => RequestReading | null;
 //#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: {
+  readonly connection: "reused" | "new";
+  readonly retried: boolean;
+  readonly error: string | null;
+  readonly pending?: boolean | undefined;
+}) => string;
 /**
  * This amount is the noise of the pipeline itself, δ_abs, as the calibration measured it. It is
  * the 99.9th percentile of the whole latency of a reset, at the concurrency cap or less. Its
@@ -877,6 +975,12 @@ interface Verdict {
   };
   /** This record is what the group of a group cell did over the counted runs: its stages, and its writes. */
   readonly group?: GroupVerdict;
+  /**
+   * These are the outcomes of the second request of an HTTP client over the counted runs, each
+   * with its count: for example "reused, a retry, a reply". An outcome other than the predicted
+   * one is a finding of its run.
+   */
+  readonly requests?: Readonly<Record<string, number>>;
   readonly why: string;
 }
 /**
@@ -961,6 +1065,10 @@ export declare const harnessImage: () => Promise<string>;
 export declare const nodeClientImage: () => Promise<string>;
 /** This function gives the image of the router. */
 export declare const routerImage: () => Promise<string>;
+/** This function gives the image of the Go HTTP client. */
+export declare const goHttpImage: () => Promise<string>;
+/** This function gives the image of the Node HTTP clients. */
+export declare const nodeHttpImage: () => Promise<string>;
 /**
  * This time is the interval of the listing of a router, when its hop does not set one. A listing
  * evicts each expired flow that it walks past, and the DESTROY event of that flow follows.
@@ -1022,6 +1130,10 @@ interface Manifest {
     readonly settings: Readonly<Record<string, string>>;
     /** These are the sysctls of its namespace, as read back after the harness set them. */
     readonly sysctls: Readonly<Record<string, string>>;
+    /** These are the files that went into the target, by their path, each with the sha256 of its content. */
+    readonly files?: Readonly<Record<string, string>>;
+    /** This line is the first line of a target that writes them: a server that tells its settings as it reads them. */
+    readonly first?: ProbeEvent;
   };
   readonly harness: {
     readonly image: string;
@@ -1113,6 +1225,8 @@ interface Lab {
   readonly topology: RunTopology | null;
   /** These are the lines of the routers of a topology, in sequence, each with the name of its hop. A direct pair has none. */
   readonly middlebox: readonly MiddleboxEvent[];
+  /** These are the lines of a target that writes them (`Target.lines`), in sequence. Another target has none. */
+  readonly server: readonly ProbeEvent[];
   /** This method adds a toxic to the Toxiproxy hop of a topology, or removes it with null. The stamps of the injector bracket it. */
   toxic(toxic: Toxic | null): Promise<{
     t0: number;
@@ -1402,6 +1516,16 @@ export declare const judge: (cell: Cell, runs: readonly Run[]) => {
   measured: Measured[];
   verdict: Verdict;
 };
+/**
+ * This time is the pause between the client's first reply and the fault. It is more than Linux's
+ * TCP_DELACK_MAX of 200 ms. Thus the delayed ACK of the reply is out before the fault.
+ */
+export declare const QUIET_MS = 250;
+/**
+ * This time is how long an HTTP client waits after its second request, before it exits. The exit
+ * closes its sockets, thus that close comes after the window of the cell.
+ */
+export declare const LINGER_MS = 1e3;
 /** This function divides a count of runs across environments, as equally as possible. */
 export declare const spread: (runs: number, environments: number) => number[];
 /**
@@ -1415,5 +1539,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, Cell, CellResult, Client, ClientImage, Crossings, Decision, ErrorOnTheWay, Fault, FaultPlace, FaultSide, Group, GroupClient, GroupLab, GroupMeasured, GroupNetworkFault, GroupPlace, GroupPrediction, GroupReading, GroupRole, GroupVerdict, GroupView, Hop, HopPlace, Interval, KernelRecord, Lab, Manifest, ManifestHop, Measured, MiddleboxEvent, MiddleboxExpectation, MiddleboxForm, NetworkFault, Observer, Outcome, Prediction, Probe, ProbeEvent, ProxyHop, ProxyTime, Recovers, Reference, Reordering, Replies, RouterHop, RttRange, Run, RunGroup, RunPart, RunTopology, SentinelEvent, SocketPlace, Spread, Stage, StageBand, StageVerdict, Stamp, Target, Topology, Toxic, Verdict, Writes };
+export type { Agent, Cell, CellResult, Client, ClientImage, Crossings, Decision, ErrorOnTheWay, Fault, FaultPlace, FaultSide, Group, GroupClient, GroupLab, GroupMeasured, GroupNetworkFault, GroupPlace, GroupPrediction, GroupReading, GroupRole, GroupVerdict, GroupView, Hop, HopPlace, HttpProbe, Interval, KernelRecord, Lab, Manifest, ManifestHop, Measured, MiddleboxEvent, MiddleboxExpectation, MiddleboxForm, NetworkFault, Observer, Outcome, Prediction, Probe, ProbeEvent, ProxyHop, ProxyTime, Recovers, Reference, Reordering, Replies, RequestPrediction, RequestReading, RouterHop, RttRange, Run, RunGroup, RunPart, RunTopology, SentinelEvent, SocketPlace, Spread, Stage, StageBand, StageVerdict, Stamp, Target, Topology, Toxic, Verdict, Writes };
 //# sourceMappingURL=index.d.ts.map