keri-ts 0.11.0 → 2.0.0

package/types/app/protocol/parsering.d.ts

@@ -0,0 +1,128 @@
+import { type AttachmentGroup, BlindState, BoundState, type CesrFrame, Cigar, FirstSeen, Prefixer, SealEvent, SealKind, SealSource, SerderACDC, SerderKERI, Siger, Texter, TypeMedia, type Versionage } from "cesr-ts";
+import type { Operation } from "effection";
+import type { RegistryObserver, RegistryObserverDecision } from "../../acdc/observing.js";
+import { KeriDispatchEnvelope, PathedMaterialGroup, TransIdxSigGroup, TransLastIdxSigGroup, TransReceiptQuadruple } from "../../core/dispatch.js";
+import { Kevery, type QueryEnvelope } from "../../core/kel/eventing.js";
+import type { KeverDecision, QueryProcessDecision } from "../../core/kel/kever-decisions.js";
+import { type KramRefusal } from "../../core/mailbox/kraming.js";
+import { type ReplyProcessDecision, Revery } from "../../core/routing.js";
+import type { TelProcessDecision, Tevery } from "../../vdr/eventing.js";
+import type { Verifier, VerifierDecision } from "../credentials/verifying.js";
+import type { ExchangeDecision } from "../exchanges/exchanging.js";
+/** Parsed input awaits exchange handlers; semantic owners commit evidence before publishing acceptance. */
+export interface ExchangerLike {
+    /** Resolve after signature admission and its required storage/handler effects finish. */
+    processEvent(args: {
+        serder: SerderKERI;
+        tsgs: TransIdxSigGroup[];
+        cigars: Cigar[];
+        ptds: PathedMaterialGroup[];
+        gvrsn?: Versionage;
+        /** Receipt-time unresolved foreign last references are not current proof. */
+        unresolvedLast?: readonly Prefixer[];
+        /** Source and last-establishment factors retain their own proof ownership. */
+        sscs?: readonly SealSource[];
+        sourceSeals?: readonly SealEvent[];
+        lsgs?: readonly TransLastIdxSigGroup[];
+        /** Ordered ordinary ESSR fragments. */
+        essrs?: readonly Texter[];
+        /** Borrowed parent-owned descendants for a supported route. */
+        nests?: readonly CesrFrame[];
+        /** Hosted endpoint that received this message, independent of its claimed sender. */
+        mailboxAid?: string | null;
+        /** Receiver-observed time supplied by local intake, independent of signed wire. */
+        receiverTime?: string;
+    }): Operation<void | ExchangeDecision>;
+}
+export interface TelDispatchArgs {
+    serder: SerderKERI;
+    seqner: SealSource["s"] | null;
+    saider: SealSource["d"] | null;
+    attachmentGroups: readonly AttachmentGroup[];
+    local: boolean;
+    sigers: Siger[];
+    wigers: Siger[];
+    cigars: Cigar[];
+    trqs: TransReceiptQuadruple[];
+    tsgs: TransIdxSigGroup[];
+    ssgs: TransLastIdxSigGroup[];
+    frcs: FirstSeen[];
+    sscs: SealSource[];
+    tdcs: SealKind[];
+}
+export interface AcdcDispatchArgs {
+    serder: SerderACDC;
+    prefixer: SealEvent["i"] | null;
+    seqner: SealEvent["s"] | null;
+    saider: SealEvent["d"] | null;
+    attachmentGroups: readonly AttachmentGroup[];
+    local: boolean;
+    ptds: PathedMaterialGroup[];
+    /** Ordered ordinary ESSR fragments carried alongside credential attachments. */
+    essrs?: readonly Texter[];
+    ssts: SealEvent[];
+    bsqs: BlindState[];
+    bsss: BoundState[];
+    tmqs: TypeMedia[];
+}
+/** A normal refusal before route processing; a parsed message is not accepted. */
+export interface MessageDropDecision {
+    kind: "drop";
+    reason: "deniedSender" | "senderNotAllowed" | "missingAuthentication" | "unsupportedRoute" | "invalidQuery" | "missingProcessor" | "referenceStub";
+}
+/** Route-specific results remain distinct from pre-dispatch refusal and unreported outcomes. */
+export type DispatchDecision = KeverDecision | TelProcessDecision | VerifierDecision | RegistryObserverDecision | QueryProcessDecision | ReplyProcessDecision | ExchangeDecision | MessageDropDecision | KramRefusal | void;
+/**
+ * Caller-owned auxiliary query receiver, analogous to KERIpy's Kevery.qvy.
+ * Sender policy and optional KRAM run first. The receiver independently checks
+ * complete signature evidence and its approved operation scope; dispatch alone
+ * grants no authority. It borrows the full envelope during this synchronous call.
+ */
+export interface AuxiliaryQueryProcessor {
+    /** Concrete custom query route selected by composition before any replay-cache admission. */
+    readonly resource: string;
+    processQuery(envelope: KeriDispatchEnvelope): DispatchDecision;
+}
+/**
+ * Convert one or more already-parsed CESR frames into KERI dispatch envelopes.
+ *
+ * Architectural rule:
+ * - CESR parsing belongs to the buffered finite CESR decoder
+ * - KERI normalization belongs here
+ * - routing into `Revery` / `Kevery` / `Exchanger` happens separately via
+ *   `dispatchEnvelope(...)`
+ */
+export declare function envelopesFromFrames(frames: readonly CesrFrame[], local?: boolean): KeriDispatchEnvelope[];
+/** The processed envelope and its exact decision; KRAM may combine earlier proof records. */
+export interface DispatchResult {
+    envelope: KeriDispatchEnvelope;
+    decision: DispatchDecision;
+}
+/**
+ * Route one already-parsed KERI dispatch envelope into the established
+ * `Revery` / `Kevery` / `Exchanger` architecture.
+ * Return ordinary buffered evidence and its decision to the application owner.
+ *
+ * @param envelope Parsed body and its exact attachment evidence.
+ * @param revery Borrowed reply-route verifier.
+ * @param kevery Input KEL processor for this dispatch.
+ * @param exchanger Optional exchange processor; absent exchange support remains explicit.
+ * @param tevery Optional legacy TEL processor.
+ * @param verifier Optional credential processor.
+ * @param mailboxAid Receiving hosted endpoint provenance, distinct from claimed sender.
+ * @param messageKevery Authoritative shared message-policy/KRAM processor when distinct from input Kevery.
+ * @param registry V2 registry intake over accepted public KEL state, without requiring a local alias.
+ * @param qvy Optional auxiliary query owner; receives full evidence after v2 message admission.
+ * @returns The processed envelope and protocol-specific decision data.
+ * @throws Unsupported input and infrastructure/handler failures follow their owning processor contracts.
+ */
+export declare function dispatchEnvelope(envelope: KeriDispatchEnvelope, revery: Revery, kevery: Kevery, exchanger?: ExchangerLike, tevery?: Tevery, verifier?: Verifier, mailboxAid?: string | null, 
+/** Long-lived v2 message policy/KRAM owner; input-specific Kevery handles KEL and legacy traffic. */
+messageKevery?: Kevery, registry?: RegistryObserver, qvy?: AuxiliaryQueryProcessor): Operation<DispatchResult>;
+/** Project one complete frame for message routing without an intermediate event array. */
+export declare function envelopeFromFrame(message: CesrFrame, local?: boolean): KeriDispatchEnvelope;
+/** Own an auxiliary query's normalized full proof and public nested evidence beyond synchronous intake. */
+export declare function copyAuxiliaryQuery(envelope: KeriDispatchEnvelope): KeriDispatchEnvelope;
+/** Normalize the actual query endorsements for ingress and per-request authorization. */
+export declare function queryEnvelopeFromDispatch(envelope: KeriDispatchEnvelope): QueryEnvelope;
+//# sourceMappingURL=parsering.d.ts.map

package/types/app/protocol/parsering.d.ts.map

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

package/types/app/{protocol-host-policy.d.ts → protocol/protocol-host-policy.d.ts}

@@ -1,4 +1,4 @@
-import type { Hab } from "./habbing.js";
+import type { Hab } from "../identity/habbing.js";
 /**
  * Route-facing policy for one hosted protocol surface.
  *
@@ -22,14 +22,5 @@ export interface ProtocolHostPolicy {
     dwsDynamic?: boolean;
     /** Use http:// when this host resolves did:webs artifacts, for local workflows. */
     dwsInsecureHttp?: boolean;
-    /**
-     * Whether non-`mbx` query POSTs may return immediate CESR reply/replay bodies.
-     *
-     * KERIpy's generic HttpEnd returns 204 for `logs`/`ksn` and relies on mailbox
-     * delivery. Tufa's controller-facing agent surface may opt in for clients
-     * that can consume synchronous query results, while mailbox hosts keep the
-     * KERIpy-compatible default.
-     */
-    directQueryResponses?: boolean;
 }
 //# sourceMappingURL=protocol-host-policy.d.ts.map

package/types/app/protocol/protocol-host-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-host-policy.d.ts","sourceRoot":"","sources":["../../../src/app/protocol/protocol-host-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,UAAU,CAAC,EAAE,GAAG,CAAC;IACjB,2EAA2E;IAC3E,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,6EAA6E;IAC7E,UAAU,CAAC,EAAE,GAAG,CAAC;IACjB,oFAAoF;IACpF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,mFAAmF;IACnF,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B"}

package/types/app/protocol/protocol-processing.d.ts

@@ -0,0 +1,140 @@
+/** Shared protocol mutations and publication, independent of byte-input and network lifetimes. */
+import type { CesrFrame } from "cesr-ts";
+import { type Operation } from "effection";
+import type { RegistryObserver } from "../../acdc/observing.js";
+import type { AgentCue } from "../../core/cues.js";
+import { Deck } from "../../core/deck.js";
+import { Kevery } from "../../core/kel/eventing.js";
+import { Revery } from "../../core/routing.js";
+import type { Tevery } from "../../vdr/eventing.js";
+import type { Verifier } from "../credentials/verifying.js";
+import { Exchanger } from "../exchanges/exchanging.js";
+import type { Habery } from "../identity/habbing.js";
+import { QueryReplies } from "../queries/query-replies.js";
+import { type AuxiliaryQueryProcessor, type DispatchResult } from "./parsering.js";
+/** Protocol choices for a frame; input owners separately own cancellation and parsing. */
+export interface DispatchOptions {
+    /** Whether the frame arrived through local witness/controller intake. */
+    local?: boolean;
+    /** Hosted mailbox endpoint provenance, independent of the signed sender. */
+    mailboxAid?: string | null;
+    /** Advance durable escrows after capturing this frame's decision and direct replies. */
+    escrows?: boolean;
+}
+/** Exact processed evidence and mailbox authorization captured at the query decision. */
+export interface ProtocolDispatchResult extends DispatchResult {
+    /** Current request authorization, never inferred solely from a matching reply SAID. */
+    mailboxQueryAuthorized: boolean;
+}
+/**
+ * Dispatch to synchronous semantic owners and publish their committed output.
+ *
+ * KERIpy supplies parsers with concrete Kevery/Revery/Exchanger owners. Domain
+ * writers decide and commit without suspension; exchange durability and application
+ * handlers run in their input's operation. Independent inputs and escrow scans may
+ * progress during that I/O. This owner captures query replies before application delivery
+ * and registers shared semantic routes once; it owns no lock, input queue or transport.
+ */
+export declare class ProtocolProcessor {
+    /** Long-lived KEL processor (kvy), used for semantic reply routes and escrow recovery. */
+    readonly kvy: Kevery;
+    /** Shared reply verifier (rvy), including BADA and registered semantic routes. */
+    readonly rvy: Revery;
+    /** Shared exchange processor (exc), with the host's configured application handlers. */
+    readonly exc: Exchanger;
+    /** Legacy transaction-event processor (tvy), explicitly absent without VDR support. */
+    readonly tvy: Tevery | null;
+    /** Credential verifier (vry), sharing the composed registry store. */
+    readonly vry: Verifier | null;
+    /** Public v2 registry intake; local alias management remains with Regery. */
+    readonly registry: RegistryObserver | null;
+    /** Private output from semantic handlers, captured before application publication. */
+    private readonly protocolCues;
+    /** Ordinary application cues; the composed cue router is the consumer. */
+    readonly cues: Deck<AgentCue>;
+    /** Shared live request correlations; each requesting connection owns its slots. */
+    readonly replies: QueryReplies;
+    readonly qvy?: AuxiliaryQueryProcessor | undefined;
+    /**
+     * Bind long-lived semantic owners and register their reply routes exactly once.
+     *
+     * @param kvy Shared KEL owner for semantic reply routes, KRAM policy and escrow recovery.
+     * @param rvy Shared reply verifier bound to the same database and private cue flow.
+     * @param exc Shared exchange owner with application handlers already configured.
+     * @param tvy Borrowed legacy TEL owner, or null without VDR support.
+     * @param vry Borrowed credential verifier, or null without that capability.
+     * @param registry Borrowed public v2 registry intake and escrow owner, or null.
+     * @param protocolCues Private semantic-output Deck; distinct from application cues.
+     * @param cues Application output Deck consumed by the composed cue router.
+     * @param replies Shared live request correlations captured before application publication.
+     * @param qvy Optional caller-owned auxiliary query receiver; owns its authorization and lifecycle.
+     * @throws TypeError for inconsistent stores or cue bindings.
+     */
+    constructor(
+    /** Long-lived KEL processor (kvy), used for semantic reply routes and escrow recovery. */
+    kvy: Kevery, 
+    /** Shared reply verifier (rvy), including BADA and registered semantic routes. */
+    rvy: Revery, 
+    /** Shared exchange processor (exc), with the host's configured application handlers. */
+    exc: Exchanger, 
+    /** Legacy transaction-event processor (tvy), explicitly absent without VDR support. */
+    tvy: Tevery | null, 
+    /** Credential verifier (vry), sharing the composed registry store. */
+    vry: Verifier | null, 
+    /** Public v2 registry intake; local alias management remains with Regery. */
+    registry: RegistryObserver | null, 
+    /** Private output from semantic handlers, captured before application publication. */
+    protocolCues: Deck<AgentCue>, 
+    /** Ordinary application cues; the composed cue router is the consumer. */
+    cues: Deck<AgentCue>, 
+    /** Shared live request correlations; each requesting connection owns its slots. */
+    replies: QueryReplies, qvy?: AuxiliaryQueryProcessor | undefined);
+    /**
+     * Construct an input-owned Kevery with identical store, policy and cue bindings; register no routes.
+     *
+     * @returns A new input-specific Kevery sharing accepted state, policy, Revery and the private cue Deck.
+     */
+    makeKevery(): Kevery;
+    /**
+     * Process one frame and publish its committed protocol cues before returning decision data.
+     *
+     * @param frame Complete hydrated frame whose evidence remains valid for this operation.
+     * @param options Local intake policy, hosted mailbox provenance and whether to advance escrows.
+     * @param kvy Input-specific Kevery in this domain; defaults to the shared owner.
+     * @returns Exact dispatch result and current mailbox authorization at its synchronous query decision.
+     * @throws Domain mismatch, infrastructure/handler or cleanup errors propagate; publication still runs in the dispatch finalizer.
+     */
+    dispatch(frame: CesrFrame, { local, mailboxAid, escrows }?: DispatchOptions, kvy?: Kevery): Operation<ProtocolDispatchResult>;
+    /** Capture direct replies before handing ordinary protocol records to the application consumer. */
+    private publishCues;
+    /** Advance configured escrow owners; each scan joins its own I/O and handler cleanup. */
+    processEscrowsOnce(): Operation<void>;
+    /**
+     * Retry only KEL/reply dependencies and publish their committed cues.
+     *
+     * Finite introduction bootstrap needs these synchronous owners, without
+     * advancing unrelated exchange, credential or registry application work.
+     * Full host escrow processing retains its existing family/publication order.
+     */
+    processKelReplyEscrowsOnce(): void;
+    /** Shared synchronous KEL/reply retry unit; the invoking composition owns publication. */
+    private advanceKelReplyEscrows;
+    /** Publish synchronous escrow facts before progressing asynchronous EXN recovery. */
+    private advanceEscrows;
+    /**
+     * Continuous escrow doer for the long-lived runtime host.
+     *
+     * KERIpy correspondence:
+     * - mirrors the dedicated `escrowDo` loop rather than folding escrow
+     *   processing into parser ingress
+     */
+    escrowDo(): Operation<never>;
+}
+/**
+ * Compose minimal KEL/reply/exchange intake over an existing Habery; acquire no stores or workers.
+ *
+ * @param hby Borrowed local habitat collection and accepted-state database.
+ * @returns A minimal KEL/reply/exchange processor with no registry owners or running workers.
+ */
+export declare function createProtocolProcessor(hby: Habery): ProtocolProcessor;
+//# sourceMappingURL=protocol-processing.d.ts.map

package/types/app/protocol/protocol-processing.d.ts.map

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

package/types/app/protocol/reactor.d.ts

@@ -0,0 +1,43 @@
+/** Input-owned buffered parsing; shared protocol work belongs to ProtocolProcessor. */
+import { type Operation } from "effection";
+import type { Kevery } from "../../core/kel/eventing.js";
+import { type IngressOptions } from "../transport/message-source.js";
+import type { ProtocolProcessor } from "./protocol-processing.js";
+/**
+ * Own direct input and its buffered parser for one composed protocol domain.
+ *
+ * Like KERIpy's direct-mode input owners, this component consumes bytes and drives
+ * protocol handlers. It borrows the shared processor and owns an independent Kevery;
+ * accepted Kever state remains in the common Baser cache. Escrow scheduling, route
+ * registration and application handler installation belong to composition.
+ */
+export declare class Reactor {
+    /** Borrowed protocol mutations/publication owner, never a transport or callback scheduler. */
+    readonly protocol: ProtocolProcessor;
+    /** Input-specific Kevery (kvy); its accepted-state cache is shared through Baser. */
+    readonly kvy: Kevery;
+    /**
+     * Bind the actual shared protocol owner; create no runtime, transport or persistent stores.
+     *
+     * @param protocol Borrowed shared protocol domain; this input creates its own Kevery over that domain.
+     */
+    constructor(
+    /** Borrowed protocol mutations/publication owner, never a transport or callback scheduler. */
+    protocol: ProtocolProcessor);
+    /**
+     * Own this input and finish dispatch before reading its next complete frame.
+     *
+     * @param source Creates cancellation-aware input bytes; this operation owns parsing and source cleanup.
+     * @param options Dispatch policy and optional upstream cancellation.
+     * @throws Source/parser, dispatch and cleanup failures propagate.
+     */
+    process(source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, options?: IngressOptions): Operation<void>;
+    /**
+     * Consume one complete record through the same buffered parser source and dispatch path as network input.
+     *
+     * @param bytes Resident complete record; each parser chunk is copied during consumption.
+     * @param options Dispatch policy and optional upstream cancellation.
+     */
+    processBytes(bytes: Uint8Array, options?: IngressOptions): Operation<void>;
+}
+//# sourceMappingURL=reactor.d.ts.map

package/types/app/protocol/reactor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactor.d.ts","sourceRoot":"","sources":["../../../src/app/protocol/reactor.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,cAAc,EAAmB,MAAM,gCAAgC,CAAC;AACtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;;;GAOG;AACH,qBAAa,OAAO;IAUhB,8FAA8F;IAC9F,QAAQ,CAAC,QAAQ,EAAE,iBAAiB;IAVtC,qFAAqF;IACrF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;;;OAIG;;IAED,8FAA8F;IACrF,QAAQ,EAAE,iBAAiB;IAKtC;;;;;;OAMG;IACH,OAAO,CACL,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,OAAO,GAAE,cAAmB,GAC3B,SAAS,CAAC,IAAI,CAAC;IAGlB;;;;;OAKG;IACF,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,GAAE,cAAmB,GAAG,SAAS,CAAC,IAAI,CAAC;CAIhF"}

package/types/app/queries/query-replies.d.ts

@@ -0,0 +1,78 @@
+import type { AgentCue } from "../../core/cues.js";
+import type { ReceiptCue, ReplayCue, ReplyCue, WitnessCue } from "../../core/cues.js";
+import type { Deck } from "../../core/deck.js";
+/** One request's direct proof/reply. Duplicate requests may share immutable evidence. */
+type DirectReply = ReplayCue | ReplyCue | ReceiptCue | WitnessCue;
+/** One correlated response or ordered protocol pair. */
+interface QueryReplyBatch {
+    /**
+     * Borrowed immutable evidence in response order: one reply, or registry before credential TSN.
+     */
+    readonly cues: readonly DirectReply[];
+}
+/** A request correlation slot; close it when its HTTP/TCP request completes or is cancelled. */
+export interface QueryReply {
+    /**
+     * Observe this existing slot without queues or retained Promise waiters; one observer at a time.
+     *
+     * @param notify Synchronous wake-up callback, including already-ready/closed state.
+     * @returns Unsubscribe function; cancellation must call it.
+     */
+    observeReady(notify: () => void): () => void;
+    /** Whether a captured batch is available for request-owned consumption. */
+    readonly ready: boolean;
+    /** Take the receipt/witness or ordered TSN pair. */
+    takeAll(): QueryReplyBatch | undefined;
+    /** Inspect the current ordered batch without removing its correlation records. */
+    peekAll(): QueryReplyBatch | undefined;
+    /** Remove this request from correlation and discard untaken records. Safe to repeat. */
+    close(): void;
+}
+/**
+ * Capture connection-owned proof/reply cues before background output consumes them.
+ * Direct TCP queries and request-owned event receipts need this correlation;
+ * ordinary HTTP queries use independent output/receive paths instead. Reserving
+ * a SAID creates a lifetime slot, never authorization to read a mailbox or proof
+ * that protocol processing accepted the request. Each borrower must close its slot.
+ */
+export declare class QueryReplies {
+    private readonly published;
+    /** One replay or a registry/credential pair per request, grouped by query SAID for fanout. */
+    private readonly active;
+    /**
+     * Borrow the application output flow so a late request claims matching queued replies synchronously.
+     *
+     * @param published Borrowed application cue Deck, synchronously scanned when a late request reserves a slot.
+     */
+    constructor(published: Deck<AgentCue>);
+    /**
+     * Reserve one response; duplicate arrivals never add another retained batch.
+     *
+     * @param said Query SAID used for correlation, never sufficient proof of request authorization.
+     * @returns A new request-owned slot; close it on request completion/cancellation.
+     */
+    reserve(said: string): QueryReply;
+    /**
+     * A connection owns only receipts for its exact event; unrelated runtime cues stay routed normally.
+     *
+     * @param pre Subject event AID.
+     * @param said Exact event SAID whose receipt/witness output belongs to the connection.
+     * @returns A request-owned event-proof slot.
+     */
+    reserveEvent(pre: string, said: string): QueryReply;
+    /**
+     * Reuse the request slot for queries and accepted-event proofs.
+     *
+     * @param said Internal query:/event: correlation key.
+     * @returns An independent slot, immediately capturing any already-published matching output.
+     */
+    private reserveKey;
+    /**
+     * Capture correlated reply pairs and share their ordinary records among matching requests.
+     *
+     * @param source Cue Deck to scan through its initial extent; unmatched cues retain their order.
+     */
+    capture(source: Deck<AgentCue>): void;
+}
+export {};
+//# sourceMappingURL=query-replies.d.ts.map

package/types/app/queries/query-replies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-replies.d.ts","sourceRoot":"","sources":["../../../src/app/queries/query-replies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACtF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE/C,yFAAyF;AACzF,KAAK,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAelE,wDAAwD;AACxD,UAAU,eAAe;IACvB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;CACvC;AAED,gGAAgG;AAChG,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC7C,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,oDAAoD;IACpD,OAAO,IAAI,eAAe,GAAG,SAAS,CAAC;IACvC,kFAAkF;IAClF,OAAO,IAAI,eAAe,GAAG,SAAS,CAAC;IACvC,wFAAwF;IACxF,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;;GAMG;AACH,qBAAa,YAAY;IAQX,OAAO,CAAC,QAAQ,CAAC,SAAS;IAPtC,8FAA8F;IAC9F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD;;;;OAIG;gBAC0B,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC;IAEtD;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAIjC;;;;;;OAMG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU;IAInD;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IA6DlB;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI;CA2BtC"}

package/types/app/queries/querying.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Finite query workflows corresponding to `keri.app.querying` doers in KERIpy.
+ *
+ * Each operation expresses a particular accepted-state predicate. It enqueues
+ * unsigned work with WitnessInquisitor, then observes local protocol state;
+ * sending a query or receiving HTTP 204 never satisfies that predicate.
+ * Composition must run the sender, cue worker and actual reply intake alongside
+ * the workflow. HTTP replies arrive through independent mailbox/direct intake;
+ * TCP may process replies on the sending connection.
+ *
+ * Unlike KERIpy's nested DoDoers, these operations borrow one composed sender.
+ * Their caller owns cancellation/deadlines and keeps the Baser open until all
+ * children have joined. Cancelling a wait does not withdraw an already enqueued
+ * query. There is no workflow retry timer or implicit OOBI bootstrap here.
+ */
+import type { SealEvent } from "cesr-ts";
+import type { Operation } from "effection";
+import type { AgentCue } from "../../core/cues.js";
+import type { Deck } from "../../core/deck.js";
+import type { Baser } from "../../db/basing.js";
+import type { WitnessInquisitor } from "./witness-inquisitor.js";
+/** Identity selection shared by the concrete workflows; copied on construction. */
+interface QueryOptions {
+    /** Local AID endorsing the query; omission uses the sender's configured/sole Hab. */
+    signer?: string;
+    /** Remote attester overrides; omission uses the subject's accepted endpoint roles. */
+    wits?: string[];
+}
+/**
+ * Ask an attester for current key state and recover the KEL if its notice is ahead.
+ *
+ * A saved KSN is a remote statement, not acceptance of the referenced KEL. A
+ * matching notice completes immediately only when the local Kever has reached
+ * its sequence. Otherwise a LogQuerier waits for that accepted sequence. The
+ * first usable matching notice fixes this operation's target; later notices stay
+ * queued rather than introducing moving-target task replacement.
+ * The subject needs a local Kever before a notice can drive this comparison;
+ * initial evidence discovery belongs to OOBI/bootstrap composition.
+ *
+ * keyStateSaved denotes a validated, persisted remote notice. Ordinary KEL
+ * acceptance alone cannot satisfy the initial notice wait. Queued notices are
+ * not correlated to a particular request or filtered for request-time freshness.
+ */
+export declare class KeyStateNoticer {
+    private readonly db;
+    private readonly inquisitor;
+    readonly pre: string;
+    private readonly cues;
+    private readonly options;
+    /**
+     * Bind borrowed collaborators without starting I/O or consuming cues yet.
+     *
+     * @param db Baser receiving accepted KEL updates from the independently running intake.
+     * @param inquisitor Query sender over that same state; its delivery worker must run concurrently.
+     * @param pre Subject AID, distinct from the local signer and selected attester.
+     * @param cues Command-owned input Deck; this noticer is its sole consumer. The
+     * application cue owner must be wired to transfer saved notices here before I/O.
+     * @param options Local signer and optional remote attesters, never transport preferences.
+     */
+    constructor(db: Baser, inquisitor: WitnessInquisitor, pre: string, cues: Deck<AgentCue>, options?: QueryOptions);
+    /**
+     * Enqueue `ksn`, then pull/match/append one cue per cooperative turn, following
+     * KERIpy's noticer model. Unrelated cues and matching notices without local
+     * state remain queued. No queue scan, broadcast or request freshness is implied.
+     * Once a usable notice selects a target, directly await accepted catch-up.
+     * The caller supervises sibling sender/receiver failures and owns cancellation;
+     * stopping this operation does not withdraw already enqueued requests.
+     */
+    queryDo(): Operation<void>;
+}
+/**
+ * Recover a KEL through the target sequence learned from a remote key-state notice.
+ * Like KERIpy LogQuerier, request logs from the beginning (`fn=0`, `s=0`) and
+ * finish when the local Kever reaches the target. This is a minimum sequence
+ * condition, not a promise that the remote peer has no newer events.
+ */
+export declare class LogQuerier {
+    private readonly db;
+    private readonly inquisitor;
+    readonly pre: string;
+    readonly targetSn: number;
+    private readonly options;
+    /**
+     * @param db Borrowed accepted-state store, kept open for the operation's lifetime.
+     * @param inquisitor Concurrently running sender; this workflow does not drive it.
+     * @param pre Subject whose KEL should catch up.
+     * @param targetSn Minimum accepted sequence, as a number rather than wire hex text.
+     * @param options Local signing AID and optional remote attester overrides.
+     */
+    constructor(db: Baser, inquisitor: WitnessInquisitor, pre: string, targetSn: number, options?: QueryOptions);
+    /** Send the initial request once and remain active until accepted state reaches the target. */
+    queryDo(): Operation<void>;
+}
+/**
+ * Request logs starting at selected KEL and first-seen ordinals.
+ *
+ * `s` selects the event sequence and `fn` selects first-seen replay position;
+ * they are different coordinates. As in KERIpy SeqNoQuerier, completion depends
+ * on accepted KEL sequence reaching targetSn, not on a first-seen cursor or a
+ * transport outcome. Even an already satisfied target still enqueues the request.
+ */
+export declare class SeqNoQuerier {
+    private readonly db;
+    private readonly inquisitor;
+    readonly pre: string;
+    readonly targetSn: number;
+    private readonly options;
+    private readonly fn;
+    /**
+     * @param db Borrowed accepted-state store updated by independent protocol intake.
+     * @param inquisitor Concurrent sender borrowing the same accepted state.
+     * @param pre Subject AID whose KEL is requested.
+     * @param targetSn Numeric sequence used both in the query and the completion predicate.
+     * @param options Numeric first-seen start (default zero), local signer and remote attesters.
+     * Wire ordinals use lowercase hex; the existing encoder clamps negatives to zero.
+     */
+    constructor(db: Baser, inquisitor: WitnessInquisitor, pre: string, targetSn: number, { fn, ...options }?: QueryOptions & {
+        fn?: number;
+    });
+    /** Complete only from an accepted KEL at or beyond the requested sequence. */
+    queryDo(): Operation<void>;
+}
+/**
+ * Find an accepted KEL event containing the exact supplied event seal.
+ *
+ * `pre` identifies the sealing KEL; anchor.i/s/d identify the event sealed in it.
+ * Mere knowledge of the subject's latest sequence does not satisfy this wait.
+ * Existing accepted sealing evidence completes without sending. Otherwise one
+ * request is enqueued per current eligible attester, preserving the bounded
+ * candidate pass needed when a retired witness never learned the anchor. This
+ * differs deliberately from KERIpy's single randomly selected attester.
+ */
+export declare class AnchorQuerier {
+    private readonly db;
+    private readonly inquisitor;
+    readonly pre: string;
+    readonly anchor: ReturnType<typeof SealEvent.toSad>;
+    private readonly options;
+    /**
+     * @param db Borrowed store containing accepted sealing events and their indexes.
+     * @param inquisitor Concurrent sender; candidates are selected when queryDo starts.
+     * @param pre AID whose KEL must contain the seal.
+     * @param anchor Exact event-seal fields, copied so later caller mutation cannot change the query.
+     * @param options Local signing AID and optional remote attesters.
+     */
+    constructor(db: Baser, inquisitor: WitnessInquisitor, pre: string, anchor: ReturnType<typeof SealEvent.toSad>, options?: QueryOptions);
+    /**
+     * Ask the finite candidate set once, then observe accepted sealing evidence.
+     * No available candidate leaves unresolved work with the sender; it is not
+     * success. The caller supplies a deadline or cancels this otherwise open wait.
+     */
+    queryDo(): Operation<void>;
+}
+export {};
+//# sourceMappingURL=querying.d.ts.map

package/types/app/queries/querying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"querying.d.ts","sourceRoot":"","sources":["../../../src/app/queries/querying.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAAE,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,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,mFAAmF;AACnF,UAAU,YAAY;IACpB,qFAAqF;IACrF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAqBD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAe;IAcxB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAhBvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC;;;;;;;;;OASG;gBAEgB,EAAE,EAAE,KAAK,EACT,UAAU,EAAE,iBAAiB,EACrC,GAAG,EAAE,MAAM,EACH,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,EACrC,OAAO,GAAE,YAAiB;IAK5B;;;;;;;OAOG;IACF,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC;CAqB5B;AAED;;;;;GAKG;AACH,qBAAa,UAAU;IAWnB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAb3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC;;;;;;OAMG;gBAEgB,EAAE,EAAE,KAAK,EACT,UAAU,EAAE,iBAAiB,EACrC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EACzB,OAAO,GAAE,YAAiB;IAK5B,+FAA+F;IAC9F,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC;CAI5B;AAED;;;;;;;GAOG;AACH,qBAAa,YAAY;IAarB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAf3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAE5B;;;;;;;OAOG;gBAEgB,EAAE,EAAE,KAAK,EACT,UAAU,EAAE,iBAAiB,EACrC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EACzB,EAAE,EAAM,EAAE,GAAG,OAAO,EAAE,GAAE,YAAY,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAO;IAM7D,8EAA8E;IAC7E,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC;CAS5B;AAED;;;;;;;;;GASG;AACH,qBAAa,aAAa;IAYtB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM;IAbtB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC;;;;;;OAMG;gBAEgB,EAAE,EAAE,KAAK,EACT,UAAU,EAAE,iBAAiB,EACrC,GAAG,EAAE,MAAM,EACpB,MAAM,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,KAAK,CAAC,EAC1C,OAAO,GAAE,YAAiB;IAM5B;;;;OAIG;IACF,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC;CAgB5B"}