@earendil-works/chord 1.5.0 → 1.5.1

package/dist/telemetry.d.ts

@@ -0,0 +1,937 @@
+import { type SchemaTelemetryCounter, type SchemaTelemetrySpan, type TelemetryCarrier, type TelemetryContext, type TelemetryMetrics, type TelemetrySchemaSpanName, type TelemetrySchemaSpanStartAttributes, type TelemetrySpan, type TypedSpanStarter, type TypedTelemetryMetrics } from "@earendil-works/pi-telemetry";
+import type { Address } from "./contracts/index.ts";
+/** A span of Chord's schema, its end attributes and events typed. */
+export type ChordSpan<N extends ChordSpanName> = SchemaTelemetrySpan<typeof CHORD_TELEMETRY_SCHEMA, N>;
+/** The names of Chord's spans. */
+export type ChordSpanName = TelemetrySchemaSpanName<typeof CHORD_TELEMETRY_SCHEMA>;
+/** Chord's instruments on one adapter's metrics, typed by its schema. */
+export type ChordMetrics = TypedTelemetryMetrics<readonly [typeof CHORD_TELEMETRY_SCHEMA]>;
+/** One of Chord's counters (or up/down counters), its attributes typed. */
+export type ChordCounter<N extends keyof (typeof CHORD_TELEMETRY_SCHEMA)["metrics"]> = SchemaTelemetryCounter<(typeof CHORD_TELEMETRY_SCHEMA)["metrics"][N]>;
+/** Chord's span, event and metric vocabulary (§29). Ids (objects, holds, calls, address keys) are span attributes only. */
+export declare const CHORD_TELEMETRY_SCHEMA: {
+    readonly version: 1;
+    readonly spans: {
+        readonly "chord.call": {
+            readonly description: "A consumer's call of a remote object's method, from the call until its reply.";
+            readonly parents: {
+                readonly kind: "any";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object type's name.";
+                };
+                readonly member: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The method's name.";
+                };
+                readonly object: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object: its type, and its params key when it has params.";
+                    readonly cardinality: "high";
+                };
+                readonly "address.kind": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The kind of the provider's host.";
+                };
+                readonly "chord.principal": {
+                    readonly type: "string";
+                    readonly required: false;
+                    readonly description: "Whom the call was for: its principal key, unless the host's `principalAttributes` hook records other attributes.";
+                    readonly cardinality: "high";
+                };
+            };
+            readonly endAttributes: {
+                outcome: {
+                    readonly type: "string";
+                    readonly values: readonly string[];
+                    readonly description: "How it ended; a cancel is no error (status ok).";
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.method": {
+            readonly description: "A provider running a method: under the call's carrier (over a link) or the caller's span (same host).";
+            readonly parents: {
+                readonly kind: "any";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object type's name.";
+                };
+                readonly member: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The method's name.";
+                };
+                readonly object: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object: its type, and its params key when it has params.";
+                    readonly cardinality: "high";
+                };
+                readonly "principal.kind": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The ctx's principal kind, or `none`.";
+                };
+                readonly "chord.principal": {
+                    readonly type: "string";
+                    readonly required: false;
+                    readonly description: "Whom the call was for: its principal key, unless the host's `principalAttributes` hook records other attributes.";
+                    readonly cardinality: "high";
+                };
+            };
+            readonly endAttributes: {
+                outcome: {
+                    readonly type: "string";
+                    readonly values: readonly string[];
+                    readonly description: "How it ended; a cancel is no error (status ok).";
+                };
+            };
+            readonly events: {
+                "chord.commit": {
+                    readonly description: "A commit of the span's object (documents and tables) inside the span's work.";
+                    readonly attributes: {
+                        readonly documents: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Documents the commit adopted.";
+                        };
+                        readonly ops: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Ops of the documents' prepared changes.";
+                        };
+                        readonly rows: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Table rows its writes changed: a `put` one, an update or delete the rows its statement changed.";
+                        };
+                        readonly duration: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Milliseconds from the commit's start to its adoption.";
+                        };
+                    };
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.relay": {
+            readonly description: "A relay forwarding a hold (until it is held upstream) or a call (until its reply came back), under the arriving carrier.";
+            readonly parents: {
+                readonly kind: "root_or_external";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object type's name.";
+                };
+                readonly member: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "`hold`, or a call's method as `#<index>` (a relay never knows names).";
+                };
+                readonly "upstream.kind": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The kind of the upstream host.";
+                };
+            };
+            readonly endAttributes: {
+                outcome: {
+                    readonly type: "string";
+                    readonly values: readonly string[];
+                    readonly description: "How it ended; a cancel is no error (status ok).";
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.hold": {
+            readonly description: "A consumer's hold of a remote object, until its first `bound` or failure.";
+            readonly parents: {
+                readonly kind: "any";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object type's name.";
+                };
+                readonly object: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object: its type, and its params key when it has params.";
+                    readonly cardinality: "high";
+                };
+                readonly "address.kind": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The kind of the provider's host.";
+                };
+            };
+            readonly endAttributes: {
+                outcome: {
+                    readonly type: "string";
+                    readonly values: readonly string[];
+                    readonly description: "How it ended; a cancel is no error (status ok).";
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.activate": {
+            readonly description: "One activation attempt until it is live, failed, parked or ended (a parked one resumes in a new span); linked to its object's first trigger.";
+            readonly parents: {
+                readonly kind: "root_or_external";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object type's name.";
+                };
+                readonly object: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object: its type, and its params key when it has params.";
+                    readonly cardinality: "high";
+                };
+                readonly attempt: {
+                    readonly type: "number";
+                    readonly required: true;
+                    readonly description: "The object's attempt, from 1.";
+                };
+            };
+            readonly endAttributes: {
+                outcome: {
+                    readonly type: "string";
+                    readonly values: readonly string[];
+                    readonly description: "How it ended; a cancel is no error (status ok).";
+                };
+            };
+            readonly events: {
+                "chord.park": {
+                    readonly description: "The attempt parked on a dependency that is not live.";
+                    readonly attributes: {
+                        readonly cause: {
+                            readonly type: "string";
+                            readonly required: true;
+                            readonly description: "`loading`, or the waiting cause's message.";
+                        };
+                    };
+                };
+                "chord.retry": {
+                    readonly description: "A transient failure: the next attempt waits for its backoff.";
+                    readonly attributes: {
+                        readonly backoff: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Milliseconds until the next attempt.";
+                        };
+                    };
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.open": {
+            readonly description: "One native's open, under its attempt's span.";
+            readonly parents: {
+                readonly kind: "spans";
+                readonly spans: readonly ["chord.activate"];
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object type's name.";
+                };
+                readonly native: {
+                    readonly type: "number";
+                    readonly required: true;
+                    readonly description: "The native's position, from 1.";
+                };
+            };
+            readonly endAttributes: {};
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.close": {
+            readonly description: "One native's close (a root: it runs at its attempt's teardown).";
+            readonly parents: {
+                readonly kind: "root_or_external";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object type's name.";
+                };
+                readonly native: {
+                    readonly type: "number";
+                    readonly required: true;
+                    readonly description: "The native's position, from 1.";
+                };
+                readonly reason: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly values: readonly ["end", "close", "reload"];
+                    readonly description: "Why.";
+                };
+            };
+            readonly endAttributes: {};
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.load": {
+            readonly description: "A host's `load`: the setups, the publication and the start barrier.";
+            readonly parents: {
+                readonly kind: "any";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly plugins: {
+                    readonly type: "number";
+                    readonly required: true;
+                    readonly description: "Plugins given.";
+                };
+            };
+            readonly endAttributes: {
+                readonly failed: {
+                    readonly type: "number";
+                    readonly description: "Plugins left out.";
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.reload": {
+            readonly description: "A host's `reload`: staging, the commit and every object's fate.";
+            readonly parents: {
+                readonly kind: "any";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly plugins: {
+                    readonly type: "number";
+                    readonly required: true;
+                    readonly description: "Plugins given.";
+                };
+            };
+            readonly endAttributes: {
+                readonly added: {
+                    readonly type: "number";
+                    readonly description: "Plugins added.";
+                };
+                readonly changed: {
+                    readonly type: "number";
+                    readonly description: "Plugins changed.";
+                };
+                readonly removed: {
+                    readonly type: "number";
+                    readonly description: "Plugins removed.";
+                };
+                readonly failed: {
+                    readonly type: "number";
+                    readonly description: "Plugins whose new code failed.";
+                };
+                readonly fates: {
+                    readonly type: "number";
+                    readonly description: "Objects that took a fate.";
+                };
+            };
+            readonly events: {
+                "chord.reload.fate": {
+                    readonly description: "One object's fate in a reload.";
+                    readonly attributes: {
+                        readonly object: {
+                            readonly type: "string";
+                            readonly required: true;
+                            readonly description: "The object: its type, and its params key when it has params.";
+                            readonly cardinality: "high";
+                        };
+                        readonly fate: {
+                            readonly type: "string";
+                            readonly required: true;
+                            readonly values: readonly ["restarted", "ended", "parked", "retried"];
+                            readonly description: "What the object did.";
+                        };
+                    };
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.resolve": {
+            readonly description: "A route resolving an address (a worker start included), linked to its first trigger.";
+            readonly parents: {
+                readonly kind: "root_or_external";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly kind: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host kind.";
+                };
+                readonly address: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The address key.";
+                    readonly cardinality: "high";
+                };
+            };
+            readonly endAttributes: {
+                outcome: {
+                    readonly type: "string";
+                    readonly values: readonly string[];
+                    readonly description: "How it ended; a cancel is no error (status ok).";
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.revoke": {
+            readonly description: "A revocation on this host.";
+            readonly parents: {
+                readonly kind: "any";
+            };
+            readonly startAttributes: {
+                "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+            };
+            readonly endAttributes: {
+                readonly count: {
+                    readonly type: "number";
+                    readonly description: "Objects it ended and child links it closed.";
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.routine": {
+            readonly description: "One routine call (`self.on`, `self.onLive`), a root linked to the span of the commit that changed its source (when known); a throw's backoff a `chord.retry` event.";
+            readonly parents: {
+                readonly kind: "root_or_external";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object type's name.";
+                };
+                readonly object: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object: its type, and its params key when it has params.";
+                    readonly cardinality: "high";
+                };
+                readonly routine: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly values: readonly ["on", "onLive"];
+                    readonly description: "Its kind.";
+                };
+                readonly position: {
+                    readonly type: "number";
+                    readonly required: true;
+                    readonly description: "Its position among its kind, from 1.";
+                };
+            };
+            readonly endAttributes: {
+                outcome: {
+                    readonly type: "string";
+                    readonly values: readonly string[];
+                    readonly description: "How it ended; a cancel is no error (status ok).";
+                };
+            };
+            readonly events: {
+                "chord.commit": {
+                    readonly description: "A commit of the span's object (documents and tables) inside the span's work.";
+                    readonly attributes: {
+                        readonly documents: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Documents the commit adopted.";
+                        };
+                        readonly ops: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Ops of the documents' prepared changes.";
+                        };
+                        readonly rows: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Table rows its writes changed: a `put` one, an update or delete the rows its statement changed.";
+                        };
+                        readonly duration: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Milliseconds from the commit's start to its adoption.";
+                        };
+                    };
+                };
+                "chord.retry": {
+                    readonly description: "A transient failure: the next attempt waits for its backoff.";
+                    readonly attributes: {
+                        readonly backoff: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Milliseconds until the next attempt.";
+                        };
+                    };
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.job": {
+            readonly description: "One phase of a job run: the intent (the start's transaction), the run, the finish; under the stored carrier (persisted) or the starter's span.";
+            readonly parents: {
+                readonly kind: "any";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly job: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The job's name.";
+                };
+                readonly phase: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly values: readonly ["intent", "run", "finish"];
+                    readonly description: "The phase.";
+                };
+                readonly object: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The object: its type, and its params key when it has params.";
+                    readonly cardinality: "high";
+                };
+                readonly "job.id": {
+                    readonly type: "string";
+                    readonly required: false;
+                    readonly description: "The run's id.";
+                    readonly cardinality: "high";
+                };
+            };
+            readonly endAttributes: {
+                readonly outcome: {
+                    readonly type: "string";
+                    readonly values: readonly string[];
+                    readonly description: "How it ended; a cancel is no error (status ok).";
+                };
+                readonly "job.id": {
+                    readonly type: "string";
+                    readonly description: "The run's id, once the intent made it.";
+                    readonly cardinality: "high";
+                };
+            };
+            readonly events: {
+                "chord.commit": {
+                    readonly description: "A commit of the span's object (documents and tables) inside the span's work.";
+                    readonly attributes: {
+                        readonly documents: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Documents the commit adopted.";
+                        };
+                        readonly ops: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Ops of the documents' prepared changes.";
+                        };
+                        readonly rows: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Table rows its writes changed: a `put` one, an update or delete the rows its statement changed.";
+                        };
+                        readonly duration: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Milliseconds from the commit's start to its adoption.";
+                        };
+                    };
+                };
+                "chord.retry": {
+                    readonly description: "A transient failure: the next attempt waits for its backoff.";
+                    readonly attributes: {
+                        readonly backoff: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Milliseconds until the next attempt.";
+                        };
+                    };
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+        readonly "chord.http": {
+            readonly description: "An HTTP request routed to a contributed route (`chord/http`); its path is never recorded.";
+            readonly parents: {
+                readonly kind: "root_or_external";
+            };
+            readonly startAttributes: {
+                readonly "chord.host": {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The host that recorded the span: its address key (`list|groceries`), `client` without an address.";
+                    readonly cardinality: "high";
+                };
+                readonly method: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The request's method.";
+                };
+                readonly route: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly description: "The route's pattern.";
+                };
+            };
+            readonly endAttributes: {
+                readonly status: {
+                    readonly type: "number";
+                    readonly description: "The response's status.";
+                };
+            };
+            readonly events: {
+                "chord.commit": {
+                    readonly description: "A commit of the span's object (documents and tables) inside the span's work.";
+                    readonly attributes: {
+                        readonly documents: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Documents the commit adopted.";
+                        };
+                        readonly ops: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Ops of the documents' prepared changes.";
+                        };
+                        readonly rows: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Table rows its writes changed: a `put` one, an update or delete the rows its statement changed.";
+                        };
+                        readonly duration: {
+                            readonly type: "number";
+                            readonly required: true;
+                            readonly description: "Milliseconds from the commit's start to its adoption.";
+                        };
+                    };
+                };
+            };
+            readonly status: {
+                readonly default: "ok";
+                readonly errorWhen: string;
+            };
+        };
+    };
+    readonly metrics: {
+        readonly "chord.data.compilations": {
+            readonly kind: "counter";
+            readonly description: "Schemas compiled.";
+            readonly attributes: {};
+        };
+        readonly "chord.data.validations": {
+            readonly kind: "counter";
+            readonly description: "Values validated against a schema.";
+            readonly attributes: {};
+        };
+        readonly "chord.data.walks": {
+            readonly kind: "counter";
+            readonly description: "Full-value walks.";
+            readonly attributes: {};
+        };
+        readonly "chord.link.checks": {
+            readonly kind: "counter";
+            readonly description: "Messages checked against the message schema.";
+            readonly attributes: {};
+        };
+        readonly "chord.link.deflates": {
+            readonly kind: "counter";
+            readonly description: "Parts deflated.";
+            readonly attributes: {};
+        };
+        readonly "chord.link.inflates": {
+            readonly kind: "counter";
+            readonly description: "Parts inflated.";
+            readonly attributes: {};
+        };
+        readonly "chord.link.encodes": {
+            readonly kind: "counter";
+            readonly description: "Member values and ops encoded for a hold.";
+            readonly attributes: {};
+        };
+        readonly "chord.store.loads": {
+            readonly kind: "counter";
+            readonly description: "Persisted documents loaded.";
+            readonly attributes: {};
+        };
+        readonly "chord.store.commits": {
+            readonly kind: "counter";
+            readonly description: "Store commits.";
+            readonly attributes: {};
+        };
+        readonly "chord.store.statements": {
+            readonly kind: "counter";
+            readonly description: "SQL statements of store commits.";
+            readonly attributes: {};
+        };
+        readonly "chord.query.runs": {
+            readonly kind: "counter";
+            readonly description: "Live query runs.";
+            readonly attributes: {};
+        };
+        readonly "chord.cycle.visits": {
+            readonly kind: "counter";
+            readonly description: "Objects a cycle check visited.";
+            readonly attributes: {};
+        };
+        readonly "chord.derive.computes": {
+            readonly kind: "counter";
+            readonly description: "Derive computations.";
+            readonly attributes: {};
+        };
+        readonly "chord.derive.diffs": {
+            readonly kind: "counter";
+            readonly description: "Derive diffs.";
+            readonly attributes: {};
+        };
+        readonly "chord.registry.composes": {
+            readonly kind: "counter";
+            readonly description: "Registry compositions.";
+            readonly attributes: {};
+        };
+        readonly "chord.registry.adapts": {
+            readonly kind: "counter";
+            readonly description: "Registry values mapped for an older reader.";
+            readonly attributes: {};
+        };
+        readonly "chord.contract.adapts": {
+            readonly kind: "counter";
+            readonly description: "State mapped for an older consumer.";
+            readonly attributes: {};
+        };
+        readonly "chord.link.state_messages": {
+            readonly kind: "counter";
+            readonly description: "`state` messages this host sent of its own.";
+            readonly attributes: {};
+        };
+        readonly "chord.link.bytes": {
+            readonly kind: "counter";
+            readonly unit: "By";
+            readonly description: "Bytes of encoded messages on this host's links (WebSocket frames, IPC messages).";
+            readonly attributes: {
+                readonly direction: {
+                    readonly type: "string";
+                    readonly required: true;
+                    readonly values: readonly ["sent", "received"];
+                    readonly description: "Which way.";
+                };
+            };
+        };
+        readonly "chord.commit.duration": {
+            readonly kind: "histogram";
+            readonly unit: "ms";
+            readonly description: "Commits of an object's documents and tables, from their start to their adoption.";
+            readonly attributes: {};
+        };
+        readonly "chord.calls.in_flight": {
+            readonly kind: "upDownCounter";
+            readonly description: "Method calls running on this host.";
+            readonly attributes: {};
+        };
+        readonly "chord.holds.active": {
+            readonly kind: "upDownCounter";
+            readonly description: "Holds arriving over links and placed on this host.";
+            readonly attributes: {};
+        };
+        readonly "chord.links.open": {
+            readonly kind: "upDownCounter";
+            readonly description: "Open links of this host.";
+            readonly attributes: {};
+        };
+        readonly "chord.park.duration": {
+            readonly kind: "histogram";
+            readonly unit: "ms";
+            readonly description: "How long an activation attempt stayed parked on its dependencies.";
+            readonly attributes: {};
+        };
+        readonly "chord.backpressure.wait": {
+            readonly kind: "histogram";
+            readonly unit: "ms";
+            readonly description: "How long a link origin's state waited for a slot of its window.";
+            readonly attributes: {};
+        };
+    };
+};
+/**
+ * Whether nothing under `parent` can be recorded: it starts spans as the NOOP context does (a host without an adapter, a
+ * context without a span, `countingOnly`'s). Span sites then start no span, build no attributes and inject no carrier
+ * (§30's cost: one call).
+ */
+export declare function untraced(parent: TelemetryContext): boolean;
+/**
+ * A span recording nothing but carrying `metrics` (a host's adapter's): the telemetry of work a host does under a context
+ * without a span (its links' accepted by an app with `BACKGROUND_CONTEXT`), so the cost counters counted through that
+ * work's context reach the host's adapter (review L6). It starts no span: span sites treat it as untraced.
+ */
+export declare function countingOnly(metrics: TelemetryMetrics): TelemetrySpan;
+/** Chord's typed span starter under `parent` (for a recorded parent: it allocates). */
+export declare function chordSpans(parent: TelemetryContext): TypedSpanStarter<readonly [typeof CHORD_TELEMETRY_SCHEMA]>;
+/**
+ * A span of work whose end is an event, not a return (a hold until bound, an attempt until its outcome, a call until
+ * its handler settled): open until `end`. Its `span` is the NOOP span until the adapter started it (Chord's adapters
+ * call back at once).
+ */
+export declare class OpenSpan<N extends ChordSpanName> {
+    #private;
+    constructor(parent: TelemetryContext, name: N, attributes: TelemetrySchemaSpanStartAttributes<typeof CHORD_TELEMETRY_SCHEMA, N>);
+    /** The span, typed by its schema entry. */
+    get span(): ChordSpan<N>;
+    /** Whether `end` ran. */
+    get ended(): boolean;
+    /** Ends the span (once; later calls do nothing). */
+    end(): void;
+    /**
+     * Ends the span when `work` settles, its `outcome` set: `ok`, `aborted` (a cancel, `signal`'s or `aborted`: status
+     * ok) or `error` with `category`.
+     */
+    endWhen(work: Promise<unknown>, category: string, signal: AbortSignal | undefined): void;
+}
+/** `text` as a span attribute: its first 256 characters. */
+export declare function capped(text: string): string;
+/** The `chord.host` attribute of the spans of a host at `address`: its key, `client` without one; capped. */
+export declare function hostAttribute(address: Address | undefined): string;
+/** The longest message a span's error or event carries (decision "Errors in telemetry"). */
+export declare const MAX_MESSAGE = 500;
+/** Marks `span` failed with `category` and `error`'s message (at most `MAX_MESSAGE` characters). */
+export declare function spanFailed(span: TelemetrySpan, category: string, error: unknown): void;
+/**
+ * How work under `span` that threw `error` ended: `aborted` for a cancel (`signal` aborted, or Chord's `aborted`), its
+ * status set ok explicitly (an adapter marks a span failed when its callback throws); else `error`, the span failed
+ * with `category`. The outcome attribute is the caller's to set.
+ */
+export declare function ended(span: TelemetrySpan, category: string, error: unknown, signal: AbortSignal | undefined): "aborted" | "error";
+/** The carrier of `span` for a link, when its adapter propagates; none under the NOOP context. */
+export declare function carrierOf(span: TelemetryContext): TelemetryCarrier | undefined;
+/** The parent `carrier` names on `adapter` (a host's), its root when absent or malformed; never throws. */
+export declare function parentOf(carrier: TelemetryCarrier | undefined, adapter: TelemetryContext): TelemetryContext;
+/** Chord's instruments on `metrics` (an adapter's, or none: NOOP), made once per metrics object and name. */
+export declare function chordMetrics(metrics: TelemetryMetrics | undefined): ChordMetrics;
+//# sourceMappingURL=telemetry.d.ts.map