@mark1russell7/harness 0.14.3 → 0.15.0

package/build/{cell-B3-BSTit.d.ts → cell-biffSiEJ.d.ts}

@@ -1,4 +1,5 @@
 import { Quantity } from "@mark1russell7/quantity";
+import { Profile, Schedule, ScheduleOptions } from "@mark1russell7/rigor-chaos";
 import { KernelRecord } from "@mark1russell7/prober";
 //#region src/cell.d.ts
 /**
@@ -331,6 +332,87 @@ interface Cluster {
     readonly start: string;
   };
 }
+/**
+ * A Kafka group is a group of brokers of Apache Kafka in KRaft mode with one controller, as data.
+ * Each node is a container from the same stock image, pinned by digest, in its own network namespace.
+ * Each run makes one new topic with one partition, with a replica on each broker. The client is the
+ * producer of kafka-clients, and it writes a stream of sequence numbers to that partition.
+ * The one controller keeps a Raft election out of each run. A fault on a broker cuts it from the
+ * controller too, and no fault acts on the controller.
+ */
+interface Kafka {
+  /** This image is the stock image of each node, pinned by digest. */
+  readonly image: string;
+  /** These are the names of the brokers. A broker's node id is its place in this list, from 1. The first broker is the first leader. */
+  readonly brokers: readonly string[];
+  /** This name is the name of the controller. Its node id comes after the ids of the brokers. */
+  readonly controller: string;
+  readonly port: number;
+  readonly controllerPort: number;
+  /** This text is the id of the cluster: 16 bytes in base64url without padding. */
+  readonly clusterId: string;
+  /** This text is the value of KAFKA_HEAP_OPTS of each node. */
+  readonly heap: string;
+  /** These are server properties of each node, by their names in Kafka: for example `broker.session.timeout.ms`. */
+  readonly settings: Readonly<Record<string, string>>;
+  /** This line tells that a node serves. */
+  readonly ready: string;
+  /** This count is the setting `min.insync.replicas` of the topic of each run. */
+  readonly minInsync: number;
+  /** This count is the number of writers of the client, each with one write at a time. */
+  readonly writers: number;
+  /** This record makes each run a run of two members of a consumer group, with one member stopped. Without it, the client is a producer. */
+  readonly pause?: KafkaPause;
+}
+/**
+ * A Kafka pause is one run of two members of a consumer group, on a topic with two partitions. The
+ * fault stops the process of the first member while it holds a batch, and the hold of the cell ends
+ * that stop. Each setting of a member comes from `Cell.driverOptions`.
+ */
+interface KafkaPause {
+  /** This name is the protocol of the group: the broker keeps the session under `consumer`, and the client sets it under `classic`. */
+  readonly protocol: "consumer" | "classic";
+  /** This time is how long the first member holds each batch before it commits. */
+  readonly process: Quantity;
+  /** This choice is what the first member does after the stop. It commits at once, or it polls until it has a new epoch and then commits. */
+  readonly afterPause: "commit" | "rejoin";
+  /** This count is the number of records in each partition before the members start. */
+  readonly fill: number;
+  /** This time is from the start of the processing of a batch to the stop. */
+  readonly stopAfter: Quantity;
+}
+/** A pause band is the band of one time of a paused consumer, from the stop. */
+interface PauseBand {
+  readonly low: Quantity;
+  readonly high: Quantity;
+}
+/**
+ * A pause prediction is the law of a paused consumer. A null fence tells that the stop is too short.
+ * The group then does not fence the member, and the other member does not get its partition.
+ */
+interface PausePrediction {
+  readonly fence: PauseBand | null;
+  /** This band is the first report of the partition by the other member. Null tells that this cell has no band for it. */
+  readonly takeover: PauseBand | null;
+  /**
+   * This choice is the result of the commit after the stop:
+   * - `fails`: a commit before any poll fails with `CommitFailedException`.
+   * - `acknowledged`: the commit succeeds, and the epoch of the member does not change.
+   * - `rejoin`: the member gets a new epoch, the same commit succeeds, and the committed offset moves back.
+   */
+  readonly thaw: "fails" | "acknowledged" | "rejoin";
+  /** This time bounds the new epoch of `rejoin`, from the end of the stop. */
+  readonly rejoinWithin?: Quantity;
+}
+/** A run pause is what a run of a paused consumer records beyond the lines of the stopped member. */
+interface RunPause {
+  /** These are the lines of the other member. */
+  readonly other: readonly ProbeEvent[];
+  /** These are the log lines of the brokers that tell that a member left this group. */
+  readonly fences: readonly string[];
+  /** This name is the group of the run. */
+  readonly group: string;
+}
 /**
  * A cluster stage is one step of the timeline of a cluster after a fault. A line of the log of a
  * node marks it, or a line of the client. These are the stages:
@@ -352,10 +434,12 @@ type GroupRole = "primary" | "replica" | "sentinel";
  * - `clients`: the clients, but not the group.
  * - `one`: one other member, in both directions.
  * - `one-way`: one other member, for the segments from the part only.
+ * - `to-clients`: the clients, for the segments from the part only. Each write of a client reaches
+ *   the part, and no reply reaches the client.
  */
 interface GroupPlace {
   readonly role: GroupRole;
-  readonly cuts?: "all" | "group" | "clients" | "one" | "one-way";
+  readonly cuts?: "all" | "group" | "clients" | "one" | "one-way" | "to-clients";
 }
 /** A toxic is one toxic of Toxiproxy, as its API takes it. Its toxicity is 1. */
 interface Toxic {
@@ -479,6 +563,9 @@ interface StageBand {
  * - `lost` is the band of the count of accepted writes that the group did not keep, in each run. A
  *   count outside it is a finding. A measurement-only cell with this band gets its decision from
  *   the findings of its runs, thus the law of the count judges the cell.
+ * - `duplicates` is the band of the count of extra copies that the group holds, in each run. It
+ *   judges a cell as `lost` does. Only a list or a log can show a copy, thus a Redis cell needs
+ *   `op: "rpush"`.
  */
 interface GroupPrediction {
   readonly lands: "new" | "same";
@@ -495,6 +582,51 @@ interface GroupPrediction {
     readonly low: number;
     readonly high: number;
   };
+  readonly duplicates?: {
+    readonly low: number;
+    readonly high: number;
+  };
+  /** These are the bands of the commits of a pair (`Cell.pair`), each by its set. A set with no band is a measurement. */
+  readonly outcomes?: Outcomes;
+}
+/** A count band is the least and the most of a count, both included. */
+interface CountBand {
+  readonly low: number;
+  readonly high: number;
+}
+/**
+ * These are the bands of the sets of a pair. A commit with no reply is in one set, by the two final reads:
+ * - `kept`: the new primary holds it.
+ * - `stranded`: only the old primary holds it, after its crash recovery.
+ * - `absent`: no server holds it.
+ */
+interface Outcomes {
+  /** This band is the count of the writes with no reply, of each set. */
+  readonly unknown?: CountBand;
+  readonly kept?: CountBand;
+  readonly stranded?: CountBand;
+  readonly absent?: CountBand;
+  /** This band is the count of the acknowledged writes that the old primary does not hold after its crash recovery. */
+  readonly missing?: CountBand;
+  /** This band is the count of the WARNING notices that the client reads. */
+  readonly warnings?: CountBand;
+}
+/**
+ * A pair is a PostgreSQL primary, the target of a cell, and one standby on its network. The topology
+ * of the cell stays in front of the primary. Nothing in the pair fails over by itself: the harness
+ * does each step, in the order of `pairOnce`.
+ */
+interface Pair {
+  /** This flag names the standby in `synchronous_standby_names`. Without it, the standby is asynchronous. */
+  readonly synchronous: boolean;
+  /** This count is the writers of the client, each with its own connection of the pool. */
+  readonly writers: number;
+  /** This time is the pause of a writer after each reply. */
+  readonly interval: Quantity;
+  /** This place is what the black hole cuts the primary from: the standby, or each peer. */
+  readonly cuts: "standby" | "all";
+  /** This count is the cancels of the waits of the primary, spread across the hold. */
+  readonly cancels?: number;
 }
 /**
  * A middlebox expectation tells what the router of a topology does with the flow in the window of
@@ -533,6 +665,16 @@ interface LineMatch {
   readonly where?: Readonly<Record<string, string | number | boolean>>;
   readonly name?: string;
 }
+/**
+ * A line count is an exact count of the lines of the target in one run, for a cell whose law gives a
+ * count (SYS-67). A count reads no timer, thus it has no band and no noise. The judge compares it with
+ * `count`, and `what` names it in the finding.
+ */
+interface LineCount {
+  readonly what: string;
+  readonly match: LineMatch;
+  readonly count: number;
+}
 /**
  * A driver step is one more band of a driver after the band of its cell. An example is the error
  * of the retry after the interruption. It has its own reference on a socket of the driver, its
@@ -684,7 +826,213 @@ type Prediction = {
    * the client. The end has no band, but each wait has one. A wait outside its band is a finding of its run.
    */
   readonly reconnects?: Reconnects;
+  /**
+   * These are the exact counts of the lines of the target in each run. A count that differs is a
+   * finding of its run. A measurement-only cell with a reference and counts gets a decision from them.
+   */
+  readonly counts?: readonly LineCount[];
+  /**
+   * This record is the law of an accept queue: its limit, its count, its counters, and what each
+   * connection sees. A value outside it is a finding of its run.
+   */
+  readonly queue?: QueuePrediction;
+  /**
+   * This record is the law of a port range: the count of connects, the ports that they use, and
+   * when a held port comes back. A value outside it is a finding of its run.
+   */
+  readonly ports?: PortsPrediction;
+  /**
+   * This record is the law of a conntrack table: its flows, a connect that finds no entry, and the
+   * return of a slot. A value outside it is a finding of its run.
+   */
+  readonly conntrack?: ConntrackPrediction;
+  /** This record is the law of a paused consumer (`Kafka.pause`). A run outside it is a finding of its run. */
+  readonly pause?: PausePrediction;
+  /** These are the limits of an open-loop cell (`Cell.probe.plan`). Without them, its load is a measurement. */
+  readonly load?: LoadPrediction;
 };
+/** A queue band is a time from one line of a queue cell to another line, with its two bounds. */
+interface QueueBand {
+  readonly low: Quantity;
+  readonly high: Quantity;
+}
+/** This prediction tells how one connection of a queue cell ends. */
+interface QueueEnd {
+  readonly errno: string;
+  /** This name is the line of the connection that the time of the end counts from. */
+  readonly from: "dial" | "connected" | "sent";
+  readonly within: QueueBand;
+  /**
+   * This band is the time from the last retransmission of the connection to its end. With an
+   * `expiry`, the retransmission before the last comes before the expiry, and the last comes after it.
+   */
+  readonly retransmitted?: QueueBand;
+}
+/** This prediction tells what one connection of a queue cell sees, by its name in the client. */
+interface QueueConnection {
+  readonly name: string;
+  /** This choice says if the connect of the connection succeeds. */
+  readonly connects: boolean;
+  /** These bands are the waits of the SYN: the first from the dial, each next one from the SYN before it. */
+  readonly syns?: readonly QueueBand[];
+  /** These bands are the waits of each SYN-ACK sent again: the first from the dial, each next one from the SYN-ACK before it. */
+  readonly synAcks?: readonly QueueBand[];
+  /** This prediction tells how the connection ends. It is null for a connection that lives to the end of the run. */
+  readonly ends: QueueEnd | null;
+  /** This count is the segments that the peer has not acknowledged at the end of the run. */
+  readonly unacked?: number;
+}
+/**
+ * This prediction is the law of an accept queue. It reads the lines of the queue client and of the
+ * queue target. The counters count from the `opened` line of the run.
+ */
+interface QueuePrediction {
+  /** This count is the limit of the queue: `sk_max_ack_backlog`, as TCP_INFO of the listener gives it. */
+  readonly max: number;
+  /** This count is the most connections that the queue holds at one time. */
+  readonly held: number;
+  /** This count is the connections that connect, and the kernel of the client tells this. */
+  readonly connected: number;
+  /** These counts are the bounds of `ListenOverflows`. */
+  readonly overflows: {
+    readonly low: number;
+    readonly high: number;
+  };
+  /** This count is `EmbryonicRsts`: the handshakes that the target reset. */
+  readonly resets: number;
+  /** These predictions are the connections with a law of their own. */
+  readonly connections: readonly QueueConnection[];
+  /** A run where this connection did not take the last place in the queue is void: its burst did not land in its sequence. */
+  readonly admitted?: string;
+  /** This record tells when the kernel of the target forgets the handshakes: the `TCPTimeouts` of their last firings, from the first dial of the burst. */
+  readonly expiry?: {
+    readonly timeouts: number;
+    readonly within: QueueBand;
+  };
+  /** This record tells when the count of the queue gets back to `count`, from the first dial of the burst, after an accept. */
+  readonly rise?: {
+    readonly count: number;
+    readonly within: QueueBand;
+  };
+  /** This count is the connections that the target accepted in the run. */
+  readonly drained?: number;
+}
+/**
+ * This prediction is the law of a port range. It reads the lines of the ports client. In each round
+ * the client connects to each destination until a connect fails with EADDRNOTAVAIL.
+ */
+interface PortsPrediction {
+  /** This port is the low end of the range. */
+  readonly low: number;
+  /** This count is the ports of the range. */
+  readonly size: number;
+  /** This count is the rounds of each run. */
+  readonly rounds: number;
+  /** This count is the destinations of each round. */
+  readonly destinations: number;
+  /** These counts are the only connects that one destination can get in one round. */
+  readonly counts: readonly number[];
+  /** These offsets from the low port are the only ports that the run uses. It uses each of them. */
+  readonly seen: readonly number[];
+  /** This time is the longest connect that fails. */
+  readonly refusedWithin: Quantity;
+  /** This record is the band of the share of the rounds that get `count` connects. */
+  readonly share?: {
+    readonly count: number;
+    readonly low: number;
+    readonly high: number;
+  };
+  /** This choice says that the ports of the parity of the low port come first in each round. */
+  readonly lowFirst?: boolean;
+  /** This band is the time from the `closing` line to each `freed` line: when each held port comes back. */
+  readonly freed?: QueueBand;
+  /** This count is the segments that the sockets of the client send again. */
+  readonly retransmissions?: number;
+}
+/**
+ * This prediction is the law of a conntrack table. It reads the lines of the ctfull client. The client
+ * holds flows on its loopback until the count of its namespace reads the limit, then it does its plan.
+ */
+interface ConntrackPrediction {
+  /** This count is the limit of the table: the flows that the client holds, and the count that it reads then. */
+  readonly max: number;
+  /** This count is what the namespace of the target reads while the client holds its flows. */
+  readonly neighbor?: number;
+  /** This record is the law of a connect that finds no entry: its end, and the rise of the two counters of the kernel. */
+  readonly refused?: {
+    readonly within: QueueBand;
+    readonly errno: string;
+    readonly drops: number;
+    readonly retransFail: number;
+  };
+  /** This band is the time from the `closing` line to the first fall of the count, and to its zero. */
+  readonly drained?: QueueBand;
+  /**
+   * This record is the law of a scan under pressure. It has the lowest count, the count after the
+   * connect, and the times of that connect. With `highest`, the lowest count is a band from `lowest` to
+   * `highest`. Then the count after the connect is one more than the lowest count of the run.
+   */
+  readonly pressure?: {
+    readonly lowest: number;
+    readonly highest?: number;
+    readonly after: number;
+    readonly points: readonly QueueBand[];
+  };
+}
+/**
+ * This setting is one sysctl of the namespace of the host, for the time of an environment. The harness
+ * reads the value before it, reads the value that it set, and restores the first value at the end.
+ */
+interface HostSysctl {
+  readonly name: string;
+  readonly value: string;
+  /** The harness does not set the value when this sysctl of the host reads above `atMost`. The cell is then void. */
+  readonly guard?: {
+    readonly name: string;
+    readonly atMost: number;
+  };
+}
+/** A load plan is the schedule of an open-loop client as data: the rate over time, and how the arrivals fall. */
+interface LoadPlan {
+  readonly profile: Profile;
+  readonly options: ScheduleOptions;
+}
+/**
+ * A load stream is one connection of the client `load`: its key, its schedule and its requests.
+ * Arrival i sends request i modulo the count of requests. Each stream has its own connection, thus
+ * a slow stream does not delay the arrivals of another stream.
+ */
+interface LoadStream {
+  /** This text names the stream in each line of the client (`k`). Two streams of a cell do not have the same key. */
+  readonly key: string;
+  readonly plan: LoadPlan;
+  /** These texts are whole HTTP/1.1 requests, each with its head and its body. */
+  readonly requests: readonly string[];
+}
+/** A run stream is the schedule that one stream of the client `load` had in a run. */
+interface RunStream {
+  readonly key: string;
+  readonly schedule: Schedule;
+}
+/** A load band is a limit on one quantile of the latency of an open-loop cell, over the arrivals of its counted runs. */
+interface LoadBand {
+  /** This number is the quantile, from 0 to 1. */
+  readonly quantile: number;
+  readonly low?: Quantity;
+  readonly high: Quantity;
+}
+/** A load prediction tells how close to its schedule a client stays, and where the latency lands. */
+interface LoadPrediction {
+  /** This time is the largest lag of a send behind its planned time. A later send is a finding of its run. */
+  readonly lag: Quantity;
+  readonly bands: readonly LoadBand[];
+  /**
+   * This share is the limit on the failed arrivals of the counted runs, from 0 to 1. An arrival fails
+   * when the client did not send it, when it has no reply, or when its reply has the status of a
+   * failure. The verdict reads the Wilson interval at 0.95, thus a limit of 0.01 needs 381 arrivals.
+   */
+  readonly failures?: number;
+}
 /** A target is the server that a cell connects to: a stock image. */
 interface Target {
   /** This image is a stock image, pinned by digest. */
@@ -740,7 +1088,7 @@ interface Target {
  * grpc-go and `etcd` is etcd on Alpine: each is a subject of a target (`Target.subject`).
  * `docker-proxy` is the userland proxy of Docker Engine 29.1.5, the program of a proxy hop.
  */
-type Shipped = "harness" | "node" | "go-http" | "node-http" | "mongo" | "pg" | "hikari" | "amqp" | "grpc" | "grpc-go" | "etcd" | "router" | "pgbouncer" | "pgpool" | "docker-proxy";
+type Shipped = "harness" | "node" | "go-http" | "node-http" | "mongo" | "pg" | "hikari" | "amqp" | "kafka" | "grpc" | "grpc-go" | "etcd" | "router" | "pgbouncer" | "pgpool" | "docker-proxy";
 /**
  * An image source tells where an image comes from, as data. The harness resolves each kind to an
  * image that it can start:
@@ -800,7 +1148,7 @@ interface Subject {
  * (`http-agent`) and an HTTP/1.1 `Client` of undici (`undici`). The MongoDB driver is `mongodb`, node-postgres is `pg`, and HikariCP over pgjdbc is `hikari`.
  * The client of amqplib is `amqp`, and the client of grpc-js is `grpc`. The WebSocket client of `@procedures/client` is a program of its subject (`ClientImage`).
  */
-type Client = "tcp" | "ioredis" | "go-http" | "http-agent" | "undici" | "mongodb" | "pg" | "hikari" | "amqp" | "grpc";
+type Client = "tcp" | "ioredis" | "go-http" | "http-agent" | "undici" | "mongodb" | "pg" | "hikari" | "amqp" | "grpc" | "load";
 /**
  * A WebSocket probe is the workload and the settings of the WebSocket client of
  * `@procedures/client`, the `client` program of its subject. The cell gives each setting, thus the client takes
@@ -868,7 +1216,15 @@ interface ClientImage {
   /** This image is a stock image by its name, pinned by digest, or the source of the image of a subject. */
   readonly image: string | ImageSource;
   readonly command: readonly string[];
+  /**
+   * These capabilities are added to the default set of the container of the client. A read of the
+   * statistics of conntrack over netlink needs NET_ADMIN in the namespace of the client.
+   */
+  readonly capabilities?: readonly ClientCapability[] | undefined;
 }
+/** These are the capabilities that a client image can get. */
+declare const CLIENT_CAPABILITIES: readonly ["NET_ADMIN"];
+type ClientCapability = (typeof CLIENT_CAPABILITIES)[number];
 /**
  * An observer is the side whose detection a cell measures. The client is one observer. The
  * server is another observer. It is the hold of the target on the connection of the client, at
@@ -893,8 +1249,13 @@ 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.
+     * On a `schedule`, it sends each request at its time in `plan`, and a send does not wait for a reply.
      */
-    readonly mode: "idle" | "inflight" | "stream" | "gap";
+    readonly mode: "idle" | "inflight" | "stream" | "gap" | "schedule";
+    /** This plan is the schedule of the requests in the mode `schedule`. */
+    readonly plan?: LoadPlan;
+    /** These streams are the plan of the client `load` in the mode `schedule`, in place of `plan`. */
+    readonly streams?: readonly LoadStream[];
     /** 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. */
@@ -912,19 +1273,26 @@ interface Cell {
     /**
      * This driver replaces the TCP client of the harness, with its own options. The driver then
      * ignores `keepalive` and `userTimeout`:
-     * - ioredis 6 on Node, whose keepAlive is the keepalive delay of the socket.
+     * - ioredis 6 on Node, whose keepAlive is the keepalive delay of the socket. In a group cell,
+     *   its write is `SET w:<n> <n>`, or `RPUSH w <n>` with `op: "rpush"`, thus a list keeps each
+     *   copy. `window` is the count of writers, each with one write in flight: 1 at the default.
      * - the MongoDB driver on Node, against the replica set `set`. Its operation is a write, or
      *   the read of a long document (`read-long`). `Cell.driverOptions` are its options.
      * - node-postgres on Node, as a `pg.Pool` against one server. Its operation is `query`, or
      *   `SELECT 1`. `Cell.driverOptions` are the options of its pool.
      * - HikariCP over pgjdbc on Java, as a `HikariDataSource` against one server. Its operation is
-     *   `query`, or `SELECT 1`. `Cell.driverOptions` are the properties of HikariConfig, and a name
-     *   with the prefix `dataSource.` is a property of pgjdbc.
+     *   `query`, or `SELECT 1`. `Cell.driverOptions` are the properties of HikariConfig. A name
+     *   with the prefix `dataSource.` is a property of pgjdbc, and a name with the prefix `system.`
+     *   is a system property of the JVM.
      *
      * A pg or hikari driver can send a different text in flight (`inflight`): the second query of
      * an in-flight run. The first query then makes the pool ready at once, and only the query in
      * flight is slow, for example `SELECT pg_sleep(20)`.
      *
+     * A hikari driver can send a burst in place of one query in flight. A burst is `count` queries,
+     * query 2 and the next ones. Each one has its own thread, and it starts `gap` after the one before
+     * it. The client writes a `burst` line at the end of the last one, with its counts.
+     *
      * A grpc driver is grpc-js on Node, with one channel. Its operation is a unary call of
      * grpc.health.v1.Health/Check. `Cell.driverOptions` are its channel options (`grpc.*`) and
      * `deadline_ms`. With `hold`, the call in flight asks the server of the harness to hold its reply
@@ -933,6 +1301,8 @@ interface Cell {
     readonly driver?: {
       readonly name: "ioredis";
       readonly keepAlive: Quantity;
+      readonly op?: "set" | "rpush";
+      readonly window?: number;
     } | {
       readonly name: "mongodb";
       readonly set: string;
@@ -945,6 +1315,10 @@ interface Cell {
       readonly name: "hikari";
       readonly query?: string;
       readonly inflight?: string;
+      readonly burst?: {
+        readonly count: number;
+        readonly gap: Quantity;
+      };
     } | {
       readonly name: "amqp";
     } | {
@@ -978,6 +1352,14 @@ interface Cell {
   readonly latency?: Quantity;
   /** These commands run in the target before a client connects, each as argv: for example, a large value to read. */
   readonly targetSetup?: readonly (readonly string[])[];
+  /** These commands run in the namespaces of the client and the target, each as argv, after the first connection of the environment. */
+  readonly namespaceSetup?: readonly (readonly string[])[];
+  /**
+   * These are sysctls of the host, which a cell needs because only the host can write them. The value
+   * applies to each container of the host, thus a shard runs them on its own runner. A host that does
+   * not have one makes the cell void (rule 8 of the environments).
+   */
+  readonly hostSysctls?: readonly HostSysctl[];
   readonly prediction: Prediction;
   /** This side is the side whose detection the cell measures. Without it, the side is the client. */
   readonly observer?: Observer;
@@ -1024,6 +1406,14 @@ interface Cell {
    * record, and the cluster does not read it.
    */
   readonly cluster?: Cluster;
+  /**
+   * This Kafka group replaces the target: brokers of Apache Kafka with one controller. The client is
+   * then the producer of kafka-clients, with the settings of `driverOptions`. `target` stays for the
+   * record, and the group does not read it.
+   */
+  readonly kafka?: Kafka;
+  /** This pair adds a standby to the target (`Pair`). The client is then node-postgres, in a stream of K writers. */
+  readonly pair?: Pair;
   /** This place is the node of the client in a cluster: the node of the leader, or of a follower. Without it, the node of a follower. */
   readonly clientAt?: ClusterClientAt;
   /**
@@ -1031,6 +1421,11 @@ interface Cell {
    * that instant, on the clock of the VM. On a direct pair, a frozen target thaws after it.
    */
   readonly hold?: Quantity;
+  /**
+   * This time is how much longer a run of a replica set continues after the lift. A prediction of
+   * no failover after a short hold needs it: the run must outlast the timers of an election.
+   */
+  readonly watch?: Quantity;
   /** This flag makes a planned failover coordinated: `SENTINEL FAILOVER <group> COORDINATED`. */
   readonly coordinated?: boolean;
   /**
@@ -1171,8 +1566,16 @@ interface 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[];
+  /** This text tells what the environment of the run could not do for its cell. The run is void. */
+  readonly missing?: string;
+  /** This record is the other member and the broker logs of a run of a paused consumer. */
+  readonly pause?: RunPause;
   /** This record is the fabric of a cell with `Topology.fabric`. */
   readonly fabric?: RunFabric;
+  /** This schedule is the one that the client of an open-loop cell had: each planned time stays with its record. */
+  readonly schedule?: Schedule;
+  /** These schedules are the ones that the streams of the client `load` had. */
+  readonly streams?: readonly RunStream[];
 }
 /** A run route is one change of a route at a leaf of a fabric, on the monotonic clock. */
 interface RunRoute {
@@ -1228,8 +1631,10 @@ interface RunGroup {
   readonly timeline: readonly SentinelEvent[];
   /** This name is the member that was the primary when the group converged after the run, or null when it did not converge. */
   readonly after: string | null;
-  /** These are the sequence numbers that the group holds after the run, when it converged, or null. */
+  /** These are the sequence numbers that the group holds after the run, one entry for each copy, when it converged, or null. */
   readonly holds: readonly number[] | null;
+  /** These are the sequence numbers that the old primary of a pair holds after its crash recovery. */
+  readonly oldHolds?: readonly number[];
   /** This record tells what a recovery drill did. */
   readonly drill?: RunDrill;
 }
@@ -1282,5 +1687,5 @@ interface RunTopology {
   }>>;
 }
 //#endregion
-export { RunRoute as $, MiddleboxExpectation as A, Reference as B, HopWrite as C, KernelRecord as D, Jitter as E, ProbeEvent as F, RouterHop as G, ReplicaSetStage as H, ProxyHop as I, RunBackup as J, RttRange as K, ProxyTime as L, Observer as M, PinnedImage as N, LineMatch as O, Prediction as P, RunPart as Q, Reconnects as R, HopSignal as S, ImageSource as T, Replies as U, ReplicaSet as V, RequestPrediction as W, RunFabric as X, RunDrill as Y, RunGroup as Z, GroupPrediction as _, Cluster as a, Stage as at, HopEvent as b, Drill as c, Target as ct, Fabric as d, WsProbe as dt, RunTopology as et, FabricManifest as f, isHopPlace as ft, GroupPlace as g, Group as h, ClientImage as i, ShippedImage as it, MiddleboxForm as j, MiddleboxEvent as k, DriverBand as l, Topology as lt, FaultPlace as m, Cell as n, SentinelStage as nt, ClusterClientAt as o, StageBand as ot, Fault as p, latestEndOf as pt, Run as q, Client as r, Shipped as rt, ClusterStage as s, Subject as st, BuildImage as t, SentinelEvent as tt, DriverStep as u, Toxic as ut, GroupRole as v, HttpProbe as w, HopPlace as x, Hop as y, Recovers as z };
-//# sourceMappingURL=cell-B3-BSTit.d.ts.map
+export { ProxyHop as $, ImageSource as A, Subject as At, LoadStream as B, Hop as C, RunTopology as Ct, HopWrite as D, ShippedImage as Dt, HopSignal as E, Shipped as Et, LineCount as F, isHopPlace as Ft, Outcomes as G, MiddleboxExpectation as H, LineMatch as I, latestEndOf as It, PausePrediction as J, Pair as K, LoadBand as L, Kafka as M, Topology as Mt, KafkaPause as N, Toxic as Nt, HostSysctl as O, Stage as Ot, KernelRecord as P, WsProbe as Pt, ProbeEvent as Q, LoadPlan as R, GroupRole as S, RunStream as St, HopPlace as T, SentinelStage as Tt, MiddleboxForm as U, MiddleboxEvent as V, Observer as W, PortsPrediction as X, PinnedImage as Y, Prediction as Z, Fault as _, RunFabric as _t, ClientCapability as a, Reconnects as at, GroupPlace as b, RunPause as bt, ClusterClientAt as c, ReplicaSet as ct, CountBand as d, RequestPrediction as dt, ProxyTime as et, Drill as f, RouterHop as ft, FabricManifest as g, RunDrill as gt, Fabric as h, RunBackup as ht, Client as i, QueuePrediction as it, Jitter as j, Target as jt, HttpProbe as k, StageBand as kt, ClusterStage as l, ReplicaSetStage as lt, DriverStep as m, Run as mt, CLIENT_CAPABILITIES as n, QueueConnection as nt, ClientImage as o, Recovers as ot, DriverBand as p, RttRange as pt, PauseBand as q, Cell as r, QueueEnd as rt, Cluster as s, Reference as st, BuildImage as t, QueueBand as tt, ConntrackPrediction as u, Replies as ut, FaultPlace as v, RunGroup as vt, HopEvent as w, SentinelEvent as wt, GroupPrediction as x, RunRoute as xt, Group as y, RunPart as yt, LoadPrediction as z };
+//# sourceMappingURL=cell-biffSiEJ.d.ts.map

package/build/{image-BMdV7yWD.js → image-BxVTFZ1o.js}

@@ -1,3 +1,4 @@
+import { valueIn } from "@mark1russell7/quantity";
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -6,6 +7,22 @@ import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpa
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
+//#region src/cell.ts
+/** These are the capabilities that a client image can get. */
+const CLIENT_CAPABILITIES = ["NET_ADMIN"];
+/** This function tells if a fault place is a hop of a topology. */
+const isHopPlace = (place) => typeof place === "object" && "hop" in place;
+/**
+* This function tells if the request of a client goes before the fault of its cell. That is so for a
+* hop event that comes while the request is in flight (`HopEvent.inFlight`). Then a request after the fault is void.
+*/
+const requestFirst = (cell) => cell.fault === "hop-event" && cell.event?.inFlight === true;
+/**
+* This function gives the latest end of a band in seconds, from the reply of the client. It is
+* the high bound, after the latest reference of the band (`startsBy`).
+*/
+const latestEndOf = (prediction) => valueIn(prediction.high, "s") + (prediction.startsBy === void 0 ? 0 : valueIn(prediction.startsBy, "s"));
+//#endregion
 //#region src/locks.ts
 /**
 * These are the names of the lockfiles that the harness records. A `go.mod` is the lockfile of a Go
@@ -191,6 +208,11 @@ const SHIPPED = {
 		dockerfile: "harness/image/amqp/Dockerfile",
 		from: ["harness/image/amqp"]
 	},
+	kafka: {
+		name: "loom-harness-kafka",
+		dockerfile: "harness/image/kafka/Dockerfile",
+		from: ["harness/image/kafka"]
+	},
 	grpc: {
 		name: "loom-harness-grpc",
 		dockerfile: "harness/image/grpc/Dockerfile",
@@ -287,6 +309,10 @@ const SHIPPED_CLIENTS = {
 	grpc: {
 		image: shipped("grpc"),
 		command: ["node", "/opt/harness/grpc/client-grpc.mjs"]
+	},
+	load: {
+		image: shipped("harness"),
+		command: ["/opt/harness/load"]
 	}
 };
 /** These are the names of the clients that the harness ships. */
@@ -624,6 +650,8 @@ const pgClientImage = () => imageOf(shipped("pg"));
 const hikariClientImage = () => imageOf(shipped("hikari"));
 /** This function gives the image of the RabbitMQ client: amqplib, with the client and the admin of a cluster cell. */
 const amqpClientImage = () => imageOf(shipped("amqp"));
+/** This function gives the image of the Kafka client: kafka-clients on Java, with the client and the admin of a Kafka cell. */
+const kafkaClientImage = () => imageOf(shipped("kafka"));
 /** 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. */
 const grpcClientImage = () => imageOf(shipped("grpc"));
 /**
@@ -634,6 +662,6 @@ const targetSourceOf = (target) => target.subject ?? target.image;
 /** This function gives the image that a target operates: the image of its subject, or its stock image. */
 const targetImageOf = (target) => imageOf(targetSourceOf(target));
 //#endregion
-export { unpinnedBases as A, routerImage as C, targetImageOf as D, subjectProblems as E, locksOf as F, npmVersions as I, versionsOf as L, cargoVersions as M, goVersions as N, targetSourceOf as O, jarVersions as P, programOf as S, subjectClient as T, mongoClientImage as _, SHIPPED_NAMES as a, pgClientImage as b, buildRecordOf as c, harnessImage as d, harnessVersion as f, inContext as g, imageProblems as h, SHIPPED_CLIENTS as i, LOCK_NAMES as j, unlockedManifests as k, goHttpImage as l, imageOf as m, PINNED as n, amqpClientImage as o, hikariClientImage as p, REPOSITORY as r, basesOf as s, CLIENT_NAMES as t, grpcClientImage as u, nodeClientImage as v, shippedSource as w, planOf as x, nodeHttpImage as y };
+export { unlockedManifests as A, isHopPlace as B, programOf as C, subjectProblems as D, subjectClient as E, jarVersions as F, requestFirst as H, locksOf as I, npmVersions as L, LOCK_NAMES as M, cargoVersions as N, targetImageOf as O, goVersions as P, versionsOf as R, planOf as S, shippedSource as T, latestEndOf as V, kafkaClientImage as _, SHIPPED_NAMES as a, nodeHttpImage as b, buildRecordOf as c, harnessImage as d, harnessVersion as f, inContext as g, imageProblems as h, SHIPPED_CLIENTS as i, unpinnedBases as j, targetSourceOf as k, goHttpImage as l, imageOf as m, PINNED as n, amqpClientImage as o, hikariClientImage as p, REPOSITORY as r, basesOf as s, CLIENT_NAMES as t, grpcClientImage as u, mongoClientImage as v, routerImage as w, pgClientImage as x, nodeClientImage as y, CLIENT_CAPABILITIES as z };
 
-//# sourceMappingURL=image-BMdV7yWD.js.map
+//# sourceMappingURL=image-BxVTFZ1o.js.map