keri-ts 1.0.0 → 2.0.1

package/types/app/{cesr-http.d.ts → transport/cesr-http.d.ts}

@@ -6,17 +6,8 @@
  * KERIpy correspondence:
  * - default behavior is one CESR message per HTTP request with the message body
  *   in the request body and attachments in `CESR-ATTACHMENT`
- *
- * Current `keri-ts` difference:
- * - `keri-ts` supports an optional `"body"` mode for mailbox operations where the
- *   full CESR payload is sent in the body instead of splitting attachments into
- *   the header
  */
 import { SerderKERI } from "cesr-ts";
-/** Mailbox HTTP framing modes supported by `keri-ts`. */
-export type CesrBodyMode = "header" | "body";
-/** Default interop mode matching KERIpy mailbox behavior. */
-export declare const DEFAULT_CESR_BODY_MODE: CesrBodyMode;
 /** CESR HTTP content type used by mailbox and exchange endpoints. */
 export declare const CESR_CONTENT_TYPE = "application/cesr";
 /** KERIpy's legacy-but-authoritative CESR HTTP media type. */
@@ -41,22 +32,8 @@ export interface CesrStreamInspection {
     readonly messages: readonly SerderKERI[];
     readonly terminal: SerderKERI | null;
 }
-/** Normalize CLI or config input into one supported CESR body mode. */
-export declare function normalizeCesrBodyMode(value: unknown, fallback?: CesrBodyMode): CesrBodyMode;
-/** Normalize a global config string into one supported CESR body mode. */
-export declare function cesrBodyModeFromGlobal(value: string | null | undefined): CesrBodyMode;
-/**
- * Build one HTTP request payload for a CESR message.
- *
- * Header mode:
- * - HTTP body carries the message body only
- * - `CESR-ATTACHMENT` carries the detached attachments
- *
- * Body mode:
- * - the full payload is sent in the HTTP body
- */
-export declare function buildCesrRequest(message: Uint8Array, { bodyMode, contentType, destination }?: {
-    bodyMode?: CesrBodyMode;
+/** Build ordinary signed-message POST framing, preserving the signed body bytes. */
+export declare function buildCesrRequest(message: Uint8Array, { contentType, destination }?: {
     contentType?: string;
     destination?: string;
 }): {
@@ -78,8 +55,8 @@ export declare function buildCesrStreamRequest(bytes: Uint8Array, { destination
 /**
  * Reconstruct one logical CESR payload from an incoming HTTP request.
  *
- * In header mode this reattaches `CESR-ATTACHMENT` bytes to the parsed message
- * body so downstream parsing always sees the canonical CESR byte stream.
+ * Header mode restores the declared `CESR-Genus` before the unchanged body and
+ * appends `CESR-ATTACHMENT`; body protocol version does not select that context.
  */
 export declare function requestBytes(req: Request, options?: {
     signal?: AbortSignal;

package/types/app/transport/cesr-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cesr-http.d.ts","sourceRoot":"","sources":["../../../src/app/transport/cesr-http.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAsD,UAAU,EAAS,MAAM,SAAS,CAAC;AAIhG,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,qBAAqB,CAAC;AACpD,8DAA8D;AAC9D,eAAO,MAAM,6BAA6B,0BAA0B,CAAC;AACrE,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB,wBAAwB,CAAC;AAC5D,oEAAoE;AACpE,eAAO,MAAM,sBAAsB,oBAAoB,CAAC;AACxD,qEAAqE;AACrE,eAAO,MAAM,uBAAuB,qBAAqB,CAAC;AAK1D,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAI3E;AAED,yEAAyE;AACzE,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,OAAO,CAET;AAED,4EAA4E;AAC5E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;CAC3C;AAED,+EAA+E;AAC/E,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI,CAAC;CACtC;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,UAAU,EACnB,EAAE,WAA+B,EAAE,WAAW,EAAE,GAAE;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GACL;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAOxD;AACD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,WAAW,EAAE,GAAE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAW9D;AACD;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GACrC,aAAa,CAAC,UAAU,CAAC,CAqB3B;AAED,mGAAmG;AACnG,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAoB5E;AAED;;;;;;;GAOG;AACH,wBAAsB,4BAA4B,CAChD,GAAG,EAAE,OAAO,GACX,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAK5B;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,OAAO,GACX,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CA0BrC;AAED,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI,CAOvE;AAED,mEAAmE;AACnE,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAE5B;AACD,iFAAiF;AACjF,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAWxF"}

package/types/app/transport/http-client.d.ts

@@ -0,0 +1,99 @@
+/** Native HTTP request construction, byte I/O and joined attempt cleanup. */
+import { type Operation } from "effection";
+/** Existing HTTP request choices; protocol framing and retry policy belong to callers. */
+export interface HttpRequestInit {
+    /** HTTP method, validated by Request before any network execution. */
+    method?: string;
+    /** Actual request headers, including protocol framing and optional Authorization. */
+    headers?: HeadersInit;
+    /** Prepared request content; producers finish serialization before network execution. */
+    body?: string | Uint8Array | ArrayBuffer | null;
+    /** Caller-selected redirect behavior; the HTTP owner adds no retry policy. */
+    redirect?: RequestRedirect;
+    /** Caller cancellation/deadline, forwarded into the request and its body. */
+    signal?: AbortSignal | null;
+}
+/** Completed finite response; its bytes remain usable after the request has closed. */
+export interface HttpResponse {
+    /** HTTP status, interpreted by the application or protocol owner. */
+    readonly status: number;
+    /** Whether the status is successful; full body consumption has already completed. */
+    readonly ok: boolean;
+    /** Received protocol metadata. */
+    readonly headers: Headers;
+    /** Complete resident response bytes. */
+    readonly body: Uint8Array;
+}
+/** Response metadata and one request-owned byte source, valid only inside its request scope. */
+export interface HttpStreamResponse {
+    /** HTTP status; non-success statuses remain application/protocol decisions. */
+    readonly status: number;
+    /** Success derived from the HTTP status, independent of body/protocol acceptance. */
+    readonly ok: boolean;
+    /** Received headers; consumers interpret their protocol meaning. */
+    readonly headers: Headers;
+    /**
+     * Borrow the response body for one consumer.
+     * Finish iteration or return it before leaving the enclosing open scope. Metadata
+     * success does not imply that this stream will reach EOF successfully.
+     *
+     * @param signal Optional consumer cancellation that interrupts the owned request/body read.
+     * @returns The single borrowed body source; chunks are available only within the open request scope.
+     */
+    body(signal?: AbortSignal): AsyncIterable<Uint8Array>;
+}
+/** A scoped HTTP implementation supplied by composition, with an explicit transport-error contract. */
+export interface HttpClient {
+    /**
+     * Return finite response bytes after the owned request scope has closed.
+     *
+     * @param url Absolute HTTP(S) URL; invalid URL/request construction fails before fetch.
+     * @param init Prepared method, headers, finite body and cancellation; omitted values use native Request defaults.
+     * @returns Status, headers and complete owned bytes after request cleanup.
+     * @throws Validation/construction errors remain caller errors; native fetch/body failures are TransportError with cause. Cancellation and cleanup failures remain visible.
+     */
+    request(url: string, init?: HttpRequestInit): Operation<HttpResponse>;
+    /**
+     * Acquire response headers and retain native I/O in the enclosing scope.
+     * HTTP non-success status remains a response for the protocol caller to interpret.
+     * Scope exit aborts unread or pending I/O, joins it, and releases the reader.
+     * The consumer must not retain the response for use after that scope closes.
+     *
+     * @param url Absolute HTTP(S) URL without embedded credentials.
+     * @param init Prepared request choices and optional upstream signal; no asynchronous upload producer.
+     * @returns Response metadata and one body reader borrowed until the enclosing scope closes.
+     * @throws Request validation errors precede network classification. Native fetch/read failures become TransportError; consumer and genuine cleanup failures propagate.
+     */
+    open(url: string, init?: HttpRequestInit): Operation<HttpStreamResponse>;
+}
+/**
+ * Own the native Request, fetch and response reader for one attempt.
+ * Construction errors remain outside network classification. Native fetch/read
+ * errors retain their causes as TransportError. Consumer execution remains outside
+ * those catches; scope exit aborts and joins I/O before releasing its reader.
+ * Protocol consumers never receive the native Response.
+ */
+export declare class FetchHttpClient implements HttpClient {
+    /**
+     * Consume finite bytes and finish the request scope before returning a completed response.
+     *
+     * @param url Absolute HTTP(S) URL; invalid URL/request construction fails before fetch.
+     * @param init Prepared method, headers, finite body and cancellation; omitted values use native Request defaults.
+     * @returns Status, headers and complete owned bytes after request cleanup.
+     * @throws Validation/construction errors remain caller errors; native fetch/body failures are TransportError with cause. Cancellation and cleanup failures remain visible.
+     */
+    request(url: string, init?: HttpRequestInit): Operation<HttpResponse>;
+    /**
+     * Acquire headers and lend response bytes until the enclosing Effection scope ends.
+     * Validate Request before fetch; scope exit aborts unread I/O, joins pending
+     * fetch/read work and releases the reader. Consumer failures stay outside the
+     * transport catches. The response must not escape this scope.
+     *
+     * @param url Absolute HTTP(S) endpoint without embedded credentials.
+     * @param init Prepared method, headers, finite body and optional upstream cancellation; native Request defaults apply.
+     * @returns Metadata and one borrowed body source; status success does not prove body completion.
+     * @throws Validation errors precede network execution. Native fetch/read failures retain their cause in TransportError; cancellation and distinct cleanup failures propagate.
+     */
+    open(url: string, init?: HttpRequestInit): Operation<HttpStreamResponse>;
+}
+//# sourceMappingURL=http-client.d.ts.map

package/types/app/transport/http-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-client.d.ts","sourceRoot":"","sources":["../../../src/app/transport/http-client.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,EAAQ,KAAK,SAAS,EAAoB,MAAM,WAAW,CAAC;AAMnE,0FAA0F;AAC1F,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,yFAAyF;IACzF,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC;IAChD,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,6EAA6E;IAC7E,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAC7B;AAED,uFAAuF;AACvF,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED,gGAAgG;AAChG,MAAM,WAAW,kBAAkB;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;CACvD;AAED,uGAAuG;AACvG,MAAM,WAAW,UAAU;IACzB;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;IACtE;;;;;;;;;;OAUG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,kBAAkB,CAAC,CAAC;CAC1E;AAED;;;;;;GAMG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAChD;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,SAAS,CAAC,YAAY,CAAC;IASzE;;;;;;;;;;OAUG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,SAAS,CAAC,kBAAkB,CAAC;CAsH7E"}

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

@@ -0,0 +1,37 @@
+/** Ordinary signed-message POST delivery, independent of query receive processing. */
+import type { Operation } from "effection";
+import { type CesrPostResult, type EgressOptions } from "./cesr-egress.js";
+import type { HttpClient } from "./http-client.js";
+/** Fixed request metadata; transport construction does not select a framing preference. */
+export type HTTPMessengerOptions = Pick<EgressOptions, "destination" | "headers">;
+/**
+ * Send ordinary signed messages as ordered HTTP POSTs and finish response cleanup.
+ * Producers own preparation and Poster owns queued work. This component needs no
+ * Habery, protocol processor, parser state, timer or response history.
+ *
+ * Corresponds to the ordinary POST role of KERIpy HTTPMessenger. Complete CESR
+ * frames become separate POSTs: original signed body in the request body, text
+ * attachments in CESR-ATTACHMENT. Only the recognized pre-intake media refusal
+ * permits a second attempt with legacy media metadata. Successful response bytes
+ * are drained and discarded; protocol receiving belongs to independent intake.
+ */
+export declare class HTTPMessenger {
+    readonly url: string;
+    private readonly http;
+    private readonly options;
+    /** Bind one endpoint and request metadata; construction performs no I/O. */
+    constructor(url: string, http: HttpClient, options?: HTTPMessengerOptions);
+    /**
+     * Send resident signed bytes through the same parser/request path as sendSource.
+     * Keep the input unchanged until completion. A complete result proves transport
+     * completion, not remote verification, storage, approval or a processed reply.
+     */
+    send(msg: Uint8Array, options?: Pick<EgressOptions, "signal">): Operation<CesrPostResult>;
+    /**
+     * Iterate ordinary messages into POSTs; this is not whole-stream PUT delivery.
+     * A later malformed message cannot prevent an earlier valid POST. Parser,
+     * transport, source and cleanup failures propagate; HTTP refusal is typed data.
+     */
+    sendSource(source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, options?: Pick<EgressOptions, "signal">): Operation<CesrPostResult>;
+}
+//# sourceMappingURL=http-messenger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-messenger.d.ts","sourceRoot":"","sources":["../../../src/app/transport/http-messenger.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,2FAA2F;AAC3F,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,EAAE,aAAa,GAAG,SAAS,CAAC,CAAC;AAElF;;;;;;;;;;GAUG;AACH,qBAAa,aAAa;IAGtB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,4EAA4E;gBAEjE,GAAG,EAAE,MAAM,EACH,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,oBAAyB;IAGrD;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAAG,SAAS,CAAC,cAAc,CAAC;IAI7F;;;;OAIG;IACH,UAAU,CACR,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAC1C,SAAS,CAAC,cAAc,CAAC;CAG7B"}

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

@@ -0,0 +1,30 @@
+/** One finite, opaque HTTP PUT following KERIpy HTTPStreamMessenger. */
+import type { Operation } from "effection";
+import type { HttpClient, HttpResponse } from "./http-client.js";
+import type { HTTPMessengerOptions } from "./http-messenger.js";
+/**
+ * Bind one complete prepared payload to KERIpy-style HTTPStreamMessenger PUT.
+ * This component does not inspect CESR frames or own a producer queue. The
+ * producer prepares introductions, genus transitions and any sealing before
+ * construction; send owns only the actual request and joined response cleanup.
+ */
+export declare class HTTPStreamMessenger {
+    readonly url: string;
+    private readonly http;
+    private readonly payload;
+    private readonly options;
+    /** Construction borrows a finite payload; its producer must not mutate it during delivery. */
+    constructor(url: string, http: HttpClient, payload: Uint8Array, options?: HTTPMessengerOptions);
+    /**
+     * Send exactly one PUT without parsing, re-encoding or fallback to POST.
+     * Return ordinary owned response bytes after request cleanup; HTTP success
+     * alone does not establish protocol acceptance. Cancellation/failures propagate.
+     * Non-success status is returned to the caller as HttpResponse for interpretation.
+     * The complete payload is the body with explicit length; CESR-ATTACHMENT is
+     * removed because this is not ordinary detached-attachment POST framing.
+     */
+    send(options?: {
+        signal?: AbortSignal;
+    }): Operation<HttpResponse>;
+}
+//# sourceMappingURL=http-stream-messenger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-stream-messenger.d.ts","sourceRoot":"","sources":["../../../src/app/transport/http-stream-messenger.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE;;;;;GAKG;AACH,qBAAa,mBAAmB;IAG5B,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL1B,8FAA8F;gBAEnF,GAAG,EAAE,MAAM,EACH,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,UAAU,EACnB,OAAO,GAAE,oBAAyB;IAGrD;;;;;;;OAOG;IACH,IAAI,CAAC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GAAG,SAAS,CAAC,YAAY,CAAC;CAetE"}

package/types/app/transport/httping.d.ts

@@ -0,0 +1,19 @@
+/** HTTP caller policies; the composed client owns native requests, readers and cleanup. */
+import { type Operation } from "effection";
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import type { HttpClient, HttpRequestInit, HttpStreamResponse } from "./http-client.js";
+/**
+ * Acquire headers under the mailbox's existing timeout-as-no-response policy.
+ * The timer ends at headers, while the client resource remains live in this
+ * caller scope for body consumption. Only this timer's exact abort becomes null;
+ * external abort, native I/O and cleanup failures remain visible.
+ *
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param clock Borrowed clock with epoch-millisecond now and millisecond timer delays.
+ * @param url Absolute HTTP(S) endpoint.
+ * @param init Prepared request fields and optional upstream cancellation.
+ * @param timeoutMs Header-acquisition window in milliseconds; body consumption has its own caller policy.
+ * @returns Scoped response after headers, or null only for this owner's header timeout.
+ */
+export declare function requestWithHeaderTimeout(http: HttpClient, clock: RuntimeClock, url: string, init: HttpRequestInit, timeoutMs: number): Operation<HttpStreamResponse | null>;
+//# sourceMappingURL=httping.d.ts.map

package/types/app/transport/httping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httping.d.ts","sourceRoot":"","sources":["../../../src/app/transport/httping.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,OAAO,EAAQ,KAAK,SAAS,EAAY,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAgB,MAAM,6BAA6B,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAExF;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,MAAM,GAChB,SAAS,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAqCtC"}

package/types/app/transport/message-source.d.ts

@@ -0,0 +1,22 @@
+import { type Operation } from "effection";
+import type { Kevery } from "../../core/kel/eventing.js";
+import type { DispatchOptions, ProtocolProcessor } from "../protocol/protocol-processing.js";
+/** Protocol choices plus cancellation of this concrete source/parser lifetime. */
+export interface IngressOptions extends DispatchOptions {
+    /** Stops source reads and dispatch waiting, joining active cleanup before return. */
+    signal?: AbortSignal;
+}
+/**
+ * Consume complete frames through the supplied input-owned Kevery and shared protocol owner.
+ * A pending read is joined before iterator return; cancellation cannot resume the
+ * caller after disposal. The owning input operation borrows processors and acquires
+ * no stores, queues, transport services or background workers here.
+ *
+ * @param source Creates the input byte source with this operation's abort signal; each source must honor cancellation.
+ * @param protocol Borrowed dispatcher over synchronous domain commits and correlated cue publication.
+ * @param kvy Input-owned KEL processor bound to the same store, reply verifier and cue flow.
+ * @param options Dispatch policy and optional upstream cancellation; defaults follow the shared processor.
+ * @throws Parsing, dispatch and cleanup failures propagate after the pending pull and iterator cleanup join.
+ */
+export declare function processMessages(source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, protocol: ProtocolProcessor, kvy: Kevery, options?: IngressOptions): Operation<void>;
+//# sourceMappingURL=message-source.d.ts.map

package/types/app/transport/message-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-source.d.ts","sourceRoot":"","sources":["../../../src/app/transport/message-source.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,SAAS,EAAQ,MAAM,WAAW,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAG7F,kFAAkF;AAClF,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD,qFAAqF;IACrF,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAiB,eAAe,CAC9B,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,QAAQ,EAAE,iBAAiB,EAC3B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,SAAS,CAAC,IAAI,CAAC,CAqDjB"}

package/types/app/transport/messengering.d.ts

@@ -0,0 +1,41 @@
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import type { HttpClient } from "./http-client.js";
+import { HTTPMessenger } from "./http-messenger.js";
+import { HTTPStreamMessenger } from "./http-stream-messenger.js";
+import { TCPMessenger } from "./tcp-messenger.js";
+import { TCPStreamMessenger } from "./tcp-stream-messenger.js";
+/** Resolved transport URLs; identity/role discovery belongs to the caller. */
+export interface MessengerUrls {
+    https?: string;
+    http?: string;
+    tcp?: string;
+}
+/**
+ * Bind ordinary signed-message delivery to the first present HTTPS/HTTP/TCP URL.
+ * A malformed higher-priority URL fails rather than falling through to another
+ * transport. There is no network retry or endpoint discovery at this boundary.
+ *
+ * @param destination Remote AID carried in the HTTP CESR-DESTINATION header.
+ * @param urls Already resolved endpoints, keyed by their actual scheme.
+ * @param http Borrowed HTTP implementation, used only for an HTTP(S) selection.
+ * @param clock Borrowed deadline clock, used only for a TCP selection.
+ * @param headers Additional HTTP headers, such as Authorization; ignored by TCP.
+ * @returns A transmit-only messenger; caller runs send and owns its lifetime.
+ */
+export declare function messengerFrom(destination: string, urls: MessengerUrls, http: HttpClient, clock: RuntimeClock, headers?: HeadersInit): HTTPMessenger | TCPMessenger;
+/**
+ * Bind one prepared opaque payload to HTTP PUT or raw TCP delivery.
+ * No parser, re-signing or fallback to ordinary POST is introduced. This follows
+ * KERIpy's separate stream factory; "stream" describes the transport operation,
+ * while this API borrows finite resident bytes.
+ *
+ * @param destination Remote AID carried in HTTP framing; not a receipt/acceptance claim.
+ * @param urls Resolved endpoints, with the same fail-fast preference as messengerFrom.
+ * @param payload Complete prepared wire; caller must keep it unchanged until send finishes.
+ * @param http Borrowed HTTP service for a possible PUT.
+ * @param clock Borrowed clock for possible TCP connection/drain deadlines.
+ * @param headers Additional HTTP headers; ignored by TCP.
+ * @returns An unstarted messenger with no receive loop or scheduling ownership.
+ */
+export declare function streamMessengerFrom(destination: string, urls: MessengerUrls, payload: Uint8Array, http: HttpClient, clock: RuntimeClock, headers?: HeadersInit): HTTPStreamMessenger | TCPStreamMessenger;
+//# sourceMappingURL=messengering.d.ts.map

package/types/app/transport/messengering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messengering.d.ts","sourceRoot":"","sources":["../../../src/app/transport/messengering.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAmBD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,GAAG,YAAY,CAI9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,mBAAmB,GAAG,kBAAkB,CAI1C"}

package/types/app/{socket-source.d.ts → transport/socket-source.d.ts}

@@ -3,6 +3,9 @@ import type { Socket } from "node:net";
 import type { SourceOptions } from "./byte-source.js";
 /** Cancellation is mandatory so a stalled read can be interrupted before iterator cleanup joins. */
 export interface SocketSourceOptions extends SourceOptions {
+    /**
+     * Required owner cancellation; abort interrupts stalled reads before iterator cleanup can join.
+     */
     signal: AbortSignal;
 }
 /**
@@ -11,6 +14,11 @@ export interface SocketSourceOptions extends SourceOptions {
  * Socket/OS buffers and a returned native view can have larger backing; copied output is independent.
  * Abort, failure or early return destroys and joins the socket. Genuine receive EOF leaves its writable
  * half intact; the caller must own later socket errors, output drain and final close (allowHalfOpen).
+ *
+ * @param socket Borrowed binary socket with no competing readable/data consumer; receive ownership is acquired on first pull.
+ * @param options Required abort signal and optional positive chunk size in bytes; default 65536.
+ * @returns An exclusive iterator allowing one pending next call; each chunk owns its backing buffer.
+ * @throws Competing readers, text/object-mode sockets, invalid chunk sizes, I/O and cleanup failures.
  */
 export declare function socketBytes(socket: Socket, { signal, maxChunkBytes }: SocketSourceOptions): AsyncIterableIterator<Uint8Array>;
 //# sourceMappingURL=socket-source.d.ts.map

package/types/app/transport/socket-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-source.d.ts","sourceRoot":"","sources":["../../../src/app/transport/socket-source.ts"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD,oGAAoG;AACpG,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,EAAE,MAAM,EAAE,aAAyB,EAAE,EAAE,mBAAmB,GACzD,qBAAqB,CAAC,UAAU,CAAC,CA6KnC"}

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"}