@mark1russell7/harness 0.12.4 → 0.14.0

package/README.md

@@ -294,9 +294,16 @@ Each run starts from kernels that keep nothing from the run before it (`lab.forg
 - **A detection by the program** (`application.ts`). The kernel has no report of it. Thus the program of the observer writes a line before each of its own acts, and the kernel stamps each act on the socket.
   - The program writes `ping` before each ping of its heartbeat. The kernel stamps the write of the ping (`tx`).
   - The reference is the first ping that got no answer (`ping-sent`): no segment with data reached the socket after its write, up to the detection. Its write starts the timer of the heartbeat that the fault met. The fault can come at any time, and its stamps are not necessary.
-  - The program writes `drop` before it drops the connection itself. The detection is the kernel's stamp of that drop: the write of its close frame, or the change of its socket out of ESTABLISHED. Without such a record in the handling time of the program (`DROP_HANDLING`, 1.5 ms), it is the stamp of the line. Where δ_abs is longer, the window is δ_abs.
+  - The program writes `drop` before it drops the connection itself. The detection is the kernel's stamp of that drop: the write of its close frame, or the change of its socket out of ESTABLISHED. Without such a record in the handling time of the program (`DROP_HANDLING`, 1.5 ms), it is the stamp of the line. Where the pairing window of the run is longer, the window is that window.
   - The handling time is not δ_abs. δ_abs is the noise of the pipeline, from a reset. The handling is the time of the code of the program, from the firing of its timer to its act.
   - In 585 drops with a close frame in CI, the write came a median of 0.652 ms after the `drop` line, and 1.017 ms at the most. Two of them came more than the δ_abs of 1 ms after it. Each failed its cell, with its time in the band. These are the runs 39390222333 and 39903020657 of the client repository. The bound is that maximum and a margin of 0.48 ms.
+  - **The pairing window of a run** (`pairingOf`, SYS-25). On a runner of GitHub, the jitter of a program can be longer than the δ_abs of 1 ms. Thus each run measures that jitter before its fault (`jitterOf`, `Run.jitter`).
+    - An act is a `write` line or a `ping` line on the connection, before the start of the fault. A fault with no stamp ends the acts at the reply of the client.
+    - The delay of an act goes from its line to the kernel's stamp of the first write of data on the socket after it. That write must come before the next act and before the fault. An act without one does not count.
+    - The bound is the longest delay of the run. The window of each pairing of the run (a `ping` line and a `drop` line) is δ_abs, or the bound when the bound is longer.
+    - The window comes from the same run, not from a constant. The rule of one miss stays (the decision of 2026-10-19): a pair outside the window of its run is still a finding.
+    - Each measurement gives its bound and its window (`Measured.pairing`), and the runner of the cells sums them in `summary.ndjson` (`pairingsOf`). A run from before SYS-25 has no jitter record. It reads as a bound of null, thus its window is δ_abs: 1 ms on a calibrated runner.
+    - In the records of the nightly run 40446582383, a bound was longer than 1 ms only in the cells of the `ws` class. Their first write (a `hello`) came up to 1.519 ms after its line. In the other cells the bound was 0.058 ms to 0.955 ms.
   - A drop counts when it comes before each report of the kernel. A report of the kernel that comes first is the detection, and the drop after it is not.
   - The second view is the stamps of the program: from its `ping` line to its `drop` line. The steps are the later pings, each from the reference.
   - The lines of a client name the socket by its local address (`local`), and the lines of a server by its peer (`peer`). For the server, the lines are the lines of the target. A line whose address is null is about a try that did not open.
@@ -354,9 +361,10 @@ Each run starts from kernels that keep nothing from the run before it (`lab.forg
 `verdictOf(prediction, runs)` (`verdict.ts`) judges a cell:
 
 - **Containment.** Each run lands in [T_lo − δ_abs, T_hi + δ_abs]. `NOISE` (δ_abs) is 4 ms, from the calibration of the first environment: the worst reset took 1.141 ms, and δ_abs is one jiffy at the minimum.
-  - **δ_abs of an environment.** A cell can give the δ_abs of its environment (`Cell.noise`). Stage 0 measures it in each environment. On a hosted runner of GitHub at HZ 1000, the worst reset took 0.147 ms, thus δ_abs is one jiffy, 1 ms. These read it (`noiseOf`): the bands, the pairing of a program line with its kernel record, and the drop of a program (with `DROP_HANDLING`).
+  - **δ_abs of an environment.** A cell can give the δ_abs of its environment (`Cell.noise`). Stage 0 measures it in each environment. On a hosted runner of GitHub at HZ 1000, the worst reset took 0.147 ms, thus δ_abs is one jiffy, 1 ms. These read it (`noiseOf`): the bands, and the rule of a late timer.
+  - **The pairing of a program line.** The pairing of a program line with its kernel record reads the window of its run (`pairingOf`). That window is δ_abs, or the jitter bound of the run when it is longer.
   - **The injector has its own bound.** A fault that the injector commits or lifts late makes a run void. That bound is `INJECT` (4 ms), not δ_abs. Stage 0 measures the commit apart. On a hosted runner it took up to 2.75 ms at 4 environments.
-  - **The drop of a program has its own bound.** The pairing of a `drop` line with its act uses `DROP_HANDLING` (1.5 ms), or δ_abs when δ_abs is longer. The band of a drop in the cells adds `DROP_HANDLING` to its high bound.
+  - **The drop of a program has its own bound.** The pairing of a `drop` line with its act uses `DROP_HANDLING` (1.5 ms), or the window of the run when that window is longer. The band of a drop in the cells adds `DROP_HANDLING` to its high bound.
 - **Median equivalence.** The order-statistic interval of the median must be in the band, made 5 % wider.
 - **Extension.** A median across the edge of the band extends the cell from 11 runs to 22, then 44. Then the verdict is inconclusive.
 - **Recovery.** The recovery after a stall gets the same test as a detection, by its band. A detection is then a finding.

package/build/{cell-jEkGFgGL.d.ts → cell-D2QNOxE8.d.ts}

@@ -1046,6 +1046,18 @@ interface ProbeEvent {
   readonly t: number;
   readonly [field: string]: unknown;
 }
+/**
+ * A jitter record tells how late the kernel stamped the acts of a program after their lines, in
+ * one run. An act is a `write` line or a `ping` line on the connection of the run, before the
+ * fault. Its delay goes from the line to the kernel's stamp of the first write of data on the
+ * socket after it. That write must come before the next act and before the fault.
+ */
+interface Jitter {
+  /** This count is the number of acts that had a write in their window. */
+  readonly acts: number;
+  /** This time is the longest delay of those acts. It is null when the run has no such act. */
+  readonly bound: Quantity | null;
+}
 /** A run is one run of a cell, as the harness records it. */
 interface Run {
   readonly environment: number;
@@ -1082,6 +1094,13 @@ interface Run {
    * late timer is in time. A run without it keeps the rule in jiffies, as the runs before 0.9.0.
    */
   readonly hz?: number;
+  /**
+   * This record is the jitter of the program of the observer in the run (`jitterOf`). The pairing
+   * window of the run is δ_abs of its cell, or the bound of the jitter when the bound is longer
+   * (`pairingOf`). A record from before SYS-25 has no jitter. It reads as a bound of null, thus
+   * its window is δ_abs of its cell: 1 ms on a calibrated runner.
+   */
+  readonly jitter?: Jitter;
   /** 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. */
@@ -1143,5 +1162,5 @@ interface RunTopology {
   }>>;
 }
 //#endregion
-export { Subject as $, Prediction as A, RequestPrediction as B, KernelRecord as C, MiddleboxForm as D, MiddleboxExpectation as E, Recovers as F, RunPart as G, RttRange as H, Reference as I, SentinelStage as J, RunTopology as K, ReplicaSet as L, ProxyHop as M, ProxyTime as N, Observer as O, Reconnects as P, StageBand as Q, ReplicaSetStage as R, ImageSource as S, MiddleboxEvent as T, Run as U, RouterHop as V, RunGroup as W, ShippedImage as X, Shipped as Y, Stage as Z, HopEvent as _, Cluster as a, latestEndOf as at, HopWrite as b, DriverBand as c, FaultPlace as d, Target as et, Group as f, Hop as g, GroupRole as h, ClientImage as i, isHopPlace as it, ProbeEvent as j, PinnedImage as k, DriverStep as l, GroupPrediction as m, Cell as n, Toxic as nt, ClusterClientAt as o, GroupPlace as p, SentinelEvent as q, Client as r, WsProbe as rt, ClusterStage as s, BuildImage as t, Topology as tt, Fault as u, HopPlace as v, LineMatch as w, HttpProbe as x, HopSignal as y, Replies as z };
-//# sourceMappingURL=cell-jEkGFgGL.d.ts.map
+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-D2QNOxE8.d.ts.map

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as Subject, A as Prediction, B as RequestPrediction, C as KernelRecord, D as MiddleboxForm, E as MiddleboxExpectation, F as Recovers, G as RunPart, H as RttRange, I as Reference, J as SentinelStage, K as RunTopology, L as ReplicaSet, M as ProxyHop, N as ProxyTime, O as Observer, P as Reconnects, Q as StageBand, R as ReplicaSetStage, S as ImageSource, T as MiddleboxEvent, U as Run, V as RouterHop, W as RunGroup, X as ShippedImage, Y as Shipped, Z as Stage, _ as HopEvent, a as Cluster, at as latestEndOf, b as HopWrite, c as DriverBand, d as FaultPlace, et as Target, f as Group, g as Hop, h as GroupRole, i as ClientImage, it as isHopPlace, j as ProbeEvent, k as PinnedImage, l as DriverStep, m as GroupPrediction, n as Cell, nt as Toxic, o as ClusterClientAt, p as GroupPlace, q as SentinelEvent, r as Client, rt as WsProbe, s as ClusterStage, t as BuildImage, tt as Topology, u as Fault, v as HopPlace, w as LineMatch, x as HttpProbe, y as HopSignal, z as Replies } from "./cell-jEkGFgGL.js";
+import { $ as StageBand, A as PinnedImage, B as Replies, C as Jitter, D as MiddleboxExpectation, E as MiddleboxEvent, F as Reconnects, G as RunGroup, H as RouterHop, I as Recovers, J as SentinelEvent, K as RunPart, L as Reference, M as ProbeEvent, N as ProxyHop, O as MiddleboxForm, P as ProxyTime, Q as Stage, R as ReplicaSet, S as ImageSource, T as LineMatch, U as RttRange, V as RequestPrediction, W as Run, X as Shipped, Y as SentinelStage, Z as ShippedImage, _ as HopEvent, a as Cluster, at as isHopPlace, b as HopWrite, c as DriverBand, d as FaultPlace, et as Subject, f as Group, g as Hop, h as GroupRole, i as ClientImage, it as WsProbe, j as Prediction, k as Observer, l as DriverStep, m as GroupPrediction, n as Cell, nt as Topology, o as ClusterClientAt, ot as latestEndOf, p as GroupPlace, q as RunTopology, r as Client, rt as Toxic, s as ClusterStage, t as BuildImage, tt as Target, u as Fault, v as HopPlace, w as KernelRecord, x as HttpProbe, y as HopSignal, z as ReplicaSetStage } from "./cell-D2QNOxE8.js";
 import { Quantity } from "@mark1russell7/quantity";
 import "testcontainers";
 //#region src/application.d.ts
@@ -33,16 +33,16 @@ import "testcontainers";
  *   These are the runs 39390222333 and 39903020657 of the client repository.
  *
  * The bound is 1.5 ms: the maximum and a margin of 0.48 ms. The pairing of a drop with its act
- * uses it, or δ_abs when δ_abs is longer. The band of a drop adds it to its high bound (the WS
- * catalog of the cells). Read the records again after a change to the subject, to Node or to
+ * uses it, or the pairing window of the run when that window is longer. The band of a drop adds
+ * it to its high bound (the WS catalog of the cells). Read the records again after a change to the subject, to Node or to
  * the runners.
  */
 export declare const DROP_HANDLING: Quantity;
 /**
  * A program event is a line of the program of the observer, with the kernel's stamp of its act.
  * The act is a write, or a change of state of the socket. Without a record of the kernel in its
- * window after the line, the instant is the stamp of the line. The window is δ_abs, and for a drop
- * it is `DROP_HANDLING` when that is longer.
+ * window after the line, the instant is the stamp of the line. The window is the pairing window of
+ * the run (`pairingOf`), and for a drop it is `DROP_HANDLING` when that is longer.
  */
 interface ProgramEvent {
   readonly line: ProbeEvent;
@@ -79,12 +79,19 @@ export declare const closeOrExit: (line: ProbeEvent, left: Quantity | null, exit
 };
 /**
  * This function tells how a drop differs from the way that its prediction gives, or gives null.
- * A close closes the socket at once: in the handling time of the program (`DROP_HANDLING`), or in
- * δ_abs (`delta`) when δ_abs is longer. A close frame is a write, and the program does not close
- * the socket at the drop. A peer that answers the close frame can close it, and that is no finding.
+ * A close closes the socket at once, in the handling time of the program (`DROP_HANDLING`). If
+ * the pairing window of the run (`delta`) is longer, that window is the limit. A close frame is a
+ * write, and the program does not close the socket at the drop. A peer that answers the close frame can close it, and that is no finding.
  */
 export declare const dropFinding: (expected: "frame" | "close", drop: ProgramEvent, left: Quantity | null, delta?: Quantity, exited?: Quantity) => string | null;
-/** This function gives each ping of the program on the connection of the run, with the kernel's stamp of its write. */
+/**
+ * This function measures the jitter of a program from its acts before `until`, the start of the
+ * fault. An act is a `write` line or a `ping` line on the connection. Its delay goes from the line
+ * to the first write of data on the socket after it, before the next act and before `until`. An
+ * act with no such write does not count. The bound is the longest delay, to the microsecond.
+ */
+export declare const jitterOfLines: (lines: readonly ProbeEvent[], socket: readonly KernelRecord[], local: unknown, until: number) => Jitter;
+/** This function gives each ping of the program on the connection, with the kernel's stamp of its write in the pairing window (`delta`). */
 export declare const pingsOf: (lines: readonly ProbeEvent[], socket: readonly KernelRecord[], local: unknown, delta?: Quantity) => ProgramEvent[];
 /**
  * This function gives the first ping that got no answer: no segment with data reached the socket
@@ -95,7 +102,7 @@ export declare const firstUnanswered: (pings: readonly ProgramEvent[], socket: r
  * This function gives the first drop of the connection by its program. The kernel stamps it as the
  * write of a close frame. Or it stamps the change of the socket out of ESTABLISHED: a close or an
  * abort. That stamp comes in the handling time of the program after the drop line
- * (`DROP_HANDLING`), or in δ_abs (`delta`) when δ_abs is longer.
+ * (`DROP_HANDLING`). If the pairing window of the run (`delta`) is longer, that window is the limit.
  */
 export declare const dropOf: (lines: readonly ProbeEvent[], socket: readonly KernelRecord[], local: unknown, delta?: Quantity) => ProgramEvent | undefined;
 /** A reconnect reading is what the client did after the detection, from its lines and from the records of the kernel. */
@@ -329,195 +336,6 @@ interface GroupReading {
  */
 export declare const measureGroup: (cell: Cell, run: Run) => GroupReading;
 //#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. The observer can also
- * close the connection itself (`closed`), or its program can drop it on its own timer (`dropped`).
- */
-type Outcome = {
-  readonly kind: "error";
-  readonly errno: string;
-} | {
-  readonly kind: "eof";
-} | {
-  readonly kind: "silent";
-} | {
-  readonly kind: "answered";
-} | {
-  readonly kind: "closed";
-} | {
-  readonly kind: "dropped";
-};
-/**
- * A request reading is what the second request of an HTTP client met, from the lines of the
- * client. It holds the connection of its first try, a new try, and its outcome. `gap` is the time
- * from the end of the first reply to the send of the second request.
- */
-interface RequestReading {
-  readonly connection: "reused" | "new";
-  readonly retried: boolean;
-  readonly error: string | null;
-  readonly pending: boolean;
-  readonly gap: Quantity | null;
-}
-/** 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 count is the number of bytes that the client read after the request. */
-  readonly bytes?: number;
-  /**
-   * This time is when a router of the topology forgot the flow of the client. It counts from the
-   * last segment that the client received before the fault. It is null when no router forgot the flow.
-   */
-  readonly forgot?: Quantity | null;
-  /**
-   * This time is the first round trip of the socket of the observer. It is the smoothed round trip
-   * in its first record, which is the sample of the handshake. It is null when no record has it.
-   */
-  readonly rtt?: Quantity | null;
-  /** This record tells what reordering did in a run of a measurement-only cell, from the records of its two ends. */
-  readonly reordering?: Reordering;
-  /** These are the times of the proxy of a calibration cell, one for each request and its reply. */
-  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 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`). */
-  readonly driver?: {
-    readonly steps: readonly DriverStepTime[];
-  };
-  /** This record is what the client did after the detection, for a prediction that says when it reconnects. */
-  readonly reconnect?: ReconnectReading;
-  /** This record is what the call in flight of a WebSocket client met. */
-  readonly call?: CallReading;
-  /**
-   * This time is from the drop line of the program to the close of its socket by its own side: a
-   * FIN or an abort. A prediction that says how the program drops (`drop`) gets it. It is null
-   * when the socket did not close itself in the run. A prediction can say that the client process
-   * ends with the run (`exits`). Then a close at that end is no close by the program, and `left` is null.
-   */
-  readonly left?: Quantity | null;
-  /**
-   * This time is from the drop line of the program to the end of the client process. A socket gets
-   * it when it stayed open until that end. The kernel closed it then, not the program (`exits`).
-   */
-  readonly exited?: Quantity;
-  /** 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;
-}
-/**
- * A reordering record is what reordering, duplicates and losses did to the data of a run. The
- * receiver is the client, and the sender is the socket of its peer.
- * - `outOfOrder` counts the arrivals at the client beyond a hole, and `duplicates` counts the
- *   arrivals whose data the client had. The prober reads the two from each arrival, against `rcv_nxt`.
- * - An arrival can hold more than one segment. The kernel joins the segments that wait in the
- *   backlog of a socket while its owner holds it.
- * - `ooo` is the count of the kernel of the client in segments (`rcv_ooopack`).
- * - `sacked` and `lost` are the most segments that the sender held as SACKed and as lost.
- * - `dsacks` is the DSACK blocks that the sender received, and `fast` its fast retransmissions.
- * - `degree` is the highest reordering degree of the sender (`tp->reordering`), and `seen` the
- *   reorderings that it detected (`reord_seen`).
- *
- * The counts of the kernel are null for a record of the prober before version 0.2.
- */
-interface Reordering {
-  readonly outOfOrder: number;
-  readonly duplicates: number;
-  readonly ooo: number | null;
-  readonly sacked: number | null;
-  readonly lost: number | null;
-  readonly dsacks: number | null;
-  readonly fast: number;
-  readonly degree: number | null;
-  readonly seen: number | null;
-}
-/**
- * A crossings record is the time of a proxy for each request (`up`) and for each reply (`down`).
- * The time of a request starts at its arrival on the socket toward the client. It stops at the
- * write on the socket toward the target. The time of a reply goes the other way. A write is a
- * `tx` record of the prober.
- */
-interface Crossings {
-  readonly hop: string;
-  readonly up: readonly Quantity[];
-  readonly down: readonly Quantity[];
-}
-/** A socket place is a socket of a run: its namespace and its cookie. */
-interface SocketPlace {
-  readonly netns: number;
-  readonly cookie: number;
-}
-/**
- * This function finds the socket of the observer of a cell in a run:
- * - the client socket, by the address that it connected from, in its namespace.
- * - the socket of the target for the same connection, in its namespace.
- * - a socket of a proxy of the topology, toward the client or toward the target. Toward the target,
- *   it is the socket that carries the request, else the first socket that the run opens.
- */
-export declare const socketOf: (cell: Cell, run: Run) => SocketPlace | undefined;
-/** This function gives what reordering did in a run, from the records of the receiver and of the sender. */
-export declare const reorderingOf: (receiver: readonly KernelRecord[], sender: readonly KernelRecord[]) => Reordering;
-/**
- * This function gives the times of a proxy in a run, for each request after the first. The time
- * of a request starts at its arrival on the socket of the proxy toward the client. It stops at the
- * next write on the socket toward the target. The time of its reply starts at its arrival on the
- * socket toward the target, and it stops at the next write toward the client. A request without
- * each record gives no time.
- */
-export declare const crossingsOf: (run: Run, hop: string, toClient: SocketPlace | undefined, toTarget: SocketPlace | undefined) => Crossings;
-/**
- * This function reads one run against its cell, from the records of the kernel first.
- * - The socket of the run is the socket of its observer. It is the socket that the client connected
- *   from, in its namespace, or the socket of the target or of a proxy for that connection.
- * - 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.
- * - For an HTTP client, it also reads what the second request met (`requestOf`). An outcome other
- *   than the one that the prediction gives is a finding.
- */
-export declare const measure: (cell: Cell, run: Run) => Measured;
-/**
- * This function reads the second request of an HTTP client from its lines. Its first try is its
- * first `request` line, and each `retry` line is a new try. Its end is its `error` line, or its
- * `replied` line. A request with neither is pending. It gives null when the client wrote no try.
- *
- * A new try that gets no connection writes no `retry` line. Its dial writes a `dial-error` line.
- * Thus a `dial-error` line after the first try and before the end is also a new try.
- */
-export declare const requestOf: (events: readonly ProbeEvent[]) => RequestReading | null;
-//#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: {
@@ -544,6 +362,35 @@ export declare const INJECT: Quantity;
 export declare const noiseOf: (cell: {
   readonly noise?: Quantity | undefined;
 }) => Quantity;
+/**
+ * A pairing is the window of a run in which a line of its program pairs with the kernel's record
+ * of its act. `bound` is the jitter of the program that the run measured, or null. `delta` is the
+ * window: δ_abs of the cell, or the bound when the bound is longer.
+ */
+interface Pairing {
+  readonly bound: Quantity | null;
+  readonly delta: Quantity;
+}
+/**
+ * This function gives the pairing window of a run (SYS-25). On a runner of GitHub, the jitter of
+ * a program can be longer than the δ_abs of 1 ms. Thus each run measures it before its fault
+ * (`Run.jitter`), and its own measurement widens its window. A run without a jitter record is
+ * from before SYS-25. It reads as a bound of null, thus its window is δ_abs. The decision of
+ * 2026-10-19 keeps the rule of one miss: a pair that a window misses is still a finding.
+ */
+export declare const pairingOf: (cell: {
+  readonly noise?: Quantity | undefined;
+}, run: Pick<Run, "jitter">) => Pairing;
+/**
+ * This function sums the pairings of the measurements of a cell. It gives the longest bound and
+ * the longest window. It also counts the pairings whose window is longer than δ_abs (`noise`). It
+ * is null when no measurement has a pairing.
+ */
+export declare const pairingsOf: (runs: readonly Measured[], noise?: Quantity) => {
+  readonly bound: Quantity | null;
+  readonly delta: Quantity;
+  readonly widened: number;
+} | null;
 /**
  * This function tells if a timer firing came late enough to void a run. A firing two jiffies or
  * more behind its wheel slot came late because the host stopped a vCPU. With the HZ of the run,
@@ -683,14 +530,18 @@ interface GroupVerdict {
   }>;
   readonly lags?: Spread | null;
 }
-/** This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). */
+/**
+ * This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). It is
+ * `quantileSorted` of @mark1russell7/rigor-statistics with the method `"nearest-rank"`.
+ */
 export declare const quantileOf: (sorted: readonly number[], p: number) => number;
 /** This function gives the spread of a set of times, or null for none. */
 export declare const spreadOf: (times: readonly Quantity[]) => Spread | null;
 /**
  * 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 %.
+ * at 98.8 %. It is `medianInterval` of @mark1russell7/rigor-statistics at the level 0.95. An
+ * empty list throws a RangeError.
  */
 export declare const medianInterval: (sorted: readonly number[]) => [number, number];
 /**
@@ -709,6 +560,207 @@ export declare const verdictOf: (prediction: Prediction, runs: readonly Measured
 /** This function sums what the group of a group cell did in its counted runs, and tests each stage that has a band. */
 export declare const groupVerdictOf: (prediction: Prediction, counted: readonly Measured[], delta?: Quantity) => GroupVerdict;
 //#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. The observer can also
+ * close the connection itself (`closed`), or its program can drop it on its own timer (`dropped`).
+ */
+type Outcome = {
+  readonly kind: "error";
+  readonly errno: string;
+} | {
+  readonly kind: "eof";
+} | {
+  readonly kind: "silent";
+} | {
+  readonly kind: "answered";
+} | {
+  readonly kind: "closed";
+} | {
+  readonly kind: "dropped";
+};
+/**
+ * A request reading is what the second request of an HTTP client met, from the lines of the
+ * client. It holds the connection of its first try, a new try, and its outcome. `gap` is the time
+ * from the end of the first reply to the send of the second request.
+ */
+interface RequestReading {
+  readonly connection: "reused" | "new";
+  readonly retried: boolean;
+  readonly error: string | null;
+  readonly pending: boolean;
+  readonly gap: Quantity | null;
+}
+/** 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 count is the number of bytes that the client read after the request. */
+  readonly bytes?: number;
+  /**
+   * This time is when a router of the topology forgot the flow of the client. It counts from the
+   * last segment that the client received before the fault. It is null when no router forgot the flow.
+   */
+  readonly forgot?: Quantity | null;
+  /**
+   * This time is the first round trip of the socket of the observer. It is the smoothed round trip
+   * in its first record, which is the sample of the handshake. It is null when no record has it.
+   */
+  readonly rtt?: Quantity | null;
+  /** This record tells what reordering did in a run of a measurement-only cell, from the records of its two ends. */
+  readonly reordering?: Reordering;
+  /** These are the times of the proxy of a calibration cell, one for each request and its reply. */
+  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 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`). */
+  readonly driver?: {
+    readonly steps: readonly DriverStepTime[];
+  };
+  /** This record is what the client did after the detection, for a prediction that says when it reconnects. */
+  readonly reconnect?: ReconnectReading;
+  /** This record is what the call in flight of a WebSocket client met. */
+  readonly call?: CallReading;
+  /**
+   * This time is from the drop line of the program to the close of its socket by its own side: a
+   * FIN or an abort. A prediction that says how the program drops (`drop`) gets it. It is null
+   * when the socket did not close itself in the run. A prediction can say that the client process
+   * ends with the run (`exits`). Then a close at that end is no close by the program, and `left` is null.
+   */
+  readonly left?: Quantity | null;
+  /**
+   * This time is from the drop line of the program to the end of the client process. A socket gets
+   * it when it stayed open until that end. The kernel closed it then, not the program (`exits`).
+   */
+  readonly exited?: Quantity;
+  /**
+   * This record is the pairing window of the run: the jitter bound that it measured, and the
+   * window that its pairings used (`pairingOf`). A run that has a jitter record gets it. Thus a
+   * reader can check each pairing of the run again.
+   */
+  readonly pairing?: Pairing;
+  /** 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;
+}
+/**
+ * A reordering record is what reordering, duplicates and losses did to the data of a run. The
+ * receiver is the client, and the sender is the socket of its peer.
+ * - `outOfOrder` counts the arrivals at the client beyond a hole, and `duplicates` counts the
+ *   arrivals whose data the client had. The prober reads the two from each arrival, against `rcv_nxt`.
+ * - An arrival can hold more than one segment. The kernel joins the segments that wait in the
+ *   backlog of a socket while its owner holds it.
+ * - `ooo` is the count of the kernel of the client in segments (`rcv_ooopack`).
+ * - `sacked` and `lost` are the most segments that the sender held as SACKed and as lost.
+ * - `dsacks` is the DSACK blocks that the sender received, and `fast` its fast retransmissions.
+ * - `degree` is the highest reordering degree of the sender (`tp->reordering`), and `seen` the
+ *   reorderings that it detected (`reord_seen`).
+ *
+ * The counts of the kernel are null for a record of the prober before version 0.2.
+ */
+interface Reordering {
+  readonly outOfOrder: number;
+  readonly duplicates: number;
+  readonly ooo: number | null;
+  readonly sacked: number | null;
+  readonly lost: number | null;
+  readonly dsacks: number | null;
+  readonly fast: number;
+  readonly degree: number | null;
+  readonly seen: number | null;
+}
+/**
+ * A crossings record is the time of a proxy for each request (`up`) and for each reply (`down`).
+ * The time of a request starts at its arrival on the socket toward the client. It stops at the
+ * write on the socket toward the target. The time of a reply goes the other way. A write is a
+ * `tx` record of the prober.
+ */
+interface Crossings {
+  readonly hop: string;
+  readonly up: readonly Quantity[];
+  readonly down: readonly Quantity[];
+}
+/** A socket place is a socket of a run: its namespace and its cookie. */
+interface SocketPlace {
+  readonly netns: number;
+  readonly cookie: number;
+}
+/**
+ * This function finds the socket of the observer of a cell in a run:
+ * - the client socket, by the address that it connected from, in its namespace.
+ * - the socket of the target for the same connection, in its namespace.
+ * - a socket of a proxy of the topology, toward the client or toward the target. Toward the target,
+ *   it is the socket that carries the request, else the first socket that the run opens.
+ */
+export declare const socketOf: (cell: Cell, run: Run) => SocketPlace | undefined;
+/** This function gives what reordering did in a run, from the records of the receiver and of the sender. */
+export declare const reorderingOf: (receiver: readonly KernelRecord[], sender: readonly KernelRecord[]) => Reordering;
+/**
+ * This function gives the times of a proxy in a run, for each request after the first. The time
+ * of a request starts at its arrival on the socket of the proxy toward the client. It stops at the
+ * next write on the socket toward the target. The time of its reply starts at its arrival on the
+ * socket toward the target, and it stops at the next write toward the client. A request without
+ * each record gives no time.
+ */
+export declare const crossingsOf: (run: Run, hop: string, toClient: SocketPlace | undefined, toTarget: SocketPlace | undefined) => Crossings;
+/**
+ * This function reads one run against its cell, from the records of the kernel first.
+ * - The socket of the run is the socket of its observer. It is the socket that the client connected
+ *   from, in its namespace, or the socket of the target or of a proxy for that connection.
+ * - 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.
+ * - For an HTTP client, it also reads what the second request met (`requestOf`). An outcome other
+ *   than the one that the prediction gives is a finding.
+ */
+export declare const measure: (cell: Cell, run: Run) => Measured;
+/**
+ * This function measures the jitter of the program of the observer in a run, from its records
+ * (`Jitter`). The acts count up to the start of the fault, or up to the reply of the client when
+ * the fault has no stamp. A run with no lines of a program, or no socket of the observer, has no act.
+ */
+export declare const jitterOf: (cell: Cell, run: Run) => Jitter;
+/**
+ * This function reads the second request of an HTTP client from its lines. Its first try is its
+ * first `request` line, and each `retry` line is a new try. Its end is its `error` line, or its
+ * `replied` line. A request with neither is pending. It gives null when the client wrote no try.
+ *
+ * A new try that gets no connection writes no `retry` line. Its dial writes a `dial-error` line.
+ * Thus a `dial-error` line after the first try and before the end is also a new try.
+ */
+export declare const requestOf: (events: readonly ProbeEvent[]) => RequestReading | null;
+//#endregion
 //#region src/lab.d.ts
 /**
  * This time is the interval of the listing of a router, when its hop does not set one. A listing
@@ -1663,5 +1715,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 CallReading, type Cell, type CellResult, type Client, type ClientImage, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type Crossings, type Cut, type Decision, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, 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 HttpProbe, type ImagePlan, type ImageSource, type Interval, type KernelRecord, type Lab, type LineMatch, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, type Outcome, type PinnedImage, type Prediction, type Probe, type ProbeEvent, type ProgramEvent, type ProxyHop, type ProxyTime, type ReconnectReading, type ReconnectVerdict, type Reconnects, type Recovers, type Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouterHop, type RttRange, type Run, type RunGroup, type RunPart, 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 Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, isHopPlace, latestEndOf };
+export { type Agent, type BuildImage, type CallReading, type Cell, type CellResult, type Client, type ClientImage, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type Crossings, type Cut, type Decision, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, 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 HttpProbe, type ImagePlan, type ImageSource, type Interval, type Jitter, type KernelRecord, type Lab, type LineMatch, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, 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 Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouterHop, type RttRange, type Run, type RunGroup, type RunPart, 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 Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, isHopPlace, latestEndOf };
 //# sourceMappingURL=index.d.ts.map