keri-ts 1.0.0 → 2.0.1

package/types/app/runtime/agent-runtime.d.ts

@@ -0,0 +1,348 @@
+import { type Operation } from "effection";
+import { Dhke } from "../../acdc/dhking.js";
+import { type Regery as AcdcRegery } from "../../acdc/registraring.js";
+import { RegistryRoot } from "../../acdc/salting.js";
+import { Unblind } from "../../acdc/unblinding.js";
+import type { AgentCue } from "../../core/cues.js";
+import { Deck } from "../../core/deck.js";
+import type { KeriDispatchEnvelope, TransIdxSigGroup } from "../../core/dispatch.js";
+import { type MessagePolicy } from "../../core/kel/eventing.js";
+import { type KramConfig } from "../../core/mailbox/kraming.js";
+import { Mailboxer } from "../../db/mailbox/mailboxing.js";
+import { Noter } from "../../db/noting.js";
+import { Reger } from "../../db/reger.js";
+import { Regery as VdrRegery } from "../../vdr/credentialing.js";
+import { Authenticator } from "../bootstrap/authenticating.js";
+import { Oobiery, type OobiJob } from "../bootstrap/oobiery.js";
+import { Poster } from "../delivery/forwarding.js";
+import { ReplyStreams } from "../delivery/reply-streams.js";
+import { Respondant } from "../delivery/respondant.js";
+import { Exchanger } from "../exchanges/exchanging.js";
+import { Anchorer } from "../identity/delegating.js";
+import type { Hab, Habery } from "../identity/habbing.js";
+import { MailboxDirector } from "../mailbox/mailbox-director.js";
+import { type MailboxPollBatch, MailboxPoller } from "../mailbox/mailbox-poller.js";
+import { type Multiplexor } from "../multisig/grouping.js";
+import { Notifier } from "../notifications/notifying.js";
+import { Signaler } from "../notifications/signaling.js";
+import { ProtocolProcessor } from "../protocol/protocol-processing.js";
+import { Reactor } from "../protocol/reactor.js";
+import { QueryReplies } from "../queries/query-replies.js";
+import { WitnessInquisitor } from "../queries/witness-inquisitor.js";
+import type { HttpClient } from "../transport/http-client.js";
+import type { RuntimeClock } from "./runtime-clock.js";
+export type { KeriDispatchEnvelope, OobiJob, TransIdxSigGroup };
+/** One explicitly selected local IPEX auxiliary owner; construction never approves a Grant. */
+export type IpexAuxiliarySelection = {
+    kind: "dhke";
+    hab: Hab;
+} | {
+    kind: "unblind";
+    hab: Hab;
+    states: readonly string[];
+};
+/** Concrete owner exposed only at composition for finite application orchestration. */
+export type IpexAuxiliary = {
+    kind: "dhke";
+    owner: Dhke;
+} | {
+    kind: "unblind";
+    owner: Unblind;
+};
+/**
+ * Shared runtime composition root owned by one `Habery`.
+ *
+ * Ownership model:
+ * - the root keeps only truly shared state: `hby` and the shared
+ *   cue deck
+ * - topic-local state belongs to the component that owns that flow
+ * - `Reactor` owns byte ingress; `ProtocolProcessor` owns shared protocol work
+ * - `Oobiery` owns durable OOBI queue processing
+ * - `Authenticator` owns well-known auth convergence
+ *
+ * KERIpy mental model:
+ * - this is the closest local analogue to a composition root that assembles
+ *   multiple doer-owning components, not a bag of every runtime queue
+ */
+export interface AgentRuntime {
+    /** Borrowed identities and accepted-state stores; the runtime never closes the Habery. */
+    hby: Habery;
+    /** Provider mailbox store, borrowed when injected and otherwise owned when enabled. */
+    mailboxer: Mailboxer | null;
+    /** Persistent notice store; ownership follows explicit injection. */
+    noter: Noter | null;
+    /** Configured notice producer, sharing the composed signer and signaler. */
+    notifier: Notifier | null;
+    /** Transient notice hints; only a runtime-created instance is closed here. */
+    signaler: Signaler | null;
+    /** Ordinary protocol facts, consumed by the composed cue workers. */
+    cues: Deck<AgentCue>;
+    /** Demand-driven input lifetime; protocol decisions stay with ProtocolProcessor. */
+    reactor: Reactor;
+    /** Shared protocol mutations, publication and background escrow processing. */
+    protocol: ProtocolProcessor;
+    /** Request-owned correlation slots shared with protocol cue publication. */
+    replies: QueryReplies;
+    /** Configured application exchange processor; workflows observe its durable completion. */
+    exc: Exchanger;
+    /** Group proposal coordinator behind the registered `/multisig/*` routes; owners share routes by child route. */
+    mux: Multiplexor;
+    /** Selected process-local IPEX operation owner, released on explicit close or scope exit. */
+    readonly ipexAuxiliary: IpexAuxiliary | null;
+    /** Durable OOBI job owner, independent of outgoing delivery. */
+    oobiery: Oobiery;
+    /** Well-known authentication jobs over the shared HTTP service. */
+    authenticator: Authenticator;
+    /** Provider stream and mailbox correlation owner. */
+    mailboxDirector: MailboxDirector;
+    /** Cue-to-signed-message producer; it publishes to postman. */
+    respondant: Respondant;
+    /** Outbound mailbox SSE polling with independently owned response lifetimes. */
+    mailboxPoller: MailboxPoller;
+    /** Single FIFO outgoing delivery queue and retained failure owner. */
+    postman: Poster;
+    /** Delegation workflow state and delivery/accepted-state gates. */
+    delegating: Anchorer;
+    /**
+     * Background unsigned-request sender, run independently of reply intake.
+     * Pending sender work excludes semantic query waits; their invoking operations
+     * must observe accepted state and own their own deadline/cancellation.
+     */
+    querying: WitnessInquisitor;
+    /** Live lazy HTTP replies, closed before their database owners. */
+    replyStreams: ReplyStreams;
+    /** Concrete legacy TEL/credential owner; absent for a readonly Habery without an injected store. */
+    readonly vdr: VdrRegery | null;
+    /** V2 registry services, separately owned from the legacy VDR environment. */
+    readonly acdc: AcdcRegery | null;
+    /**
+     * Registered `/registry/root` owner; null without a v2 registry or when the
+     * composition refuses root copies.
+     */
+    readonly registryRoot: RegistryRoot | null;
+    /** Borrowed HTTP implementation selected by the application root. */
+    readonly http: HttpClient;
+    /** Borrowed clock selected by the same application root. */
+    readonly clock: RuntimeClock;
+    /** Close only runtime-owned sidecars; caller-injected resources stay caller-owned. */
+    close(): Operation<void>;
+}
+/**
+ * Store acquisition and protocol policy choices for one composed agent.
+ *
+ * Required I/O collaborators are separate arguments. Optional stores select
+ * borrowed resources; omitted stores follow the explicit acquisition rules.
+ */
+export interface AgentRuntimeOptions {
+    /**
+     * Borrowed provider store; omission creates none unless enableMailboxStore is true.
+     */
+    mailboxer?: Mailboxer;
+    /**
+     * Borrowed notice store; omission may acquire a writable default store.
+     */
+    noter?: Noter;
+    /**
+     * Borrowed transient hint source, shared with any injected notifier.
+     */
+    signaler?: Signaler;
+    /**
+     * Borrowed notice producer; signer/store/signaler identities must match the composition.
+     */
+    notifier?: Notifier;
+    /** Construct a provider mailbox store. Omitted leaves it absent; injected mailboxer stays borrowed. */
+    enableMailboxStore?: boolean;
+    /** Borrowed legacy registry store; the runtime creates its processors and never closes this store. */
+    reger?: Reger;
+    /** An injected v2 manager and its backing store remain caller-owned. */
+    acdc?: AcdcRegery;
+    /** Sender filtering for v2 non-event ingress; denial always wins. */
+    messagePolicy?: MessagePolicy;
+    /** Optional KRAM uses the trusted runtime receiver clock. */
+    kram?: KramConfig;
+    /** Select one local owner; requires an available v2 registry and explicitly enabled KRAM. */
+    ipexAuxiliary?: IpexAuxiliarySelection;
+    /**
+     * `/registry/root` policy. `"accept"` (default) registers `RegistryRoot` when
+     * a v2 registry is available, so copies are retained or escrowed on arrival.
+     * `"refuse"` registers a `RouteRefuser` so a copy is rejected and nothing is
+     * persisted; service roles that hold no registries use it.
+     */
+    registryRoots?: "accept" | "refuse";
+}
+/** Summary of pending runtime-backed durable work for bounded command hosts. */
+export interface RuntimePendingState {
+    /**
+     * Whether ordinary application cues await routing.
+     */
+    cues: boolean;
+    /**
+     * Whether reply-signature escrow rows remain.
+     */
+    replyEscrow: boolean;
+    /**
+     * Whether durable OOBI jobs await acquisition.
+     */
+    oobiQueued: boolean;
+    /**
+     * Whether OOBI jobs are marked in flight.
+     */
+    oobiInFlight: boolean;
+    /**
+     * Whether multi-OOBI work remains.
+     */
+    multiPending: boolean;
+    /**
+     * Whether well-known authentication jobs await processing.
+     */
+    authQueued: boolean;
+    /**
+     * Whether authentication requests are marked in flight.
+     */
+    authInFlight: boolean;
+    /**
+     * Whether witness, unanchored or publication delegation escrow remains.
+     */
+    delegationPending: boolean;
+    /** True while unsigned query requests or their current transport attempt remain. */
+    queriesPending: boolean;
+    /** True while independently retained query/cue delivery owners remain. */
+    deliveriesPending: boolean;
+}
+/**
+ * Create the shared runtime composition root used by CLI commands and
+ * `tufa agent`.
+ *
+ * Construction rule:
+ * - application roots supply HTTP, clock and mailbox transport explicitly
+ * - hosts choose concrete optional stores and borrow supplied dependencies
+ * - the composition owns only stores it constructs
+ *
+ * @param hby Borrowed local identities and accepted-state stores.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param clock Borrowed clock with epoch-millisecond now and millisecond timer delays.
+ * @param options Optional borrowed stores and protocol policy; omitted writable stores follow the documented acquisition rules.
+ * @returns A composed runtime within the enclosing Effection scope; workers are started separately.
+ * @throws Dependency mismatch/acquisition errors propagate after owned resource cleanup.
+ */
+export declare function createAgentRuntime(hby: Habery, http: HttpClient, clock: RuntimeClock, options?: AgentRuntimeOptions): Operation<AgentRuntime>;
+/**
+ * Queue one OOBI resolution job through the durable OOBI component.
+ *
+ * Unlike the older bootstrap runtime, this no longer stages jobs on a root
+ * in-memory deck. The authoritative queue is the `oobis.` database family.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param job URL and optional alias admitted to the durable OOBI owner.
+ */
+export declare function enqueueOobi(runtime: AgentRuntime, job: OobiJob): void;
+/**
+ * Parse and settle one or more complete KERI/CESR records immediately.
+ *
+ * This is the shared ingress-settlement seam for mailbox-delivered batches and
+ * HTTP request payloads that should advance parser and escrow state together.
+ *
+ * Maintainer mental model:
+ * - this helper is intentionally route-policy-free
+ * - callers decide whether a message should be treated as `local` or ordinary
+ *   remote ingress before calling it
+ * - once called, it always does the same two things: finish each record and run
+ *   one escrow replay turn
+ *
+ * Why `local` matters:
+ * - `local` is not an HTTP transport detail
+ * - it is a parser/runtime semantic switch used when the host is acting as the
+ *   local controller or local witness for the received message
+ * - witness hosting relies on that distinction so accepted witness-targeted
+ *   events emit witness cues rather than ordinary remote receipt cues
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param messages Complete resident wire records, processed in iterable order.
+ * @param options Optional local-controller/witness policy and receiving mailbox endpoint provenance.
+ */
+export declare function settleRuntimeIngress(runtime: AgentRuntime, messages: Iterable<Uint8Array>, { local, mailboxAid, }?: {
+    local?: boolean;
+    /** Receiving hosted endpoint; passed through each dispatch rather than stored globally. */
+    mailboxAid?: string | null;
+}): Operation<void>;
+/**
+ * Process one remote mailbox batch and its follow-on escrow work.
+ *
+ * The poller awaits this operation before recording the provider cursor or
+ * reading the next event. Protocol completion can accept, escrow or reject input;
+ * it does not acknowledge the message to the provider or delete its stored row.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param batch Ordered wire messages for one mailbox subject and provider AID; each is processed before the final escrow pass.
+ */
+export declare function settleMailboxPollBatch(runtime: AgentRuntime, batch: MailboxPollBatch): Operation<void>;
+/**
+ * Return the current pending-work summary for bounded command-local hosts.
+ *
+ * `queriesPending` describes the background sender only. A concrete workflow
+ * remains active in its invoking operation until its accepted-state predicate holds.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @returns Current selected work summary; retained Poster failures/completion cues do not imply pending delivery.
+ */
+export declare function runtimePendingState(runtime: AgentRuntime): RuntimePendingState;
+/**
+ * Return true when any command-local runtime work remains in flight.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @returns Whether any category in runtimePendingState is pending.
+ */
+export declare function runtimeHasPendingWork(runtime: AgentRuntime): boolean;
+/**
+ * Return true once OOBI acceptance and its ingress/query dependencies settle.
+ * Background receipt delivery is not remote acknowledgement of OOBI acceptance;
+ * static OOBI servers may refuse unsolicited posts. Runtime close still joins I/O.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param url Exact requested OOBI/well-known URL whose durable state is inspected.
+ * @returns Whether the documented authentication/convergence predicate currently holds.
+ */
+export declare function runtimeOobiConverged(runtime: AgentRuntime, url: string): boolean;
+/**
+ * Run host workers until the caller's predicate succeeds or its deadline expires.
+ * The deadline uses Date.now wall time in the current implementation. The worker
+ * is halted and joined on success, timeout, failure or cancellation before the
+ * caller can release stores. A true predicate at entry starts no worker.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param done Synchronous accepted-state/completion predicate, checked before worker startup and each turn.
+ * @param options Required timeoutMs plus optional signer and mailbox polling selection.
+ * @throws Timeout or worker/cleanup failure propagates.
+ */
+export declare function runAgentRuntimeUntil(runtime: AgentRuntime, done: () => boolean, options: {
+    hab?: Hab;
+    timeoutMs: number;
+    pollMailbox?: boolean;
+}): Operation<void>;
+/**
+ * Yield cooperatively back to the host scheduler between runtime turns.
+ *
+ * Re-exported here because earlier Gate E helpers imported the scheduler
+ * boundary from `agent-runtime.ts`, and the boundary still conceptually belongs
+ * to the shared runtime surface even though components use it internally too.
+ */
+export { runtimeTurn } from "./runtime-turn.js";
+/**
+ * Start the independently progressing runtime workers and suspend until halted.
+ * Compose query delivery, Poster delivery, cue routing,
+ * ProtocolProcessor escrows, OOBI/authentication, optional notice/mailbox workers,
+ * delegation and ordinary query sending. The finalizer halts children in reverse
+ * order; store ownership remains with the composition scope.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param options Optional default query/cue signer, remote pollMailbox switch
+ * (default true) and command-owned queryCues Deck. Wire queryCues before starting
+ * workers; the application cue owner transfers saved notices to its sole noticer.
+ * Provider storage never enables local consumption.
+ */
+export declare function runAgentRuntime(runtime: AgentRuntime, options?: {
+    hab?: Hab;
+    pollMailbox?: boolean;
+    queryCues?: Deck<AgentCue>;
+}): Operation<void>;
+//# sourceMappingURL=agent-runtime.d.ts.map

package/types/app/runtime/agent-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runtime.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/agent-runtime.ts"],"names":[],"mappings":"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"}

package/types/app/runtime/cue-runtime.d.ts

@@ -0,0 +1,33 @@
+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 "./agent-runtime.js";
+/**
+ * Route one initial cue batch to its concrete owners before removing source records.
+ *
+ * Transfer query instructions to the sender, stream cues to mailbox correlation
+ * and produced responder messages to Poster. No network delivery runs inline.
+ * Saved key-state facts transfer once to the command's optional query Deck;
+ * its noticer never competes with this worker over the runtime source Deck.
+ * Admission and source removal run synchronously within this finite batch.
+ *
+ * @param runtime Borrowed composed runtime containing the actual cue consumers.
+ * @param options Explicit signer and optional command-owned query cue destination.
+ * Without a query destination, saved notices retain the ordinary unhandled-cue behavior.
+ */
+export declare function processCuesOnce(runtime: AgentRuntime, { hab, queryCues }?: {
+    hab?: Hab;
+    queryCues?: Deck<AgentCue>;
+}): Operation<void>;
+/**
+ * Continuous cue worker; network output belongs to the concrete query and reply workers.
+ *
+ * @param runtime Borrowed composed runtime containing the actual cue consumers.
+ * @param options Explicit signer and optional command-owned query cue destination.
+ */
+export declare function cueDo(runtime: AgentRuntime, options?: {
+    hab?: Hab;
+    queryCues?: Deck<AgentCue>;
+}): Operation<never>;
+//# sourceMappingURL=cue-runtime.d.ts.map

package/types/app/runtime/cue-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cue-runtime.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/cue-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAiBvD;;;;;;;;;;;;GAYG;AACH,wBAAiB,eAAe,CAC9B,OAAO,EAAE,YAAY,EACrB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAE;IAAE,GAAG,CAAC,EAAE,GAAG,CAAC;IAAC,SAAS,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;CAAO,GACjE,SAAS,CAAC,IAAI,CAAC,CAgBjB;AAED;;;;;GAKG;AACH,wBAAiB,KAAK,CACpB,OAAO,EAAE,YAAY,EACrB,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,GAAG,CAAC;IAAC,SAAS,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;CAAO,GACtD,SAAS,CAAC,KAAK,CAAC,CAKlB"}

package/types/app/runtime/runtime-clock.d.ts

@@ -0,0 +1,28 @@
+/** Opaque timer handle returned by the selected clock implementation. */
+export type RuntimeTimer = unknown;
+/** Wall time and timers shared by timeout-sensitive operations; timestamps use epoch milliseconds and delays use elapsed milliseconds. */
+export interface RuntimeClock {
+    /**
+     * Read the current epoch time in milliseconds.
+     *
+     * @returns Current epoch wall time in milliseconds; persistence consumers must not substitute a process-relative timer.
+     */
+    now(): number;
+    /**
+     * Schedule one callback after the requested elapsed milliseconds.
+     *
+     * @param callback One-shot callback invoked after the delay; cancellation prevents a still-pending invocation.
+     * @param ms Elapsed delay in milliseconds, not an epoch timestamp.
+     * @returns Opaque handle that must be cancelled through this same clock.
+     */
+    setTimeout(callback: () => void, ms: number): RuntimeTimer;
+    /**
+     * Cancel a timer acquired from this clock.
+     *
+     * @param timer Handle returned by this clock's setTimeout.
+     */
+    clearTimeout(timer: RuntimeTimer): void;
+}
+/** Production clock; application composition supplies it to its consumers. */
+export declare const systemClock: RuntimeClock;
+//# sourceMappingURL=runtime-clock.d.ts.map

package/types/app/runtime/runtime-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-clock.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/runtime-clock.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC;AAEnC,0IAA0I;AAC1I,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,GAAG,IAAI,MAAM,CAAC;IACd;;;;;;OAMG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC;IAC3D;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;CACzC;AAED,8EAA8E;AAC9E,eAAO,MAAM,WAAW,EAAE,YAIxB,CAAC"}

package/types/app/runtime/runtime-turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-turn.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/runtime-turn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAiB,WAAW,IAAI,SAAS,CAAC,IAAI,CAAC,CAK9C"}

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