@mark1russell7/harness 0.14.3 → 0.14.4

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as RunRoute, A as MiddleboxExpectation, B as Reference, C as HopWrite, D as KernelRecord, E as Jitter, F as ProbeEvent, G as RouterHop, H as ReplicaSetStage, I as ProxyHop, J as RunBackup, K as RttRange, L as ProxyTime, M as Observer, N as PinnedImage, O as LineMatch, P as Prediction, Q as RunPart, R as Reconnects, S as HopSignal, T as ImageSource, U as Replies, V as ReplicaSet, W as RequestPrediction, X as RunFabric, Y as RunDrill, Z as RunGroup, _ as GroupPrediction, a as Cluster, at as Stage, b as HopEvent, c as Drill, ct as Target, d as Fabric, dt as WsProbe, et as RunTopology, f as FabricManifest, ft as isHopPlace, g as GroupPlace, h as Group, i as ClientImage, it as ShippedImage, j as MiddleboxForm, k as MiddleboxEvent, l as DriverBand, lt as Topology, m as FaultPlace, n as Cell, nt as SentinelStage, o as ClusterClientAt, ot as StageBand, p as Fault, pt as latestEndOf, q as Run, r as Client, rt as Shipped, s as ClusterStage, st as Subject, t as BuildImage, tt as SentinelEvent, u as DriverStep, ut as Toxic, v as GroupRole, w as HttpProbe, x as HopPlace, y as Hop, z as Recovers } from "./cell-B3-BSTit.js";
+import { $ as Replies, A as LineCount, B as Prediction, C as HopSignal, Ct as latestEndOf, D as Jitter, E as ImageSource, F as Observer, G as QueueConnection, H as ProxyHop, I as Outcomes, J as Reconnects, K as QueueEnd, L as Pair, M as MiddleboxEvent, N as MiddleboxExpectation, O as Kafka, P as MiddleboxForm, Q as ReplicaSetStage, R as PinnedImage, S as HopPlace, St as isHopPlace, T as HttpProbe, U as ProxyTime, V as ProbeEvent, W as QueueBand, X as Reference, Y as Recovers, Z as ReplicaSet, _ as GroupPlace, _t as Subject, a as Cluster, at as RunDrill, b as Hop, bt as Toxic, c as CountBand, ct as RunPart, d as DriverStep, dt as SentinelEvent, et as RequestPrediction, f as Fabric, ft as SentinelStage, g as Group, gt as StageBand, h as FaultPlace, ht as Stage, i as ClientImage, it as RunBackup, j as LineMatch, k as KernelRecord, l as Drill, lt as RunRoute, m as Fault, mt as ShippedImage, n as Cell, nt as RttRange, o as ClusterClientAt, ot as RunFabric, p as FabricManifest, pt as Shipped, q as QueuePrediction, r as Client, rt as Run, s as ClusterStage, st as RunGroup, t as BuildImage, tt as RouterHop, u as DriverBand, ut as RunTopology, v as GroupPrediction, vt as Target, w as HopWrite, x as HopEvent, xt as WsProbe, y as GroupRole, yt as Topology, z as PortsPrediction } from "./cell-DZm8zXN4.js";
 import { Quantity } from "@mark1russell7/quantity";
 import { StartedTestContainer } from "testcontainers";
 //#region src/application.d.ts
@@ -295,6 +295,9 @@ interface ErrorOnTheWay {
  *   of a split brain. It is null when the group did not converge after the run.
  * - `unknown` are the writes that the client sent and did not see accepted: an error, or no answer.
  *   `held` tells if the group kept each one, or null when it did not converge.
+ * - `duplicates` has one entry for each extra copy that the group holds: a write held three times
+ *   has two entries. It is null when the group did not converge. A key holds one copy by
+ *   construction, thus only a list can show a copy.
  */
 interface Writes {
   readonly sent: number;
@@ -305,6 +308,18 @@ interface Writes {
     readonly n: number;
     readonly held: boolean | null;
   }>;
+  readonly duplicates?: readonly number[] | null;
+  /** These are the counts of a pair (`Cell.pair`), from its two final reads. */
+  readonly sets?: PairSets;
+}
+/** These are the counts that the bands of `Outcomes` judge: each one has the same name there. */
+interface PairSets {
+  readonly unknown: number;
+  readonly kept: number;
+  readonly stranded: number;
+  readonly absent: number;
+  readonly missing: number;
+  readonly warnings: number;
 }
 /** A group measurement is what one run of a group cell measured, beside its time. */
 interface GroupMeasured {
@@ -406,6 +421,78 @@ interface GroupReading {
  */
 export declare const measureGroup: (cell: Cell, run: Run) => GroupReading;
 //#endregion
+//#region src/ports.d.ts
+/** This record is what a run of a port cell measured. */
+interface PortsReading {
+  /** This count is the rounds of the run, each destination once. */
+  readonly rounds: number;
+  /** This record gives the count of searches for each count of connects, by that count. */
+  readonly counts: Readonly<Record<string, number>>;
+  /** These offsets from the low port are the ports that the run used, in rising order. */
+  readonly seen: readonly number[];
+  /** These errnos ended the searches of the run, each one time. */
+  readonly errnos: readonly string[];
+  /** This time is the longest connect that failed. */
+  readonly refusal: Quantity;
+  /** This time is from the `closing` line to the first `freed` line. */
+  readonly firstFreed: Quantity | null;
+  /** This time is from the `closing` line to the last `freed` line. */
+  readonly lastFreed: Quantity | null;
+  /** This count is the `freed` lines of the run. */
+  readonly freed: number;
+  /** This count is the connects that failed before the last `freed` line. */
+  readonly tries: number;
+}
+/**
+ * This function reads one run of a port cell. The `round` lines give each search. The `closing` and
+ * `freed` lines give when each held port comes back. The records of the prober give the
+ * retransmissions.
+ */
+export declare const measurePorts: (run: Run, expected: PortsPrediction) => Measured;
+//#endregion
+//#region src/queue.d.ts
+/** This record is what one connection of a queue cell did, from its lines and the records of its socket. */
+interface QueueConnectionReading {
+  readonly name: string;
+  readonly connected: boolean;
+  /** These times are the waits of the SYN. The first one counts from the dial. */
+  readonly syns: readonly Quantity[];
+  /** These times are the waits of each SYN-ACK sent again. The first one counts from the dial. */
+  readonly synAcks: readonly Quantity[];
+  /** This count is the segments that the socket sent again. */
+  readonly retransmissions: number;
+  readonly errno: string | null;
+  /** This time is from the line of the prediction to the end of the connection. It is null for a live connection, or with no prediction. */
+  readonly ended: Quantity | null;
+  /** This time is from the last retransmission to the end of the connection. */
+  readonly afterLast: Quantity | null;
+  /** This count is the segments of the socket with no acknowledgment at the end of the run. */
+  readonly unacked: number | null;
+}
+/** This record is what a run of a queue cell measured. The counts are the changes in the run. */
+interface QueueReading {
+  readonly max: number;
+  readonly held: number;
+  readonly connected: number;
+  readonly overflows: number;
+  readonly drops: number;
+  readonly cookies: number;
+  readonly timeouts: number;
+  readonly resets: number;
+  readonly drained: number;
+  /** This time is from the first dial of the burst to the last `TCPTimeouts` of the prediction. */
+  readonly expiry: Quantity | null;
+  /** This time is from the first dial of the burst to the rise of the count of the queue. */
+  readonly rise: Quantity | null;
+  readonly connections: readonly QueueConnectionReading[];
+}
+/**
+ * This function reads one run of a queue cell. The client lines give the connections and the
+ * counters at the two ends of the run. The target lines give the count of the queue. The records of
+ * the prober give the waits of each socket.
+ */
+export declare const measureQueue: (run: Run, expected: QueuePrediction) => Measured;
+//#endregion
 //#region src/verdict.d.ts
 /** This function gives the words of the outcome of a second request: its connection, a retry, and its end. */
 export declare const requestWords: (outcome: {
@@ -577,6 +664,8 @@ interface StageVerdict {
  * - `unknown` counts the writes whose outcome the client did not see, and how many the group kept.
  * - `errors` are the errors on the way: the runs that met each, and the median of its first time.
  * - `lags` is the spread of the delays of the stamps, for a calibration.
+ * - `duplicates` counts the extra copies that the group holds, in each run. A cell with no band of
+ *   copies has no such count.
  */
 interface GroupVerdict {
   readonly stages: readonly StageVerdict[];
@@ -601,6 +690,12 @@ interface GroupVerdict {
     readonly first: Quantity;
   }>;
   readonly lags?: Spread | null;
+  readonly duplicates?: {
+    readonly runs: number;
+    readonly total: number;
+    readonly median: number | null;
+    readonly max: number | null;
+  };
 }
 /**
  * This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). It is
@@ -712,6 +807,10 @@ interface Measured {
   readonly crossings?: Crossings;
   /** This record is what a run of a group cell measured: the stages of its timeline, and what became of each write. */
   readonly group?: GroupMeasured;
+  /** This record is what a run of a queue cell measured: the count of the queue, its counters, and each connection. */
+  readonly queue?: QueueReading;
+  /** This record is what a run of a port cell measured: the count of each search, and when each port came back. */
+  readonly ports?: PortsReading;
   /** This record is what the second request of an HTTP client met, for a cell whose prediction says it. */
   readonly request?: RequestReading | null;
   /** This record is the time of each later band of a driver cell (`DriverBand.then`). */
@@ -1102,6 +1201,8 @@ export declare const pgClientImage: () => Promise<string>;
 export declare const hikariClientImage: () => Promise<string>;
 /** This function gives the image of the RabbitMQ client: amqplib, with the client and the admin of a cluster cell. */
 export declare const amqpClientImage: () => Promise<string>;
+/** This function gives the image of the Kafka client: kafka-clients on Java, with the client and the admin of a Kafka cell. */
+export declare const kafkaClientImage: () => Promise<string>;
 /** This function gives the image of the gRPC client of the harness: grpc-js 1.14.6 on Node 24.21.0, with its client. */
 export declare const grpcClientImage: () => Promise<string>;
 /**
@@ -1239,6 +1340,8 @@ interface FaultOptions {
   readonly code?: "host" | "net" | "port" | "admin";
   /** This length is the longest segment in bytes that an MTU drop lets through. */
   readonly above?: number;
+  /** These are the addresses that the rule faces, in place of the peer of its place. */
+  readonly peers?: readonly string[];
 }
 /**
  * A fault side is the namespace that gets the rules of a fault: the namespace of the peer of the
@@ -1380,8 +1483,17 @@ interface Agent {
   exec(argv: readonly string[]): Promise<string>;
   stop(): Promise<void>;
 }
+/** A sibling is a server that a lab starts on the network of the target, for example a standby. */
+interface Sibling {
+  readonly ip: string;
+  readonly netns: number;
+  /** This method starts a command in the sibling, and gives its standard output. */
+  exec(argv: readonly string[]): Promise<string>;
+}
 /** A lab is one environment: the target, the client, the hops of a topology, the injectors and the prober. */
 interface Lab {
+  /** This address is the address of the target on its own network. */
+  readonly serverIp: string;
   /** This address is the address that the client connects to: the target, or the first proxy of a topology. */
   readonly targetIp: string;
   /** This port is the port that the client connects to. */
@@ -1412,6 +1524,10 @@ interface Lab {
   agent(image: string, command: readonly string[], options?: {
     readonly pid?: boolean;
   }): Promise<Agent>;
+  /** This method starts a sibling, and waits for a line of its log. */
+  sibling(image: string, command: readonly string[], ready: string): Promise<Sibling>;
+  /** This method starts a command in the target, and gives its standard output. */
+  exec(argv: readonly string[]): Promise<string>;
   /** These are all the records that the prober wrote, in sequence. */
   readonly kernel: readonly KernelRecord[];
   /** This method sets the sysctls of the client namespace through its privileged sidecar, and reads them back. */
@@ -1578,6 +1694,32 @@ export declare const deviceOf: (route: string) => string;
  */
 export declare const openLab: (target: Target, kind?: Client | ClientImage, topology?: Topology) => Promise<Lab>;
 //#endregion
+//#region src/standby.d.ts
+/** This text is the line of the log of a standby that serves reads (src/backend/postmaster/postmaster.c:3740). */
+export declare const STANDBY_READY: string;
+/** This text is the write of the client, with its sequence number. */
+export declare const INSERT: string;
+/** This function gives the command of a standby: a base backup of the primary, then the server in recovery. */
+export declare const standbyCommand: (primary: string) => string[];
+/** This command starts the old primary again, after the stop of each of its processes. Its crash recovery runs before the wait ends. */
+export declare const RESTART: readonly string[];
+/** This function reads the output of a query for sequence numbers into a sorted list. */
+export declare const numbersOf: (text: string) => number[];
+/** This function gives the arguments of the client of a run. */
+export declare const pairArgs: (cell: Cell, lab: Pick<Lab, "targetIp" | "targetPort">) => string[];
+/** This function gives the instants of the cancels of a hold, in ns from the fault: equal parts of the hold. */
+export declare const cancelsOf: (pair: Pair, holdNs: number) => number[];
+/**
+ * This function opens the pair of an environment. The table comes first and the standby next: the
+ * base backup has it. A synchronous standby is named last, thus no setup step waits for it.
+ */
+export declare const openStandby: (lab: Lab, cell: Cell) => Promise<Sibling>;
+/**
+ * This function does one run of a pair. A dry run writes and stops, with no fault: the warm-up of the
+ * environment. It removes its rows, thus the numbers of the run start on an empty table.
+ */
+export declare const pairOnce: (lab: Lab, standby: Sibling, cell: Cell, environment: number, index: number, dry?: boolean) => Promise<Run>;
+//#endregion
 //#region src/locks.d.ts
 /**
  * This module reads the lockfiles of a build context for the manifest of a run. A lockfile pins each
@@ -1632,6 +1774,28 @@ export declare const versionsOf: (files: readonly ContextFile[]) => Record<strin
 export declare const manifestProblems: (manifest: Manifest) => string[];
 /** This function gives the problem of the commit of a record: no commit, or a text that is not a commit of git. */
 export declare const commitProblems: (commit: string | undefined) => string[];
+/** The code of a record is the commit of the checkout that operated, and if its tracked files had changes. */
+interface RecordCode {
+  readonly commit: string;
+  readonly dirty: boolean;
+}
+/** These are the parts of a record that tell if it pins the programs of its runs. */
+interface Pinnable {
+  readonly code?: RecordCode | undefined;
+  readonly manifests: readonly Manifest[];
+  /** A local debug run marks its record so. No page reads such a record. */
+  readonly debug?: boolean | undefined;
+}
+/** This problem is the problem of a checkout with changes: its commit does not hold the code that operated. */
+export declare const DIRTY = "the checkout has changes to tracked files that no commit holds";
+/** This problem is the problem of a record of a local debug run. */
+export declare const DEBUG = "the record is of a local debug run, and no page reads it";
+/**
+ * This function gives each problem that stops a record from pinning the programs of its runs. A
+ * record with a problem is not a record (SYS-101). The writer of the cells refuses it, and the read
+ * of a schedule refuses it. A commit with changes to tracked files is not a pin.
+ */
+export declare const recordProblems: (record: Pinnable) => string[];
 //#endregion
 //#region src/group.d.ts
 /**
@@ -1708,8 +1872,8 @@ export declare const memberConfig: (group: Group, primary: string | null) => str
 export declare const sentinelConfig: (group: Group, primary: string) => string;
 /**
  * This function gives the peers that a fault on a part cuts it from, by their addresses. `all` is
- * each other part and the client, `group` is the other parts, and `clients` is the client. `one`
- * and `one-way` are the first other member. The observer is not a peer, thus the timeline of the
+ * each other part and the client, `group` is the other parts, and `clients` and `to-clients` are
+ * the client. `one` and `one-way` are the first other member. The observer is not a peer, thus the timeline of the
  * group stays whole.
  */
 export declare const peersOf: (parts: {
@@ -2009,6 +2173,7 @@ export declare const clusterViewOf: (cluster: Cluster, rows: readonly StatusRow[
  * This function gives the peers that a fault on a node cuts it from. `all` is each other node and the
  * client, `group` is the other nodes, and `clients` is the client. `one` is the first other node in
  * the sequence of the cluster, and `one-way` is the same node for the segments from the part only.
+ * `to-clients` is the client, for the segments from the part only.
  */
 export declare const clusterCutOf: (cluster: Cluster, members: Readonly<Record<string, RunPart>>, client: string, part: string, cuts: NonNullable<GroupPlace["cuts"]>) => Cut;
 /** A wall stamp is the wall clock in ns around a command of a node: the run puts it on the monotonic clock. */
@@ -2109,6 +2274,106 @@ export declare const restamped: (line: NodeLine, events: readonly ProbeEvent[])
  */
 export declare const clusterOnce: (lab: ClusterLab, cell: Cell, environment: number, index: number) => Promise<Run>;
 //#endregion
+//#region src/kafka.d.ts
+/** This function gives the node id of a name. A broker has its place in the list from 1, and the controller has the id after them. */
+export declare const nodeIdOf: (kafka: Kafka, name: string) => number;
+/**
+ * This function gives the variable of a server property for the image. The wrapper of the image
+ * reverses this map (KafkaDockerWrapper.scala:188-203). After the prefix `KAFKA_`, `___` is a
+ * hyphen, `__` is an underscore and `_` is a dot.
+ */
+export declare const envOf: (property: string) => string;
+/** This function gives the environment of a broker. */
+export declare const brokerEnv: (kafka: Kafka, name: string) => Record<string, string>;
+/** This function gives the environment of the controller. The start script of the image stops on an advertised listener here (configure:43-48). */
+export declare const controllerEnv: (kafka: Kafka) => Record<string, string>;
+/** A partition view is the output of the command `view` of the admin. Without a topic it has only the brokers. */
+interface PartitionView {
+  readonly brokers: readonly number[];
+  readonly leader?: number | null;
+  readonly isr?: readonly number[];
+  readonly replicas?: readonly number[];
+}
+/**
+ * This function judges a view of a partition: its leader, and if the group is healthy. A healthy
+ * group has each broker not fenced, one leader, and each broker in the in-sync replicas.
+ */
+export declare const kafkaViewOf: (kafka: Kafka, view: PartitionView) => GroupView;
+/**
+ * This function gives the peers that a fault on a broker cuts it from. Only `group` has a law: the
+ * other brokers and the controller, and the client keeps its route to the broker.
+ */
+export declare const kafkaCutOf: (kafka: Kafka, members: Readonly<Record<string, RunPart>>, controller: RunPart, part: string, cuts: NonNullable<GroupPlace["cuts"]>) => Cut;
+/** This function gives the addresses that the client and the admin bootstrap from. */
+export declare const bootstrapOf: (kafka: Kafka) => string;
+/** This function gives the name of the topic of a run. A warm-up has the index -1. */
+export declare const topicOf: (environment: number, index: number) => string;
+/** A Kafka lab is one environment of a Kafka cell. */
+interface KafkaLab {
+  readonly kafka: Kafka;
+  readonly clientIp: string;
+  readonly members: Readonly<Record<string, RunPart>>;
+  readonly controller: RunPart;
+  readonly netns: {
+    readonly client: number;
+  };
+  /** These are all the records that the prober wrote, in sequence. */
+  readonly kernel: readonly KernelRecord[];
+  /** These are the last raw lines of the console of each node, for the diagnosis of a lab: at most RAW_TAIL of each. */
+  readonly raw: Readonly<Record<string, readonly string[]>>;
+  /** This method sets the sysctls of the client namespace through its privileged sidecar, and reads them back. */
+  sysctl(values: Readonly<Record<string, string>>): Promise<Record<string, string>>;
+  /** This method waits until each broker is not fenced. */
+  brokersUp(within?: number): Promise<void>;
+  /** This method makes the topic of a run. */
+  create(topic: string): Promise<void>;
+  /** This method waits until the partition is whole and calm, and gives the name of the broker of its leader. */
+  converge(topic: string, within?: number): Promise<string>;
+  /** This method gives the sequence numbers that the partition holds, one entry for each copy. */
+  holds(topic: string): Promise<number[]>;
+  /** This method starts the client of a run, with the arguments of `ClientKafka`. */
+  client(args: readonly string[]): Promise<GroupClient>;
+  /** This method applies a network fault between a broker and some of its peers, at once or at an instant of the VM. */
+  fault(kind: GroupNetworkFault, part: string, cuts: NonNullable<GroupPlace["cuts"]>, at?: number): Promise<Stamp>;
+  /** This method removes a network fault, at once or at an instant of the VM. */
+  lift(kind: GroupNetworkFault, part: string, cuts: NonNullable<GroupPlace["cuts"]>, at?: number): Promise<Stamp>;
+  /** This method removes the TCP metrics of the client namespace: each run starts from a kernel that keeps nothing. */
+  forget(): Promise<void>;
+  /** This method waits for the next clock line of the prober, which gives the count of lost records. */
+  settle(): Promise<number | null>;
+  manifest(sysctls: Readonly<Record<string, string>>): Promise<Manifest>;
+  close(): Promise<void>;
+}
+/**
+ * This function opens one environment of a Kafka cell:
+ * - one new network, with each node, the client and the commander on it.
+ * - the controller first, then each broker: the stock image with its own command. The brokers
+ *   register with the controller, thus they need it first.
+ * - an injector sidecar for each node, in its network and process namespaces.
+ * - a client that holds its own network namespace, with a privileged sidecar for its sysctls.
+ * - the prober, which watches the namespace of the client.
+ */
+export declare const openKafkaLab: (kafka: Kafka) => Promise<KafkaLab>;
+/**
+ * This time is how long a run continues after its lift. The record then shows the step-down of the
+ * leader and the writes after it. It has no source. It is above the largest step-down of the
+ * law, which is approximately 2 s after the lift.
+ */
+export declare const KAFKA_TAIL_MS = 1e4;
+/** This function gives the arguments of the client of a Kafka cell: the topic, the writers, the stream of writes and the settings. */
+export declare const kafkaArgs: (cell: Cell, topic: string) => string[];
+/**
+ * This function does one run of a Kafka cell:
+ * - Each broker is up, the topic of the run exists, and its partition is whole. The client starts,
+ *   and its stream of writes gets steady.
+ * - The fault cuts the leader from the other brokers and the controller, and it lifts at its instant
+ *   in the VM. The client keeps its route to the leader, thus only the group knows of the cut.
+ * - The run waits for the lift and for the tail after it.
+ * - Each fault goes, the client stops, and the partition converges again. The admin then reads
+ *   the whole partition, thus the record tells which writes the group kept.
+ */
+export declare const kafkaOnce: (lab: KafkaLab, cell: Cell, environment: number, index: number) => Promise<Run>;
+//#endregion
 //#region src/run.d.ts
 /** A cell result is a cell with its manifests, its runs, their measurements and its verdict. */
 interface CellResult {
@@ -2157,5 +2422,5 @@ export declare const spread: (runs: number, environments: number) => number[];
  */
 export declare const runCell: (cell: Cell, say?: (line: string) => void) => Promise<CellResult>;
 //#endregion
-export { type Agent, type BuildImage, type BuildRecord, type CallReading, type Cell, type CellResult, type Client, type ClientImage, type ClockPair, type Cloud, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type ContextFile, type Crossings, type Cut, type Decision, type Drill, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, type Fabric, type FabricLab, type FabricManifest, type FabricParts, type Fault, type FaultPlace, type FaultSide, type Group, type GroupClient, type GroupLab, type GroupMeasured, type GroupNetworkFault, type GroupPlace, type GroupPrediction, type GroupReading, type GroupRole, type GroupVerdict, type GroupView, type Hop, type HopEvent, type HopPlace, type HopSignal, type HopWrite, type Host, type HttpProbe, type ImagePlan, type ImageSource, type Interval, type Jitter, type KernelRecord, type Lab, type Layer, type LeafViews, type LineMatch, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, type OplogRead, type OplogTime, type Outcome, type Pairing, type PinnedImage, type Prediction, type Probe, type ProbeEvent, type ProgramEvent, type ProxyHop, type ProxyTime, type ReconnectReading, type ReconnectVerdict, type Reconnects, type Recovers, type RecoveryMeasured, type Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouteLine, type RouterHop, type RttRange, type Run, type RunBackup, type RunDrill, type RunFabric, type RunGroup, type RunPart, type RunRoute, type RunTopology, type SentinelEvent, type SentinelStage, type Shipped, type ShippedImage, type SocketPlace, type Spread, type Stage, type StageBand, type StageVerdict, type Stamp, type Status, type StatusRow, type Subject, type Substrate, type SubstrateSource, type Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, isHopPlace, latestEndOf };
+export { type Agent, type BuildImage, type BuildRecord, type CallReading, type Cell, type CellResult, type Client, type ClientImage, type ClockPair, type Cloud, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type ContextFile, type CountBand, type Crossings, type Cut, type Decision, type Drill, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, type Fabric, type FabricLab, type FabricManifest, type FabricParts, type Fault, type FaultPlace, type FaultSide, type Group, type GroupClient, type GroupLab, type GroupMeasured, type GroupNetworkFault, type GroupPlace, type GroupPrediction, type GroupReading, type GroupRole, type GroupVerdict, type GroupView, type Hop, type HopEvent, type HopPlace, type HopSignal, type HopWrite, type Host, type HttpProbe, type ImagePlan, type ImageSource, type Interval, type Jitter, type Kafka, type KafkaLab, type KernelRecord, type Lab, type Layer, type LeafViews, type LineCount, type LineMatch, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, type OplogRead, type OplogTime, type Outcome, type Outcomes, type Pair, type PairSets, type Pairing, type PartitionView, type Pinnable, type PinnedImage, type PortsPrediction, type PortsReading, type Prediction, type Probe, type ProbeEvent, type ProgramEvent, type ProxyHop, type ProxyTime, type QueueBand, type QueueConnection, type QueueConnectionReading, type QueueEnd, type QueuePrediction, type QueueReading, type ReconnectReading, type ReconnectVerdict, type Reconnects, type RecordCode, type Recovers, type RecoveryMeasured, type Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouteLine, type RouterHop, type RttRange, type Run, type RunBackup, type RunDrill, type RunFabric, type RunGroup, type RunPart, type RunRoute, type RunTopology, type SentinelEvent, type SentinelStage, type Shipped, type ShippedImage, type Sibling, type SocketPlace, type Spread, type Stage, type StageBand, type StageVerdict, type Stamp, type Status, type StatusRow, type Subject, type Substrate, type SubstrateSource, type Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, isHopPlace, latestEndOf };
 //# sourceMappingURL=index.d.ts.map