@mark1russell7/harness 0.14.4 → 0.15.1

package/build/index.d.ts

@@ -1,5 +1,6 @@
-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 { $ as ProxyHop, A as ImageSource, At as Subject, B as LoadStream, C as Hop, Ct as RunTopology, D as HopWrite, Dt as ShippedImage, E as HopSignal, Et as Shipped, F as LineCount, Ft as isHopPlace, G as Outcomes, H as MiddleboxExpectation, I as LineMatch, It as latestEndOf, J as PausePrediction, K as Pair, L as LoadBand, M as Kafka, Mt as Topology, N as KafkaPause, Nt as Toxic, O as HostSysctl, Ot as Stage, P as KernelRecord, Pt as WsProbe, Q as ProbeEvent, R as LoadPlan, S as GroupRole, St as RunStream, T as HopPlace, Tt as SentinelStage, U as MiddleboxForm, V as MiddleboxEvent, W as Observer, X as PortsPrediction, Y as PinnedImage, Z as Prediction, _ as Fault, _t as RunFabric, a as ClientCapability, at as Reconnects, b as GroupPlace, bt as RunPause, c as ClusterClientAt, ct as ReplicaSet, d as CountBand, dt as RequestPrediction, et as ProxyTime, f as Drill, ft as RouterHop, g as FabricManifest, gt as RunDrill, h as Fabric, ht as RunBackup, i as Client, it as QueuePrediction, j as Jitter, jt as Target, k as HttpProbe, kt as StageBand, l as ClusterStage, lt as ReplicaSetStage, m as DriverStep, mt as Run, n as CLIENT_CAPABILITIES, nt as QueueConnection, o as ClientImage, ot as Recovers, p as DriverBand, pt as RttRange, q as PauseBand, r as Cell, rt as QueueEnd, s as Cluster, st as Reference, t as BuildImage, tt as QueueBand, u as ConntrackPrediction, ut as Replies, v as FaultPlace, vt as RunGroup, w as HopEvent, wt as SentinelEvent, x as GroupPrediction, xt as RunRoute, y as Group, yt as RunPart, z as LoadPrediction } from "./cell-biffSiEJ.js";
 import { Quantity } from "@mark1russell7/quantity";
+import { LoadMeasure, Schedule } from "@mark1russell7/rigor-chaos";
 import { StartedTestContainer } from "testcontainers";
 //#region src/application.d.ts
 /**
@@ -135,6 +136,140 @@ interface CallReading {
 /** This function reads the call that the client sent into the fault: its `call-error` or `data` line after the request. */
 export declare const callOf: (events: readonly ProbeEvent[], request: ProbeEvent, detected: number | undefined) => CallReading;
 //#endregion
+//#region src/load.d.ts
+/**
+ * The measure and the verdict of an open-loop cell (SYS-68). A client on a schedule sends each
+ * arrival at its time, thus a stall counts in each arrival that it delayed. The package rigor-chaos
+ * counts each latency from the planned time. The package rigor-bench judges a quantile by a
+ * distribution-free interval.
+ */
+/** This path is where the client of an open-loop cell finds its schedule. */
+export declare const SCHEDULE_PATH = "/tmp/schedule.json";
+/**
+ * This function gives the measure of one run of a schedule from the lines of its client. It gives
+ * null when the client did not start the schedule. The first `sent` line of a client is its request
+ * before `ready`, and it names no arrival. The end of the run is its last line.
+ */
+export declare const loadOf: (events: readonly ProbeEvent[], plan: Schedule) => RunLoad | null;
+/**
+ * A run load is the measure of one run of a schedule. `failed` counts the replies with a status
+ * outside 200 to 299. Such a reply is a completion, thus its time is in `latency`. The client
+ * `schedule` gives no status, and a record from before this field has none: both read as 0.
+ */
+type RunLoad = LoadMeasure & {
+  readonly failed?: number;
+};
+/** This path is where the client `load` finds its plan. */
+export declare const LOAD_PATH = "/tmp/load.json";
+/** This text is the format of the plan of the client `load`. */
+export declare const LOAD_FORMAT = "systems-load/1";
+/**
+ * This function gives the schedule of each stream of a cell, and the text of the plan of the client
+ * `load`. It throws for no stream, for two streams with one key and for a stream with no request.
+ */
+export declare const loadPlanOf: (streams: readonly LoadStream[]) => {
+  readonly streams: readonly RunStream[];
+  readonly content: string;
+};
+/**
+ * This function gives the measure of each stream of a run of the client `load`, and their pool. Each
+ * stream counts its arrivals from 0, thus the lines of a stream are the lines with its key. The pool
+ * sums the counts and joins the times, in the order of the streams. It gives null when the client did
+ * not start its schedule.
+ */
+export declare const streamsLoadOf: (events: readonly ProbeEvent[], streams: readonly RunStream[]) => {
+  readonly pool: RunLoad;
+  readonly streams: Readonly<Record<string, RunLoad>>;
+} | null;
+/** This function gives the pool of some measures: it sums the counts and joins the times, in the order of the measures. */
+export declare const poolOf: (measures: readonly RunLoad[]) => RunLoad & {
+  readonly failed: number;
+};
+/**
+ * This time is the tolerance of a closed-loop estimate, in ms. A send later than its expected time
+ * by more than this tolerance is a pause of the client: a driver gap.
+ */
+export declare const CLOSED_TOLERANCE = 5;
+/**
+ * A run estimate is the latency of the open loop that a closed-loop stream hid (SYS-91). The package
+ * rigor-chaos puts back each send that a stall or a pause of the client hid (`closedLoopPlan`).
+ * `hidden` counts those sends, and `driverGaps` counts the pauses of the client. Its times are in ms.
+ */
+type RunEstimate = LoadMeasure & {
+  readonly hidden: number;
+  readonly driverGaps: number;
+  readonly driverGapTotal: number;
+};
+/**
+ * This function gives the estimate of one closed-loop stream from its requests, in the order of their
+ * sends. Each time is a time of a line of the client. The client waits `interval` ms after each reply,
+ * thus the interval is also the pause of the driver. The function gives undefined for no request, and
+ * for a request with no reply before the last request.
+ */
+export declare const estimateOf: (requests: ReadonlyArray<{
+  readonly sent: number;
+  readonly done: number | null;
+}>, end: number, interval: number) => RunEstimate | undefined;
+/** A load spread is a part of the distribution of one measure of an open-loop cell, over its counted runs. */
+interface LoadSpread {
+  readonly p50: Quantity;
+  readonly p99: Quantity;
+  readonly max: Quantity;
+}
+/**
+ * A load verdict sums the schedule of an open-loop cell over its counted runs. `latency` counts from
+ * the planned time, and `service` counts from the send: the measure of a closed-loop driver. Each
+ * arrival with no reply counts in `latency` at its age at the end of its run, a lower bound.
+ */
+interface LoadVerdict {
+  readonly planned: number;
+  readonly unsent: number;
+  readonly unfinished: number;
+  /** This count is the replies with a status of a failure, over the counted runs. */
+  readonly failed: number;
+  readonly latency: LoadSpread | null;
+  readonly service: LoadSpread | null;
+  readonly lag: LoadSpread | null;
+  /** This text is the verdict of each band, in the order of the prediction. */
+  readonly bands: readonly string[];
+  /** This text is the verdict of the share of failed arrivals, when the prediction has a limit on it. */
+  readonly failures?: string;
+}
+/** This record is what the verdict of a cell takes from its load: the runs that broke the schedule, and the sum. */
+interface LoadJudgement {
+  readonly holds: boolean;
+  readonly outside: ReadonlyArray<{
+    readonly run: string;
+    readonly why: string;
+  }>;
+  readonly load: LoadVerdict;
+}
+/**
+ * This function judges the load of an open-loop cell over its counted runs. A run that did not keep
+ * its schedule measures its driver, not the target, thus it is a finding of that run. Each
+ * band reads all the arrivals of the counted runs.
+ */
+export declare const loadVerdict: (prediction: LoadPrediction, runs: ReadonlyArray<{
+  readonly name: string;
+  readonly load: RunLoad | undefined;
+}>) => LoadJudgement;
+/**
+ * An estimate verdict sums the closed-loop estimates of a cell over its counted runs. Its latency
+ * is an estimate of the open loop, not a measure of it: a record of an open-loop client stays the
+ * better measure. Each hidden send after a request with no reply counts at its age at the end.
+ */
+interface EstimateVerdict {
+  readonly planned: number;
+  readonly hidden: number;
+  readonly driverGaps: number;
+  readonly driverGapTotal: Quantity;
+  readonly latency: LoadSpread | null;
+  /** This text gives the estimate in words, for the verdict of the cell. */
+  readonly words: string;
+}
+/** This function gives the estimate verdict of the counted runs, or undefined when no run has an estimate. */
+export declare const estimateVerdict: (estimates: ReadonlyArray<RunEstimate | undefined>) => EstimateVerdict | undefined;
+//#endregion
 //#region src/driver.d.ts
 /**
  * This module measures a run of a cell whose client is a driver with more than one socket, for
@@ -204,6 +339,103 @@ export declare const referenceOf: (run: Run, from: Reference, role: string, data
  */
 export declare const measureDriver: (cell: Cell, run: Run) => Measured;
 //#endregion
+//#region src/conntrack.d.ts
+/** This record is the end of a connect that found no entry at its start. */
+interface StallReading {
+  readonly errno: string;
+  readonly time: Quantity;
+  /** This count is the rise of the field `drop` of the conntrack statistics during the connect. */
+  readonly drops: number;
+  /** This count is the rise of `TCPRetransFail` during the connect. */
+  readonly retransFail: number;
+}
+/** This record is what a run of a conntrack cell measured. */
+interface ConntrackReading {
+  /** This count is the flows that the client holds at its `full` line. */
+  readonly flows: number;
+  /** This count is what the namespace of the client reads at that line. */
+  readonly count: number;
+  /** This count is what the namespace of the target reads while the client holds its flows. */
+  readonly neighbor: number | null;
+  readonly stall: StallReading | null;
+  /** This time is from the `closing` line to the first fall of the count. */
+  readonly firstFall: Quantity | null;
+  /** This time is from the `closing` line to the zero of the count. */
+  readonly zero: Quantity | null;
+  /** This count is what the namespace reads after each side closes. */
+  readonly closed: number | null;
+  /** This count is the lowest that the poll of the count read. */
+  readonly lowest: number | null;
+  /** This count is what the namespace reads after a connect that got a slot. */
+  readonly after: number | null;
+}
+/**
+ * This function reads one run of a conntrack cell from the lines of its client and its target. An
+ * `unsettled` line makes the run void. The entries of the run before it were still in the table, thus
+ * the run did not start from an empty table.
+ */
+export declare const measureConntrack: (run: Run, expected: ConntrackPrediction) => Measured;
+//#endregion
+//#region src/pause.d.ts
+/**
+ * This module reads one run of a paused consumer against its law. Two members of a group each hold
+ * one partition. A SIGSTOP stops the first member while it holds a batch, and a SIGCONT ends that
+ * stop. Three sources give the reading: the lines of each member, the log lines of the brokers, and
+ * the stamps of the injector.
+ *
+ * The broker writes its log on the clock of the wall, and the members and the injector use the
+ * monotonic clock. The `start` line of a member has both clocks, thus it converts a log line.
+ */
+/** A commit reading is the first commit of the stopped member after the stop. */
+interface PauseCommit {
+  readonly acked: boolean;
+  /** This name is the class of the error of the commit. It is null for a commit that the broker acknowledged. */
+  readonly name: string | null;
+  readonly message: string | null;
+  /** This number is the epoch that the member held at the commit. */
+  readonly epoch: number | null;
+}
+/** A pause reading is what one run of a paused consumer measured. Each offset is the next offset to read, as a commit names it. */
+interface PauseReading {
+  /** This number is the partition of the stopped member before the stop. */
+  readonly partition: number;
+  /** This time is from the stop to the log line of the broker that removes the member. It is null when no such line came. */
+  readonly fence: Quantity | null;
+  /** This time is from the stop to the first report of the partition by the other member. It is null when no report came. */
+  readonly takeover: Quantity | null;
+  readonly commit: PauseCommit | null;
+  /** This number is the epoch at the last acknowledged commit before the stop. */
+  readonly epochBefore: number | null;
+  /** This offset is the last acknowledged commit of the stopped member before the stop. */
+  readonly lastAck: number;
+  /** This offset is the first offset of the partition that the other member read after the stop. */
+  readonly otherFirst: number | null;
+  /** This offset is the last acknowledged commit of the other member on the partition, before the commit of the stopped member. */
+  readonly otherLast: number | null;
+  /** This time is from the end of the stop to the new epoch of the member. It is null when no new epoch came. */
+  readonly rejoin: Quantity | null;
+  /** This value tells if the stopped member reported the partition again between the end of the stop and its commit. */
+  readonly reassigned: boolean;
+  /** This offset is the committed offset that the member read after its commit. */
+  readonly committed: number | null;
+  /** This offset is what the first commit after the stop names for the partition. */
+  readonly stale: number | null;
+}
+/** This function gives the time of a log line on the monotonic clock of a member, in ns, from the `start` line of that member. It is null for a line with no stamp. */
+export declare const logTimeOf: (line: string, start: ProbeEvent) => number | null;
+/**
+ * This function tells if the two members can take the fault. Each member holds one partition, the
+ * two partitions differ, and the first member has two acknowledged commits on its partition after its
+ * last change. Thus the first member reads and commits at a steady rate.
+ */
+export declare const pauseReady: (first: readonly ProbeEvent[], other: readonly ProbeEvent[]) => boolean;
+/** This function tells if a log line of a broker tells that a member left a group, under either protocol. */
+export declare const isFenceLine: (line: string) => boolean;
+/** This function tells if a fence line names a group. The two protocols write the name in different words. */
+export declare const namesGroup: (line: string, group: string) => boolean;
+/** This function reads one run of a paused consumer against its law. */
+export declare const measurePause: (run: Run, prediction: PausePrediction) => Measured;
+//#endregion
 //#region src/recovery.d.ts
 /**
  * This module holds the pure parts of a recovery drill. These are the scripts of the shell, the reader
@@ -596,6 +828,10 @@ interface Verdict {
   readonly slowest?: Quantity;
   /** This record is the sum of what reordering did in each counted run of a measurement-only cell. */
   readonly reordering?: Reordering;
+  /** This record is the load of an open-loop cell over its counted runs. */
+  readonly load?: LoadVerdict;
+  /** This record is the estimate of the open loop of a closed-loop stream over its counted runs (SYS-91). */
+  readonly estimate?: EstimateVerdict;
   /** This record is the time of the proxy of a calibration cell, in each direction. */
   readonly proxy?: {
     readonly hop: string;
@@ -783,6 +1019,10 @@ interface Measured {
    * sample is the time from its send to the first data after it.
    */
   readonly samples?: readonly Quantity[];
+  /** This measure is the run of an open-loop cell against its schedule (`Run.schedule`), with its failed replies. Its times are in ms. */
+  readonly load?: RunLoad;
+  /** This estimate is the open loop that a closed-loop stream of the client of the harness hid (SYS-91). Its times are in ms. */
+  readonly estimate?: RunEstimate;
   /** This count is the number of keepalive probes that the kernel sent. */
   readonly probes: number;
   /** This count is the number of segments that the kernel sent again. */
@@ -811,6 +1051,8 @@ interface Measured {
   readonly queue?: QueueReading;
   /** This record is what a run of a port cell measured: the count of each search, and when each port came back. */
   readonly ports?: PortsReading;
+  /** This record is what a run of a conntrack cell measured: the flows, the count, and when a slot came back. */
+  readonly conntrack?: ConntrackReading;
   /** This record is what the second request of an HTTP client met, for a cell whose prediction says it. */
   readonly request?: RequestReading | null;
   /** This record is the time of each later band of a driver cell (`DriverBand.then`). */
@@ -839,6 +1081,8 @@ interface Measured {
    * reader can check each pairing of the run again.
    */
   readonly pairing?: Pairing;
+  /** This record is what a run of a paused consumer measured. */
+  readonly pause?: PauseReading;
   /** This text is the reason that the run cannot count, or null. A void run is not a pass and not a finding. */
   readonly void: string | null;
   /** This text tells what in the run disagrees with the prediction, other than its timing, or null. */
@@ -1363,6 +1607,14 @@ interface ManifestHop {
   /** These are the sysctls of the namespace of the hop, as read back after the harness set them. */
   readonly sysctls: Readonly<Record<string, string>>;
 }
+/** This record is one sysctl of the host for one environment, as the harness read it. */
+interface HostSetting {
+  readonly name: string;
+  readonly before: string;
+  readonly set: string;
+  /** This value is the read after the restore. It is null until the restore. */
+  readonly restored: string | null;
+}
 /** A manifest is what a lab records about its machine, its images and its settings. */
 interface Manifest {
   readonly kernel: string;
@@ -1416,6 +1668,7 @@ interface Manifest {
   readonly client: {
     readonly kind: Client | "image";
     readonly image: string;
+    readonly capabilities?: readonly ClientCapability[];
     readonly source?: ImageSource;
     readonly build?: BuildRecord;
   };
@@ -1427,6 +1680,8 @@ interface Manifest {
   };
   /** These are the sysctls of the client namespace, as read back after the harness set them. */
   readonly sysctls: Readonly<Record<string, string>>;
+  /** These are the sysctls of the host that the cell set: each value before, as set, and as restored. */
+  readonly host?: readonly HostSetting[];
   /** These are the hops of a topology, in sequence from the client. */
   readonly hops?: readonly ManifestHop[];
   /** These are the parts of a group, with their settings as each part read them back. */
@@ -1536,6 +1791,12 @@ interface Lab {
   configure(values: Readonly<Record<string, string>>): Promise<Record<string, string>>;
   /** This method sets the sysctls of the target namespace through a privileged sidecar there, and reads them back. */
   targetSysctl(values: Readonly<Record<string, string>>): Promise<Record<string, string>>;
+  /** This method runs each command in the namespace of the client and in the namespace of the target. */
+  namespaceSetup(commands: readonly (readonly string[])[]): Promise<void>;
+  /** This method sets sysctls of the host through a privileged sidecar on the network of the host, and reads them back. */
+  hostSysctl(settings: readonly HostSysctl[]): Promise<void>;
+  /** This method puts back each value that `hostSysctl` changed, once, and gives the record of each. Closing the lab also does it. */
+  restoreHost(): Promise<readonly HostSetting[]>;
   /**
    * This method applies a fault between the client and the target, by default from the namespace
    * of the target. The fault is a black hole, or a reset that answers the next segment of the
@@ -1613,7 +1874,11 @@ interface Lab {
     t0: number;
     t1: number;
   } | null>;
-  probe(args: readonly string[]): Promise<Probe>;
+  /** This method starts the client with `args`. Each file is in its container before it starts. */
+  probe(args: readonly string[], files?: ReadonlyArray<{
+    readonly content: string;
+    readonly target: string;
+  }>): Promise<Probe>;
   /**
    * This method waits for the next clock line of the prober, which gives the count of lost
    * records. It gives null when no clock line comes in 5 s, because then nothing tells the count.
@@ -2308,6 +2573,11 @@ export declare const kafkaCutOf: (kafka: Kafka, members: Readonly<Record<string,
 export declare const bootstrapOf: (kafka: Kafka) => string;
 /** This function gives the name of the topic of a run. A warm-up has the index -1. */
 export declare const topicOf: (environment: number, index: number) => string;
+/** A Kafka member is one member of a consumer group. A signal goes from a sidecar in its process namespace. */
+interface KafkaMember extends GroupClient {
+  /** This method sends a signal to the process of the member, at once or at an instant of the VM. The injector stamps it. */
+  signal(signal: "STOP" | "CONT", at?: number): Promise<Stamp>;
+}
 /** A Kafka lab is one environment of a Kafka cell. */
 interface KafkaLab {
   readonly kafka: Kafka;
@@ -2325,8 +2595,14 @@ interface KafkaLab {
   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>;
+  /** These are the log lines of the brokers that tell that a member left a group (`isFenceLine`), in sequence. */
+  readonly fences: readonly string[];
+  /** This method makes the topic of a run, with one partition or more. */
+  create(topic: string, partitions?: number): Promise<void>;
+  /** This method writes `count` records in each partition of a topic, each acknowledged by each in-sync replica. */
+  fill(topic: string, partitions: number, count: number): Promise<void>;
+  /** This method starts one member of a consumer group, with the arguments of `ConsumerKafka` after the bootstrap. */
+  consumer(args: readonly string[]): Promise<KafkaMember>;
   /** This method waits until the partition is whole and calm, and gives the name of the broker of its leader. */
   converge(topic: string, within?: number): Promise<string>;
   /** This method gives the sequence numbers that the partition holds, one entry for each copy. */
@@ -2373,6 +2649,18 @@ export declare const kafkaArgs: (cell: Cell, topic: string) => string[];
  *   the whole partition, thus the record tells which writes the group kept.
  */
 export declare const kafkaOnce: (lab: KafkaLab, cell: Cell, environment: number, index: number) => Promise<Run>;
+/**
+ * This function does one run of a paused consumer:
+ * - The topic of the run has two partitions, each with records that a run does not finish.
+ * - Two members join one group, and the run waits until each member holds one partition and the
+ *   first member has two commits on its partition.
+ * - A SIGSTOP stops the first member while it holds its next batch, and a SIGCONT ends the stop
+ *   after the hold of the cell. The run then waits for the tail.
+ *
+ * The fault is null when the members did not get one partition each. The measure then voids the run.
+ * The law reads no kernel record, thus a lost record does not void this run.
+ */
+export declare const kafkaPauseOnce: (lab: KafkaLab, cell: Cell, environment: number, index: number) => Promise<Run>;
 //#endregion
 //#region src/run.d.ts
 /** A cell result is a cell with its manifests, its runs, their measurements and its verdict. */
@@ -2422,5 +2710,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 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 };
+export { type Agent, type BuildImage, type BuildRecord, CLIENT_CAPABILITIES, type CallReading, type Cell, type CellResult, type Client, type ClientCapability, type ClientImage, type ClockPair, type Cloud, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type ConntrackPrediction, type ConntrackReading, type ContextFile, type CountBand, type Crossings, type Cut, type Decision, type Drill, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, type EstimateVerdict, type Fabric, type FabricLab, type FabricManifest, type FabricParts, type Fault, type FaultPlace, type FaultSide, type Group, type GroupClient, type GroupLab, type GroupMeasured, type GroupNetworkFault, type GroupPlace, type GroupPrediction, type GroupReading, type GroupRole, type GroupVerdict, type GroupView, type Hop, type HopEvent, type HopPlace, type HopSignal, type HopWrite, type Host, type HostSetting, type HostSysctl, type HttpProbe, type ImagePlan, type ImageSource, type Interval, type Jitter, type Kafka, type KafkaLab, type KafkaMember, type KafkaPause, type KernelRecord, type Lab, type Layer, type LeafViews, type LineCount, type LineMatch, type LoadBand, type LoadJudgement, type LoadPlan, type LoadPrediction, type LoadSpread, type LoadStream, type LoadVerdict, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, type OplogRead, type OplogTime, type Outcome, type Outcomes, type Pair, type PairSets, type Pairing, type PartitionView, type PauseBand, type PauseCommit, type PausePrediction, type PauseReading, type Pinnable, type PinnedImage, type PortsPrediction, type PortsReading, type Prediction, type Probe, type ProbeEvent, type ProgramEvent, type ProxyHop, type ProxyTime, type QueueBand, type QueueConnection, type QueueConnectionReading, type QueueEnd, type QueuePrediction, type QueueReading, type ReconnectReading, type ReconnectVerdict, type Reconnects, type RecordCode, type Recovers, type RecoveryMeasured, type Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouteLine, type RouterHop, type RttRange, type Run, type RunBackup, type RunDrill, type RunEstimate, type RunFabric, type RunGroup, type RunLoad, type RunPart, type RunPause, type RunRoute, type RunStream, type RunTopology, type SentinelEvent, type SentinelStage, type Shipped, type ShippedImage, type Sibling, type SocketPlace, type Spread, type Stage, type StageBand, type StageVerdict, type StallReading, type Stamp, type Status, type StatusRow, type Subject, type Substrate, type SubstrateSource, type Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, isHopPlace, latestEndOf };
 //# sourceMappingURL=index.d.ts.map