@claxedo/agent-runtime-contract 0.8.0 → 0.10.0

package/dist/availability.d.ts

@@ -24,9 +24,9 @@ export type AgentRuntimeStatus = {
     type: "busy";
 } | {
     type: "retry";
-    attempt: number;
     message: string;
-    next: number;
+    attempt?: number;
+    next?: number;
     action?: {
         reason: string;
         provider: string;
@@ -36,7 +36,6 @@ export type AgentRuntimeStatus = {
         link?: string;
     };
 } | {
-    type: "recovering";
-    kind: "process_restart";
+    type: "interrupted";
     message: string;
 };

package/dist/background-work.d.ts

@@ -0,0 +1,10 @@
+/** Work a harness runs for a session outside any turn, counted by kind. A task the harness marks ambient is not activity and is not counted. */
+export type BackgroundWork = {
+    agents: number;
+    shells: number;
+    other: number;
+};
+export declare const NO_BACKGROUND_WORK: BackgroundWork;
+export declare function backgroundWorkActive(work: BackgroundWork): boolean;
+export declare function sameBackgroundWork(a: BackgroundWork, b: BackgroundWork): boolean;
+export declare function parseBackgroundWork(value: unknown): BackgroundWork | undefined;

package/dist/claims.d.ts

@@ -20,6 +20,8 @@
  * credential without an email is ordinary.
  */
 export declare function emailFromClaims(input: Record<string, unknown> | undefined): string | undefined;
+/** When a JWT stops being accepted, from its own `exp`, in epoch milliseconds; nothing when the value is not a JWT or names none. */
+export declare function expiryFromJwt(token: string | undefined): number | undefined;
 /**
  * The ChatGPT account a login document names.
  *

package/dist/connections.d.ts

@@ -1,6 +1,40 @@
 import type { AgentCapabilities, ModelSelection } from "./capabilities";
-export type ConnectionReadiness = "ready" | "unavailable" | "disabled";
+export type ConnectionReadiness = "configured" | "ready" | "unavailable" | "disabled";
+/** Ready proves the ACP handshake, not subscription authentication or session admission. */
+export type ConnectionRuntimeState = "configured" | "connecting" | "ready" | "auth-required" | "disconnected" | "failed";
+export type ConnectionRuntimeObservation = {
+    generation: string;
+    role: "execution" | "discovery";
+    state: Exclude<ConnectionRuntimeState, "configured">;
+    observedAt: number;
+    reason?: string;
+};
+export type ConnectionRuntimeStatus = {
+    state: ConnectionRuntimeState;
+    processes: ConnectionRuntimeObservation[];
+};
+/** A harness's health as the runtime reads it, for the runtime or for one session. */
+export type AgentRuntimeHealth = {
+    status: "ok" | "degraded" | "unavailable";
+    reason?: string;
+    message?: string;
+    sessions?: Array<{
+        id: string;
+        status?: string | null;
+        message?: string | null;
+    }>;
+};
 export type HarnessConnectionCapabilities = Omit<AgentCapabilities, "harness" | "modelSelection">;
+/** An operator-configured connection as the control plane stores it; `config` is readable only by its provider. */
+export type HarnessConnectionDescriptor<TConfig = unknown> = {
+    connectionId: string;
+    providerKey: string;
+    configRevision: number;
+    enabled: boolean;
+    config: TConfig;
+    /** Opaque host-persistence references. Raw secret values never enter config. */
+    secretRefs?: Readonly<Record<string, string>>;
+};
 /** Public discovery metadata. Provider configuration and credentials stay on the host. */
 export type HarnessConnectionRef = {
     connectionId: string;
@@ -19,3 +53,34 @@ export type HarnessConnectionsCatalog = {
 };
 export declare function decodeHarnessConnectionsCatalog(value: unknown): HarnessConnectionsCatalog;
 export declare function decodeModelSelection(value: unknown): ModelSelection;
+export type ConnectionSecretLease = {
+    /** Provider-named secret values, resolved only at the trusted runtime boundary. */
+    secrets: Readonly<Record<string, string>>;
+    /** Non-secret version or expiry token that keys the transport generation. */
+    secretLeaseGeneration: string;
+};
+/**
+ * The proof the operation that needs a connection was admitted under. A remote
+ * secret lease is requested with it, so a background turn proves itself with
+ * its own turn lease rather than with whichever request happens to be running.
+ */
+export type ConnectionSecretAuthority = {
+    kind: "request";
+    credential: string;
+} | {
+    kind: "turn";
+    lease: string;
+};
+export type ConnectionSecretOwner = {
+    kind: "machine-owner";
+} | {
+    kind: "person";
+    userId: string;
+};
+export type ConnectionSecretResolver = (input: {
+    descriptor: HarnessConnectionDescriptor;
+    directory: string;
+    authority?: ConnectionSecretAuthority;
+    /** The session owner whose accounts the connection spends, whoever sent the turn. */
+    owner: ConnectionSecretOwner;
+}) => Promise<ConnectionSecretLease> | ConnectionSecretLease;

package/dist/content.d.ts

@@ -1,4 +1,5 @@
 import type { AgentMessageAuthor } from "./sessions";
+import { type TranscriptNotice } from "./transcript-notice";
 /** Token accounting, reported identically by assistant messages and step-finish parts. */
 export type AgentTokenUsage = {
     total?: number;
@@ -42,8 +43,10 @@ export type AgentUserMessage = {
         body?: string;
         diffs: AgentSnapshotFileDiff[];
     };
-    agent: string;
-    model: AgentModelRef;
+    /** Present only when the prompt named an engine agent; a harness with no agent concept sends none. */
+    agent?: string;
+    /** Absent when the connection owns model selection. */
+    model?: AgentModelRef;
     system?: string;
     tools?: Record<string, boolean>;
     claxedo?: {
@@ -60,10 +63,10 @@ export type AgentAssistantMessage = {
     };
     error?: AgentMessageError;
     parentID: string;
-    modelID: string;
-    providerID: string;
+    modelID?: string;
+    providerID?: string;
     mode: string;
-    agent: string;
+    agent?: string;
     path: {
         cwd: string;
         root: string;
@@ -113,6 +116,13 @@ export type AgentMessage = {
     info: AgentMessageInfo;
     parts: AgentContentPart[];
     harnessPayload?: unknown;
+    /**
+     * The turn the runtime projected this message in, named by the assistant
+     * message id that turn's start opened. A prompt steered into a running turn
+     * and every reply after it carry that turn's id; a message no turn holds has
+     * none.
+     */
+    turnId?: string;
 };
 type AgentPartBase<Type extends string> = {
     id: string;
@@ -120,6 +130,10 @@ type AgentPartBase<Type extends string> = {
     messageID: string;
     type: Type;
 };
+/** The harness withdrew the response this content belongs to; the content is kept, not erased. */
+export type AgentPartRetraction = {
+    reason: string;
+};
 export type AgentTextPart = AgentPartBase<"text"> & {
     text: string;
     synthetic?: boolean;
@@ -129,6 +143,7 @@ export type AgentTextPart = AgentPartBase<"text"> & {
         end?: number;
     };
     metadata?: Record<string, unknown>;
+    retracted?: AgentPartRetraction;
 };
 export type AgentReasoningPart = AgentPartBase<"reasoning"> & {
     text: string;
@@ -137,6 +152,7 @@ export type AgentReasoningPart = AgentPartBase<"reasoning"> & {
         end?: number;
     };
     metadata?: Record<string, unknown>;
+    retracted?: AgentPartRetraction;
 };
 export type AgentFilePartSourceText = {
     value: string;
@@ -180,6 +196,9 @@ export type AgentFilePartSource = AgentFileSource | AgentSymbolSource | AgentRes
  * image was instead of rendering a broken one.
  */
 export type AgentFileLocation = {
+    kind: "tool-file";
+    path: string;
+} | {
     kind: "workspace-file";
     path: string;
 } | {
@@ -193,15 +212,15 @@ export type AgentFilePart = AgentPartBase<"file"> & {
     location?: AgentFileLocation;
     source?: AgentFilePartSource;
 };
-export type AgentTextPartInput = Omit<AgentTextPart, "id" | "sessionID" | "messageID"> & {
-    id?: string;
-};
-export type AgentFilePartInput = Omit<AgentFilePart, "id" | "sessionID" | "messageID"> & {
-    id?: string;
-};
-export type AgentAgentPartInput = Omit<AgentAgentPart, "id" | "sessionID" | "messageID"> & {
-    id?: string;
-};
+export type AgentTextPartInput = Omit<AgentTextPart, "id" | "sessionID" | "messageID">;
+export type AgentFilePartInput = Omit<AgentFilePart, "id" | "sessionID" | "messageID">;
+export type AgentAgentPartInput = Omit<AgentAgentPart, "id" | "sessionID" | "messageID">;
+/**
+ * A prompt part's id, minted by the runtime from its message id. Part ids are
+ * one primary key across every session a runtime stores, so an id the client
+ * chose could name another session's part.
+ */
+export declare function promptPartId(messageId: string, index: number): string;
 export type AgentToolState = {
     status: "pending";
     input: Record<string, unknown>;
@@ -241,6 +260,9 @@ export type AgentToolPart = AgentPartBase<"tool"> & {
     tool: string;
     state: AgentToolState;
     metadata?: Record<string, unknown>;
+    /** A read sent only what the collapsed row draws (`toolPartHeader`); the whole part is read when the row opens. */
+    headerOnly?: true;
+    retracted?: AgentPartRetraction;
 };
 /**
  * Whether a tool name spawns a subagent. Every harness spelling — Claude's `Agent`,
@@ -311,7 +333,13 @@ export type AgentHandoffPart = AgentPartBase<"handoff"> & {
         connection?: unknown;
     };
 };
-export type AgentContentPart = AgentTextPart | AgentReasoningPart | AgentFilePart | AgentToolPart | AgentSubtaskPart | AgentStepStartPart | AgentStepFinishPart | AgentSnapshotPart | AgentPatchPart | AgentAgentPart | AgentRetryPart | AgentCompactionPart | AgentHandoffPart;
+export type AgentNoticePart = AgentPartBase<"notice"> & {
+    notice: TranscriptNotice;
+    time: {
+        created: number;
+    };
+};
+export type AgentContentPart = AgentTextPart | AgentReasoningPart | AgentFilePart | AgentToolPart | AgentSubtaskPart | AgentStepStartPart | AgentStepFinishPart | AgentSnapshotPart | AgentPatchPart | AgentAgentPart | AgentRetryPart | AgentCompactionPart | AgentHandoffPart | AgentNoticePart;
 export type AgentPromptResponse = {
     info: AgentAssistantMessage;
     parts: AgentContentPart[];
@@ -335,6 +363,9 @@ export type AgentQuestionInfo = {
     custom?: boolean;
 };
 export type AgentQuestionAnswer = string[];
+export type AgentPermissionReply = "once" | "always" | "reject" | {
+    optionId: string;
+};
 export type AgentPermission = {
     id: string;
     sessionID: string;
@@ -344,6 +375,11 @@ export type AgentPermission = {
     };
     title?: string;
     permission: string;
+    options?: {
+        id: string;
+        label: string;
+        description?: string;
+    }[];
     patterns: string[];
     always: string[];
     metadata: Record<string, unknown>;
@@ -366,10 +402,25 @@ export type AgentCommand = {
     name: string;
     content?: string;
     description?: string;
+    input?: {
+        hint: string;
+    } | null;
+    source?: "command" | "mcp" | "skill";
     harnessPayload?: unknown;
 };
+/** A user's command as configuration carries it: its name and the prompt text it expands to. */
+export type SavedCommand = {
+    name: string;
+    content: string;
+};
+export type RuntimeCommand = AgentCommand & ((SavedCommand & {
+    origin: "saved";
+}) | {
+    origin: "transport";
+});
 export type AgentAgent = {
     name: string;
+    id?: string;
     description?: string;
     mode?: string;
     harnessPayload?: unknown;
@@ -387,6 +438,8 @@ export type AgentConfigOption = {
         description?: string;
         value?: unknown;
         connected?: boolean;
+        /** The full model id an alias row runs (`haiku` runs `claude-haiku-4-5-20251001`). */
+        resolvedModel?: string;
         harnessPayload?: unknown;
     }>;
     harnessPayload?: unknown;
@@ -408,4 +461,8 @@ export declare function isAgentMessageInfo(value: unknown): value is AgentMessag
 export declare function isAgentMessage(value: unknown): value is AgentMessage;
 /** The message `value` holds, or `undefined` when it is not one. */
 export declare function parseAgentMessage(value: unknown): AgentMessage | undefined;
+/** Is `value` a todo as the runtime reports it? */
+export declare function isAgentTodo(value: unknown): value is AgentTodo;
+/** Is `value` one file's entry in a session's diff summary? */
+export declare function isAgentSnapshotFileDiff(value: unknown): value is AgentSnapshotFileDiff;
 export {};

package/dist/credential-broker-errors.d.ts

@@ -66,6 +66,10 @@ export declare const CREDENTIAL_BROKER_ERRORS: {
         readonly fault: "harness";
         readonly message: "The credential broker answers loopback callers only";
     };
+    readonly runtime_token_rate_limited: {
+        readonly fault: "harness";
+        readonly message: "Too many requests without a verifiable runtime token from this client";
+    };
 };
 export type CredentialBrokerErrorCode = keyof typeof CREDENTIAL_BROKER_ERRORS;
 /**

package/dist/custom-provider-headers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The request headers an operator-declared provider may carry beside its
+ * credential: routing and attribution metadata only. Anything else is either a
+ * credential or unknown, and an unknown header is refused rather than trusted,
+ * because its value travels in the runtime snapshot and the engine's config in
+ * the clear. The stored credential reaches the provider through the broker at
+ * the header the provider declares for it, never as one of these.
+ */
+export declare const CUSTOM_PROVIDER_METADATA_HEADERS: readonly ["HTTP-Referer", "X-Title", "OpenAI-Organization", "OpenAI-Project"];
+export declare function isCustomProviderMetadataHeader(name: string): boolean;
+/** Whether the broker can write a custom provider's stored key into this header: never a metadata header, never one the connection owns. */
+export declare function isCustomProviderCredentialHeader(name: string): boolean;

package/dist/d1-bookmarks.d.ts

@@ -0,0 +1,39 @@
+/**
+ * How the hosted control plane's clients carry D1 bookmarks between requests.
+ *
+ * A bookmark names a version of one of the control plane's databases; a read
+ * that starts from it is answered by a replica at least that new
+ * (developers.cloudflare.com/d1/best-practices/read-replication/). The control
+ * plane hands bookmarks out on its answers and on the live-sync notices of
+ * the writes they announce; a client returns the newest it holds per
+ * database, the browser as cookies and a client without a cookie jar in
+ * `D1_BOOKMARKS_HEADER`, written as `auth=<bookmark>, control=<bookmark>`.
+ */
+export type D1BookmarkName = "auth" | "control";
+export declare const D1_BOOKMARKS_HEADER = "x-claxedo-d1-bookmarks";
+/** Followed by the database's name; `__Host-` keeps the cookie on the exact origin, over HTTPS, at path `/`. */
+export declare const D1_BOOKMARK_COOKIE_PREFIX = "__Host-claxedo.d1-";
+/**
+ * Long enough to outlast replica lag, short enough that no bookmark outlives
+ * the database it names: resetting staging recreates the control-plane
+ * database, whose versions start again below any bookmark a client still holds.
+ */
+export declare const D1_BOOKMARK_MAX_AGE_SECONDS = 300;
+/** The cookie that carries `name`'s bookmark; scripts may read and raise it, since it says only which version a reader has seen. */
+export declare function d1BookmarkCookie(name: D1BookmarkName, bookmark: string): string;
+export declare function isD1Bookmark(value: unknown): value is string;
+/** D1 bookmarks "are lexicographically sortable", oldest first (developers.cloudflare.com/d1/reference/time-travel/). */
+export declare function newerD1Bookmark(held: string | undefined, next: string): string;
+export declare function readD1Bookmarks(header: string): [D1BookmarkName, string][];
+export declare function writeD1Bookmarks(entries: Iterable<readonly [D1BookmarkName, string]>): string;
+/** The bookmark a live-sync frame announces, past the write it rings for. */
+export declare function announcedD1Bookmark(frame: unknown): string | undefined;
+/**
+ * Raises the control-plane bookmark a browser's cookie jar (`document`)
+ * sends with every request to `bookmark`, so the re-reads a notice sets off
+ * are answered by a replica that holds the change it announces. The jar is
+ * every tab's, so a newer bookmark is never lowered.
+ */
+export declare function raiseD1BookmarkCookie(jar: {
+    cookie: string;
+}, bookmark: string): void;

package/dist/daemon-ownership-snapshot.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The redacted ownership view a machine owner rewrites beside its discovery
+ * record each time what it owns changes, and never otherwise: `changedAt` is
+ * when that last happened, not a heartbeat. Whether the view is still current
+ * is whether its writer is still alive, which a reader establishes from the
+ * writer's process identity rather than from the file's age.
+ *
+ * The file name lives here because the writer and the reader are in different
+ * products with a boundary between them: the launcher that reads this file
+ * cannot import the daemon that writes it, and a filename agreed twice is a
+ * filename that drifts once.
+ */
+export declare const DAEMON_OWNERSHIP_SNAPSHOT_FILE = "local-daemon-ownership.json";
+/** Readers and writers must resolve the same file even when their data roots have trailing separators. */
+export declare function daemonOwnershipSnapshotPath(dataRoot: string): string;
+/** One owner row as the snapshot carries it: ids, states and generations, never a command. */
+export type DaemonOwnershipRow = {
+    id: string;
+    kind: string;
+    generation: string;
+    state: string;
+    pins: boolean;
+    detail?: string;
+};
+/**
+ * What a launcher may rely on in a snapshot it did not write.
+ *
+ * Both sides validate through this rather than each declaring the shape: the
+ * writer is a daemon and the reader is the launcher that cannot import it, so
+ * two declarations would be two chances to drift.
+ */
+export declare function isDaemonOwnershipSnapshot(value: unknown): value is {
+    machineId: string;
+    generation: string;
+    pid: number;
+    revision: string;
+    changedAt: number;
+    residencyPins: number;
+    owners: DaemonOwnershipRow[];
+};

package/dist/diagnostics.d.ts

@@ -0,0 +1,24 @@
+/** The declared severities, as the single source for both the type and the parser. */
+declare const RUNTIME_DIAGNOSTIC_SEVERITIES: readonly ["debug", "info", "warn", "error"];
+export type RuntimeDiagnosticSeverity = (typeof RUNTIME_DIAGNOSTIC_SEVERITIES)[number];
+export type RuntimeDiagnostic = {
+    code: string;
+    message: string;
+    severity: RuntimeDiagnosticSeverity;
+    source?: string;
+    method?: string;
+    raw?: unknown;
+    details?: Record<string, unknown>;
+};
+export declare function runtimeDiagnostic(input: {
+    code: string;
+    message: string;
+    severity?: RuntimeDiagnosticSeverity;
+    source?: string;
+    method?: string;
+    raw?: unknown;
+    details?: Record<string, unknown>;
+}): RuntimeDiagnostic;
+/** Parses an unknown payload into diagnostics, dropping rows that carry no code or message. */
+export declare function normalizeDiagnostics(input: unknown): RuntimeDiagnostic[];
+export {};

package/dist/elicitation-pattern-worker.d.ts

@@ -0,0 +1,6 @@
+import type { ElicitationPatternCheck } from "./elicitation-validation";
+/** Worker-only evaluator. Self-contained so Node can serialize trusted code without a worker asset. */
+export declare function evaluateNativeElicitationPatterns(checks: ElicitationPatternCheck[]): {
+    code: "invalid_schema" | "invalid_answer";
+    message: string;
+} | null;

package/dist/elicitation-pattern-worker.mjs

@@ -0,0 +1,17 @@
+// src/elicitation-pattern-worker.ts
+function evaluateNativeElicitationPatterns(checks) {
+  for (const check of checks) {
+    let pattern;
+    try {
+      pattern = new RegExp(check.pattern, "u");
+    } catch {
+      return { code: "invalid_schema", message: `Invalid pattern for ${check.field}` };
+    }
+    if (check.value !== undefined && !pattern.test(check.value))
+      return { code: "invalid_answer", message: `Invalid value for ${check.field}` };
+  }
+  return null;
+}
+export {
+  evaluateNativeElicitationPatterns
+};

package/dist/elicitation-validation.d.ts

@@ -0,0 +1,23 @@
+import { type ElicitationContent, type ElicitationSchema } from "./elicitation";
+export type ElicitationValidationCode = "invalid_answer" | "invalid_schema" | "validation_timeout" | "validation_unavailable" | "validation_busy" | "validation_cancelled";
+export declare class ElicitationValidationError extends Error {
+    readonly code: ElicitationValidationCode;
+    constructor(code: ElicitationValidationCode, message: string);
+}
+/** Consent links are displayed without fetching or accepting embedded credentials. */
+export declare function validateElicitationUrl(value: string): void;
+export type ElicitationPatternCheck = {
+    field: string;
+    pattern: string;
+    value?: string;
+};
+export type ElicitationPatternEvaluator = (checks: ElicitationPatternCheck[], signal?: AbortSignal) => Promise<void>;
+export declare const ELICITATION_PATTERN_LIMITS: {
+    readonly fields: 64;
+    readonly pattern: 4096;
+    readonly value: 65536;
+    readonly total: 262144;
+};
+export declare function elicitationPatternChecks(schema: ElicitationSchema, content?: ElicitationContent): ElicitationPatternCheck[];
+/** Complete response validation; the evaluator must isolate native regex work. */
+export declare function validateElicitationResponse(schema: ElicitationSchema, value: unknown, evaluate: ElicitationPatternEvaluator, signal?: AbortSignal): Promise<ElicitationContent>;

package/dist/elicitation.d.ts

@@ -0,0 +1,51 @@
+export type ElicitationChoice = {
+    const: string;
+    title?: string;
+    description?: string;
+};
+export type ElicitationContent = Record<string, string | number | boolean | string[]>;
+export type ElicitationField = {
+    type: "string" | "number" | "integer" | "boolean" | "array";
+    title?: string;
+    description?: string;
+    default?: unknown;
+    enum?: string[];
+    oneOf?: ElicitationChoice[];
+    items?: {
+        type?: "string";
+        enum?: string[];
+        anyOf?: ElicitationChoice[];
+    };
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    minItems?: number;
+    maxItems?: number;
+    format?: string;
+    /** Native ECMAScript constraint evaluated by the asynchronous response validator. */
+    pattern?: string | null;
+};
+export type ElicitationSchema = {
+    type: "object";
+    properties: Record<string, ElicitationField>;
+    required?: string[];
+    title?: string;
+    description?: string;
+    _meta?: Record<string, unknown>;
+};
+export type AgentElicitation = {
+    agentName: string;
+    message: string;
+} & ({
+    mode: "form";
+    requestedSchema: ElicitationSchema;
+} | {
+    mode: "url";
+    url: string;
+    elicitationId: string;
+});
+export declare function elicitationChoices(field: ElicitationField): ElicitationChoice[] | undefined;
+export declare function readElicitationSchema(input: unknown): ElicitationSchema;
+/** Primitive constraints. Use validateElicitationResponse for complete validation including patterns. */
+export declare function validateElicitationContent(schema: ElicitationSchema, value: unknown): asserts value is ElicitationContent;

package/dist/errors.d.ts

@@ -40,4 +40,11 @@ export declare class AgentRuntimeContractError extends Error {
     readonly detail: AgentRuntimeError;
     constructor(detail: AgentRuntimeError);
 }
-export declare function assertAgentExecutionBinding(binding: Readonly<AgentExecutionBinding>, expected?: AgentExecutionBindingExpectation): AgentExecutionBinding;
+/** The binding is complete: workspace-scoped and every field a non-empty string. */
+export declare function requireAgentExecutionBinding(binding: Readonly<AgentExecutionBinding>): AgentExecutionBinding;
+/**
+ * The binding is complete AND matches the expectation this caller independently
+ * holds. `expected` has no default: an expectation copied from the binding
+ * itself compares every field to itself and proves nothing.
+ */
+export declare function assertAgentExecutionBinding(binding: Readonly<AgentExecutionBinding>, expected: AgentExecutionBindingExpectation): AgentExecutionBinding;

package/dist/event-cursor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The position in a runtime's event feed a response was taken at, so a reader
+ * can tell whether the live stream it holds covers everything a read did not
+ * include. A read answers the position its snapshot is good up to; an event
+ * stream answers the position it starts after. The stream covers the read
+ * when both come from the same feed and the stream starts no later than the
+ * read: nothing then fell between the two.
+ *
+ * `feed` identifies one runtime process's numbering; a position from another
+ * feed is not comparable, so a reader treats the pair as uncovered.
+ */
+export declare const EVENT_CURSOR_HEADER = "X-Event-Cursor";
+export type EventCursor = {
+    readonly feed: string;
+    readonly at: number;
+};
+export declare function formatEventCursor(cursor: EventCursor): string;
+export declare function parseEventCursor(value: string | null | undefined): EventCursor | undefined;
+export declare function eventCursorCovers(streamSince: EventCursor | undefined, readAt: EventCursor | undefined): boolean;