@mark1russell7/harness 0.0.0-stage → 0.2.0

package/build/index.d.ts

@@ -0,0 +1,546 @@
+import { Quantity } from "@mark1russell7/quantity";
+import { KernelRecord } from "@mark1russell7/prober";
+//#region src/cell.d.ts
+/**
+ * A fault is a failure that the harness injects, by the name of its manifestation. Each name is
+ * the last segment of the identifier of the manifestation in the corpus:
+ * - `blackhole` is two DROP rules in the network namespace of the target. Thus the measurement
+ *   gets the kernel timers of the client.
+ * - `freeze-process` is the cgroup freezer on the target, while its kernel stays up.
+ * - `rst` answers the next segment of the client with a reset, from the namespace of the target.
+ *   It is the reference for the noise of the harness itself.
+ * - `stall` is a black hole that stops by itself, `Cell.stall` after the client sends its
+ *   request. The VM times it. It shows what recovers, and when.
+ * - `fin` stops the process of the peer with SIGKILL, while its kernel stays up. The kernel closes its sockets
+ *   with a FIN, or with a reset when unread data is in the queue.
+ * - `unreachable` answers each segment from the observer with an ICMP unreachable (`Cell.icmp`).
+ *   Linux keeps it as a soft error on an established socket, and it continues to retransmit.
+ * - `simplex` drops the segments in one direction only (`Cell.drops`).
+ * - `mtu-blackhole` drops each segment to the observer that is longer than `Cell.mtu` bytes.
+ * - `netem` is tc netem on the egress of the target (`Cell.netem`): loss, duplication,
+ *   reordering or corruption. Its outcome is a distribution.
+ */
+type Fault = "blackhole" | "freeze-process" | "rst" | "stall" | "fin" | "unreachable" | "simplex" | "mtu-blackhole" | "netem";
+/**
+ * A reference is the event that the time of a detector counts from: the event that arms the
+ * timer in its machine document. Keepalive counts from the last received segment. The give-up of
+ * the retransmissions counts from the first retransmission of the RTO timer, not from the tail
+ * loss probe one RTO before it. The request itself meets a reset, thus a reset counts from the
+ * send of the client. A FIN counts from the change of state of the socket of the peer when its
+ * process dies (`peer-closed`).
+ */
+type Reference = "last-received" | "first-retransmission" | "request-sent" | "peer-closed";
+/**
+ * This prediction tells when a connection moves again after a stall. That occurs at the first
+ * firing of its retransmission timer after the stall stops, and its reply comes back one round
+ * trip later.
+ */
+interface Recovers {
+  /** This count identifies the firing that gets through: the number of firings before it. */
+  readonly firing: number;
+  /** This time is the earliest return of the reply, from the send of the request. */
+  readonly low: Quantity;
+  /** This time is the latest return of the reply, from the send of the request. */
+  readonly high: Quantity;
+  /**
+   * This range is where the stall must stop, from the send, so that this firing is the first
+   * after it. The range starts after the latest time of the firing before, and it stops before
+   * the earliest time of this firing.
+   */
+  readonly heal: {
+    readonly low: Quantity;
+    readonly high: Quantity;
+  };
+}
+/**
+ * A prediction is what a cell predicts. Either a detection occurs in an interval [T_lo, T_hi]
+ * after the reference event, or nothing detects the fault in a window. Nothing detects a stall
+ * that is shorter than the give-up, and the connection recovers from it. The prediction then also
+ * tells when.
+ *
+ * A cell whose outcome is a distribution, for example under netem loss, has no band. Its
+ * prediction is `detects: null` with the reason, and its runs are measurements only.
+ */
+type Prediction = {
+  readonly detects: true;
+  /** This name is the timer of the machine that fires first, or the event that detects the fault, with its errno. */
+  readonly timer: string;
+  /** This name is the errno of the detection, or EOF for an end of file without an error. */
+  readonly errno: string;
+  readonly from: Reference;
+  /** This time is the closed form, less the most that the timer can fire early. */
+  readonly low: Quantity;
+  /** This time is the closed form, plus the most that the timer can fire late. */
+  readonly high: Quantity;
+} | {
+  readonly detects: false;
+  readonly window: Quantity;
+  readonly recovers?: Recovers;
+} | {
+  readonly detects: null;
+  readonly window: Quantity;
+  readonly why: string;
+};
+/** A target is the server that a cell connects to: a stock image. */
+interface Target {
+  /** This image is a stock image, pinned by digest. */
+  readonly image: string;
+  readonly port: number;
+  /** This text is the log line that tells that the target serves. */
+  readonly ready: string;
+  /**
+   * These commands set and read one setting of the target, as argv in it. The name and the value
+   * come after them: `redis-cli CONFIG SET` and `CONFIG GET` for Redis. Without them, the target
+   * has no settings to set.
+   */
+  readonly settings?: {
+    readonly set: readonly string[];
+    readonly get: readonly string[];
+  };
+  /**
+   * This command replaces the command of the image, for example a shell that holds the server
+   * process as its child. Then a `fin` fault can stop the server, and the container stays up.
+   */
+  readonly command?: readonly string[];
+  /** This command stops the server process in the target with SIGKILL, as argv, for a `fin` fault. */
+  readonly kill?: readonly string[];
+}
+/** A client is what the runs of a cell use: the TCP client of the harness, or a driver on its socket. */
+type Client = "tcp" | "ioredis";
+/**
+ * An observer is the side whose detection a cell measures. The client is one observer. The
+ * server is the other observer. It is the hold of the target on the connection of the client, at
+ * its server socket in its namespace. The fault is on the peer of the observer. Thus
+ * freeze-process freezes the target for the client, and the client for the server.
+ */
+type Observer = "client" | "server";
+/** A cell is one cell of the matrix: a topology, its settings, a workload, a fault and the prediction. */
+interface Cell {
+  readonly name: string;
+  readonly target: Target;
+  /** These are the sysctls of the network namespace of the client, as the kernel spells them. The harness sets them before the client connects. */
+  readonly sysctls: Readonly<Record<string, string>>;
+  readonly probe: {
+    /**
+     * 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.
+     */
+    readonly mode: "idle" | "inflight" | "stream";
+    /** 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. */
+    readonly interval?: Quantity;
+    /** This flag sets SO_KEEPALIVE without overrides for the socket: the keepalive sysctls of the namespace apply. */
+    readonly keepalive: boolean;
+    /** This time sets TCP_USER_TIMEOUT. Without it, the default of the kernel (off) applies. */
+    readonly userTimeout?: Quantity;
+    /**
+     * This text is the request that an in-flight run sends, as a Redis inline command. Without it,
+     * the request is PING. BLPOP with a timeout makes the server answer only at the timeout. Thus
+     * a cell on the server side has a reply in flight when the fault occurs.
+     */
+    readonly request?: string;
+    /**
+     * This driver replaces the TCP client of the harness, with its own options. It is ioredis 6 on
+     * Node, whose keepAlive is the keepalive delay of the socket. The driver then ignores `keepalive`
+     * and `userTimeout`.
+     */
+    readonly driver?: {
+      readonly name: "ioredis";
+      readonly keepAlive: Quantity;
+    };
+  };
+  readonly fault: Fault;
+  /** This time is the length of a stall, from the send of the request. */
+  readonly stall?: Quantity;
+  /** This code is the ICMP unreachable of an `unreachable` fault. */
+  readonly icmp?: "host" | "net" | "port" | "admin";
+  /** This direction is the one that a `simplex` fault drops: the segments to the server, or to the client. */
+  readonly drops?: "to-server" | "to-client";
+  /** This length is the longest segment, in bytes, that an `mtu-blackhole` fault lets through to the observer. */
+  readonly mtu?: number;
+  /** This specification is the tc netem of a `netem` fault, on the egress of the target: for example "loss 5%". */
+  readonly netem?: string;
+  /**
+   * This delay goes on the egress of the target before the client connects, with tc netem. Thus
+   * each round trip is longer by the delay, and so is the RTO.
+   */
+  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[])[];
+  readonly prediction: Prediction;
+  /** This side is the side whose detection the cell measures. Without it, the side is the client. */
+  readonly observer?: Observer;
+  /** These are the settings of the target. The harness sets them in each environment before a client connects. */
+  readonly targetSettings?: Readonly<Record<string, string>>;
+  /** These are the sysctls of the network namespace of the target, for a cell on the server side: its tcp_retries2. */
+  readonly targetSysctls?: Readonly<Record<string, string>>;
+  /** This count is the number of runs of the cell (11), across new environments (two at least). */
+  readonly runs: number;
+  readonly environments: number;
+  /**
+   * This count is the number of environments at the same time, each with its own prober. Without
+   * it, the count is one. The calibration does its reference cells at 1, 4 and 8, to find how
+   * many environments the machine holds before its noise increases.
+   */
+  readonly concurrency?: number;
+}
+/** A probe event is one line that the client wrote. `t` is CLOCK_MONOTONIC in nanoseconds: an instant, not an amount. */
+interface ProbeEvent {
+  readonly ev: string;
+  readonly t: number;
+  readonly [field: string]: unknown;
+}
+/** A run is one run of a cell, as the harness records it. */
+interface Run {
+  readonly environment: number;
+  readonly index: number;
+  readonly events: readonly ProbeEvent[];
+  /** This bracket is the time of the injector around the commit of the fault, on the same clock. It is null for a freeze. */
+  readonly fault: {
+    readonly t0: number;
+    readonly t1: number;
+  } | null;
+  /** This bracket is the time around the commit that stopped a stall. */
+  readonly heal?: {
+    readonly t0: number;
+    readonly t1: number;
+  } | null;
+  /** These are the records of the prober from the start to the end of the run, in the two namespaces. */
+  readonly kernel: readonly KernelRecord[];
+  /** This inode identifies the network namespace of the client, thus the records of the client. */
+  readonly netns: number;
+  /** This inode identifies the namespace of the target, where the records of its server socket are. */
+  readonly targetNetns: number;
+  /**
+   * This count is the number of records that the prober lost in the run. One lost record makes
+   * the run void. Null also makes the run void: no clock line came after the run to tell the count.
+   */
+  readonly lost: number | null;
+}
+//#endregion
+//#region src/observe.d.ts
+/**
+ * An outcome tells how the wait of a run ended. The socket failed with an errno, or it read the
+ * end of the file. Or nothing came, or the reply came back after a stall.
+ */
+type Outcome = {
+  readonly kind: "error";
+  readonly errno: string;
+} | {
+  readonly kind: "eof";
+} | {
+  readonly kind: "silent";
+} | {
+  readonly kind: "answered";
+};
+/** A measurement is what one run measured, against the prediction of its cell. */
+interface Measured {
+  readonly environment: number;
+  readonly index: number;
+  readonly outcome: Outcome;
+  /**
+   * This time is from the reference event of the prediction to the detection, both as the kernel
+   * stamped them in the records of the prober. It is null when nothing detected the fault.
+   */
+  readonly elapsed: Quantity | null;
+  /** This time is the same interval from the TCP_INFO samples of the client, the second vantage. */
+  readonly socket: Quantity | null;
+  /** This time is how long the client took to see the error after the kernel reported it. */
+  readonly noticed: Quantity | null;
+  /**
+   * These are the steps of the kernel after the reference: each keepalive probe, or each firing of
+   * the RTO timer. After a stall, they are each retransmission from the send, the loss probe first.
+   */
+  readonly steps: readonly Quantity[];
+  /**
+   * These are the reply times of a measurement-only cell. For each request after the first, a
+   * sample is the time from its send to the first data after it.
+   */
+  readonly samples?: readonly Quantity[];
+  /** 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. */
+  readonly retransmissions: number;
+  /** This count is the number of segments that the socket received after the request. */
+  readonly acks: number;
+  /** 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. */
+  readonly finding: string | null;
+}
+/**
+ * This function reads one run against its cell, from the records of the kernel first.
+ * - The socket of the run is the socket that the client connected from, in its namespace.
+ * - The fault must hold before the event that it must meet. That is before the request goes into
+ *   it, and before the first keepalive probe. A live peer answers that probe, and the answer
+ *   starts the idle time again. A run where the fault was late is void. A run whose records the
+ *   prober lost is also void.
+ */
+export declare const measure: (cell: Cell, run: Run) => Measured;
+//#endregion
+//#region src/verdict.d.ts
+/**
+ * This amount is the noise of the pipeline itself, δ_abs, as the calibration measured it. It is
+ * the 99.9th percentile of the whole latency of a reset, at the concurrency cap or less. Its
+ * minimum is one jiffy. On 2026-10-12 the worst of 60 resets at 1 and 4 environments took
+ * 1.141 ms, thus the minimum sets it to 4 ms. The calibration occurs again after each change to
+ * the harness, the kernel or Docker.
+ */
+export declare const NOISE: Quantity;
+/** This fraction, δ_rel, is how far the median of a cell can be outside the prediction and stay equivalent. */
+export declare const RELATIVE = .05;
+/** These are the run counts of a cell: 11, then 22 and 44 while its median crosses the edge of the band. */
+export declare const STEPS: readonly [11, 22, 44];
+/**
+ * A decision is the result of a verdict. A cell whose outcome is a distribution has no band, and
+ * its decision is `measured`: a record, not a test.
+ */
+type Decision = "holds" | "fails" | "extend" | "inconclusive" | "measured";
+/** An interval is a range of times. */
+interface Interval {
+  readonly low: Quantity;
+  readonly high: Quantity;
+}
+/** A verdict is the judgement of a cell on its runs. */
+interface Verdict {
+  readonly decision: Decision;
+  readonly counted: number;
+  readonly voided: number;
+  /** This band is where each run must land: [T_lo − δ_abs, T_hi + δ_abs]. It is null for a silent prediction. */
+  readonly band: Interval | null;
+  /** These are the runs outside the band, and the reason for each. Each is a finding. */
+  readonly outside: ReadonlyArray<{
+    readonly run: string;
+    readonly why: string;
+  }>;
+  readonly median: Quantity | null;
+  /** This interval is the order-statistic interval of the median at 95 %, or the whole range for fewer than six runs. */
+  readonly medianInterval: Interval | null;
+  readonly why: string;
+}
+/**
+ * This function gives the distribution-free interval of a median: [x_(k), x_(n+1−k)], for the
+ * largest k whose two tails each hold 2.5 % or less. For eleven runs, it gives [x_(2), x_(10)],
+ * at 98.8 %.
+ */
+export declare const medianInterval: (sorted: readonly number[]) => [number, number];
+/**
+ * This function gives the verdict of a cell, from two tests:
+ * - Containment: each run lands in [T_lo − δ_abs, T_hi + δ_abs]. A run outside is a finding.
+ * - Median equivalence: the interval of the median is in the band, made wider by δ_rel. An
+ *   interval outside the band fails. An interval across its edge extends the cell to 22 runs, then
+ *   44, and then the verdict is inconclusive.
+ *
+ * A silent prediction holds only if no run detected the fault in its window. After a stall, the
+ * return of the reply gets the same test as a detection, by its interval, and a detection is a
+ * finding. The distribution test (a DKW band) needs a predicted distribution from a simulator,
+ * which does not exist at this time.
+ */
+export declare const verdictOf: (prediction: Prediction, runs: readonly Measured[]) => Verdict;
+//#endregion
+//#region src/lab.d.ts
+/** This function gives the image of the harness. */
+export declare const harnessImage: () => Promise<string>;
+/** This function gives the image of the Node client. */
+export declare const nodeClientImage: () => Promise<string>;
+/**
+ * A network fault is a fault that the injector applies as a filter rule. It is a black hole (both
+ * directions, or one), or a reset on the next segment. It can also be an ICMP unreachable for each
+ * segment, or a drop of each segment that is longer than a length.
+ */
+type NetworkFault = "blackhole" | "rst" | "reject" | "mtu";
+/** These are the options of a network fault: the direction of a black hole, the code of a reject, the length of an MTU drop. */
+interface FaultOptions {
+  /** This direction is relative to the namespace of the rule: `in` drops what comes from the peer, `out` what goes to it. */
+  readonly direction?: "in" | "out";
+  readonly code?: "host" | "net" | "port" | "admin";
+  /** This length is the longest segment in bytes that an MTU drop lets through. */
+  readonly above?: number;
+}
+/**
+ * A fault side is the namespace that gets the rules of a fault: the namespace of the peer of the
+ * observer. For the client, it is the namespace of the target (the injector). For the server, it
+ * is the namespace of the client (its privileged admin). Rules in the namespace of the observer
+ * make its sends fail locally, with EPERM, and the network does not lose them. Thus its
+ * retransmissions do not go out. The retransmission tracepoint of the kernel then records none,
+ * because it fires only for a retransmission that went out.
+ */
+type FaultSide = "target" | "client";
+/** A manifest is what a lab records about its machine, its images and its settings. */
+interface Manifest {
+  readonly kernel: string;
+  /** This text is the architecture of the machine, as uname -m gives it: x86_64. */
+  readonly architecture: string;
+  readonly hz: string | null;
+  readonly boot_id: string;
+  readonly docker: string;
+  /** This record is the target, and its settings as it read them back. */
+  readonly target: {
+    readonly image: string;
+    readonly id: string;
+    readonly settings: Readonly<Record<string, string>>;
+    /** These are the sysctls of its namespace, as read back after the harness set them. */
+    readonly sysctls: Readonly<Record<string, string>>;
+  };
+  readonly harness: {
+    readonly image: string;
+    readonly id: string;
+    readonly packages: string[];
+  };
+  /** This record is the client of each run: the TCP client of the harness, or a driver from its own image. */
+  readonly client: {
+    readonly kind: Client;
+    readonly image: string;
+  };
+  /** These are the namespaces that the prober watched, by inode. */
+  readonly netns: {
+    readonly client: number;
+    readonly target: number;
+  };
+  /** These are the sysctls of the client namespace, as read back after the harness set them. */
+  readonly sysctls: Readonly<Record<string, string>>;
+}
+/** A probe is the client container of one run. */
+interface Probe {
+  /** This method gives the first event of one of these kinds, or it rejects after `within` ms. */
+  until(kinds: readonly string[], within: number): Promise<ProbeEvent>;
+  /** This method lets an in-flight probe send its request. */
+  go(): Promise<void>;
+  /** This method freezes the client with the cgroup freezer: its process stops, and its kernel continues to answer. */
+  freeze(): Promise<void>;
+  thaw(): Promise<void>;
+  /** This method stops the process of the client with SIGKILL. Its kernel then closes its socket with a FIN, or a reset. */
+  kill(): Promise<void>;
+  readonly events: readonly ProbeEvent[];
+  stop(): Promise<void>;
+}
+/** A lab is one environment: the target, the client, the injector and the prober. */
+interface Lab {
+  readonly targetIp: string;
+  readonly clientIp: string;
+  readonly netns: {
+    readonly client: number;
+    readonly target: number;
+  };
+  /** 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. */
+  sysctl(values: Readonly<Record<string, string>>): Promise<Record<string, string>>;
+  /** This method sets the settings of the target in it before a client connects, and reads them back. */
+  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 applies a fault between the client and the target, from the namespace of the
+   * target. The fault is a black hole, or a reset that answers the next segment of the client. The stamps of
+   * the injector bracket it.
+   */
+  fault(kind: NetworkFault, at?: FaultSide, options?: FaultOptions): Promise<{
+    t0: number;
+    t1: number;
+  }>;
+  /** This method removes a fault. */
+  lift(kind: NetworkFault, at?: FaultSide, options?: FaultOptions): Promise<void>;
+  /**
+   * This method puts tc netem on the egress of a namespace, for example "delay 20ms" or "loss 5%",
+   * or removes it with null. The stamps of the injector bracket it.
+   */
+  netem(spec: string | null, at?: FaultSide): Promise<{
+    t0: number;
+    t1: number;
+  }>;
+  /**
+   * This method sets the TSO, GSO and GRO of a namespace. With them off, netem and a length match
+   * act on segments, not on GSO super-packets of up to 64 KB.
+   */
+  offload(on: boolean, at?: FaultSide): Promise<void>;
+  /** This method stops the server process in the target with SIGKILL, with the command of the target. */
+  kill(): Promise<void>;
+  /**
+   * This method resolves the neighbors of the path in the two directions, with a ping from each
+   * namespace. Without it, the first connection of an environment waits for ARP. Under a netem
+   * delay, that wait is one more delayed round, and its round trip and RTO are longer.
+   */
+  warm(): Promise<void>;
+  /** This method runs commands in the target before a client connects, each as argv. */
+  setup(commands: ReadonlyArray<readonly string[]>): Promise<void>;
+  /**
+   * This method stops a black hole at an instant on the monotonic clock of the VM. The injector
+   * waits for that instant in the VM, thus the length of a stall does not include the latency of
+   * a docker exec. Stamps bracket it, as for a fault.
+   */
+  heal(at: FaultSide, when: number): Promise<{
+    t0: number;
+    t1: number;
+  }>;
+  /**
+   * This method removes what the two kernels learned from their earlier connections. These are
+   * the TCP metrics that each kernel keeps for a peer address when a connection closes. These metrics set the
+   * first round trip of the next connection, and thus its RTO. A run with these metrics is not
+   * independent of the run before it.
+   */
+  forget(): Promise<void>;
+  /** This method freezes the target with the cgroup freezer: its process stops, and its kernel continues to answer. */
+  freeze(): Promise<void>;
+  thaw(): Promise<void>;
+  probe(args: readonly 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.
+   */
+  settle(): Promise<number | null>;
+  manifest(sysctls: Readonly<Record<string, string>>, settings?: Readonly<Record<string, string>>, targetSysctls?: Readonly<Record<string, string>>): Promise<Manifest>;
+  close(): Promise<void>;
+}
+/**
+ * This function opens one environment:
+ * - a new network and the stock target.
+ * - a client that holds its own network namespace, with a privileged sidecar in it for its
+ *   sysctls. Docker Desktop keeps /proc/sys read-only in a container that operates.
+ * - an injector sidecar in the namespace of the target.
+ * - the prober, a privileged container that loads the kernel program and watches the two
+ *   namespaces.
+ *
+ * The client of each run is its own container in the namespace of the client. It is the TCP
+ * client of the harness, or a driver from its own image (ioredis on Node). The two print the same
+ * lines.
+ */
+export declare const openLab: (target: Target, kind?: Client) => Promise<Lab>;
+//#endregion
+//#region src/run.d.ts
+/** A cell result is a cell with its manifests, its runs, their measurements and its verdict. */
+interface CellResult {
+  readonly cell: Cell;
+  readonly manifests: readonly Manifest[];
+  readonly runs: readonly Run[];
+  readonly measured: readonly Measured[];
+  readonly verdict: Verdict;
+  /** These times are when its first environment opened and its last environment closed, on the wall clock. */
+  readonly at: {
+    readonly started: string;
+    readonly ended: string;
+  };
+}
+/**
+ * This function measures and judges the raw records of a cell, with the code of the harness at
+ * this time. `runCell` uses it during a cell. A holder of the raw records of a cell can use it
+ * again later. Thus the records get a new analysis after a change to observe.ts or to the verdict.
+ */
+export declare const judge: (cell: Cell, runs: readonly Run[]) => {
+  measured: Measured[];
+  verdict: Verdict;
+};
+/** This function divides a count of runs across environments, as equally as possible. */
+export declare const spread: (runs: number, environments: number) => number[];
+/**
+ * This function does the runs of a cell. They go across new environments, and each environment records
+ * its manifest. Then the verdict judges the runs. A median across the edge of the band extends
+ * the cell from 11 runs to 22, and then to 44, each extension in new environments. With a
+ * concurrency of more than one, that many environments operate at the same time, each with its
+ * own prober. The runs then go across at least as many environments.
+ */
+export declare const runCell: (cell: Cell, say?: (line: string) => void) => Promise<CellResult>;
+//#endregion
+export type { Cell, CellResult, Client, Decision, Fault, FaultSide, Interval, KernelRecord, Lab, Manifest, Measured, NetworkFault, Observer, Outcome, Prediction, Probe, ProbeEvent, Recovers, Reference, Run, Target, Verdict };
+//# sourceMappingURL=index.d.ts.map