effect-inspect 0.1.0

package/dist/protocol/Schema.d.ts

@@ -0,0 +1,1237 @@
+/**
+ * The effect-inspect wire protocol.
+ *
+ * Three unions: {@link ClientMessage} (instrumented program → collector),
+ * {@link CollectorMessage} (collector → instrumented program) and
+ * {@link WebappMessage} (collector → webapp).
+ *
+ * Informed by `effect/devtools/DevToolsSchema` but deliberately different:
+ * spans are delta-encoded as `SpanStart` / `SpanEnd` rather than a full span
+ * snapshot re-sent on end, every message carries a `sessionId`, and attribute
+ * values are a bounded {@link Json} union instead of `Schema.Any`.
+ */
+import { Schema } from 'effect';
+/**
+ * Monotonic nanosecond timestamp, matching `Tracer.Span#startTime`.
+ *
+ * Carried as a decimal string on the wire because JSON numbers cannot hold
+ * nanos without precision loss.
+ */
+export declare const Timestamp: Schema.BigIntFromString;
+export type Timestamp = Schema.Schema.Type<typeof Timestamp>;
+/**
+ * A JSON value.
+ *
+ * Attribute and annotation values are bounded to this rather than
+ * `Schema.Any`: anything unrepresentable (a function, a symbol, a class
+ * instance, a `bigint`) is stringified by the producer at the edge, so a
+ * decoder never has to guess.
+ */
+export type Json = string | number | boolean | null | ReadonlyArray<Json> | {
+    readonly [key: string]: Json;
+};
+export declare const Json: Schema.Codec<Json>;
+/** Span attributes, log annotations, and metric/event attributes. */
+export declare const Attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+export type Attributes = Schema.Schema.Type<typeof Attributes>;
+/** Identifies one run of an instrumented program. */
+export declare const SessionId: Schema.String;
+export type SessionId = Schema.Schema.Type<typeof SessionId>;
+/** Mirrors `Tracer.SpanKind`. */
+export declare const SpanKind: Schema.Literals<readonly ["internal", "server", "client", "producer", "consumer"]>;
+export type SpanKind = Schema.Schema.Type<typeof SpanKind>;
+/** Mirrors `LogLevel.LogLevel`. */
+export declare const LogLevel: Schema.Literals<readonly ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace", "None"]>;
+export type LogLevel = Schema.Schema.Type<typeof LogLevel>;
+/**
+ * Wall-clock anchor for a session's monotonic clock.
+ *
+ * `startTime` is nanos from the same monotonic source as span times;
+ * `wallClockEpochMillis` is `Date.now()` sampled at the same instant. Together
+ * they let the webapp render absolute times and align sessions with each other.
+ */
+export declare const Clock: Schema.Struct<{
+    readonly startTime: Schema.BigIntFromString;
+    readonly wallClockEpochMillis: Schema.Natural;
+}>;
+export type Clock = Schema.Schema.Type<typeof Clock>;
+/** First message on a client connection; opens the session. */
+export declare const Hello: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Hello">;
+    readonly program: Schema.String;
+    readonly pid: Schema.Natural;
+    readonly runtime: Schema.String;
+    readonly protocolVersion: Schema.Natural;
+    readonly clock: Schema.Struct<{
+        readonly startTime: Schema.BigIntFromString;
+        readonly wallClockEpochMillis: Schema.Natural;
+    }>;
+}>;
+export type Hello = Schema.Schema.Type<typeof Hello>;
+/** The protocol version a `Hello` must carry. Bump on any breaking change. */
+export declare const protocolVersion = 1;
+/**
+ * A span parent that lives outside this session's span tree — propagated from
+ * another tracing system, so the collector has ids but no span body.
+ */
+export declare const ExternalParent: Schema.Struct<{
+    readonly _tag: Schema.tag<"ExternalParent">;
+    readonly spanId: Schema.String;
+    readonly traceId: Schema.String;
+    readonly sampled: Schema.Boolean;
+}>;
+export type ExternalParent = Schema.Schema.Type<typeof ExternalParent>;
+/** A span parent within this session, referenced by id only. */
+export declare const LocalParent: Schema.Struct<{
+    readonly _tag: Schema.tag<"LocalParent">;
+    readonly spanId: Schema.String;
+}>;
+export type LocalParent = Schema.Schema.Type<typeof LocalParent>;
+export declare const SpanParent: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"LocalParent">;
+    readonly spanId: Schema.String;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"ExternalParent">;
+    readonly spanId: Schema.String;
+    readonly traceId: Schema.String;
+    readonly sampled: Schema.Boolean;
+}>]>;
+export type SpanParent = Schema.Schema.Type<typeof SpanParent>;
+/**
+ * A span opened. Sent once, when the span starts — never re-sent.
+ *
+ * `parent` is absent for a root span.
+ */
+export declare const SpanStart: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"SpanStart">;
+    readonly spanId: Schema.String;
+    readonly traceId: Schema.String;
+    readonly parent: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"LocalParent">;
+        readonly spanId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"ExternalParent">;
+        readonly spanId: Schema.String;
+        readonly traceId: Schema.String;
+        readonly sampled: Schema.Boolean;
+    }>]>>;
+    readonly name: Schema.String;
+    readonly kind: Schema.Literals<readonly ["internal", "server", "client", "producer", "consumer"]>;
+    readonly startTime: Schema.BigIntFromString;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    readonly sampled: Schema.Boolean;
+    readonly fiberId: Schema.optional<Schema.Natural>;
+}>;
+export type SpanStart = Schema.Schema.Type<typeof SpanStart>;
+/**
+ * How a span finished.
+ *
+ * The full `Cause` is not carried: the webapp only needs to colour the span and
+ * show a message, so the producer flattens failures to `error` (rendered
+ * message) plus optional `stack`. `_tag: "Failure"` covers expected errors,
+ * defects and interrupts alike, distinguished by `kind`.
+ */
+export declare const SpanOutcomeSuccess: Schema.Struct<{
+    readonly _tag: Schema.tag<"Success">;
+}>;
+export type SpanOutcomeSuccess = Schema.Schema.Type<typeof SpanOutcomeSuccess>;
+export declare const SpanOutcomeFailure: Schema.Struct<{
+    readonly _tag: Schema.tag<"Failure">;
+    readonly kind: Schema.Literals<readonly ["Fail", "Die", "Interrupt"]>;
+    readonly error: Schema.String;
+    readonly stack: Schema.optional<Schema.String>;
+}>;
+export type SpanOutcomeFailure = Schema.Schema.Type<typeof SpanOutcomeFailure>;
+export declare const SpanOutcome: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"Success">;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"Failure">;
+    readonly kind: Schema.Literals<readonly ["Fail", "Die", "Interrupt"]>;
+    readonly error: Schema.String;
+    readonly stack: Schema.optional<Schema.String>;
+}>]>;
+export type SpanOutcome = Schema.Schema.Type<typeof SpanOutcome>;
+/**
+ * A span closed.
+ *
+ * `attributes` carries only attributes added after `SpanStart` was sent; the
+ * collector merges them over the ones it already has.
+ */
+export declare const SpanEnd: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"SpanEnd">;
+    readonly spanId: Schema.String;
+    readonly endTime: Schema.BigIntFromString;
+    readonly outcome: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Success">;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Failure">;
+        readonly kind: Schema.Literals<readonly ["Fail", "Die", "Interrupt"]>;
+        readonly error: Schema.String;
+        readonly stack: Schema.optional<Schema.String>;
+    }>]>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+}>;
+export type SpanEnd = Schema.Schema.Type<typeof SpanEnd>;
+/** A point-in-time event recorded against a span. */
+export declare const SpanEvent: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"SpanEvent">;
+    readonly spanId: Schema.String;
+    readonly name: Schema.String;
+    readonly time: Schema.BigIntFromString;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+}>;
+export type SpanEvent = Schema.Schema.Type<typeof SpanEvent>;
+/** A log record, in the same ordered stream as spans. */
+export declare const Log: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Log">;
+    readonly time: Schema.BigIntFromString;
+    readonly level: Schema.Literals<readonly ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace", "None"]>;
+    readonly message: Schema.Codec<Json, Json, never, never>;
+    readonly spanId: Schema.optional<Schema.String>;
+    readonly fiberId: Schema.optional<Schema.Natural>;
+    readonly annotations: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+}>;
+export type Log = Schema.Schema.Type<typeof Log>;
+export declare const Counter: Schema.Struct<{
+    readonly type: Schema.tag<"Counter">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly count: Schema.Natural;
+        readonly incremental: Schema.Boolean;
+    }>;
+}>;
+export type Counter = Schema.Schema.Type<typeof Counter>;
+export declare const Gauge: Schema.Struct<{
+    readonly type: Schema.tag<"Gauge">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly value: Schema.Finite;
+    }>;
+}>;
+export type Gauge = Schema.Schema.Type<typeof Gauge>;
+export declare const Histogram: Schema.Struct<{
+    readonly type: Schema.tag<"Histogram">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly buckets: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.Natural]>>;
+        readonly count: Schema.Natural;
+        readonly min: Schema.Finite;
+        readonly max: Schema.Finite;
+        readonly sum: Schema.Finite;
+    }>;
+}>;
+export type Histogram = Schema.Schema.Type<typeof Histogram>;
+export declare const Frequency: Schema.Struct<{
+    readonly type: Schema.tag<"Frequency">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly occurrences: Schema.$Record<Schema.String, Schema.Natural>;
+    }>;
+}>;
+export type Frequency = Schema.Schema.Type<typeof Frequency>;
+export declare const Summary: Schema.Struct<{
+    readonly type: Schema.tag<"Summary">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly quantiles: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.NullOr<Schema.Finite>]>>;
+        readonly count: Schema.Natural;
+        readonly min: Schema.Finite;
+        readonly max: Schema.Finite;
+        readonly sum: Schema.Finite;
+    }>;
+}>;
+export type Summary = Schema.Schema.Type<typeof Summary>;
+export declare const Metric: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.tag<"Counter">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly count: Schema.Natural;
+        readonly incremental: Schema.Boolean;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"Gauge">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly value: Schema.Finite;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"Histogram">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly buckets: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.Natural]>>;
+        readonly count: Schema.Natural;
+        readonly min: Schema.Finite;
+        readonly max: Schema.Finite;
+        readonly sum: Schema.Finite;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"Frequency">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly occurrences: Schema.$Record<Schema.String, Schema.Natural>;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"Summary">;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+    readonly state: Schema.Struct<{
+        readonly quantiles: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.NullOr<Schema.Finite>]>>;
+        readonly count: Schema.Natural;
+        readonly min: Schema.Finite;
+        readonly max: Schema.Finite;
+        readonly sum: Schema.Finite;
+    }>;
+}>]>;
+export type Metric = Schema.Schema.Type<typeof Metric>;
+/** A snapshot of every metric, taken at `time`. */
+export declare const Metrics: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Metrics">;
+    readonly time: Schema.BigIntFromString;
+    readonly metrics: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.tag<"Counter">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly count: Schema.Natural;
+            readonly incremental: Schema.Boolean;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"Gauge">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly value: Schema.Finite;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"Histogram">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly buckets: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.Natural]>>;
+            readonly count: Schema.Natural;
+            readonly min: Schema.Finite;
+            readonly max: Schema.Finite;
+            readonly sum: Schema.Finite;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"Frequency">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly occurrences: Schema.$Record<Schema.String, Schema.Natural>;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"Summary">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly quantiles: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.NullOr<Schema.Finite>]>>;
+            readonly count: Schema.Natural;
+            readonly min: Schema.Finite;
+            readonly max: Schema.Finite;
+            readonly sum: Schema.Finite;
+        }>;
+    }>]>>;
+}>;
+export type Metrics = Schema.Schema.Type<typeof Metrics>;
+/** A fiber lifecycle transition. */
+export declare const FiberEvent: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"FiberEvent">;
+    readonly fiberId: Schema.Natural;
+    readonly event: Schema.Literals<readonly ["Start", "End", "Suspend", "Resume"]>;
+    readonly parentFiberId: Schema.optional<Schema.Natural>;
+    readonly time: Schema.BigIntFromString;
+}>;
+export type FiberEvent = Schema.Schema.Type<typeof FiberEvent>;
+/**
+ * A `process.memoryUsage()` reading, sampled on an interval by the client.
+ *
+ * Node and Bun only: a runtime without `process.memoryUsage` emits none of
+ * these and a session simply has no memory track. Figures are bytes, as the
+ * runtime reports them; `time` shares the monotonic base of span times, so the
+ * webapp can draw the curve against the same x-axis as the flame chart.
+ */
+export declare const MemorySample: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"MemorySample">;
+    readonly time: Schema.BigIntFromString;
+    readonly heapUsed: Schema.Natural;
+    readonly heapTotal: Schema.Natural;
+    readonly rss: Schema.Natural;
+    readonly external: Schema.Natural;
+}>;
+export type MemorySample = Schema.Schema.Type<typeof MemorySample>;
+export declare const Ping: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Ping">;
+}>;
+export type Ping = Schema.Schema.Type<typeof Ping>;
+export declare const Pong: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Pong">;
+}>;
+export type Pong = Schema.Schema.Type<typeof Pong>;
+/** Asks the client for a {@link Metrics} snapshot. */
+export declare const MetricsRequest: Schema.Struct<{
+    readonly _tag: Schema.tag<"MetricsRequest">;
+}>;
+export type MetricsRequest = Schema.Schema.Type<typeof MetricsRequest>;
+/** Telemetry the instrumented program sends to the collector. */
+export declare const ClientMessage: Schema.Union<readonly [Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Hello">;
+    readonly program: Schema.String;
+    readonly pid: Schema.Natural;
+    readonly runtime: Schema.String;
+    readonly protocolVersion: Schema.Natural;
+    readonly clock: Schema.Struct<{
+        readonly startTime: Schema.BigIntFromString;
+        readonly wallClockEpochMillis: Schema.Natural;
+    }>;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"SpanStart">;
+    readonly spanId: Schema.String;
+    readonly traceId: Schema.String;
+    readonly parent: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"LocalParent">;
+        readonly spanId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"ExternalParent">;
+        readonly spanId: Schema.String;
+        readonly traceId: Schema.String;
+        readonly sampled: Schema.Boolean;
+    }>]>>;
+    readonly name: Schema.String;
+    readonly kind: Schema.Literals<readonly ["internal", "server", "client", "producer", "consumer"]>;
+    readonly startTime: Schema.BigIntFromString;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    readonly sampled: Schema.Boolean;
+    readonly fiberId: Schema.optional<Schema.Natural>;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"SpanEnd">;
+    readonly spanId: Schema.String;
+    readonly endTime: Schema.BigIntFromString;
+    readonly outcome: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Success">;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Failure">;
+        readonly kind: Schema.Literals<readonly ["Fail", "Die", "Interrupt"]>;
+        readonly error: Schema.String;
+        readonly stack: Schema.optional<Schema.String>;
+    }>]>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"SpanEvent">;
+    readonly spanId: Schema.String;
+    readonly name: Schema.String;
+    readonly time: Schema.BigIntFromString;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Log">;
+    readonly time: Schema.BigIntFromString;
+    readonly level: Schema.Literals<readonly ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace", "None"]>;
+    readonly message: Schema.Codec<Json, Json, never, never>;
+    readonly spanId: Schema.optional<Schema.String>;
+    readonly fiberId: Schema.optional<Schema.Natural>;
+    readonly annotations: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Metrics">;
+    readonly time: Schema.BigIntFromString;
+    readonly metrics: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.tag<"Counter">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly count: Schema.Natural;
+            readonly incremental: Schema.Boolean;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"Gauge">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly value: Schema.Finite;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"Histogram">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly buckets: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.Natural]>>;
+            readonly count: Schema.Natural;
+            readonly min: Schema.Finite;
+            readonly max: Schema.Finite;
+            readonly sum: Schema.Finite;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"Frequency">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly occurrences: Schema.$Record<Schema.String, Schema.Natural>;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"Summary">;
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+        readonly state: Schema.Struct<{
+            readonly quantiles: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.NullOr<Schema.Finite>]>>;
+            readonly count: Schema.Natural;
+            readonly min: Schema.Finite;
+            readonly max: Schema.Finite;
+            readonly sum: Schema.Finite;
+        }>;
+    }>]>>;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"FiberEvent">;
+    readonly fiberId: Schema.Natural;
+    readonly event: Schema.Literals<readonly ["Start", "End", "Suspend", "Resume"]>;
+    readonly parentFiberId: Schema.optional<Schema.Natural>;
+    readonly time: Schema.BigIntFromString;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"MemorySample">;
+    readonly time: Schema.BigIntFromString;
+    readonly heapUsed: Schema.Natural;
+    readonly heapTotal: Schema.Natural;
+    readonly rss: Schema.Natural;
+    readonly external: Schema.Natural;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Ping">;
+}>]>;
+export type ClientMessage = Schema.Schema.Type<typeof ClientMessage>;
+/** What the collector sends back to the instrumented program. */
+export declare const CollectorMessage: Schema.Union<readonly [Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Pong">;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"MetricsRequest">;
+}>]>;
+export type CollectorMessage = Schema.Schema.Type<typeof CollectorMessage>;
+/** A session the collector knows about, as listed to the webapp. */
+export declare const Session: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly program: Schema.String;
+    readonly pid: Schema.Natural;
+    readonly runtime: Schema.String;
+    readonly clock: Schema.Struct<{
+        readonly startTime: Schema.BigIntFromString;
+        readonly wallClockEpochMillis: Schema.Natural;
+    }>;
+    readonly active: Schema.Boolean;
+    readonly endedAtEpochMillis: Schema.optional<Schema.Natural>;
+}>;
+export type Session = Schema.Schema.Type<typeof Session>;
+/** Every session the collector holds. Sent on connect and on change. */
+export declare const SessionList: Schema.Struct<{
+    readonly _tag: Schema.tag<"SessionList">;
+    readonly sessions: Schema.$Array<Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly program: Schema.String;
+        readonly pid: Schema.Natural;
+        readonly runtime: Schema.String;
+        readonly clock: Schema.Struct<{
+            readonly startTime: Schema.BigIntFromString;
+            readonly wallClockEpochMillis: Schema.Natural;
+        }>;
+        readonly active: Schema.Boolean;
+        readonly endedAtEpochMillis: Schema.optional<Schema.Natural>;
+    }>>;
+}>;
+export type SessionList = Schema.Schema.Type<typeof SessionList>;
+/**
+ * Everything already recorded for a session, replayed in arrival order.
+ *
+ * Sent once when the webapp subscribes, before any live telemetry for that
+ * session. `complete` is false when the backlog is split across several
+ * messages, so the webapp knows more is coming.
+ */
+export declare const Backlog: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Backlog">;
+    readonly messages: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Hello">;
+        readonly program: Schema.String;
+        readonly pid: Schema.Natural;
+        readonly runtime: Schema.String;
+        readonly protocolVersion: Schema.Natural;
+        readonly clock: Schema.Struct<{
+            readonly startTime: Schema.BigIntFromString;
+            readonly wallClockEpochMillis: Schema.Natural;
+        }>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanStart">;
+        readonly spanId: Schema.String;
+        readonly traceId: Schema.String;
+        readonly parent: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"LocalParent">;
+            readonly spanId: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"ExternalParent">;
+            readonly spanId: Schema.String;
+            readonly traceId: Schema.String;
+            readonly sampled: Schema.Boolean;
+        }>]>>;
+        readonly name: Schema.String;
+        readonly kind: Schema.Literals<readonly ["internal", "server", "client", "producer", "consumer"]>;
+        readonly startTime: Schema.BigIntFromString;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+        readonly sampled: Schema.Boolean;
+        readonly fiberId: Schema.optional<Schema.Natural>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanEnd">;
+        readonly spanId: Schema.String;
+        readonly endTime: Schema.BigIntFromString;
+        readonly outcome: Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"Success">;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Failure">;
+            readonly kind: Schema.Literals<readonly ["Fail", "Die", "Interrupt"]>;
+            readonly error: Schema.String;
+            readonly stack: Schema.optional<Schema.String>;
+        }>]>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanEvent">;
+        readonly spanId: Schema.String;
+        readonly name: Schema.String;
+        readonly time: Schema.BigIntFromString;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Log">;
+        readonly time: Schema.BigIntFromString;
+        readonly level: Schema.Literals<readonly ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace", "None"]>;
+        readonly message: Schema.Codec<Json, Json, never, never>;
+        readonly spanId: Schema.optional<Schema.String>;
+        readonly fiberId: Schema.optional<Schema.Natural>;
+        readonly annotations: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Metrics">;
+        readonly time: Schema.BigIntFromString;
+        readonly metrics: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.tag<"Counter">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly count: Schema.Natural;
+                readonly incremental: Schema.Boolean;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Gauge">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly value: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Histogram">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly buckets: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.Natural]>>;
+                readonly count: Schema.Natural;
+                readonly min: Schema.Finite;
+                readonly max: Schema.Finite;
+                readonly sum: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Frequency">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly occurrences: Schema.$Record<Schema.String, Schema.Natural>;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Summary">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly quantiles: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.NullOr<Schema.Finite>]>>;
+                readonly count: Schema.Natural;
+                readonly min: Schema.Finite;
+                readonly max: Schema.Finite;
+                readonly sum: Schema.Finite;
+            }>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"FiberEvent">;
+        readonly fiberId: Schema.Natural;
+        readonly event: Schema.Literals<readonly ["Start", "End", "Suspend", "Resume"]>;
+        readonly parentFiberId: Schema.optional<Schema.Natural>;
+        readonly time: Schema.BigIntFromString;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"MemorySample">;
+        readonly time: Schema.BigIntFromString;
+        readonly heapUsed: Schema.Natural;
+        readonly heapTotal: Schema.Natural;
+        readonly rss: Schema.Natural;
+        readonly external: Schema.Natural;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Ping">;
+    }>]>>;
+    readonly complete: Schema.Boolean;
+}>;
+export type Backlog = Schema.Schema.Type<typeof Backlog>;
+/** A live client message forwarded to the webapp as it arrives. */
+export declare const Live: Schema.Struct<{
+    readonly _tag: Schema.tag<"Live">;
+    readonly message: Schema.Union<readonly [Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Hello">;
+        readonly program: Schema.String;
+        readonly pid: Schema.Natural;
+        readonly runtime: Schema.String;
+        readonly protocolVersion: Schema.Natural;
+        readonly clock: Schema.Struct<{
+            readonly startTime: Schema.BigIntFromString;
+            readonly wallClockEpochMillis: Schema.Natural;
+        }>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanStart">;
+        readonly spanId: Schema.String;
+        readonly traceId: Schema.String;
+        readonly parent: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"LocalParent">;
+            readonly spanId: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"ExternalParent">;
+            readonly spanId: Schema.String;
+            readonly traceId: Schema.String;
+            readonly sampled: Schema.Boolean;
+        }>]>>;
+        readonly name: Schema.String;
+        readonly kind: Schema.Literals<readonly ["internal", "server", "client", "producer", "consumer"]>;
+        readonly startTime: Schema.BigIntFromString;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+        readonly sampled: Schema.Boolean;
+        readonly fiberId: Schema.optional<Schema.Natural>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanEnd">;
+        readonly spanId: Schema.String;
+        readonly endTime: Schema.BigIntFromString;
+        readonly outcome: Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"Success">;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Failure">;
+            readonly kind: Schema.Literals<readonly ["Fail", "Die", "Interrupt"]>;
+            readonly error: Schema.String;
+            readonly stack: Schema.optional<Schema.String>;
+        }>]>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanEvent">;
+        readonly spanId: Schema.String;
+        readonly name: Schema.String;
+        readonly time: Schema.BigIntFromString;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Log">;
+        readonly time: Schema.BigIntFromString;
+        readonly level: Schema.Literals<readonly ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace", "None"]>;
+        readonly message: Schema.Codec<Json, Json, never, never>;
+        readonly spanId: Schema.optional<Schema.String>;
+        readonly fiberId: Schema.optional<Schema.Natural>;
+        readonly annotations: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Metrics">;
+        readonly time: Schema.BigIntFromString;
+        readonly metrics: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.tag<"Counter">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly count: Schema.Natural;
+                readonly incremental: Schema.Boolean;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Gauge">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly value: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Histogram">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly buckets: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.Natural]>>;
+                readonly count: Schema.Natural;
+                readonly min: Schema.Finite;
+                readonly max: Schema.Finite;
+                readonly sum: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Frequency">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly occurrences: Schema.$Record<Schema.String, Schema.Natural>;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Summary">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly quantiles: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.NullOr<Schema.Finite>]>>;
+                readonly count: Schema.Natural;
+                readonly min: Schema.Finite;
+                readonly max: Schema.Finite;
+                readonly sum: Schema.Finite;
+            }>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"FiberEvent">;
+        readonly fiberId: Schema.Natural;
+        readonly event: Schema.Literals<readonly ["Start", "End", "Suspend", "Resume"]>;
+        readonly parentFiberId: Schema.optional<Schema.Natural>;
+        readonly time: Schema.BigIntFromString;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"MemorySample">;
+        readonly time: Schema.BigIntFromString;
+        readonly heapUsed: Schema.Natural;
+        readonly heapTotal: Schema.Natural;
+        readonly rss: Schema.Natural;
+        readonly external: Schema.Natural;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Ping">;
+    }>]>;
+}>;
+export type Live = Schema.Schema.Type<typeof Live>;
+/**
+ * A session ended — its program exited or its connection dropped.
+ *
+ * **Nothing emits this.** The collector marks the session `active: false` and
+ * re-sends the whole {@link SessionList} on every change, which already tells
+ * the webapp everything this message would. The variant is kept because the
+ * protocol is extended additively and removing it would break the union for
+ * anyone decoding an older stream; the webapp handler for it was deleted
+ * rather than left looking implemented.
+ */
+export declare const SessionEnded: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"SessionEnded">;
+    readonly endedAtEpochMillis: Schema.Natural;
+}>;
+export type SessionEnded = Schema.Schema.Type<typeof SessionEnded>;
+/** What the collector sends to the webapp. */
+export declare const WebappMessage: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"SessionList">;
+    readonly sessions: Schema.$Array<Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly program: Schema.String;
+        readonly pid: Schema.Natural;
+        readonly runtime: Schema.String;
+        readonly clock: Schema.Struct<{
+            readonly startTime: Schema.BigIntFromString;
+            readonly wallClockEpochMillis: Schema.Natural;
+        }>;
+        readonly active: Schema.Boolean;
+        readonly endedAtEpochMillis: Schema.optional<Schema.Natural>;
+    }>>;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Backlog">;
+    readonly messages: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Hello">;
+        readonly program: Schema.String;
+        readonly pid: Schema.Natural;
+        readonly runtime: Schema.String;
+        readonly protocolVersion: Schema.Natural;
+        readonly clock: Schema.Struct<{
+            readonly startTime: Schema.BigIntFromString;
+            readonly wallClockEpochMillis: Schema.Natural;
+        }>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanStart">;
+        readonly spanId: Schema.String;
+        readonly traceId: Schema.String;
+        readonly parent: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"LocalParent">;
+            readonly spanId: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"ExternalParent">;
+            readonly spanId: Schema.String;
+            readonly traceId: Schema.String;
+            readonly sampled: Schema.Boolean;
+        }>]>>;
+        readonly name: Schema.String;
+        readonly kind: Schema.Literals<readonly ["internal", "server", "client", "producer", "consumer"]>;
+        readonly startTime: Schema.BigIntFromString;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+        readonly sampled: Schema.Boolean;
+        readonly fiberId: Schema.optional<Schema.Natural>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanEnd">;
+        readonly spanId: Schema.String;
+        readonly endTime: Schema.BigIntFromString;
+        readonly outcome: Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"Success">;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Failure">;
+            readonly kind: Schema.Literals<readonly ["Fail", "Die", "Interrupt"]>;
+            readonly error: Schema.String;
+            readonly stack: Schema.optional<Schema.String>;
+        }>]>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanEvent">;
+        readonly spanId: Schema.String;
+        readonly name: Schema.String;
+        readonly time: Schema.BigIntFromString;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Log">;
+        readonly time: Schema.BigIntFromString;
+        readonly level: Schema.Literals<readonly ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace", "None"]>;
+        readonly message: Schema.Codec<Json, Json, never, never>;
+        readonly spanId: Schema.optional<Schema.String>;
+        readonly fiberId: Schema.optional<Schema.Natural>;
+        readonly annotations: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Metrics">;
+        readonly time: Schema.BigIntFromString;
+        readonly metrics: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.tag<"Counter">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly count: Schema.Natural;
+                readonly incremental: Schema.Boolean;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Gauge">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly value: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Histogram">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly buckets: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.Natural]>>;
+                readonly count: Schema.Natural;
+                readonly min: Schema.Finite;
+                readonly max: Schema.Finite;
+                readonly sum: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Frequency">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly occurrences: Schema.$Record<Schema.String, Schema.Natural>;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Summary">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly quantiles: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.NullOr<Schema.Finite>]>>;
+                readonly count: Schema.Natural;
+                readonly min: Schema.Finite;
+                readonly max: Schema.Finite;
+                readonly sum: Schema.Finite;
+            }>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"FiberEvent">;
+        readonly fiberId: Schema.Natural;
+        readonly event: Schema.Literals<readonly ["Start", "End", "Suspend", "Resume"]>;
+        readonly parentFiberId: Schema.optional<Schema.Natural>;
+        readonly time: Schema.BigIntFromString;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"MemorySample">;
+        readonly time: Schema.BigIntFromString;
+        readonly heapUsed: Schema.Natural;
+        readonly heapTotal: Schema.Natural;
+        readonly rss: Schema.Natural;
+        readonly external: Schema.Natural;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Ping">;
+    }>]>>;
+    readonly complete: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"Live">;
+    readonly message: Schema.Union<readonly [Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Hello">;
+        readonly program: Schema.String;
+        readonly pid: Schema.Natural;
+        readonly runtime: Schema.String;
+        readonly protocolVersion: Schema.Natural;
+        readonly clock: Schema.Struct<{
+            readonly startTime: Schema.BigIntFromString;
+            readonly wallClockEpochMillis: Schema.Natural;
+        }>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanStart">;
+        readonly spanId: Schema.String;
+        readonly traceId: Schema.String;
+        readonly parent: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"LocalParent">;
+            readonly spanId: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"ExternalParent">;
+            readonly spanId: Schema.String;
+            readonly traceId: Schema.String;
+            readonly sampled: Schema.Boolean;
+        }>]>>;
+        readonly name: Schema.String;
+        readonly kind: Schema.Literals<readonly ["internal", "server", "client", "producer", "consumer"]>;
+        readonly startTime: Schema.BigIntFromString;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+        readonly sampled: Schema.Boolean;
+        readonly fiberId: Schema.optional<Schema.Natural>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanEnd">;
+        readonly spanId: Schema.String;
+        readonly endTime: Schema.BigIntFromString;
+        readonly outcome: Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"Success">;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Failure">;
+            readonly kind: Schema.Literals<readonly ["Fail", "Die", "Interrupt"]>;
+            readonly error: Schema.String;
+            readonly stack: Schema.optional<Schema.String>;
+        }>]>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"SpanEvent">;
+        readonly spanId: Schema.String;
+        readonly name: Schema.String;
+        readonly time: Schema.BigIntFromString;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Log">;
+        readonly time: Schema.BigIntFromString;
+        readonly level: Schema.Literals<readonly ["All", "Fatal", "Error", "Warn", "Info", "Debug", "Trace", "None"]>;
+        readonly message: Schema.Codec<Json, Json, never, never>;
+        readonly spanId: Schema.optional<Schema.String>;
+        readonly fiberId: Schema.optional<Schema.Natural>;
+        readonly annotations: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Metrics">;
+        readonly time: Schema.BigIntFromString;
+        readonly metrics: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.tag<"Counter">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly count: Schema.Natural;
+                readonly incremental: Schema.Boolean;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Gauge">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly value: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Histogram">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly buckets: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.Natural]>>;
+                readonly count: Schema.Natural;
+                readonly min: Schema.Finite;
+                readonly max: Schema.Finite;
+                readonly sum: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Frequency">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly occurrences: Schema.$Record<Schema.String, Schema.Natural>;
+            }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"Summary">;
+            readonly name: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly state: Schema.Struct<{
+                readonly quantiles: Schema.$Array<Schema.Tuple<readonly [Schema.Finite, Schema.NullOr<Schema.Finite>]>>;
+                readonly count: Schema.Natural;
+                readonly min: Schema.Finite;
+                readonly max: Schema.Finite;
+                readonly sum: Schema.Finite;
+            }>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"FiberEvent">;
+        readonly fiberId: Schema.Natural;
+        readonly event: Schema.Literals<readonly ["Start", "End", "Suspend", "Resume"]>;
+        readonly parentFiberId: Schema.optional<Schema.Natural>;
+        readonly time: Schema.BigIntFromString;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"MemorySample">;
+        readonly time: Schema.BigIntFromString;
+        readonly heapUsed: Schema.Natural;
+        readonly heapTotal: Schema.Natural;
+        readonly rss: Schema.Natural;
+        readonly external: Schema.Natural;
+    }>, Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly _tag: Schema.tag<"Ping">;
+    }>]>;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"SessionEnded">;
+    readonly endedAtEpochMillis: Schema.Natural;
+}>]>;
+export type WebappMessage = Schema.Schema.Type<typeof WebappMessage>;
+/** Asks the collector to stream one session: its backlog, then live messages. */
+export declare const Subscribe: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Subscribe">;
+}>;
+export type Subscribe = Schema.Schema.Type<typeof Subscribe>;
+/** Stops the stream started by {@link Subscribe}. */
+export declare const Unsubscribe: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Unsubscribe">;
+}>;
+export type Unsubscribe = Schema.Schema.Type<typeof Unsubscribe>;
+/** What the webapp sends to the collector. */
+export declare const WebappRequest: Schema.Union<readonly [Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Subscribe">;
+}>, Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly _tag: Schema.tag<"Unsubscribe">;
+}>]>;
+export type WebappRequest = Schema.Schema.Type<typeof WebappRequest>;
+/**
+ * Line 1 of a saved trace file.
+ *
+ * The rest of the file is {@link ClientMessage} NDJSON, byte-identical to what
+ * the wire carries — a trace file is the protocol message stream with a header
+ * on top, not a second representation of a trace. So any new `ClientMessage`
+ * variant is carried by a saved trace for free, and {@link traceFileFormatVersion}
+ * only moves if *this* struct or the line layout changes.
+ *
+ * The full {@link Session} is embedded because a loaded trace has no
+ * `SessionList` to get its `clock` from, and without the clock the webapp
+ * cannot show absolute times.
+ */
+export declare const TraceFileHeader: Schema.Struct<{
+    readonly _tag: Schema.tag<"TraceFileHeader">;
+    readonly formatVersion: Schema.Natural;
+    /** {@link protocolVersion} at save time. Recorded for diagnosis, not enforced. */
+    readonly protocolVersion: Schema.Natural;
+    readonly session: Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly program: Schema.String;
+        readonly pid: Schema.Natural;
+        readonly runtime: Schema.String;
+        readonly clock: Schema.Struct<{
+            readonly startTime: Schema.BigIntFromString;
+            readonly wallClockEpochMillis: Schema.Natural;
+        }>;
+        readonly active: Schema.Boolean;
+        readonly endedAtEpochMillis: Schema.optional<Schema.Natural>;
+    }>;
+    readonly savedAtEpochMillis: Schema.Natural;
+}>;
+export type TraceFileHeader = Schema.Schema.Type<typeof TraceFileHeader>;
+/** The trace file layout version. Bump only on a change to the header or the line layout. */
+export declare const traceFileFormatVersion = 1;