@downtrace/protocol 0.6.0 → 0.7.1

package/dist/index.d.ts

@@ -1,8 +1,16 @@
 //#region src/generated/paths.d.ts
 /** Path, relative to the ingest URL, that receives AggregatesBatch payloads. */
 declare const AGGREGATES_PATH = "/v0/aggregates";
+/** Path template that receives a capture's evidence. `{id}` is the capture's identifier. */
+declare const CAPTURE_EVIDENCE_PATH = "/v0/captures/{id}/evidence";
+/** The evidence path for one capture. Here rather than in every caller: one place builds it (gh-322). */
+declare function captureEvidencePath(id: string): string;
 //#endregion
 //#region src/generated/aggregates.d.ts
+/**
+ * Whether an observer is attached (`on`), was not asked for (`off`), or was asked for and could not attach (`unavailable`) — a driver that is not resolvable from the application's root, for instance. The third one is the point: without it, a service that is not being watched looks exactly like a service that has nothing to watch (COB-01, invariant 14).
+ */
+type ObserverState = "on" | "off" | "unavailable";
 /**
  * A batch of per-interval, per-route aggregates sent by an agent to the cloud (POST /v0/aggregates).
  */
@@ -10,22 +18,108 @@ interface AggregatesBatch {
   /**
    * Protocol version this batch conforms to. Every published minor of v0 stays acceptable.
    */
-  protocol: "0.1.0" | "0.2.0" | "0.3.0" | "0.4.0" | "0.5.0" | "0.6.0";
+  protocol: "0.1.0" | "0.2.0" | "0.3.0" | "0.4.0" | "0.5.0" | "0.6.0" | "0.7.0";
   agent: AgentInfo;
   instance: InstanceInfo;
   deploy: DeployInfo;
   /**
-   * @minItems 1
+   * The intervals this batch carries. May be empty when the batch carries a profile: the profile has a cadence of its own and hangs off the batch, not off an interval (ADR 0017), so tying its delivery to one meant it was lost whenever a window closed with no traffic — at shutdown, always (gh-375). A batch with neither is refused by the cloud with a reason, which the schema cannot say without making the generated types unusable.
+   *
+   * @minItems 0
    * @maxItems 6
    */
-  intervals: [Interval] | [Interval, Interval] | [Interval, Interval, Interval] | [Interval, Interval, Interval, Interval] | [Interval, Interval, Interval, Interval, Interval] | [Interval, Interval, Interval, Interval, Interval, Interval];
+  intervals: [] | [Interval] | [Interval, Interval] | [Interval, Interval, Interval] | [Interval, Interval, Interval, Interval] | [Interval, Interval, Interval, Interval, Interval] | [Interval, Interval, Interval, Interval, Interval, Interval];
   profile?: Profile;
+  /**
+   * Progress on the captures this sender was asked for. Absent from every sender that predates it, and from every batch with nothing to report. Bounded like the answer that carries the orders.
+   *
+   * @maxItems 16
+   */
+  captures?: [] | [CaptureProgress] | [CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress] | [CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress, CaptureProgress];
+  /**
+   * Distinct exception signatures this process saw outside any request. Absent from every sender that predates it and from every batch with none. Bounded: a process crashing in a loop must not become an unbounded batch.
+   *
+   * @maxItems 32
+   */
+  exceptions?: ProcessException[];
+  /**
+   * Local signals that ask for a capture. `product.md:124` gives the instrumentation «disparar por señales locales»: it sees a process in trouble before any aggregate crosses the cloud, and asking in the batch costs no channel of its own — the answer already carries the orders (ADR 0071). Absent from every sender that predates it and from every batch with nothing to ask. The cloud decides: the same budget, cooldown and concurrency as any other capture (`product.md:122`), and a refusal is silence, because there is nothing the instrumentation would do differently.
+   *
+   * @maxItems 4
+   */
+  triggers?: [] | [LocalTrigger] | [LocalTrigger, LocalTrigger] | [LocalTrigger, LocalTrigger, LocalTrigger] | [LocalTrigger, LocalTrigger, LocalTrigger, LocalTrigger];
 }
 interface AgentInfo {
   name: string;
   version: string;
   runtime: "node" | "go";
   runtimeVersion: string;
+  observers?: Observers;
+  withholding?: Withholding;
+  resources?: AgentResources;
+}
+/**
+ * Absent from an instrumentation older than protocol 0.7.0. Absent is not 'nothing is observed': it is 'this one did not say', and the two must not be shown alike.
+ */
+interface Observers {
+  pg?: ObserverState;
+  http?: ObserverState;
+  redis?: ObserverState;
+  runtime?: ObserverState;
+}
+/**
+ * Absent means **this sender did not say**, not that it withholds nothing — the same reading as `observers`, and for the same reason.
+ */
+interface Withholding {
+  /**
+   * True when the sender is in minimal mode: no query text, no route templates, no dependency hosts, no error messages. Only ever true — a sender that is not in minimal mode leaves it out.
+   */
+  freeText?: true;
+  /**
+   * How many endpoints are excluded. Absent means none are.
+   */
+  endpoints?: number;
+  /**
+   * How many dependencies are excluded. Absent means none are.
+   */
+  dependencies?: number;
+}
+/**
+ * What the instrumentation costs and what it has lost, measured by itself. Absent means **this sender did not say**, the same reading as `observers` and `withholding`. `product.md:239` asks for it by name: «recursos internos medidos».
+ */
+interface AgentResources {
+  /**
+   * Batches the instrumentation threw away because its queue was full, since the previous batch. This is telemetry that existed and is gone: the number that separates «nothing happened» from «nothing arrived».
+   */
+  droppedBatches?: number;
+  /**
+   * Batches the cloud refused as invalid, since the previous batch. Nothing broke: something was sent wrong.
+   */
+  rejectedBatches?: number;
+  /**
+   * Batches that could not be sent —network, timeout, a cloud that was not there— since the previous batch. Not the same as dropped: these are retried, and only become loss if the queue fills.
+   */
+  failedBatches?: number;
+  /**
+   * Errors inside the instrumentation itself, since the previous batch. It disables itself after enough of them, and a sender that has gone quiet with these climbing is not a quiet service.
+   */
+  internalErrors?: number;
+  /**
+   * What the black box's registers have allocated, right now. An instant, and arithmetic rather than a measurement: the rings are preallocated.
+   */
+  bufferBytes?: number;
+  /**
+   * Estimated milliseconds of the instrumentation's own hooks per request. **An estimate**, sampled, and named as one: it is what invariant 3 budgets, and reporting it as an exact measurement would claim a precision the sampling does not have.
+   */
+  hookMsPerRequest?: number;
+  /**
+   * What the instrumentation has given up because it was costing too much, cheapest loss first. `product.md:241` asks for both halves —«se autolimita» and «lo registra como pérdida de cobertura»— and this is the second. An enum and not free text: it is ours, and it has to be comparable between senders.
+   */
+  shed?: "nothing" | "fine" | "profile";
+  /**
+   * Why it gave ground. Absent when nothing was given up.
+   */
+  shedReason?: "latency" | "memory";
 }
 interface InstanceInfo {
   /**
@@ -168,13 +262,13 @@ interface Dependency {
   waitMs?: number;
 }
 /**
- * Health of the agent's own process during the interval. Optional: an agent that does not measure it omits it. Per interval, not per route, because it belongs to the process.
+ * What the runtime itself was doing. Every field is optional and at least one has to be there: `product.md:251` says the protocol is independent of the language, and a Go runtime has garbage collection, a heap and a resident set but no event loop. Requiring the six of them meant it could either invent an event loop or send none of the three it does have. An empty object is not a reading, hence the minimum of one (gh-285).
  */
 interface RuntimeHealth {
   /**
    * How long the event loop was late, in ms. The signal that says the process itself is the bottleneck.
    */
-  eventLoopDelayMs: {
+  eventLoopDelayMs?: {
     /**
      * Median delay.
      */
@@ -191,23 +285,23 @@ interface RuntimeHealth {
   /**
    * Total time spent in garbage collection during the interval.
    */
-  gcPauseMs: number;
+  gcPauseMs?: number;
   /**
    * Garbage collections during the interval.
    */
-  gcCount: number;
+  gcCount?: number;
   /**
    * Heap in use at the end of the interval.
    */
-  heapUsedMb: number;
+  heapUsedMb?: number;
   /**
    * Resident set size at the end of the interval.
    */
-  rssMb: number;
+  rssMb?: number;
   /**
    * Peak concurrent in-flight requests during the interval.
    */
-  inFlightMax: number;
+  inFlightMax?: number;
 }
 /**
  * What each route normally does, sent once a minute rather than with every interval: a profile changes when the code changes, and at the aggregates' cadence it would not fit in the project's row budget (ADR 0017).
@@ -266,6 +360,69 @@ interface Operation {
    * Only on the `(other)` bucket: how many distinct operations it merges, so a cap does not become a lie by omission.
    */
   distinct?: number;
+  /**
+   * What kind of statement this is, when the sender could not normalise it safely. Its presence is the reason the text is absent: `product.md:104` says a query the normaliser does not understand travels «solo como hash y clase», and this is the class. Never sent together with `text` — they are two answers to the same question. Our word and not the service's: it is decided from the first keyword, which is all that can be told without understanding the rest (gh-344).
+   */
+  class?: "select" | "insert" | "update" | "delete" | "other";
+}
+/**
+ * What the instrumentation has to say about a capture the cloud asked it for. The order travels in the ingest response (ADR 0071) and the answer travels here, on the same cadence and at the same cost: a path of its own would be one more call per capture, and one more thing to authenticate, for a fact that fits in the batch that is already going (gh-378).
+ */
+interface CaptureProgress {
+  /**
+   * The capture's id, as the ingest response gave it. Carries nothing the service wrote.
+   */
+  id: string;
+  /**
+   * Unix milliseconds when observation **really** started, which CAP-01 keeps apart from when the capture was accepted.
+   */
+  startedAt: number;
+}
+/**
+ * Something thrown outside any instrumented operation: an exception nobody caught, or a promise rejected with no `catch`. `product.md:77` asks for «errores **y excepciones**», and these are the two the word «excepciones» names. They live on the batch and not in the profile because they have **no route** — they happen outside a request's life, or after it ended — and filing them under a route that is not theirs would be worse than not having them (gh-341, ADR 0102).
+ */
+interface ProcessException {
+  /**
+   * Which of the two. Two different failures with two different fixes: counting them together hides which one is happening.
+   */
+  kind: "uncaught" | "unhandled-rejection";
+  /**
+   * Stable identity of the signature, the same shape a query's or an operation error's has (ADR 0017).
+   */
+  hash: string;
+  /**
+   * Type, sanitised message and stack signature. Optional and for the same reason as everywhere else: when nothing recognisable survives the sanitising, only the type and the signature travel (ADR 0084). Its absence is not the absence of an exception.
+   */
+  text?: string;
+  /**
+   * How many times this signature happened. An instant per occurrence would be a row per crash of a process that crashes in a loop; what a reader asks is how many.
+   */
+  count: number;
+}
+/**
+ * One local signal, sustained past its threshold. It asks for detail; it does not claim a cause (invariant 7).
+ */
+interface LocalTrigger {
+  /**
+   * Which signal fired. An enum and not free text: the cloud files findings by footprint, and a trigger type nobody can compare is a footprint that never matches. `product.md:114` names the absolute-threshold signals; this is the first of them.
+   */
+  signal: "event-loop-delay";
+  /**
+   * Unix milliseconds when the signal was last seen over its threshold. Milliseconds and not a date string because that is how this contract writes an instant —an interval's `start`, a capture's `startedAt`— and the evidence, which writes dates, is a different payload with different readers.
+   */
+  observedAt: number;
+  /**
+   * What was measured: the p99 of the event loop delay over the interval that fired.
+   */
+  valueMs?: number;
+  /**
+   * The threshold it passed, sent with the value because a number without its threshold cannot be read by anyone who does not have this version of the instrumentation in front of them.
+   */
+  thresholdMs?: number;
+  /**
+   * How many consecutive intervals it stayed over. More than one is what makes it sustained rather than a spike (`product.md:114`).
+   */
+  intervals?: number;
 }
 //#endregion
 //#region src/generated/boundaries.d.ts
@@ -278,11 +435,190 @@ declare const CALLS_PER_REQUEST_BOUNDARIES_V0: readonly number[];
 /** Number of calls-per-request buckets: boundaries + 1 open-ended bucket. */
 declare const CALLS_PER_REQUEST_BUCKETS_V0 = 8;
 //#endregion
+//#region src/generated/capture-evidence.d.ts
+/**
+ * What an instrumentation sends back for a capture the cloud asked for (POST /v0/captures/{id}/evidence). It is the contents of the black box's fine register, frozen: requests with their operations, in order, with starts and ends. Hashes only — the text of a query never travels here (invariant 5). Its own path and not the aggregates batch, because a batch is what goes out every ten seconds and this is a rare event several orders of magnitude larger.
+ */
+interface CaptureEvidence {
+  /**
+   * Protocol version this payload conforms to. Same enum as a batch: every published minor of v0 stays acceptable.
+   */
+  protocol: "0.1.0" | "0.2.0" | "0.3.0" | "0.4.0" | "0.5.0" | "0.6.0" | "0.7.0";
+  /**
+   * Which process observed this. Several instances of one deployment get the same order on purpose (ADR 0071), so the cloud has to be able to tell two answers apart.
+   */
+  instance: {
+    id: string;
+    hostname?: string;
+    pid?: number;
+  };
+  /**
+   * The **effective start of observation**, which is the instant CAP-01 insists on keeping apart from the acceptance. It travels with the evidence rather than in a call of its own: a capture that started and never finished should not cost two requests.
+   */
+  startedAt: string;
+  /**
+   * When the instrumentation stopped watching.
+   */
+  endedAt: string;
+  coverage: CaptureCoverage;
+  /**
+   * The requests observed, oldest first. An empty array is a real answer and the commonest one: a route nobody called during the window. It means the capture is `empty`, and `product.md:192` is explicit that this must never read as an invitation to ask again unchanged.
+   *
+   * @maxItems 4096
+   */
+  requests: CapturedRequest[];
+  reference?: ReferenceSamples;
+}
+/**
+ * `product.md:192` asks a capture to declare **both** coverages: what it attached from detail still retained, and what it observed from its effective start. Two numbers, never one — a total would hide that half of it is older than the capture.
+ */
+interface CaptureCoverage {
+  /**
+   * Requests seen from the effective start onwards.
+   */
+  observedRequests: number;
+  /**
+   * Requests that were already in the register when the capture started, and are attached. Zero is normal: the register may have wrapped, and nothing brings back what was not kept.
+   */
+  attachedRequests: number;
+  /**
+   * Requests whose operations were overwritten before they could be read. Their timing is still true; what is gone is the detail. Reported rather than dropped, because a request with no operations reads as one that ran nothing (invariant 14).
+   */
+  detailLost: number;
+  /**
+   * Requests that ran more operations than the register keeps per request. Their count is real and their list is not complete.
+   */
+  truncated: number;
+}
+interface CapturedRequest {
+  method: string;
+  /**
+   * The route template, never the path with its values in it (invariant 5).
+   */
+  route: string;
+  status: number;
+  /**
+   * When this request started. Absolute, so requests from two instances can be read side by side.
+   */
+  startedAt: string;
+  durationMs: number;
+  /**
+   * What it ran, in the order it started them. Empty means it ran nothing — unless `detailLost` says the list was overwritten, which is why that flag is on the request and not only in the totals.
+   *
+   * @maxItems 256
+   */
+  operations: CapturedOperation[];
+  /**
+   * This request ran more operations than the register keeps per request. Absent means false.
+   */
+  truncated?: boolean;
+  /**
+   * This request's operations were overwritten before they were read. Absent means false. Its timing is still true.
+   */
+  detailLost?: boolean;
+}
+/**
+ * One operation inside a request. Starts and ends and not durations, because the whole reason for capturing detail is order and overlap, which a duration cannot express (ADR 0068).
+ */
+interface CapturedOperation {
+  /**
+   * The fingerprint's hash. Never the text: the profile is where a sender chooses whether to ship the text of its queries, and this path never carries it (invariant 5, ADR 0017).
+   */
+  hash: string;
+  /**
+   * Milliseconds from the start of its own request.
+   */
+  startMs: number;
+  endMs: number;
+}
+/**
+ * A few requests of each endpoint kept as something to compare the captured ones against. `product.md:100`: «Comparar requests degradadas con requests de referencia exige conservar ambas; el detalle fino de hace una hora ya no existe». Being earlier does not certify health, which is why every field here is about how they were chosen and none of them says «healthy».
+ */
+interface ReferenceSamples {
+  /**
+   * How they were chosen. Travels with them because a sample whose selection is unknown cannot support an attribution (ATR-01). `uniform-reservoir`: every request observed of that endpoint had the same chance of being kept, whatever it did — which is what «the fastest N» would not be.
+   */
+  selection: "uniform-reservoir";
+  /**
+   * How many requests they were drawn from, over the life of the sending process.
+   */
+  population: number;
+  /**
+   * Endpoints seen that the register had no room for. Counted rather than silently absent: an endpoint with no samples is not an endpoint with no traffic (invariant 14).
+   */
+  routesDropped?: number;
+  /**
+   * True when requests were observed that the register deliberately did not consider. The instrumentation pauses renewal while it is watching a capture, which is the closest it can get to REF-01 from inside the process: it cannot know whether an incident is open, but it knows detail has been asked of it. Absent means false.
+   */
+  renewalPaused?: boolean;
+  /**
+   * The kept requests, in the same shape as the captured ones. An empty array is a real answer: a process that has just started has nothing to compare with yet.
+   *
+   * @maxItems 64
+   */
+  samples: CapturedRequest[];
+}
+//#endregion
+//#region src/generated/ingest-response.d.ts
+/**
+ * What the cloud answers to POST /v0/aggregates. Described here, and not left as an implementation detail, because since protocol 0.7.0 it carries instructions: the captures the cloud is waiting for. It follows the same rules as the batch — fields are only ever added, each addition bumps the minor, and a published minor is accepted for ever — with one difference in who owes what. An agent that does not read this body must behave exactly as it did before (ADR 0008), so every field here is something an agent may ignore.
+ */
+interface IngestResponse {
+  /**
+   * How many intervals of the batch the cloud took.
+   */
+  accepted: number;
+  /**
+   * How many rows were new. Lower than `accepted` when a batch is re-sent: ingest is idempotent.
+   */
+  inserted: number;
+  /**
+   * Captures the cloud is waiting for, in the environment this batch came from. Absent or empty means none. Bounded because this rides on every batch: the cloud never asks for more at once than an instrumentation could reasonably freeze, and the concurrency budget is far below this anyway. Several instances of one deployment receive the same list on purpose — the cloud knows which instance sent recently, not which is alive, so dealing one capture to one instance would lose it silently when that process is gone (invariant 14).
+   *
+   * @maxItems 16
+   */
+  captures?: PendingCapture[];
+}
+interface PendingCapture {
+  /**
+   * What the evidence will be sent back under. Carries nothing the service wrote.
+   */
+  id: string;
+  /**
+   * The environment this capture is about, which is always the one the batch came from. Sent anyway so the payload is readable on its own.
+   */
+  environment?: string;
+  /**
+   * HTTP method of the route to watch.
+   */
+  method?: string;
+  /**
+   * Route template to watch. Empty when the capture is about a dependency rather than a route.
+   */
+  route?: string;
+  /**
+   * Dependency kind to watch. Empty when the capture is about a route.
+   */
+  kind?: string;
+  /**
+   * Dependency target to watch.
+   */
+  target?: string;
+  /**
+   * How long to watch for, from the effective start of observation.
+   */
+  windowSeconds: number;
+  /**
+   * After this instant the cloud stops waiting. An instrumentation that reads a stale response must not start a capture past it: the cloud will refuse the evidence, and a capture nobody is waiting for spends the fine register for nothing.
+   */
+  expiresAt: string;
+}
+//#endregion
 //#region src/generated/versions.d.ts
 /** Every published minor of v0, oldest first. The cloud never stops accepting one it published (ADR 0008). */
-declare const ACCEPTED_PROTOCOL_VERSIONS_V0: readonly ["0.1.0", "0.2.0", "0.3.0", "0.4.0", "0.5.0", "0.6.0"];
+declare const ACCEPTED_PROTOCOL_VERSIONS_V0: readonly ["0.1.0", "0.2.0", "0.3.0", "0.4.0", "0.5.0", "0.6.0", "0.7.0"];
 /** The newest published minor: what an up-to-date agent stamps on every batch. */
-declare const PROTOCOL_VERSION = "0.6.0";
+declare const PROTOCOL_VERSION = "0.7.0";
 //#endregion
 //#region src/index.d.ts
 /** The JSON Schema (draft 2020-12) for AggregatesBatch, for validators on either side. */
@@ -317,10 +653,35 @@ declare const AGGREGATES_SCHEMA_V0: {
       items: {
         $ref: string;
       };
+      description: string;
     };
     profile: {
       $ref: string;
     };
+    captures: {
+      type: string;
+      maxItems: number;
+      items: {
+        $ref: string;
+      };
+      description: string;
+    };
+    exceptions: {
+      type: string;
+      maxItems: number;
+      items: {
+        $ref: string;
+      };
+      description: string;
+    };
+    triggers: {
+      type: string;
+      maxItems: number;
+      items: {
+        $ref: string;
+      };
+      description: string;
+    };
   };
   $defs: {
     AgentInfo: {
@@ -347,6 +708,18 @@ declare const AGGREGATES_SCHEMA_V0: {
           minLength: number;
           maxLength: number;
         };
+        observers: {
+          $ref: string;
+          description: string;
+        };
+        withholding: {
+          $ref: string;
+          description: string;
+        };
+        resources: {
+          $ref: string;
+          description: string;
+        };
       };
     };
     InstanceInfo: {
@@ -553,7 +926,6 @@ declare const AGGREGATES_SCHEMA_V0: {
       description: string;
       type: string;
       additionalProperties: boolean;
-      required: string[];
       properties: {
         eventLoopDelayMs: {
           type: string;
@@ -604,6 +976,7 @@ declare const AGGREGATES_SCHEMA_V0: {
           description: string;
         };
       };
+      minProperties: number;
     };
     Dependency: {
       title: string;
@@ -742,6 +1115,486 @@ declare const AGGREGATES_SCHEMA_V0: {
           minimum: number;
           description: string;
         };
+        class: {
+          enum: string[];
+          description: string;
+        };
+      };
+      not: {
+        required: string[];
+        properties: {
+          class: {};
+          text: {};
+        };
+      };
+    };
+    ObserverState: {
+      title: string;
+      enum: string[];
+      description: string;
+    };
+    Observers: {
+      title: string;
+      type: string;
+      additionalProperties: boolean;
+      description: string;
+      properties: {
+        pg: {
+          $ref: string;
+        };
+        http: {
+          $ref: string;
+        };
+        redis: {
+          $ref: string;
+        };
+        runtime: {
+          $ref: string;
+        };
+      };
+    };
+    Withholding: {
+      title: string;
+      type: string;
+      additionalProperties: boolean;
+      minProperties: number;
+      description: string;
+      properties: {
+        freeText: {
+          type: string;
+          description: string;
+          const: boolean;
+        };
+        endpoints: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        dependencies: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+      };
+    };
+    CaptureProgress: {
+      title: string;
+      type: string;
+      additionalProperties: boolean;
+      required: string[];
+      description: string;
+      properties: {
+        id: {
+          type: string;
+          minLength: number;
+          maxLength: number;
+          description: string;
+        };
+        startedAt: {
+          type: string;
+          description: string;
+        };
+      };
+    };
+    ProcessException: {
+      title: string;
+      type: string;
+      additionalProperties: boolean;
+      required: string[];
+      description: string;
+      properties: {
+        kind: {
+          enum: string[];
+          description: string;
+        };
+        hash: {
+          type: string;
+          minLength: number;
+          maxLength: number;
+          description: string;
+        };
+        text: {
+          type: string;
+          maxLength: number;
+          description: string;
+        };
+        count: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+      };
+    };
+    LocalTrigger: {
+      type: string;
+      title: string;
+      additionalProperties: boolean;
+      required: string[];
+      description: string;
+      properties: {
+        signal: {
+          type: string;
+          enum: string[];
+          description: string;
+        };
+        observedAt: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        valueMs: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        thresholdMs: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        intervals: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+      };
+    };
+    AgentResources: {
+      title: string;
+      type: string;
+      additionalProperties: boolean;
+      description: string;
+      properties: {
+        droppedBatches: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        rejectedBatches: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        failedBatches: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        internalErrors: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        bufferBytes: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        hookMsPerRequest: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        shed: {
+          type: string;
+          enum: string[];
+          description: string;
+        };
+        shedReason: {
+          type: string;
+          enum: string[];
+          description: string;
+        };
+      };
+    };
+  };
+};
+/**
+ * The JSON Schema for what the cloud answers. A contract since 0.8.0, when the answer started carrying the
+ * captures the cloud is waiting for: an agent that ignores this body behaves exactly as it always did.
+ */
+declare const INGEST_RESPONSE_SCHEMA_V0: {
+  $schema: string;
+  $id: string;
+  title: string;
+  description: string;
+  type: string;
+  additionalProperties: boolean;
+  required: string[];
+  properties: {
+    accepted: {
+      type: string;
+      minimum: number;
+      description: string;
+    };
+    inserted: {
+      type: string;
+      minimum: number;
+      description: string;
+    };
+    captures: {
+      type: string;
+      maxItems: number;
+      items: {
+        $ref: string;
+      };
+      description: string;
+    };
+  };
+  $defs: {
+    PendingCapture: {
+      type: string;
+      title: string;
+      additionalProperties: boolean;
+      required: string[];
+      properties: {
+        id: {
+          type: string;
+          minLength: number;
+          maxLength: number;
+          description: string;
+        };
+        environment: {
+          type: string;
+          maxLength: number;
+          description: string;
+        };
+        method: {
+          type: string;
+          maxLength: number;
+          description: string;
+        };
+        route: {
+          type: string;
+          maxLength: number;
+          description: string;
+        };
+        kind: {
+          type: string;
+          maxLength: number;
+          description: string;
+        };
+        target: {
+          type: string;
+          maxLength: number;
+          description: string;
+        };
+        windowSeconds: {
+          type: string;
+          minimum: number;
+          maximum: number;
+          description: string;
+        };
+        expiresAt: {
+          type: string;
+          format: string;
+          description: string;
+        };
+      };
+    };
+  };
+};
+/**
+ * The JSON Schema for a capture's evidence: the black box's fine detail, frozen and sent back. Its own path
+ * and its own contract, because a batch goes out every ten seconds and this is a rare event several orders of
+ * magnitude larger.
+ */
+declare const CAPTURE_EVIDENCE_SCHEMA_V0: {
+  $schema: string;
+  $id: string;
+  title: string;
+  description: string;
+  "x-evidence-path": string;
+  type: string;
+  additionalProperties: boolean;
+  required: string[];
+  properties: {
+    protocol: {
+      type: string;
+      description: string;
+      enum: string[];
+    };
+    instance: {
+      type: string;
+      additionalProperties: boolean;
+      required: string[];
+      description: string;
+      properties: {
+        id: {
+          type: string;
+          minLength: number;
+          maxLength: number;
+        };
+        hostname: {
+          type: string;
+          maxLength: number;
+        };
+        pid: {
+          type: string;
+          minimum: number;
+        };
+      };
+    };
+    startedAt: {
+      type: string;
+      format: string;
+      description: string;
+    };
+    endedAt: {
+      type: string;
+      format: string;
+      description: string;
+    };
+    coverage: {
+      $ref: string;
+    };
+    requests: {
+      type: string;
+      maxItems: number;
+      items: {
+        $ref: string;
+      };
+      description: string;
+    };
+    reference: {
+      $ref: string;
+    };
+  };
+  $defs: {
+    Coverage: {
+      type: string;
+      title: string;
+      additionalProperties: boolean;
+      required: string[];
+      description: string;
+      properties: {
+        observedRequests: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        attachedRequests: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        detailLost: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        truncated: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+      };
+    };
+    CapturedRequest: {
+      type: string;
+      title: string;
+      additionalProperties: boolean;
+      required: string[];
+      properties: {
+        method: {
+          type: string;
+          maxLength: number;
+        };
+        route: {
+          type: string;
+          maxLength: number;
+          description: string;
+        };
+        status: {
+          type: string;
+          minimum: number;
+          maximum: number;
+        };
+        startedAt: {
+          type: string;
+          format: string;
+          description: string;
+        };
+        durationMs: {
+          type: string;
+          minimum: number;
+        };
+        operations: {
+          type: string;
+          maxItems: number;
+          items: {
+            $ref: string;
+          };
+          description: string;
+        };
+        truncated: {
+          type: string;
+          description: string;
+        };
+        detailLost: {
+          type: string;
+          description: string;
+        };
+      };
+    };
+    CapturedOperation: {
+      type: string;
+      title: string;
+      additionalProperties: boolean;
+      required: string[];
+      description: string;
+      properties: {
+        hash: {
+          type: string;
+          minLength: number;
+          maxLength: number;
+          description: string;
+        };
+        startMs: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        endMs: {
+          type: string;
+          minimum: number;
+        };
+      };
+    };
+    Reference: {
+      type: string;
+      title: string;
+      additionalProperties: boolean;
+      required: string[];
+      description: string;
+      properties: {
+        selection: {
+          type: string;
+          enum: string[];
+          description: string;
+        };
+        population: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        routesDropped: {
+          type: string;
+          minimum: number;
+          description: string;
+        };
+        renewalPaused: {
+          type: string;
+          description: string;
+        };
+        samples: {
+          type: string;
+          maxItems: number;
+          items: {
+            $ref: string;
+          };
+          description: string;
+        };
       };
     };
   };
@@ -751,4 +1604,4 @@ declare function latencyBucket(ms: number): number;
 /** Index of the bucket a call count falls into: first boundary >= count, else the open-ended last bucket. */
 declare function callsPerRequestBucket(calls: number): number;
 //#endregion
-export { ACCEPTED_PROTOCOL_VERSIONS_V0, AGGREGATES_PATH, AGGREGATES_SCHEMA_V0, type AgentInfo, type AggregatesBatch, CALLS_PER_REQUEST_BOUNDARIES_V0, CALLS_PER_REQUEST_BUCKETS_V0, type Dependency, type DeployInfo, type Endpoint, type InstanceInfo, type Interval, LATENCY_BOUNDARIES_V0, LATENCY_BUCKETS_V0, type LatencyHistogram, PROTOCOL_VERSION, type PostgresStats, type RuntimeHealth, type StatusClasses, callsPerRequestBucket, latencyBucket };
+export { ACCEPTED_PROTOCOL_VERSIONS_V0, AGGREGATES_PATH, AGGREGATES_SCHEMA_V0, type AgentInfo, type AgentResources, type AggregatesBatch, CALLS_PER_REQUEST_BOUNDARIES_V0, CALLS_PER_REQUEST_BUCKETS_V0, CAPTURE_EVIDENCE_PATH, CAPTURE_EVIDENCE_SCHEMA_V0, type CaptureCoverage, type CaptureEvidence, type CaptureProgress, type CapturedOperation, type CapturedRequest, type Dependency, type DeployInfo, type Endpoint, INGEST_RESPONSE_SCHEMA_V0, type IngestResponse, type InstanceInfo, type Interval, LATENCY_BOUNDARIES_V0, LATENCY_BUCKETS_V0, type LatencyHistogram, type LocalTrigger, type ObserverState, type Observers, type Operation, PROTOCOL_VERSION, type PendingCapture, type PostgresStats, type Profile, type ProfileEndpoint, type RuntimeHealth, type StatusClasses, callsPerRequestBucket, captureEvidencePath, latencyBucket };