@mark1russell7/harness 0.14.2 → 0.14.4

package/build/{cell-BccWKiXh.d.ts → cell-DZm8zXN4.d.ts}

@@ -59,8 +59,13 @@ import { KernelRecord } from "@mark1russell7/prober";
  * - `drain` puts the node of the part in maintenance mode: `rabbitmq-upgrade drain`. The node closes the
  *   connections of its clients, and it moves the leadership of each of its queues to another node.
  *   `rabbitmq-upgrade revive` ends it after the run.
+ *
+ * This fault is of a fabric (`Topology.fabric`):
+ * - `silence` drops each packet of spine1 in one commit, and its links stay up. Each leaf loses its
+ *   neighbor only by a detector of its own, and the routes move to spine2. The measured move ends
+ *   the stall of the client (`Run.heal`).
  */
-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" | "step-down" | "drain" | "hop-event" | "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" | "step-down" | "drain" | "hop-event" | "silence" | "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.
@@ -185,13 +190,33 @@ interface HopWrite {
  * of the side of the client, and the network of the side of the target.
  */
 type Hop = RouterHop | ProxyHop;
+/**
+ * A fabric is a routed network on layer E3 (`fabric.ts`), by its timers. The detector of a fabric
+ * is the BGP hold timer, or BFD when it has `bfd`.
+ */
+interface Fabric {
+  readonly keepalive: Quantity;
+  readonly hold: Quantity;
+  /** These are the receive and transmit interval and the multiplier of BFD, or null for no BFD. */
+  readonly bfd: {
+    readonly interval: Quantity;
+    readonly multiplier: number;
+  } | null;
+}
+/** A fabric manifest tells what a fabric ran on: its timers, its image and containerlab. */
+interface FabricManifest extends Fabric {
+  readonly image: string;
+  readonly containerlab: string;
+}
 /**
  * A topology is the chain of hops between the client and the target, in sequence from the client.
- * Without hops, the client and the target are a direct pair.
+ * Without hops, the client and the target are a direct pair. With `fabric`, a routed network
+ * joins them, and the chain of hops is empty.
  */
 interface Topology {
   readonly name: string;
   readonly hops: readonly Hop[];
+  readonly fabric?: Fabric;
 }
 /**
  * A group is a replicated group under an external failover authority, as data. It is a primary and
@@ -257,6 +282,28 @@ interface ReplicaSet {
   /** This line tells that a member serves. */
   readonly ready: string;
 }
+/**
+ * A drill is a recovery drill of a replica set cell, as data. The store gets generated data for
+ * each tenant and real backups while a client writes. Then the fault removes the disk of a member,
+ * or of each member, and the store recovers. A drill shortens the interval of the backups. The
+ * loss of a backup depends on the age of the newest backup at the fault, and `age` sets that age.
+ */
+interface Drill {
+  /** This count is the number of tenants. The size of the store follows it. */
+  readonly tenants: number;
+  /** This size is the generated data of one tenant. */
+  readonly perTenant: Quantity;
+  /** This count is the number of slices of the oplog after the dump. */
+  readonly slices: number;
+  /** This time is the interval from the dump to the first slice, and between two slices. */
+  readonly sliceEvery: Quantity;
+  /** This time is the age of the newest backup at the fault: from its last write, or from its end in the control. */
+  readonly age: Quantity;
+  /** This word tells how the store recovers. An election follows the loss of the disk of the primary. A restore from the backups follows the loss of each disk. */
+  readonly recovery: "election" | "restore";
+  /** This flag makes the drill a control: the client stops before the dump, thus no write comes after it. */
+  readonly quiet?: true;
+}
 /**
  * A cluster is a cluster of RabbitMQ nodes with one quorum queue, as data. The members of the queue
  * elect its leader by Raft, one member on each node. Each node is a container from the same stock
@@ -284,6 +331,36 @@ 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;
+}
 /**
  * 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:
@@ -305,10 +382,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 {
@@ -432,6 +511,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";
@@ -448,6 +530,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
@@ -486,6 +613,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
@@ -637,7 +774,120 @@ 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;
 };
+/** 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;
+}
 /** A target is the server that a cell connects to: a stock image. */
 interface Target {
   /** This image is a stock image, pinned by digest. */
@@ -693,7 +943,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:
@@ -865,19 +1115,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
@@ -886,6 +1143,8 @@ interface Cell {
     readonly driver?: {
       readonly name: "ioredis";
       readonly keepAlive: Quantity;
+      readonly op?: "set" | "rpush";
+      readonly window?: number;
     } | {
       readonly name: "mongodb";
       readonly set: string;
@@ -898,6 +1157,10 @@ interface Cell {
       readonly name: "hikari";
       readonly query?: string;
       readonly inflight?: string;
+      readonly burst?: {
+        readonly count: number;
+        readonly gap: Quantity;
+      };
     } | {
       readonly name: "amqp";
     } | {
@@ -977,6 +1240,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;
   /**
@@ -984,6 +1255,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;
   /**
@@ -995,6 +1271,8 @@ interface Cell {
   readonly writeConcern?: "majority" | 1;
   /** This flag makes the fault hold before the client starts. The client then meets it at its first selection. */
   readonly before?: boolean;
+  /** This drill makes the cell a recovery drill. It needs `replicaSet`, and its runs have two clients when the store restores. */
+  readonly drill?: Drill;
   /** This count is the number of runs of the cell (11), across new environments (two at least). */
   readonly runs: number;
   readonly environments: number;
@@ -1108,6 +1386,12 @@ interface Run {
    * its window is δ_abs of its cell: 1 ms on a calibrated runner.
    */
   readonly jitter?: Jitter;
+  /**
+   * This share is the CPU time from 0 to 1 that the host took from this machine in the run, from
+   * `/proc/stat` (`stealShare`). A run of a plain cell writes it. A group, a replica set or a cluster
+   * writes it with its first cell on layer E4.
+   */
+  readonly steal?: number;
   /** These are the addresses and the namespaces of a topology, which the measurement of a run reads. */
   readonly topology?: RunTopology;
   /** These are the lines of the routers of a topology from the start to the end of the run. */
@@ -1116,6 +1400,29 @@ 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 record is the fabric of a cell with `Topology.fabric`. */
+  readonly fabric?: RunFabric;
+}
+/** A run route is one change of a route at a leaf of a fabric, on the monotonic clock. */
+interface RunRoute {
+  readonly leaf: string;
+  readonly t: number;
+  readonly deleted: boolean;
+  readonly prefix: string;
+  readonly via: string | null;
+  readonly dev: string | null;
+}
+/**
+ * A run fabric is what the routers did in a run. It holds each change of a route. It also holds the
+ * count of established sessions of each leaf at the start and the end. A session that went down and
+ * came back in the run raises its count.
+ */
+interface RunFabric {
+  readonly routes: readonly RunRoute[];
+  readonly established: {
+    readonly before: Readonly<Record<string, number>>;
+    readonly after: Readonly<Record<string, number>>;
+  };
 }
 /** 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 {
@@ -1150,8 +1457,45 @@ 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;
+}
+/** A run backup is one backup of a drill: a dump with its oplog, or one slice of the oplog. */
+interface RunBackup {
+  readonly kind: "dump" | "slice";
+  /** These are the start and the end of the backup, on the wall clock of the runner, in ms. */
+  readonly started: number;
+  readonly ended: number;
+  /** This write is the last one that the backups hold up to this backup, or null with no write. Its time is the time that the client sent it. */
+  readonly last: {
+    readonly n: number;
+    readonly t: number;
+  } | null;
+  /** This size is the size of the backup on disk. */
+  readonly size: Quantity;
+}
+/** A run drill is what a recovery drill did in one run. */
+interface RunDrill {
+  /** This text is the first line of `mongodump --version`. */
+  readonly tool: string;
+  /** This word tells where the data of the tenants came from. It is always generated data. */
+  readonly seed: "generated";
+  readonly backups: readonly RunBackup[];
+  /** This hash is the hash of the data of the tenants before the first client. */
+  readonly before: string;
+  /** This hash is the hash of the data of the tenants after the run, or null when the set did not converge. */
+  readonly after: string | null;
+  /** These are the start and the end of the restore, on the wall clock of the runner, in ms, or null without a restore. */
+  readonly restored: {
+    readonly started: number;
+    readonly ended: number;
+  } | null;
+  /** This number is the first sequence number of the second client, or null with one client. */
+  readonly second: number | null;
 }
 /**
  * A run topology tells where each socket of a run is, in a topology:
@@ -1169,5 +1513,5 @@ interface RunTopology {
   }>>;
 }
 //#endregion
-export { StageBand as $, PinnedImage as A, Replies as B, Jitter as C, MiddleboxExpectation as D, MiddleboxEvent as E, Reconnects as F, RunGroup as G, RouterHop as H, Recovers as I, SentinelEvent as J, RunPart as K, Reference as L, ProbeEvent as M, ProxyHop as N, MiddleboxForm as O, ProxyTime as P, Stage as Q, ReplicaSet as R, ImageSource as S, LineMatch as T, RttRange as U, RequestPrediction as V, Run as W, Shipped as X, SentinelStage as Y, ShippedImage as Z, HopEvent as _, Cluster as a, isHopPlace as at, HopWrite as b, DriverBand as c, FaultPlace as d, Subject as et, Group as f, Hop as g, GroupRole as h, ClientImage as i, WsProbe as it, Prediction as j, Observer as k, DriverStep as l, GroupPrediction as m, Cell as n, Topology as nt, ClusterClientAt as o, latestEndOf as ot, GroupPlace as p, RunTopology as q, Client as r, Toxic as rt, ClusterStage as s, BuildImage as t, Target as tt, Fault as u, HopPlace as v, KernelRecord as w, HttpProbe as x, HopSignal as y, ReplicaSetStage as z };
-//# sourceMappingURL=cell-BccWKiXh.d.ts.map
+export { Replies as $, LineCount as A, Prediction as B, HopSignal as C, latestEndOf as Ct, Jitter as D, ImageSource as E, Observer as F, QueueConnection as G, ProxyHop as H, Outcomes as I, Reconnects as J, QueueEnd as K, Pair as L, MiddleboxEvent as M, MiddleboxExpectation as N, Kafka as O, MiddleboxForm as P, ReplicaSetStage as Q, PinnedImage as R, HopPlace as S, isHopPlace as St, HttpProbe as T, ProxyTime as U, ProbeEvent as V, QueueBand as W, Reference as X, Recovers as Y, ReplicaSet as Z, GroupPlace as _, Subject as _t, Cluster as a, RunDrill as at, Hop as b, Toxic as bt, CountBand as c, RunPart as ct, DriverStep as d, SentinelEvent as dt, RequestPrediction as et, Fabric as f, SentinelStage as ft, Group as g, StageBand as gt, FaultPlace as h, Stage as ht, ClientImage as i, RunBackup as it, LineMatch as j, KernelRecord as k, Drill as l, RunRoute as lt, Fault as m, ShippedImage as mt, Cell as n, RttRange as nt, ClusterClientAt as o, RunFabric as ot, FabricManifest as p, Shipped as pt, QueuePrediction as q, Client as r, Run as rt, ClusterStage as s, RunGroup as st, BuildImage as t, RouterHop as tt, DriverBand as u, RunTopology as ut, GroupPrediction as v, Target as vt, HopWrite as w, HopEvent as x, WsProbe as xt, GroupRole as y, Topology as yt, PortsPrediction as z };
+//# sourceMappingURL=cell-DZm8zXN4.d.ts.map