keri-ts 0.11.0 → 2.0.0

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

@@ -0,0 +1,41 @@
+/** Transport readers. Each operation owns its reader and joins cancellation. */
+export interface SourceOptions {
+    /** Abort reads and release the transport when its operation stops. */
+    signal?: AbortSignal;
+    /** Buffer size used when chunking resident bytes or reading a local file. */
+    maxChunkBytes?: number;
+}
+/**
+ * Adapt an already resident finite value into independent bounded parser chunks.
+ *
+ * @param bytes Borrowed resident input; each yielded chunk is a copy independent of subsequent producer mutation.
+ * @param options Optional signal and positive integer chunk size in bytes; defaults to 65536.
+ * @yields Copied byte chunks in input order; this does not parse message boundaries.
+ */
+export declare function chunkBytes(bytes: Uint8Array, { signal, maxChunkBytes }?: SourceOptions): AsyncGenerator<Uint8Array>;
+/**
+ * Read a Fetch stream on demand and cancel its reader when parsing stops.
+ *
+ * @param stream Borrowed Web stream to read exclusively; null yields no bytes.
+ * @param options Optional signal that cancels the pending read.
+ * @yields Nonempty chunks supplied by the underlying stream.
+ * @throws Read/cancel/unlock failures, combined when distinct failures occur.
+ */
+export declare function streamBytes(stream: ReadableStream<Uint8Array> | null, { signal }?: Pick<SourceOptions, "signal">): AsyncGenerator<Uint8Array>;
+/**
+ * Stream a local file with fixed-size owned buffers and close it on break or abort.
+ *
+ * @param path Local filesystem path opened read-only for this iteration.
+ * @param options Optional cancellation and positive read buffer size in bytes; defaults to 65536.
+ * @yields Owned buffers up to the selected chunk size until file EOF.
+ * @throws Open/read failures or cancellation; the file closes on EOF, break or failure.
+ */
+export declare function fileBytes(path: string, { signal, maxChunkBytes }?: SourceOptions): AsyncGenerator<Uint8Array>;
+/**
+ * Collect an explicitly finite operation; bulk ingress should consume its source directly.
+ *
+ * @param source Finite byte source whose iteration errors propagate; do not pass an unbounded mailbox stream.
+ * @returns A contiguous owned array containing all chunks in order.
+ */
+export declare function collectBytes(source: AsyncIterable<Uint8Array>): Promise<Uint8Array<ArrayBuffer>>;
+//# sourceMappingURL=byte-source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"byte-source.d.ts","sourceRoot":"","sources":["../../../src/app/transport/byte-source.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAKhF,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAuB,UAAU,CAC/B,KAAK,EAAE,UAAU,EACjB,EAAE,MAAM,EAAE,aAAyB,EAAE,GAAE,aAAkB,GACxD,cAAc,CAAC,UAAU,CAAC,CAQ5B;AAED;;;;;;;GAOG;AACH,wBAAuB,WAAW,CAChC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,EACzC,EAAE,MAAM,EAAE,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAC7C,cAAc,CAAC,UAAU,CAAC,CA4C5B;AAED;;;;;;;GAOG;AACH,wBAAuB,SAAS,CAC9B,IAAI,EAAE,MAAM,EACZ,EAAE,MAAM,EAAE,aAAyB,EAAE,GAAE,aAAkB,GACxD,cAAc,CAAC,UAAU,CAAC,CA0B5B;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAetG"}

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

@@ -0,0 +1,117 @@
+/**
+ * CESR framing and bounded media negotiation over explicitly owned HTTP attempts.
+ * Ordinary send helpers finish response EOF/cleanup and return delivery facts.
+ * requestFrame instead lends a live response from an Effection resource: its
+ * caller consumes that body before leaving the enclosing scope. Neither path
+ * implicitly feeds successful response bytes into protocol processing.
+ *
+ * Match KERIpy's detached-attachment POST contract while retaining the exact
+ * signed body. Only the known pre-intake Falcon media refusal permits a second
+ * request; authentication/application failures and network errors are not retries.
+ */
+import { type CesrFrame } from "cesr-ts";
+import { type Operation } from "effection";
+import { ValidationError } from "../../core/errors.js";
+import type { HttpClient, HttpRequestInit, HttpStreamResponse } from "./http-client.js";
+/** Positive remote HTTP refusal, distinct from source, transport, storage and cleanup failure. */
+export declare class CesrHttpRefusal extends ValidationError {
+    readonly status: number;
+    /**
+     * Describe a completed HTTP refusal without classifying it as a network failure.
+     *
+     * @param message Endpoint/status detail for the observed peer refusal.
+     * @param status Actual non-success HTTP status returned by the peer.
+     */
+    constructor(message: string, status: number);
+}
+/** Expected remote HTTP refusal; infrastructure and cleanup failures still throw. */
+export type CesrPostResult = {
+    /** Complete means response EOF and cleanup finished; refuse is an observed non-success status. */
+    kind: "complete";
+} | {
+    /** Complete means response EOF and cleanup finished; refuse is an observed non-success status. */
+    kind: "refuse";
+    /** Completed peer refusal, retaining its HTTP status and decoded detail. */
+    error: CesrHttpRefusal;
+};
+/** Transport choices for one CESR frame. */
+export interface EgressOptions {
+    /** Additional transport headers, such as witness Authorization; CESR framing is set by the sender. */
+    headers?: HeadersInit;
+    /** Optional endpoint AID carried in CESR-DESTINATION. */
+    destination?: string;
+    /** Upstream cancellation joins the same request lifetime as Effection cancellation. */
+    signal?: AbortSignal;
+}
+/**
+ * Drain successful response bytes; retain refusal text for reporting and media negotiation.
+ *
+ * @param response Borrowed response; this function consumes its body once to EOF.
+ * @param signal Cancels the pending body read through its HTTP owner.
+ * @returns Decoded refusal text, or an empty string after draining a successful body.
+ * @throws Body-read or cancellation errors propagate; an HTTP status alone does not throw.
+ */
+export declare function readResponseDetail(response: HttpStreamResponse, signal: AbortSignal): Promise<string>;
+/**
+ * Open one frame response for a caller that needs to consume its bytes.
+ * The caller must keep its scope alive while reading; returning this handle from
+ * a closing scope does not transfer response ownership. Media fallback closes the
+ * rejected attempt before opening the legacy header-media attempt.
+ * The handle travels directly as this generator's return value: yield* requestFrame
+ * resumes with HttpStreamResponse while its resource remains provided to the
+ * enclosing scope. This is borrowing, not a detached response or a consume callback.
+ *
+ * @param url HTTP(S) endpoint to receive the framed POST; redirect handling is manual.
+ * @param frame Parsed signed body and attachments; framing preserves the signed body bytes.
+ * @param http Borrowed HTTP implementation supplied by composition; owns native request/body I/O.
+ * @param options Destination, extra headers and optional cancellation for ordinary signed-message POSTs.
+ * @returns A successful response borrowed until the enclosing Effection scope ends.
+ * @throws CesrHttpRefusal for a completed refusal; request, transport and cleanup failures propagate.
+ */
+export declare function requestFrame(url: string, frame: CesrFrame, http: HttpClient, options?: EgressOptions): Operation<HttpStreamResponse>;
+/**
+ * Recognize KERIpy v1's exact preprocessing media refusal, before protocol intake.
+ * Attachment framing and the current media type are required. Authentication,
+ * KRAM and application refusals cannot trigger a second submission merely by
+ * mentioning content type in their diagnostic text.
+ *
+ * @param request Exact prepared request whose response is being classified.
+ * @param status Observed peer HTTP status.
+ * @param detail Fully consumed refusal body decoded as text.
+ * @returns True only for the pinned Falcon content-type error representation.
+ */
+export declare function isLegacyCesrMediaRejection(request: HttpRequestInit, status: number, detail: string): boolean;
+/**
+ * Send a CESR source and throw on a completed peer refusal.
+ * One parsed frame becomes one POST, and its request scope closes before the next
+ * source pull. A refusal stops the sequence; prior frames may already be delivered.
+ * Cancellation aborts active work, joins any pending source pull and returns the
+ * parser iterator before leaving. There is no automatic retry beyond media fallback.
+ * A pending asynchronous source pull can finish after cancellation is requested;
+ * abort it first, then join that pull and return the iterator. Genuine late
+ * cleanup failures are retained alongside the primary failure rather than
+ * misreported as harmless cancellation.
+ *
+ * @param url HTTP(S) endpoint to receive the framed POST; redirect handling is manual.
+ * @param source Creates the CESR byte source for this invocation; it must observe the supplied abort signal.
+ * @param http Borrowed HTTP implementation supplied by composition; owns native request/body I/O.
+ * @param options Destination, extra headers and optional cancellation for ordinary signed-message POSTs.
+ * @throws Source/parser, transport and cleanup failures propagate without becoming peer refusals. A completed refusal throws CesrHttpRefusal.
+ */
+export declare function postCesr(url: string, source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, http: HttpClient, options?: EgressOptions): Operation<void>;
+/**
+ * Send frames sequentially and return a completed peer refusal as data.
+ * One parsed frame becomes one POST, and its request scope closes before the next
+ * source pull. A refusal stops the sequence; prior frames may already be delivered.
+ * Cancellation aborts active work, joins any pending source pull and returns the
+ * parser iterator before leaving. There is no automatic retry beyond media fallback.
+ *
+ * @param url HTTP(S) endpoint to receive the framed POST; redirect handling is manual.
+ * @param source Creates the CESR byte source for this invocation; it must observe the supplied abort signal.
+ * @param http Borrowed HTTP implementation supplied by composition; owns native request/body I/O.
+ * @param options Destination, extra headers and optional cancellation for ordinary signed-message POSTs.
+ * @returns The attempt result after all frames or the first refusal, with source/request cleanup joined.
+ * @throws Source/parser, transport and cleanup failures propagate without becoming peer refusals.
+ */
+export declare function attemptPostCesr(url: string, source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, http: HttpClient, options?: EgressOptions): Operation<CesrPostResult>;
+//# sourceMappingURL=cesr-egress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cesr-egress.d.ts","sourceRoot":"","sources":["../../../src/app/transport/cesr-egress.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAGL,KAAK,SAAS,EAGf,MAAM,SAAS,CAAC;AACjB,OAAO,EAAgB,KAAK,SAAS,EAA0B,MAAM,WAAW,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAQvD,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAExF,kGAAkG;AAClG,qBAAa,eAAgB,SAAQ,eAAe;IAOrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IANpD;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAW,MAAM,EAAE,MAAM;CAGrD;AAED,qFAAqF;AACrF,MAAM,MAAM,cAAc,GAAG;IAC3B,kGAAkG;IAClG,IAAI,EAAE,UAAU,CAAC;CAClB,GAAG;IACF,kGAAkG;IAClG,IAAI,EAAE,QAAQ,CAAC;IACf,4EAA4E;IAC5E,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAgBF,4CAA4C;AAC5C,MAAM,WAAW,aAAa;IAC5B,sGAAsG;IACtG,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uFAAuF;IACvF,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ3G;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,YAAY,CAC3B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,kBAAkB,CAAC,CAI/B;AAiFD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAc5G;AAqCD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAiB,QAAQ,CACvB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,IAAI,CAAC,CAGjB;AACD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,cAAc,CAAC,CAoE3B"}

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

@@ -6,18 +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";
-import { type SourceOptions } from "./byte-source.js";
-/** 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. */
@@ -42,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;
 }): {
@@ -70,7 +46,7 @@ export declare function buildCesrRequest(message: Uint8Array, { bodyMode, conten
  * This is the right helper for endpoints that accept an already assembled CESR
  * payload or a multi-message CESR stream in the body.
  */
-export declare function buildCesrStreamRequest(bytes: Uint8Array, { destination, }?: {
+export declare function buildCesrStreamRequest(bytes: Uint8Array, { destination }?: {
     destination?: string;
 }): {
     headers: Record<string, string>;
@@ -79,14 +55,14 @@ 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, { maxHeaderBytes, ...options }?: SourceOptions & {
-    maxHeaderBytes?: number;
+export declare function requestBytes(req: Request, options?: {
+    signal?: AbortSignal;
 }): AsyncIterable<Uint8Array>;
-/** Collect a bounded administrative/receipt request; generic ingress uses requestBytes directly. */
-export declare function readCesrRequestBytes(req: Request, limit?: number): Promise<Uint8Array>;
+/** Collect a finite administrative/receipt request; generic ingress uses requestBytes directly. */
+export declare function readCesrRequestBytes(req: Request): Promise<Uint8Array>;
 /**
  * Read one direct signed-KERI ingress request.
  *

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,15 +3,22 @@ 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;
 }
 /**
  * Borrow exclusive binary readable ownership on first pull; yield independent finite backing buffers.
- * The caller admits connection and two maxChunkBytes materialized read/copy allowances before pulling.
- * A returned view can pin larger native/pool backing; the host accounts for that and socket/OS buffers
- * separately. Neither twice the chunk ceiling nor readableHighWaterMark is a full native/RSS bound.
+ * Read size controls each materialized chunk, without claiming a native/RSS memory bound.
+ * 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"}