keri-ts 0.11.0 → 2.0.0

package/types/app/transport/tcp-egress.d.ts

@@ -0,0 +1,118 @@
+/** Concrete TCP connections and pull-driven writers; applications compose receive work. */
+import { type CesrFrame } from "cesr-ts";
+import { type Socket } from "node:net";
+import { type Operation } from "effection";
+import { type RuntimeClock } from "../runtime/runtime-clock.js";
+/** Actual connection/write choices, without a parser or receive callback. */
+export interface TcpSendOptions {
+    /** Serializer chunk size; default 64 KiB. */
+    maxChunkBytes?: number;
+    /** Connection acquisition deadline; default 30 seconds. */
+    connectTimeoutMs?: number;
+    /** Absolute local-drain deadline from output EOF, also covering peer close for duplex; default 30 seconds. */
+    drainTimeoutMs?: number;
+    /**
+     * Optional upstream cancellation; abort stops source/output and joins the owned connection.
+     */
+    signal?: AbortSignal;
+}
+/** Producer observes abort and joins cleanup on return. */
+export type TcpSourceFactory = (signal: AbortSignal) => AsyncIterable<Uint8Array> | Promise<AsyncIterable<Uint8Array>>;
+/** A borrowed real connection. Its owner joins close after application children stop. */
+export interface TcpConnection {
+    /**
+     * Paused binary socket with allowHalfOpen; borrower supplies any receive processing.
+     */
+    readonly socket: Socket;
+    /**
+     * Settles on native socket close; does not itself imply successful transmission.
+     */
+    readonly closed: Promise<void>;
+    /**
+     * Combined caller/connection cancellation, including the originating connection failure.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Stop both directions immediately, retaining the originating failure.
+     *
+     * @param reason Optional failure/cancellation reason retained by the connection signal.
+     */
+    close(reason?: unknown): void;
+}
+/**
+ * Open a socket and lend it to application-owned receive/transmit operations.
+ * This resource does not parse incoming data. Its scope destroys the socket and
+ * joins native close after child operations stop. Receive EOF can leave output
+ * open; the borrower must complete or cancel both directions before releasing it.
+ *
+ * @param url TCP endpoint with an explicit port in the range 1–65535.
+ * @param clock Borrowed clock for connection/drain deadlines and scheduler yields; durations are milliseconds.
+ * @param options Connection timeout in milliseconds and optional upstream cancellation; default timeout is 30000.
+ * @returns A paused half-open-capable connection borrowed until the enclosing scope ends.
+ * @throws URL/option validation failures precede connection acquisition; connection errors retain their causes as TransportError.
+ */
+export declare function openTcpConnection(url: string, clock: RuntimeClock, options?: Pick<TcpSendOptions, "connectTimeoutMs" | "signal">): Operation<TcpConnection>;
+/**
+ * Send a resident value over the same concrete connection/source owner as streaming output.
+ *
+ * @param url TCP endpoint with an explicit port in the range 1–65535.
+ * @param bytes Resident signed wire bytes; chunking copies each outgoing segment.
+ * @param clock Borrowed clock for connection/drain deadlines and scheduler yields; durations are milliseconds.
+ * @param options Chunk size, connection/drain deadlines and optional cancellation; defaults are 64 KiB and 30-second deadlines.
+ * @returns Local output completion after owned socket cleanup joins; no receive-EOF or protocol-acceptance guarantee.
+ * @throws Source/serialization, transport, cancellation and cleanup errors propagate.
+ */
+export declare function sendCesrTcp(url: string, bytes: Uint8Array, clock: RuntimeClock, options?: TcpSendOptions): Operation<void>;
+/**
+ * Transmit-only flow completes local drain, then its connection owner joins close without awaiting peer EOF.
+ *
+ * @param url TCP endpoint with an explicit port in the range 1–65535.
+ * @param source Creates a finite binary source with the owner's cancellation signal; must interrupt reads and finish cleanup when aborted.
+ * @param clock Borrowed clock for connection/drain deadlines and scheduler yields; durations are milliseconds.
+ * @param options Chunk size, connection/drain deadlines and optional cancellation; defaults are 64 KiB and 30-second deadlines.
+ * @returns Local output completion after owned socket cleanup joins; no receive-EOF or protocol-acceptance guarantee.
+ * @throws Source/serialization, transport, cancellation and cleanup errors propagate.
+ */
+export declare function streamCesrTcp(url: string, source: TcpSourceFactory, clock: RuntimeClock, options?: TcpSendOptions): Operation<void>;
+/**
+ * Borrow an already hydrated frame through serializer completion, without reparsing.
+ *
+ * @param url TCP endpoint with an explicit port in the range 1–65535.
+ * @param frame Borrowed parsed frame; serialization preserves its body and attachments without reparsing.
+ * @param clock Borrowed clock for connection/drain deadlines and scheduler yields; durations are milliseconds.
+ * @param options Chunk size, connection/drain deadlines and optional cancellation; defaults are 64 KiB and 30-second deadlines.
+ * @returns Local output completion after owned socket cleanup joins; no receive-EOF or protocol-acceptance guarantee.
+ * @throws Source/serialization, transport, cancellation and cleanup errors propagate.
+ */
+export declare function sendCesrTcpFrame(url: string, frame: CesrFrame, clock: RuntimeClock, options?: TcpSendOptions): Operation<void>;
+/** Write options for a caller-owned socket; this operation never ends its writable half. */
+export interface TcpSocketWriteOptions {
+    /**
+     * Optional caller cancellation; abort destroys this socket but its caller owns joining close.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Pull/write/drain one chunk at a time and join source cleanup before returning.
+ *
+ * @param socket Borrowed writable socket; this operation never calls end on successful completion.
+ * @param factory Creates a finite binary source with the owner's cancellation signal; must interrupt reads and finish cleanup when aborted.
+ * @param clock Borrowed clock for connection/drain deadlines and scheduler yields; durations are milliseconds.
+ * @param options Optional cancellation for this write/source lifetime.
+ * @returns Local output completion after source cleanup; caller still owns final socket close.
+ * @throws Source and write errors propagate; abort destroys the socket to interrupt pending output.
+ */
+export declare function writeCesrTcpSocket(socket: Socket, factory: TcpSourceFactory, clock: RuntimeClock, { signal }?: TcpSocketWriteOptions): Operation<void>;
+/**
+ * Finish output on a duplex connection and wait for native connection close.
+ * The receiver must run concurrently and consume the peer's readable half. The
+ * messenger separately joins receive processing before reporting duplex success.
+ *
+ * @param connection Borrowed connection with an application-owned concurrent receive operation.
+ * @param factory Creates a finite binary source with the owner's cancellation signal; must interrupt reads and finish cleanup when aborted.
+ * @param clock Borrowed clock for connection/drain deadlines and scheduler yields; durations are milliseconds.
+ * @param options Absolute drain timeout starting at source EOF; default 30000 milliseconds.
+ * @returns Completion after local end and peer close, within the same drain deadline.
+ */
+export declare function sendCesrTcpSocket(connection: TcpConnection, factory: TcpSourceFactory, clock: RuntimeClock, options?: Pick<TcpSendOptions, "drainTimeoutMs">): Operation<void>;
+//# sourceMappingURL=tcp-egress.d.ts.map

package/types/app/transport/tcp-egress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcp-egress.d.ts","sourceRoot":"","sources":["../../../src/app/transport/tcp-egress.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,OAAO,EAAE,KAAK,SAAS,EAAgB,MAAM,SAAS,CAAC;AACvD,OAAO,EAAoB,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,EAAQ,KAAK,SAAS,EAAY,MAAM,WAAW,CAAC;AAG3D,OAAO,EAAE,KAAK,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAInF,6EAA6E;AAC7E,MAAM,WAAW,cAAc;IAC7B,6CAA6C;IAC7C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8GAA8G;IAC9G,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,2DAA2D;AAC3D,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC;AAEvH,yFAAyF;AACzF,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/B;AAeD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,YAAY,EACnB,OAAO,GAAE,IAAI,CAAC,cAAc,EAAE,kBAAkB,GAAG,QAAQ,CAAM,GAChE,SAAS,CAAC,aAAa,CAAC,CAwD1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,YAAY,EACnB,OAAO,GAAE,cAAmB,GAC3B,SAAS,CAAC,IAAI,CAAC,CAGjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,YAAY,EACnB,OAAO,GAAE,cAAmB,GAC3B,SAAS,CAAC,IAAI,CAAC,CAMjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,YAAY,EACnB,OAAO,GAAE,cAAmB,GAC3B,SAAS,CAAC,IAAI,CAAC,CAYjB;AAED,4FAA4F;AAC5F,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,YAAY,EACnB,EAAE,MAAM,EAAE,GAAE,qBAA0B,GACrC,SAAS,CAAC,IAAI,CAAC,CAWjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,aAAa,EACzB,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,YAAY,EACnB,OAAO,GAAE,IAAI,CAAC,cAAc,EAAE,gBAAgB,CAAM,GACnD,SAAS,CAAC,IAAI,CAAC,CAEjB"}

package/types/app/transport/tcp-messenger.d.ts

@@ -0,0 +1,69 @@
+import { type Operation } from "effection";
+import type { Kevery } from "../../core/kel/eventing.js";
+import type { ProtocolProcessor } from "../protocol/protocol-processing.js";
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import { type TcpSendOptions, type TcpSourceFactory } from "./tcp-egress.js";
+/** Per-attempt choices; collaborators are required constructor dependencies. */
+export interface TCPMessengerOptions extends TcpSendOptions {
+    /** Process same-socket replies through receive EOF; omitted completes local TX only. */
+    replies?: boolean;
+    /** Locally received witness/controller semantics for parsed protocol frames. */
+    local?: boolean;
+}
+/**
+ * Own one TCP delivery attempt and its parser/Kevery, following KERIpy TCPMessenger.
+ *
+ * Poster or WitnessInquisitor owns queued source work and delivery policy. This messenger runs
+ * directly in that owner's scope, keeps no message queue or sent history, and joins
+ * TX, optional RX, parser/source cleanup and connection close before returning.
+ * Finite bytes and pull sources share the same socket implementation.
+ *
+ * Transmit-only is the default. Reply mode starts RX before TX so the peer may
+ * answer during upload, then waits for receive EOF and dispatch completion.
+ * Those are socket/protocol-processing facts, not the calling workflow's
+ * accepted-state predicate or an application acknowledgement from the peer.
+ */
+export declare class TCPMessenger {
+    readonly url: string;
+    private readonly clock;
+    private readonly protocol;
+    /** Input-owned Kevery (kvy); null when no protocol receive capability was supplied. */
+    readonly kvy: Kevery | null;
+    /**
+     * Bind the actual receiver and clock without opening a socket or acquiring stores.
+     *
+     * @param url TCP endpoint bound to this messenger.
+     * @param clock Borrowed clock for connection/drain deadlines and scheduler yields; durations are milliseconds.
+     * @param protocol Optional borrowed receiver; omitted means transmit-only.
+     */
+    constructor(url: string, clock: RuntimeClock, protocol?: ProtocolProcessor | null);
+    /**
+     * Adapt resident signed wire to the same pull-source lifetime as streamed output.
+     *
+     * @param msg Resident signed CESR bytes; copied into chunks as transmitted.
+     * @param options Chunk size, connection/drain deadlines and optional cancellation; defaults are 64 KiB and 30-second deadlines. Set replies to process same-socket input through EOF; local controls KEL intake policy.
+     * @returns Completion after local output; reply mode also joins receive EOF and protocol processing.
+     * @throws Reply mode requires a protocol processor. Source/parser, dispatch, transport and cleanup failures propagate.
+     */
+    send(msg: Uint8Array, options?: TCPMessengerOptions): Operation<void>;
+    /**
+     * Send one source; duplex processing is explicit and never changes the local-only success contract.
+     *
+     * @param source Creates a finite binary source with the owner's cancellation signal; must interrupt reads and finish cleanup when aborted.
+     * @param options Chunk size, connection/drain deadlines and optional cancellation; defaults are 64 KiB and 30-second deadlines. Set replies to process same-socket input through EOF; local controls KEL intake policy.
+     * @returns Completion after local output; reply mode also joins receive EOF and protocol processing.
+     * @throws Reply mode requires a protocol processor. Source/parser, dispatch, transport and cleanup failures propagate.
+     */
+    sendSource(source: TcpSourceFactory, options?: TCPMessengerOptions): Operation<void>;
+    /**
+     * Send while processing replies, corresponding to KERIpy TCPMessenger.receiptDo/msgDo.
+     * Cancel and join concurrent RX/TX children before releasing the borrowed socket.
+     *
+     * @param source Creates a finite binary source with the owner's cancellation signal; must interrupt reads and finish cleanup when aborted.
+     * @param options Chunk size, connection/drain deadlines and optional cancellation; defaults are 64 KiB and 30-second deadlines. Set replies to process same-socket input through EOF; local controls KEL intake policy.
+     * @returns Completion after output, processed receive EOF and joined connection cleanup.
+     * @throws Missing receive capability, source/parser, dispatch, transport and cleanup failures propagate.
+     */
+    private receiptDo;
+}
+//# sourceMappingURL=tcp-messenger.d.ts.map

package/types/app/transport/tcp-messenger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcp-messenger.d.ts","sourceRoot":"","sources":["../../../src/app/transport/tcp-messenger.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,SAAS,EAAe,MAAM,WAAW,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAE5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AAEzB,gFAAgF;AAChF,MAAM,WAAW,mBAAoB,SAAQ,cAAc;IACzD,wFAAwF;IACxF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gFAAgF;IAChF,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,YAAY;IAYrB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAb3B,uFAAuF;IACvF,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B;;;;;;OAMG;gBAEQ,GAAG,EAAE,MAAM,EACH,KAAK,EAAE,YAAY,EACnB,QAAQ,GAAE,iBAAiB,GAAG,IAAW;IAK5D;;;;;;;OAOG;IACH,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,mBAAwB,GAAG,SAAS,CAAC,IAAI,CAAC;IAIzE;;;;;;;OAOG;IACH,UAAU,CAAC,MAAM,EAAE,gBAAgB,EAAE,OAAO,GAAE,mBAAwB,GAAG,SAAS,CAAC,IAAI,CAAC;IAKxF;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;CAqElB"}

package/types/app/transport/tcp-stream-messenger.d.ts

@@ -0,0 +1,25 @@
+/** Finite raw TCP stream delivery using the existing socket owner. */
+import type { Operation } from "effection";
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import { type TcpSendOptions } from "./tcp-egress.js";
+/**
+ * KERIpy-style TCPStreamMessenger over one already prepared opaque payload.
+ * Borrow bytes until send finishes, with no CESR parsing, receive processor or
+ * private queue. Reuse the ordinary socket owner for connection, local drain and
+ * joined cancellation; producers retain preparation and any delivery policy.
+ */
+export declare class TCPStreamMessenger {
+    readonly url: string;
+    private readonly clock;
+    private readonly payload;
+    /** Construction borrows prepared bytes and opens no connection. */
+    constructor(url: string, clock: RuntimeClock, payload: Uint8Array);
+    /**
+     * Send all bytes and join local drain/cleanup without awaiting remote EOF.
+     * Completion does not prove the peer parsed, accepted or durably stored them.
+     * Connection/drain deadlines use the borrowed clock; source, transport and
+     * genuine cleanup failures propagate to this operation's caller.
+     */
+    send(options?: TcpSendOptions): Operation<void>;
+}
+//# sourceMappingURL=tcp-stream-messenger.d.ts.map

package/types/app/transport/tcp-stream-messenger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcp-stream-messenger.d.ts","sourceRoot":"","sources":["../../../src/app/transport/tcp-stream-messenger.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAErE;;;;;GAKG;AACH,qBAAa,kBAAkB;IAG3B,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,mEAAmE;gBAExD,GAAG,EAAE,MAAM,EACH,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,UAAU;IAGtC;;;;;OAKG;IACH,IAAI,CAAC,OAAO,GAAE,cAAmB,GAAG,SAAS,CAAC,IAAI,CAAC;CAQpD"}

package/types/app/transport/transport-error.d.ts

@@ -0,0 +1,12 @@
+/** A failure observed at a concrete network I/O boundary, retaining its original cause. */
+export declare class TransportError extends Error {
+    /**
+     * Preserve a concrete I/O failure for transport owners to classify.
+     * Protocol refusals and arbitrary parser/storage failures must not be wrapped here.
+     *
+     * @param message Description of the actual failing network boundary.
+     * @param options Native Error options, normally containing the original I/O cause.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=transport-error.d.ts.map

package/types/app/transport/transport-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-error.d.ts","sourceRoot":"","sources":["../../../src/app/transport/transport-error.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/types/app/witness/http-endpoints.d.ts

@@ -0,0 +1,77 @@
+import { type Operation } from "effection";
+import { type Hab } from "../identity/habbing.js";
+import type { AgentRuntime } from "../runtime/agent-runtime.js";
+/** Host-side decision for `POST /receipts`. */
+export type WitnessReceiptPostResult = {
+    kind: "accepted";
+    status: 200;
+    body: Uint8Array;
+} | {
+    kind: "escrow";
+    status: 202;
+} | {
+    kind: "reject";
+    status: number;
+    message: string;
+};
+/** Host-side decision for `GET /receipts`. */
+export type WitnessReceiptGetResult = {
+    kind: "accepted";
+    status: 200;
+    body: Uint8Array;
+} | {
+    kind: "reject";
+    status: number;
+    message: string;
+};
+/** Host-side decision for `GET /query`. */
+export type WitnessQueryGetResult = {
+    kind: "accepted";
+    status: 200;
+    messages: Iterable<Uint8Array>;
+} | {
+    kind: "reject";
+    status: number;
+    message: string;
+};
+/** Options for one witness receipt POST. */
+export interface WitnessReceiptPostOptions {
+    /**
+     * Process the event with witness-local authority (default true). Hosts that
+     * gate receipting on controller authentication pass false for an
+     * unauthenticated request: the event is processed as remote input, so a new
+     * event naming this witness goes to misfit escrow (202) while an already
+     * accepted event is still receipted (200), as witness-hk does.
+     */
+    local?: boolean;
+}
+/** Handle the synchronous witness receipt POST policy. */
+export declare function witnessReceiptPost(runtime: AgentRuntime, serviceHab: Hab, bytes: Uint8Array, { local }?: WitnessReceiptPostOptions): Operation<WitnessReceiptPostResult>;
+/** Handle `GET /receipts` witness retrieval. */
+export declare function witnessReceiptGet(serviceHab: Hab, query: {
+    pre?: string | null;
+    sn?: number | null;
+    said?: string | null;
+}): WitnessReceiptGetResult;
+/** Handle `GET /query` witness log replay. */
+export declare function witnessQueryGet(serviceHab: Hab, query: {
+    typ?: string | null;
+    pre?: string | null;
+    sn?: number | null;
+}): WitnessQueryGetResult;
+/** Host-side decision for an endorsed, fully witnessed key-state notice. */
+export type WitnessKeyStateGetResult = {
+    kind: "accepted";
+    status: 200;
+    body: Uint8Array;
+} | {
+    kind: "reject";
+    status: number;
+    message: string;
+};
+/** Return an actual signed KERI reply; unknown or incompletely witnessed state is not advertised. */
+export declare function witnessKeyStateGet(serviceHab: Hab, query: {
+    pre?: string | null;
+    destination?: string | null;
+}): WitnessKeyStateGetResult;
+//# sourceMappingURL=http-endpoints.d.ts.map

package/types/app/witness/http-endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-endpoints.d.ts","sourceRoot":"","sources":["../../../src/app/witness/http-endpoints.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAShE,+CAA+C;AAC/C,MAAM,MAAM,wBAAwB,GAChC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,8CAA8C;AAC9C,MAAM,MAAM,uBAAuB,GAC/B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,2CAA2C;AAC3C,MAAM,MAAM,qBAAqB,GAC7B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAA;CAAE,GACjE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAkCxD,4CAA4C;AAC5C,MAAM,WAAW,yBAAyB;IACxC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,0DAA0D;AAC1D,wBAAiB,kBAAkB,CACjC,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,GAAG,EACf,KAAK,EAAE,UAAU,EACjB,EAAE,KAAY,EAAE,GAAE,yBAA8B,GAC/C,SAAS,CAAC,wBAAwB,CAAC,CAuCrC;AAED,gDAAgD;AAChD,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,GAAG,EACf,KAAK,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACvE,uBAAuB,CAqDzB;AAED,8CAA8C;AAC9C,wBAAgB,eAAe,CAC7B,UAAU,EAAE,GAAG,EACf,KAAK,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACtE,qBAAqB,CAmDvB;AAED,4EAA4E;AAC5E,MAAM,MAAM,wBAAwB,GAChC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,qGAAqG;AACrG,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,GAAG,EACf,KAAK,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAC1D,wBAAwB,CAqB1B"}

package/types/app/witness/ingress.d.ts

@@ -0,0 +1,65 @@
+import { type Operation } from "effection";
+import type { AgentCue } from "../../core/cues.js";
+import { type Deck } from "../../core/deck.js";
+import { type Hab } from "../identity/habbing.js";
+import type { AgentRuntime } from "../runtime/agent-runtime.js";
+/**
+ * Route one initial witness cue batch, leaving saved key-state facts for the
+ * application cue worker and its optional command-owned noticer destination.
+ * Respondant publishes Poster work; this ingress helper never drains Poster
+ * network delivery. Query network I/O stays with the independent sender.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param serviceHab Optional hosted witness signer; absent selection must be unambiguous.
+ * @param cues Exact runtime application Deck; foreign Decks are rejected.
+ * @param options deliver defaults true: publish outgoing work for the independent senders. False performs local signing side effects only.
+ */
+export declare function drainWitnessCues(runtime: AgentRuntime, serviceHab: Hab | undefined, cues: Deck<AgentCue>, { deliver }?: {
+    deliver?: boolean;
+}): Operation<void>;
+/** Witness-local dispatch and existing responder delivery policy for one ingress source. */
+export interface WitnessIngressOptions {
+    /** Accept with witness-local semantics; default false preserves ordinary ingress policy. */
+    local?: boolean;
+    /** Route queries/replies through their owners; receipts use false to produce their own finite proof. */
+    deliver?: boolean;
+}
+/**
+ * Own one witness input and settle each frame before requesting more input.
+ * Each complete frame publishes its prepared replies before requesting more input.
+ * Source abort and cleanup belong to this input scope.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param serviceHab Hosted witness/controller habitat used for local replies.
+ * @param source Creates cancellation-aware wire input owned by this operation.
+ * @param options local defaults false; deliver defaults true and controls cue publication, not Poster queue draining.
+ */
+export declare function processWitnessIngressSource(runtime: AgentRuntime, serviceHab: Hab, source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, { local, deliver }?: WitnessIngressOptions): Operation<void>;
+/**
+ * Parse and settle one inbound witness-host payload.
+ *
+ * This is the witness-host counterpart to generic runtime ingress.
+ *
+ * Responsibilities:
+ * - settle one inbound CESR payload with the correct witness-local semantics
+ * - immediately drain the resulting cues through the hosted witness habitat
+ * - leave request-scoped receipt construction with the endpoint owner
+ *
+ * `local=true` is the crucial switch for the witness receipt path: accepted
+ * events that list the hosted witness emit `witness` cues instead of ordinary
+ * `receipt` cues.
+ *
+ * Durable routing rule:
+ * - TCP witness ingress, witness `/receipts`, and ordinary HTTP root ingress
+ *   that targets the hosted witness AID should all reach this seam when the
+ *   host is acting as that witness
+ * - generic runtime ingress should remain separate for mailbox streaming,
+ *   `/ksn` replay publication, and other non-witness-root policies
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param serviceHab Hosted reply signer.
+ * @param bytes Finite signed input bytes adapted to the same source path.
+ * @param options Witness intake/local-production policy forwarded to processWitnessIngressSource.
+ */
+export declare function processWitnessIngress(runtime: AgentRuntime, serviceHab: Hab, bytes: Uint8Array, options?: WitnessIngressOptions): Operation<void>;
+//# sourceMappingURL=ingress.d.ts.map

package/types/app/witness/ingress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingress.d.ts","sourceRoot":"","sources":["../../../src/app/witness/ingress.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAElD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAahE;;;;;;;;;;GAUG;AACH,wBAAiB,gBAAgB,CAC/B,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,GAAG,GAAG,SAAS,EAC3B,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,EACpB,EAAE,OAAc,EAAE,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7C,SAAS,CAAC,IAAI,CAAC,CA4BjB;AAED,4FAA4F;AAC5F,MAAM,WAAW,qBAAqB;IACpC,4FAA4F;IAC5F,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wGAAwG;IACxG,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAiB,2BAA2B,CAC1C,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,GAAG,EACf,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,EAAE,KAAa,EAAE,OAAc,EAAE,GAAE,qBAA0B,GAC5D,SAAS,CAAC,IAAI,CAAC,CA2CjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAiB,qBAAqB,CACpC,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,GAAG,EACf,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,qBAA0B,GAClC,SAAS,CAAC,IAAI,CAAC,CAOjB"}

package/types/app/witness/receipt-client.d.ts

@@ -0,0 +1,82 @@
+/** Controller-side witness transport: HTTP receipts, explicit media fallback and optional duplex TCP intake. */
+import { Cigar, type Siger, type Versionage } from "cesr-ts";
+import { type Operation } from "effection";
+import { type Hab } from "../identity/habbing.js";
+import { type ProtocolProcessor } from "../protocol/protocol-processing.js";
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import type { HttpClient } from "../transport/http-client.js";
+/** Controller-side result of posting to one witness receipt endpoint. */
+export type WitnessReceiptEndpointResponse = {
+    kind: "accepted";
+    status: 200;
+    body: Uint8Array;
+    wigers: readonly Siger[];
+    cigars: readonly Cigar[];
+} | {
+    kind: "escrow";
+    status: 202;
+} | {
+    kind: "reject";
+    status: number;
+    message: string;
+};
+/** Resolve the HTTP or HTTPS witness endpoint when available. */
+export declare function witnessHttpUrl(hab: Hab, witness: string): string | null;
+/** Resolve the TCP witness endpoint when available. */
+export declare function witnessTcpUrl(hab: Hab, witness: string): string | null;
+/**
+ * Send via HTTP first; an explicit protocol processor processes same-socket TCP replies.
+ * Without a protocol processor TCP reports local transmission only. Actual socket/parser
+ * cleanup finishes before this borrowed protocol processor can be released.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param witness Target witness AID whose accepted locations choose HTTP-first/TCP fallback.
+ * @param bytes Complete signed event/introduction wire.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param clock Borrowed clock with epoch-millisecond now and millisecond timer delays.
+ * @param protocol Optional same-socket reply processor; null selects transmit-only TCP.
+ * @param auth Optional HTTP Authorization header value.
+ * @throws Missing endpoint, peer refusal, transport/parser or cleanup failures propagate.
+ */
+export declare function sendWitnessMessage(hab: Hab, witness: string, bytes: Uint8Array, http: HttpClient, clock: RuntimeClock, protocol: ProtocolProcessor | null, auth?: string): Operation<void>;
+/**
+ * Poll one witness `GET /receipts` endpoint until the receipt becomes available.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param witness Witness AID whose HTTP receipt endpoint is selected.
+ * @param pre Event subject AID.
+ * @param sn Event sequence number.
+ * @param said Exact event SAID to verify against returned proof.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param gvrsn Configured endpoint's reply attachment genus, selected before its complete response body.
+ * @returns Receipt endpoint status and wire result for later verification; HTTP success alone is not accepted witness state.
+ */
+export declare function pollWitnessReceipt(hab: Hab, witness: string, pre: string, sn: number, said: string, http: HttpClient, gvrsn?: Versionage): Operation<WitnessReceiptEndpointResponse>;
+/**
+ * Request one witness receipt via `POST /receipts`.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param witness Witness AID whose HTTP receipt endpoint is selected.
+ * @param message Complete signed event wire requesting a witness receipt.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param auth Optional witness HTTP Authorization value.
+ * @param gvrsn Reply attachment genus; the caller already encoded request proofs with this endpoint's selection.
+ * @returns Receipt endpoint status and wire result for later verification; HTTP success alone is not accepted witness state.
+ */
+export declare function postWitnessReceiptEndpoint(hab: Hab, witness: string, message: Uint8Array, http: HttpClient, auth?: string, gvrsn?: Versionage): Operation<WitnessReceiptEndpointResponse>;
+/**
+ * Request one stored witness receipt via `GET /receipts`.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param witness Witness AID whose HTTP receipt endpoint is selected.
+ * @param query Receipt lookup subject, sequence and digest fields.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param gvrsn Explicit response attachment genus; preserve v1 by default.
+ * @returns Receipt endpoint status and wire result for later verification; HTTP success alone is not accepted witness state.
+ */
+export declare function getWitnessReceiptEndpoint(hab: Hab, witness: string, query: {
+    pre: string;
+    sn?: number;
+    said?: string;
+}, http: HttpClient, gvrsn?: Versionage): Operation<WitnessReceiptEndpointResponse>;
+//# sourceMappingURL=receipt-client.d.ts.map

package/types/app/witness/receipt-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receipt-client.d.ts","sourceRoot":"","sources":["../../../src/app/witness/receipt-client.ts"],"names":[],"mappings":"AAAA,gHAAgH;AAChH,OAAO,EAAE,KAAK,EAAwB,KAAK,KAAK,EAAE,KAAK,UAAU,EAAY,MAAM,SAAS,CAAC;AAC7F,OAAO,EAAgB,KAAK,SAAS,EAAU,MAAM,WAAW,CAAC;AAGjE,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAE5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,KAAK,EAAE,UAAU,EAAsB,MAAM,6BAA6B,CAAC;AAgBlF,yEAAyE;AACzE,MAAM,MAAM,8BAA8B,GACtC;IACA,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,GAAG,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IACzB,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;CAC1B,GACC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AA4BxD,iEAAiE;AACjE,wBAAgB,cAAc,CAC5B,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAGf;AAED,uDAAuD;AACvD,wBAAgB,aAAa,CAC3B,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAGf;AAUD;;;;;;;;;;;;;GAaG;AACH,wBAAiB,kBAAkB,CACjC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,iBAAiB,GAAG,IAAI,EAClC,IAAI,CAAC,EAAE,MAAM,GACZ,SAAS,CAAC,IAAI,CAAC,CAsBjB;AAYD;;;;;;;;;;;GAWG;AACH,wBAAiB,kBAAkB,CACjC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,KAAK,GAAE,UAAqB,GAC3B,SAAS,CAAC,8BAA8B,CAAC,CAsC3C;AAED;;;;;;;;;;GAUG;AACH,wBAAiB,0BAA0B,CACzC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,IAAI,CAAC,EAAE,MAAM,EACb,KAAK,GAAE,UAAqB,GAC3B,SAAS,CAAC,8BAA8B,CAAC,CAwD3C;AAED;;;;;;;;;GASG;AACH,wBAAiB,yBAAyB,CACxC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,EACf,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAClD,IAAI,EAAE,UAAU,EAChB,KAAK,GAAE,UAAqB,GAC3B,SAAS,CAAC,8BAA8B,CAAC,CAuC3C"}

package/types/app/witness/receipt-messages.d.ts

@@ -0,0 +1,21 @@
+/** Receipt framing follows the receipt body version; core serialization owns the counters. */
+import { type Cigar, type SerderKERI, type Siger } from "cesr-ts";
+/** Build a collected receipt with an attachment enclosure. Signatures cover the receipted event. */
+export declare function buildDetachedReceiptMessage(serder: SerderKERI, { wigers, cigars }: {
+    wigers?: readonly Siger[];
+    cigars?: readonly Cigar[];
+}): Uint8Array;
+/** Match KERIpy receipt endpoints: body plus receipt material without an attachment enclosure. */
+export declare function buildEndpointDetachedReceiptMessage(serder: SerderKERI, { wigers, cigars }: {
+    wigers?: readonly Siger[];
+    cigars?: readonly Cigar[];
+}): Uint8Array;
+/** Build one attached `rct` message carrying witness indexed signatures. */
+export declare function buildWitnessReceiptMessage(serder: SerderKERI, wigers: readonly Siger[]): Uint8Array;
+/** Inspect one complete receipt; hydrated proof values have no asynchronous lifetime. */
+export declare function inspectReceiptMessage(bytes: Uint8Array): {
+    serder: SerderKERI;
+    wigers: readonly Siger[];
+    cigars: readonly Cigar[];
+};
+//# sourceMappingURL=receipt-messages.d.ts.map

package/types/app/witness/receipt-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receipt-messages.d.ts","sourceRoot":"","sources":["../../../src/app/witness/receipt-messages.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,OAAO,EAAE,KAAK,KAAK,EAAc,KAAK,UAAU,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAK9E,oGAAoG;AACpG,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAW,EAAE,MAAW,EAAE,EAAE;IAC5F,MAAM,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;CAC3B,GAAG,UAAU,CAGb;AAED,kGAAkG;AAClG,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAW,EAAE,MAAW,EAAE,EAAE;IACpG,MAAM,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;CAC3B,GAAG,UAAU,CAGb;AAED,4EAA4E;AAC5E,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,SAAS,KAAK,EAAE,GACvB,UAAU,CAEZ;AAED,yFAAyF;AACzF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,GAChB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAA;CAAE,CAK5E"}

package/types/app/witness/receipting.d.ts

@@ -0,0 +1,117 @@
+/** Collect accepted historical witness receipts and fan them out before reporting event completion. */
+import { type Versionage } from "cesr-ts";
+import { type Operation } from "effection";
+import { type Habery } from "../identity/habbing.js";
+import { type ProtocolProcessor } from "../protocol/protocol-processing.js";
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import type { HttpClient } from "../transport/http-client.js";
+/** Supported witness-auth payloads keyed by witness AID. */
+export type WitnessAuthMap = Record<string, string>;
+/** Result of one full witness receipt orchestration pass. */
+export interface WitnessReceiptRunResult {
+    readonly witnesses: readonly string[];
+    readonly statuses: Readonly<Record<string, number>>;
+}
+/**
+ * Controller-side synchronous witness receipt orchestration.
+ *
+ * Responsibilities:
+ * - publish through HTTP receipt endpoints (generic submission opts into TCP reply intake)
+ * - catch up newly added witnesses before receipting
+ * - persist returned receipts locally through the protocol processor
+ * - fan witness receipts out to the complementary witnesses
+ */
+export declare class Receiptor {
+    /** Borrowed accepted state and local signer collection. */
+    readonly hby: Habery;
+    /** Shared receipt verification, cue publication and escrow processing. */
+    readonly protocol: ProtocolProcessor;
+    /** Input-owned Kevery (kvy) for request-owned receipt GET/POST evidence. */
+    private readonly kvy;
+    /** Borrowed HTTP and clock services used by actual receipt operations. */
+    readonly http: HttpClient;
+    /** Borrowed clock for this owner's actual network deadlines. */
+    readonly clock: RuntimeClock;
+    /** Explicit attachment framing for the configured witness endpoints; independent of KEL body version. */
+    readonly gvrsn: Versionage;
+    /**
+     * Bind configured intake over the same Habery; acquire no stores or background workers.
+     *
+     * @param hby Borrowed local identities and accepted-state stores.
+     * @param protocol Borrowed same-database protocol owner for receipt intake.
+     * @param http Borrowed HTTP implementation selected by composition.
+     * @param clock Borrowed clock with epoch-millisecond now and millisecond timer delays.
+     * @param options Explicit witness attachment genus; the historical v1 default is independent of KEL body version.
+     */
+    constructor(hby: Habery, protocol: ProtocolProcessor, http: HttpClient, clock: RuntimeClock, { gvrsn }?: {
+        gvrsn?: Versionage;
+    });
+    /** Submit the latest or specified event to all witnesses and gather receipts. */
+    receipt(pre: string, { sn, auths, allowTcp }?: {
+        sn?: number;
+        auths?: WitnessAuthMap;
+        /** Generic WitnessReceiptor permits TCP; explicit receipt endpoints remain HTTP-only. */
+        allowTcp?: boolean;
+    }): Operation<WitnessReceiptRunResult>;
+    /**
+     * One scoped attempt joins actual receipt HTTP/TCP work before returning.
+     *
+     * @param pre Local event subject AID.
+     * @param options Optional event sequence and witness Authorization map.
+     * @param allowTcp Whether missing HTTP receipt routes may use TCP message delivery.
+     * @returns Receipt-attempt result based on verified local witness proof.
+     */
+    private receiptOnce;
+    /**
+     * Query a stored witness receipt and apply it to local state when found.
+     *
+     * @param pre Event subject AID.
+     * @param options Optional sequence/SAID selection; defaults follow current accepted state.
+     * @returns Whether matching verified witness receipt state was obtained.
+     */
+    get(pre: string, { sn, said }?: {
+        sn?: number;
+        said?: string;
+    }): Operation<boolean>;
+    /**
+     * Catch one witness up through the same protocol processor used for receipt intake.
+     *
+     * @param pre Local KEL subject to replay.
+     * @param witness Witness AID to catch up.
+     */
+    catchup(pre: string, witness: string): Operation<void>;
+    /** Complete streams select their framing before the body; detached receipt headers retain their existing enclosure. */
+    private selected;
+}
+/**
+ * Higher-level full witness submission helper.
+ *
+ * HTTP uses finite receipt endpoints; TCP uses same-socket local reply intake
+ * and requires the requested witness signature to be persisted before fanout.
+ */
+export declare class WitnessReceiptor {
+    /** Actual receipt-intake/fanout owner over the same shared protocol domain. */
+    readonly receiptor: Receiptor;
+    /** Borrowed identities and accepted witness cohorts. */
+    readonly hby: Habery;
+    /** Existing explicit request to publish even when cached receipt completion is available. */
+    readonly force: boolean;
+    /**
+     * Bind actual protocol/I/O dependencies; only the scalar force choice is optional.
+     *
+     * @param hby Borrowed local identities and accepted-state stores.
+     * @param protocol Borrowed same-database protocol owner for receipt intake.
+     * @param http Borrowed HTTP implementation selected by composition.
+     * @param clock Borrowed clock with epoch-millisecond now and millisecond timer delays.
+     * @param options force defaults false; true requests the existing forced witness submission policy.
+     */
+    constructor(hby: Habery, protocol: ProtocolProcessor, http: HttpClient, clock: RuntimeClock, { force }?: {
+        force?: boolean;
+    });
+    /** Ensure the current event reaches full witness receipt convergence. */
+    submit(pre: string, { sn, auths }?: {
+        sn?: number;
+        auths?: WitnessAuthMap;
+    }): Operation<WitnessReceiptRunResult>;
+}
+//# sourceMappingURL=receipting.d.ts.map