keri-ts 0.11.0 → 2.0.0

package/types/app/{verifying.d.ts → credentials/verifying.d.ts}

@@ -10,12 +10,12 @@
  *   flow; durable corruption and unsupported `DI2I` still fail explicitly
  */
 import { Diger, NumberPrimitive, Prefixer, SerderACDC } from "cesr-ts";
-import type { AgentCue } from "../core/cues.js";
-import { Deck } from "../core/deck.js";
-import type { VcStateRecordShape } from "../core/records.js";
-import type { Reger } from "../db/reger.js";
-import type { Habery } from "./habbing.js";
-import type { AcdcDispatchArgs } from "./parsering.js";
+import type { AgentCue } from "../../core/cues.js";
+import { Deck } from "../../core/deck.js";
+import type { VcStateRecordShape } from "../../core/records.js";
+import type { Reger } from "../../db/reger.js";
+import type { Habery } from "../identity/habbing.js";
+import type { AcdcDispatchArgs } from "../protocol/parsering.js";
 export type VerifierEscrowReason = "missingRegistry" | "missingSchema" | "missingChain";
 export type VerifierRejectReason = "missingAnchor" | "invalidCredential" | "invalidSchema" | "invalidEdge" | "revokedChain" | "unsupportedChainOperator";
 export type VerifierDecision = {
@@ -30,6 +30,8 @@ export type VerifierDecision = {
     reason: VerifierRejectReason;
     said: string;
     detail?: string;
+    /** Original validation failure, retained for owner diagnostics without changing the decision. */
+    cause?: unknown;
 };
 export type VerifierCue = Extract<AgentCue, {
     kin: "telquery" | "query" | "proof" | "saved";
@@ -45,7 +47,7 @@ export interface VerifierOptions {
     missingIssuerTimeoutMs?: number;
 }
 /**
- * Concrete verifier service consumed by `Reactor` through `VerifierLike`.
+ * Concrete credential verifier supplied to the shared `ProtocolProcessor`.
  *
  * The verifier owns only credential validation/indexing and its own VDR escrows.
  * TEL processing remains delegated to `Tevery`, and webhook/application policy
@@ -73,9 +75,8 @@ export declare class Verifier {
         seqner: NumberPrimitive;
         saider: Diger;
     }): VerifierDecision;
-    /** Admit the actual dependency before credential/proof/date writes in one synchronous turn.
+    /** Persist dependency evidence before publishing its ordinary query cue.
      * Registry/schema queries follow new membership; chain retries always request their dependency.
-     * Preparation refusal leaves the current escrow family and any prior credential proof unchanged.
      */
     private escrowDependency;
     /** Missing registry escrow. */
@@ -110,6 +111,16 @@ export declare class Verifier {
     }): void;
     /** Verify the credential at the far end of an edge. */
     verifyChain(nodeSaid: string, op: string | undefined, issuer: string): VcStateRecordShape | null;
+    /**
+     * Retry one dependency family and report terminal removals after they succeed.
+     *
+     * Acceptance and migration to another family are ordinary progress, not ejection.
+     * Storage failures propagate with the original evidence still owned by its escrow.
+     *
+     * @param db Pending credential identities and their original admission timestamps.
+     * @param expectedReason Dependency family whose membership this pass owns.
+     * @param timeoutMs Maximum pending age in milliseconds; equality remains eligible.
+     */
     private processEscrow;
     private isCredentialStateStale;
 }

package/types/app/credentials/verifying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifying.d.ts","sourceRoot":"","sources":["../../../src/app/credentials/verifying.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAEL,KAAK,EAEL,eAAe,EACf,QAAQ,EAER,UAAU,EACX,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAG1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG,eAAe,GAAG,cAAc,CAAC;AACxF,MAAM,MAAM,oBAAoB,GAC5B,eAAe,GACf,mBAAmB,GACnB,eAAe,GACf,aAAa,GACb,cAAc,GACd,0BAA0B,CAAC;AAE/B,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,oBAAoB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9D;IACA,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,oBAAoB,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iGAAiG;IACjG,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEJ,MAAM,MAAM,WAAW,GAAG,OAAO,CAC/B,QAAQ,EACR;IAAE,GAAG,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA;CAAE,CAClD,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,GAAG,SAAS,CAAC;CAC9D;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED;;;;;;GAMG;AACH,qBAAa,QAAQ;IACnB,MAAM,CAAC,QAAQ,CAAC,yBAAyB,kBAAsB;IAC/D,MAAM,CAAC,QAAQ,CAAC,+BAA+B,WAAa;IAC5D,MAAM,CAAC,QAAQ,CAAC,6BAA6B,WAAa;IAE1D,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;IAC1C,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;gBAE5B,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe;IASjD,+CAA+C;IAC/C,IAAI,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAEjC;IAED,sCAAsC;IACtC,WAAW,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB;IAiBrD,wDAAwD;IACxD,iBAAiB,CAAC,IAAI,EAAE;QACtB,MAAM,EAAE,UAAU,CAAC;QACnB,QAAQ,EAAE,QAAQ,CAAC;QACnB,MAAM,EAAE,eAAe,CAAC;QACxB,MAAM,EAAE,KAAK,CAAC;KACf,GAAG,gBAAgB;IAmHpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB,+BAA+B;IAC/B,SAAS,CAAC,IAAI,EAAE;QACd,MAAM,EAAE,UAAU,CAAC;QACnB,QAAQ,EAAE,QAAQ,CAAC;QACnB,MAAM,EAAE,eAAe,CAAC;QACxB,MAAM,EAAE,KAAK,CAAC;KACf,GAAG,OAAO;IAKX,4BAA4B;IAC5B,SAAS,CAAC,IAAI,EAAE;QACd,MAAM,EAAE,UAAU,CAAC;QACnB,QAAQ,EAAE,QAAQ,CAAC;QACnB,MAAM,EAAE,eAAe,CAAC;QACxB,MAAM,EAAE,KAAK,CAAC;KACf,GAAG,OAAO;IAKX,6BAA6B;IAC7B,SAAS,CAAC,IAAI,EAAE;QACd,MAAM,EAAE,UAAU,CAAC;QACnB,QAAQ,EAAE,QAAQ,CAAC;QACnB,MAAM,EAAE,eAAe,CAAC;QACxB,MAAM,EAAE,KAAK,CAAC;KACf,GAAG,OAAO;IAKX,gFAAgF;IAChF,cAAc,IAAI,IAAI;IAMtB,uEAAuE;IACvE,cAAc,CAAC,IAAI,EAAE;QACnB,MAAM,EAAE,UAAU,CAAC;QACnB,QAAQ,EAAE,QAAQ,CAAC;QACnB,MAAM,EAAE,eAAe,CAAC;QACxB,MAAM,EAAE,KAAK,CAAC;KACf,GAAG,IAAI;IAmBR,uDAAuD;IACvD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAkChG;;;;;;;;;OASG;IACH,OAAO,CAAC,aAAa;IA6CrB,OAAO,CAAC,sBAAsB;CAO/B"}

package/types/app/delivery/forwarding.d.ts

@@ -0,0 +1,227 @@
+import { type Operation } from "effection";
+import { Deck } from "../../core/deck.js";
+import type { Mailboxer } from "../../db/mailbox/mailboxing.js";
+import type { Habery } from "../identity/habbing.js";
+import type { ProtocolProcessor } from "../protocol/protocol-processing.js";
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import type { HttpClient } from "../transport/http-client.js";
+/** Prepared signed source; Poster copies its bytes before publishing an ordinary admission. */
+export interface PosterMsg {
+    /**
+     * Local sender AID used to resolve the signing habitat on each attempt.
+     */
+    readonly src: string;
+    /**
+     * Final recipient AID; this is not necessarily the intermediary endpoint.
+     */
+    readonly dest: string;
+    /**
+     * Mailbox routing topic; required when using indirect delivery.
+     */
+    readonly topic: string;
+    /**
+     * Original signed message copied at admission; caller mutation cannot change queued work.
+     */
+    readonly msg: Uint8Array;
+    /**
+     * Request same-socket TCP reply processing; requires a protocol processor.
+     */
+    readonly replies?: boolean;
+}
+/** One finite stream whose endpoint selection is shared by every constituent message. */
+export interface PosterStream extends Omit<PosterMsg, "msg"> {
+    /** Complete signed source messages, copied into one finite stream before publication. */
+    readonly msgs: readonly Uint8Array[];
+}
+/** Concrete queued operation identity, shared by execution and its optional completion waiter. */
+export interface PosterEvent extends PosterMsg {
+    /** Ordinary traversal or first-present-role stream delivery, selected by the producer operation. */
+    readonly kin: "msg" | "stream";
+}
+/** Optional terminal observation of one concrete delivery attempt, not remote acceptance. */
+export type PosterOutcome = {
+    /** Terminal local attempt result; neither variant proves remote protocol acceptance. */
+    kin: "sent";
+    /** Exact admitted event identity matched by wait(evt), including repeated same-SAID sends. */
+    evt: PosterEvent;
+    /** Successful network URLs or local-mailbox:<eid> publications, including partial success. */
+    deliveries: string[];
+} | {
+    /** Terminal local attempt result; neither variant proves remote protocol acceptance. */
+    kin: "failed";
+    /** Exact admitted event identity matched by wait(evt), including repeated same-SAID sends. */
+    evt: PosterEvent;
+    /** Successful network URLs or local-mailbox:<eid> publications, including partial success. */
+    deliveries: string[];
+    /** Observed failure with original status/cause, including any aggregated target failures. */
+    error: unknown;
+};
+/**
+ * Deliver queued signed messages using KERIpy's ordinary Poster role traversal.
+ *
+ * Send to every controller and agent endpoint, then one mailbox (or provider-local
+ * storage). Only recipients without those roles use one witness. Transport
+ * completion and opt-in outcomes do not prove remote protocol acceptance. Finite
+ * stream admissions use the first present role through the same execution owner.
+ */
+export declare class Poster {
+    /** Borrowed habitat collection and backing accepted protocol state. */
+    readonly hby: Habery;
+    /** Borrowed mailbox store (mbx); null means this host provides no local mailbox. */
+    readonly mbx: Mailboxer | null;
+    /** Borrowed HTTP client selected explicitly by composition. */
+    readonly http: HttpClient;
+    /** Borrowed clock for this owner's actual network deadlines. */
+    readonly clock: RuntimeClock;
+    /** Runnable signed messages in admission order; the delivery worker is the sole consumer. */
+    readonly evts: Deck<PosterEvent>;
+    /** Opt-in terminal outcomes, matched by concrete admitted event identity. */
+    readonly cues: Deck<PosterOutcome>;
+    /** Events whose callers requested one terminal observation. */
+    private readonly notifications;
+    /** Enforce one active completion observer per event. */
+    private readonly waiters;
+    /** Prevent overlapping drains of the runnable queue. */
+    private processing;
+    /** Terminal admission state; closing a Poster cannot be reversed. */
+    private closed;
+    /** Cancels the current delivery pass before store teardown. */
+    private active?;
+    /** Resolves after active delivery and its owned cleanup have joined. */
+    private joined?;
+    /** Borrowed same-socket protocol receiver; null explicitly selects send-only capability. */
+    private readonly protocol;
+    /**
+     * Bind actual collaborators; Poster owns queue/I/O lifetimes and borrows their stores.
+     *
+     * @param hby Borrowed local habitat collection and accepted-state database.
+     * @param mbx Borrowed provider mailbox store, or null when local storage is unavailable.
+     * @param protocol Borrowed same-database processor for TCP replies; null permits send-only work.
+     * @param http Borrowed HTTP implementation selected by composition.
+     * @param clock Borrowed clock for transport deadlines; times are milliseconds.
+     * @throws RangeError if protocol state belongs to a different database.
+     */
+    constructor(hby: Habery, mbx: Mailboxer | null, protocol: ProtocolProcessor | null, http: HttpClient, clock: RuntimeClock);
+    /**
+     * Admit signed source bytes; callers must observe an outcome before reporting transmission.
+     *
+     * @param evt Concrete source-message record; completion/failure lookup uses object identity, not message SAID.
+     * @param options Set notify to retain one terminal outcome for this admission; default false.
+     * @returns A fresh admitted record with copied msg bytes; admission is not transmission.
+     * @throws Closed owner or unsupported reply capability rejects before queue publication.
+     */
+    send(evt: PosterMsg, { notify }?: {
+        notify?: boolean;
+    }): PosterEvent;
+    /**
+     * Admit a complete finite stream using KERIpy StreamPoster's first-present-role selection.
+     * All messages share one selected direct-endpoint set or one relay for the attempt.
+     *
+     * @param stream Signed source messages in production order; no iterator survives admission.
+     * @param options Set notify to request the same concrete-event completion contract as send.
+     * @returns Copied queued stream identity; admission does not establish delivery.
+     */
+    sendStream({ msgs, ...evt }: PosterStream, { notify }?: {
+        notify?: boolean;
+    }): PosterEvent;
+    /**
+     * Copy one source and atomically publish its concrete operation.
+     * @param evt Resolved producer record; source bytes remain caller-owned until copied.
+     * @param kin Real ordinary or finite-stream operation, not a user routing preference.
+     * @param notify Whether this admission needs one terminal observation.
+     * @returns New identity owned by the runnable queue.
+     */
+    private admit;
+    /**
+     * Construct all source records before atomically publishing a complete cue or reply pair.
+     *
+     * @param evts Finite iterable for one cue/pair; every record is checked and copied before atomic queue publication.
+     * @throws Any construction/capability failure leaves the runnable queue unchanged.
+     */
+    sendAll(evts: Iterable<PosterMsg>): void;
+    /**
+     * Wait for one admission without owning its delivery.
+     * The delivery worker must run independently. Cancellation removes the observer and
+     * its notification; it does not withdraw queued work or abort the attempt.
+     *
+     * @param evt Exact record returned by send with notify enabled.
+     * @returns This admission's sent or failed outcome, consuming its notification.
+     * @throws Missing notification, duplicate waiter or closure before an outcome is available.
+     */
+    wait(evt: PosterEvent): Operation<PosterOutcome>;
+    /**
+     * Consume only this event's outcome while preserving other observers' queue order.
+     *
+     * @param evt Concrete source-message record; completion/failure lookup uses object identity, not message SAID.
+     * @returns Matching outcome, or undefined; other outcome order is preserved.
+     */
+    private takeOutcome;
+    /** Run queued delivery independently of query response intake and producer lifetimes. */
+    deliverDo(): Operation<void>;
+    /** Runnable and active work determine convergence; consumable observations do not. */
+    get hasPending(): boolean;
+    /** Reject new production before a closed output owner can consume its source. */
+    ensureOpen(): void;
+    /** Abort/join active I/O, report unconsumed failures, then release process-local work. */
+    close(): Operation<void>;
+    /** Deliver the current FIFO contents; recognized refusals publish failure and allow later work. */
+    process(): Operation<void>;
+    /**
+     * Publish an opted-in terminal outcome or report an unobserved failure once.
+     * This owner retains no recovery history. Cancellation and close return abandoned
+     * observations here after removing their notification, so failed work stays visible.
+     *
+     * @param outcome Completed attempt, including source identity, original cause and partial delivery.
+     */
+    private publishOutcome;
+    /**
+     * Resolve and execute one event using sequential current endpoints.
+     * Observed HTTP refusal and TransportError permit remaining targets to run.
+     * Unexpected construction/parser/storage/cleanup errors propagate so process can
+     * publish or report the failed outcome before exposing the error.
+     *
+     * @param evt Concrete source-message record; completion/failure lookup uses object identity, not message SAID.
+     * @param deliveries Mutable accumulator of successfully delivered target URLs, retained even if a later target throws.
+     * @param signal Active Poster pass cancellation; forwarded into each messenger attempt.
+     * @returns Sent if every target completes; otherwise a failure with partial successes.
+     */
+    private deliverEvent;
+    /** Execute one prepared target, adapting completed HTTP refusal to this owner's fanout outcome. */
+    private sendPreparedTarget;
+    /**
+     * Snapshot ordinary Poster's current role traversal without network execution.
+     *
+     * Controller and agent roles each retain all endpoints. An indirect role picks
+     * one random provider, unless an explicitly composed store owns an eligible local
+     * AID. Empty location maps retain role selection and become execution failures.
+     *
+     * @param hab Local signing habitat borrowing accepted role/location state.
+     * @param recipient Resolved final recipient AID.
+     * @param topic Recipient mailbox topic; indirect routes require a nonempty topic.
+     * @param kin Ordinary messages traverse all primary roles; streams retain the first present role.
+     * @returns Ordered role groups; no eligible role returns an empty array.
+     */
+    private findBytesRoutes;
+    /**
+     * Prepare a target using the supplied wire and selected endpoint.
+     *
+     * @param hab Local habitat used to construct/sign this output; stores remain borrowed.
+     * @param route Selected direct or forwarded endpoint group.
+     * @param endpoint One selected endpoint AID and URL from the route.
+     * @param evt Original signed source and concrete ordinary/stream operation.
+     * @returns A prepared remote target, or stored after authorized local mailbox publication.
+     */
+    private prepareBytesTarget;
+    /**
+     * Prepare complete signed wire and its introduction before opening transport.
+     *
+     * @param hab Local habitat used to construct/sign this output; stores remain borrowed.
+     * @param recipient Final recipient AID, distinct from the intermediary endpoint.
+     * @param topic Recipient mailbox topic used by the forwarding envelope.
+     * @param evt Original signed source and operation; outer envelopes may be rebuilt.
+     * @param endpoint Mailbox/witness endpoint selected for this attempt.
+     * @returns Stored for a local endpoint, or signed forwarding wire with its introduction.
+     */
+    private prepareForwardedTarget;
+}
+//# sourceMappingURL=forwarding.d.ts.map

package/types/app/delivery/forwarding.d.ts.map

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

package/types/app/delivery/introducing.d.ts

@@ -0,0 +1,21 @@
+import type { Hab } from "../identity/habbing.js";
+/**
+ * Borrow a Hab/store for lazy introduction output, preserving target KEL, oldest
+ * delegator first, then endpoint/location replies. Capture begins on iteration.
+ * No source is opened when a witness/receipt already makes introduction unnecessary.
+ * V2 proof/key copies and the large-history transport caller remain separately qualified.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param remote Remote endpoint AID whose receipt history determines whether introduction is needed.
+ * @returns Reopenable introduction iterable.
+ */
+export declare function introductionMessages(hab: Hab, remote: string): Iterable<Uint8Array>;
+/**
+ * Collect the introduction required by the existing finite query/forwarding path.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param remote Remote endpoint AID whose receipt history determines whether introduction is needed.
+ * @returns Collected introduction bytes, possibly empty.
+ */
+export declare function introduce(hab: Hab, remote: string): Uint8Array;
+//# sourceMappingURL=introducing.d.ts.map

package/types/app/delivery/introducing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introducing.d.ts","sourceRoot":"","sources":["../../../src/app/delivery/introducing.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAElD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,GACb,QAAQ,CAAC,UAAU,CAAC,CAkBtB;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAE9D"}

package/types/app/delivery/reply-streams.d.ts

@@ -0,0 +1,49 @@
+/** Own lazy HTTP replay readers until EOF, transport cancellation, or runtime shutdown. */
+export declare class ReplyStreams {
+    /** Closing readers do not retain their replay source or its current event. */
+    private readonly readers;
+    /** Shutdown permanently closes this runtime's response creation. */
+    private closed;
+    /**
+     * Acquire one source iterator without advancing until HTTP requests bytes.
+     * Transfer the optional disposer through source closure, including acquisition failure.
+     *
+     * @param messages Synchronous wire-message iterable; its iterator remains owned by the response until EOF/cancel/close.
+     * @param dispose Cleanup callback retained through iterator closure; invoked once even if acquisition fails.
+     * @returns Request-owned Web stream.
+     * @throws Source or disposer failures propagate; independent cleanup failures are retained.
+     */
+    open(messages: Iterable<Uint8Array>, dispose?: () => void): ReadableStream<Uint8Array>;
+    /**
+     * Prime one message; empty output closes ownership for a caller's 404 decision.
+     *
+     * @param messages Synchronous wire-message iterable; its iterator remains owned by the response until EOF/cancel/close.
+     * @param dispose Cleanup callback retained through iterator closure; invoked once even if acquisition fails.
+     * @returns Request-owned Web stream, or null after empty-source cleanup.
+     * @throws Source or disposer failures propagate; independent cleanup failures are retained.
+     */
+    openNonEmpty(messages: Iterable<Uint8Array>, dispose?: () => void): ReadableStream<Uint8Array> | null;
+    /**
+     * Optional priming shares the same response owner/disposer; ordinary open always returns a stream.
+     *
+     * @param messages Synchronous wire-message iterable; its iterator remains owned by the response until EOF/cancel/close.
+     * @param dispose Cleanup callback retained through iterator closure; invoked once even if acquisition fails.
+     * @param requireContent Prime one nonempty message before publishing; empty sources close and return null.
+     * @returns Request-owned Web stream, or null after empty-source cleanup.
+     * @throws Source or disposer failures propagate; independent cleanup failures are retained.
+     */
+    private openChecked;
+    /**
+     * Keep the optional disposer through iterator cleanup, including cancellation before the first pull.
+     *
+     * @param messages Synchronous wire-message iterable; its iterator remains owned by the response until EOF/cancel/close.
+     * @param release Cleanup callback retained through iterator closure; invoked once even if acquisition fails.
+     * @param requireContent Prime one nonempty message before publishing; empty sources close and return null.
+     * @returns Request-owned Web stream, or null after empty-source cleanup.
+     * @throws Source or disposer failures propagate; independent cleanup failures are retained.
+     */
+    private openOwned;
+    /** Abort all response readers before their underlying runtime/database owners close. */
+    close(): void;
+}
+//# sourceMappingURL=reply-streams.d.ts.map

package/types/app/delivery/reply-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-streams.d.ts","sourceRoot":"","sources":["../../../src/app/delivery/reply-streams.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,qBAAa,YAAY;IACvB,8EAA8E;IAC9E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IACjE,oEAAoE;IACpE,OAAO,CAAC,MAAM,CAAS;IACvB;;;;;;;;OAQG;IACH,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,IAAI,GAAG,cAAc,CAAC,UAAU,CAAC;IAItF;;;;;;;OAOG;IACH,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,IAAI,GAAG,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI;IAIrG;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IAuBnB;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IA0HjB,wFAAwF;IACxF,KAAK,IAAI,IAAI;CAad"}

package/types/app/delivery/respondant.d.ts

@@ -0,0 +1,52 @@
+import type { AgentCue } from "../../core/cues.js";
+import { Deck } from "../../core/deck.js";
+import type { Hab, Habery } from "../identity/habbing.js";
+import type { Poster } from "./forwarding.js";
+/**
+ * Shared host-side responder for indirect and witness runtimes.
+ *
+ * KERIpy correspondence:
+ * - this is the local analogue of `Respondant` for reply/replay/receipt-style
+ *   cues
+ * - `BaseHab.processCuesIter()` interprets the cue; `Poster` delivers the
+ *   resulting bytes
+ * - mailbox-query `stream` cues stay with mailbox storage/query coordination
+ *
+ * Boundary rule:
+ * - this class constructs signed non-`stream` output and admits it to Poster
+ * - `MailboxDirector` owns provider publication and `stream` cue correlation,
+ *   using its separately owned Mailboxer for actual storage
+ * - ordinary query replies follow this output path rather than returning from
+ *   the HTTP query POST; direct TCP correlation claims its own reply cues first
+ *
+ * Source cue removal proves complete output admission, not delivery. Poster runs
+ * independently and owns routing, transport attempts and failure outcomes. Keep
+ * mailbox provider writes in that routing path, not in responder cue interpretation.
+ */
+export declare class Respondant {
+    /** Borrowed local signer and accepted-state collection. */
+    private readonly hby;
+    /** Delivery owner; source cues are consumed only after its admission succeeds. */
+    private readonly postman;
+    /** Bind borrowed identity and delivery owners without acquiring stores or network lifetimes. */
+    constructor(hby: Habery, postman: Poster);
+    /**
+     * Produce a whole cue before publishing or removing it; construction failure leaves the source visible.
+     *
+     * @param hab Local habitat used to construct/sign this output; stores remain borrowed.
+     * @param cues Source Deck; only its current head is interpreted, and removed after full publication.
+     * @param hint Optional local sender hint used when cue provenance does not resolve a habitat.
+     * @returns True after complete admission/removal; false if the head has no routable responder output.
+     * @throws Construction/admission failures leave the source cue present.
+     */
+    enqueueCue(hab: Hab, cues: Deck<AgentCue>, hint?: Hab | null): boolean;
+    /**
+     * Admit already produced witness messages without signing them again.
+     *
+     * @param hab Local habitat used to construct/sign this output; stores remain borrowed.
+     * @param cue Routing/provenance cue for the already-signed output.
+     * @param msgs Complete signed messages; Poster copies them during atomic admission.
+     */
+    enqueueMsgs(hab: Hab, cue: AgentCue, msgs: readonly Uint8Array[]): void;
+}
+//# sourceMappingURL=respondant.d.ts.map

package/types/app/delivery/respondant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"respondant.d.ts","sourceRoot":"","sources":["../../../src/app/delivery/respondant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,UAAU;IACrB,2DAA2D;IAC3D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,gGAAgG;gBACpF,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAKxC;;;;;;;;OAQG;IACH,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,GAAG,OAAO;IAatE;;;;;;OAMG;IACH,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI;CAMxE"}

package/types/app/delivery/stored-replies.d.ts

@@ -0,0 +1,11 @@
+/** Finite stored endpoint-reply reconstruction; current proof rows are borrowed only during this synchronous call. */
+import { type Versionage } from "cesr-ts";
+import type { Baser } from "../../db/basing.js";
+/**
+ * Rebuild one persisted reply with all stored groups and exactly one optional cigar.
+ *
+ * Missing bodies return empty bytes. Stored groups preserve key order; attachment
+ * framing and validation belong to the shared serializer.
+ */
+export declare function loadStoredReply(db: Baser, said: string, gvrsn?: Versionage): Uint8Array;
+//# sourceMappingURL=stored-replies.d.ts.map

package/types/app/delivery/stored-replies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-replies.d.ts","sourceRoot":"","sources":["../../../src/app/delivery/stored-replies.ts"],"names":[],"mappings":"AAAA,sHAAsH;AACtH,OAAO,EAAkC,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAK1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,UAAU,GAAG,UAAU,CAuCvF"}

package/types/app/exchanges/essr.d.ts

@@ -0,0 +1,53 @@
+import type { Hab } from "../identity/habbing.js";
+/** Expected recipient outcomes; acceptance returns ordinary authenticated data. */
+export type EssrDecision = {
+    kind: "accept";
+    message: EssrMessage;
+} | {
+    kind: "refuse";
+    reason: "unaccepted";
+} | {
+    kind: "reject";
+    reason: "envelope" | "digest" | "decrypt" | "framing";
+};
+/**
+ * Authenticated inner bytes owned by the caller. No disposal API or persistent
+ * plaintext record is created. body is a view into the decrypted allocation;
+ * consumers decide how long to retain it and whether to overwrite sensitive data.
+ */
+export interface EssrMessage {
+    /** Sender authenticated by both the signed EXN and decrypted SCS prefix. */
+    sender: string;
+    /** Explicit hosted recipient selected by the signed destination. */
+    recipient: string;
+    /** Caller-owned inner CESR bytes, excluding the authenticated SCS header and padding. */
+    body: Uint8Array;
+}
+/** Verify and decrypt accepted LMDB evidence for one explicitly hosted recipient. */
+export declare class EssrRecipient {
+    private readonly hab;
+    /** Bind the local key owner; recipient selection never searches other habitats. */
+    constructor(hab: Hab);
+    /**
+     * Read accepted evidence, verify its signed commitment and return authenticated inner bytes.
+     *
+     * Processing is synchronous: LMDB and sealed-box crypto already expose finite bytes.
+     * The result has no file/disposal lifecycle and is never persisted automatically.
+     * Envelope checks bind the EXN sender/source and destination to this local Hab;
+     * the decrypted SCS header must repeat the authenticated sender. Verify the
+     * signed digest over stored Texter raw bytes before attempting decryption.
+     *
+     * Baser follows pinned-main ordered-set semantics: repeated identical Texters
+     * can be lost during persistence. Such retained evidence fails this digest check
+     * rather than returning unauthenticated plaintext. See the repeated-fragment
+     * report in docs/reports/essr for the known reference limitation.
+     *
+     * @param said Accepted outer ESSR EXN SAID, not the payload digest.
+     * @returns Typed absence, authentication/framing rejection or authenticated bytes.
+     * @throws Corrupt stored identity, missing local key state and storage/crypto
+     * infrastructure failures propagate; only actual sealed-box authentication failure
+     * becomes a decrypt rejection.
+     */
+    decrypt(said: string): EssrDecision;
+}
+//# sourceMappingURL=essr.d.ts.map

package/types/app/exchanges/essr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"essr.d.ts","sourceRoot":"","sources":["../../../src/app/exchanges/essr.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAElD,mFAAmF;AACnF,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAA;CAAE,CAAC;AAE9E;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,yFAAyF;IACzF,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,qFAAqF;AACrF,qBAAa,aAAa;IAEZ,OAAO,CAAC,QAAQ,CAAC,GAAG;IADhC,mFAAmF;gBACtD,GAAG,EAAE,GAAG;IAErC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;CA4CpC"}

package/types/app/exchanges/exchange-messaging.d.ts

@@ -0,0 +1,73 @@
+/** Construct signed exchanges in their producer and run standalone queued sends. */
+import { type SerderKERI, type Versionage } from "cesr-ts";
+import { type Operation } from "effection";
+import type { Hab, Habery } from "../identity/habbing.js";
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import type { HttpClient } from "../transport/http-client.js";
+/** Resolved recipient and business fields used to construct one signed exchange. */
+export interface ExchangeMessageArgs {
+    /**
+     * Resolved final recipient AID; standalone sending may resolve a user alias first.
+     */
+    dest: string;
+    /**
+     * EXN route interpreted by the receiving application.
+     */
+    route: string;
+    /**
+     * Route-defined signed business attributes; this is wire schema data, not a dependency bag.
+     */
+    payload: Record<string, unknown>;
+    /** Omit the business recipient for KERIpy delegation-request exchanges. */
+    exchangeRecipient?: string | null;
+    /**
+     * Optional route-defined signed query modifiers.
+     */
+    modifiers?: Record<string, unknown>;
+    /**
+     * Optional protocol timestamp; omission uses exchange construction defaults.
+     */
+    date?: string;
+    /**
+     * Optional prior exchange SAID for conversation correlation.
+     */
+    dig?: string;
+    /**
+     * Named independently signed/framed CESR messages to embed.
+     */
+    embeds?: Record<string, Uint8Array>;
+    /**
+     * Explicit exchange body version for legacy v1 conversations; omission follows the
+     * habitat's KEL version, or v1 when pathed embeds are present.
+     */
+    pvrsn?: Versionage;
+}
+/**
+ * Sign the producer's exchange once, including any independently framed embedded material.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param args Resolved recipient, route and business fields; optional embeds carry independently framed wire.
+ * @returns Signed EXN body plus complete message bytes; this performs no delivery.
+ */
+export declare function createExchangeMessage(hab: Hab, args: ExchangeMessageArgs): {
+    serder: SerderKERI;
+    msg: Uint8Array;
+};
+/**
+ * Run a standalone command's Poster and await actual delivery before closing its worker.
+ *
+ * @param hby Borrowed local identities and accepted-state stores.
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param clock Borrowed clock with epoch-millisecond now and millisecond timer delays.
+ * @param args Exchange fields plus optional mailbox topic; recipient aliases are resolved before signing.
+ * @returns Signed EXN and successfully delivered target URLs after the worker/Poster scope joins.
+ * @throws A failed terminal outcome is thrown; admission alone never returns success.
+ */
+export declare function sendExchangeMessage(hby: Habery, hab: Hab, http: HttpClient, clock: RuntimeClock, args: ExchangeMessageArgs & {
+    topic?: string;
+}): Operation<{
+    serder: SerderKERI;
+    deliveries: string[];
+}>;
+//# sourceMappingURL=exchange-messaging.d.ts.map

package/types/app/exchanges/exchange-messaging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exchange-messaging.d.ts","sourceRoot":"","sources":["../../../src/app/exchanges/exchange-messaging.ts"],"names":[],"mappings":"AACA,oFAAoF;AACpF,OAAO,EAAe,KAAK,UAAU,EAAE,KAAK,UAAU,EAAY,MAAM,SAAS,CAAC;AAClF,OAAO,EAAQ,KAAK,SAAS,EAAmB,MAAM,WAAW,CAAC;AAIlE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,oFAAoF;AACpF,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,2EAA2E;IAC3E,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACpC;;;OAGG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,mBAAmB,GACxB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,UAAU,CAAA;CAAE,CAezC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,mBAAmB,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,SAAS,CAAC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAoBzD"}