keri-ts 0.11.0 → 2.0.0

package/types/app/queries/witness-inquisitor.d.ts

@@ -0,0 +1,150 @@
+import { type Operation } from "effection";
+import type { QueryCue, QueryRequest } from "../../core/cues.js";
+import { Deck } from "../../core/deck.js";
+import type { Hab, 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";
+/**
+ * KERIpy-shaped query sender, independent from semantic query completion.
+ *
+ * Responsibilities:
+ * - turn incomplete portable `query` cues into honest outbound `qry` wire
+ *   packets when a local habitat and remote attester can be resolved
+ * - capture signed requests and own their concrete, joined transport attempts
+ *
+ * Unresolved signer/attester work stays unsigned for a later pass. Once a packet
+ * is prepared, the request leaves the Deck before transport: a failed attempt is
+ * reported, not automatically retried. Preparation failures leave the source
+ * head available and propagate. HTTP completion includes response EOF/cleanup;
+ * same-socket TCP completion also includes received protocol processing. Neither
+ * is a substitute for the calling workflow's accepted-state predicate.
+ */
+export declare class WitnessInquisitor {
+    /** Borrowed local signers and accepted-state stores. */
+    private readonly hby;
+    /** Borrowed receive processor for same-socket TCP replies only. */
+    private readonly protocol;
+    /** Borrowed HTTP client selected at composition. */
+    private readonly http;
+    /** Borrowed clock for this owner's actual network deadlines. */
+    private readonly clock;
+    /** One operation owns the current network attempt. */
+    private delivering;
+    /** Aborts the active send when this sender closes. */
+    private output?;
+    /** Joins active request/parser cleanup before owned queues are cleared. */
+    private outputJoined?;
+    /** Unsigned query instructions awaiting an available signer/endpoint. */
+    private readonly requests;
+    /** Inspect deferred work without exposing queue mutation outside its owner. */
+    get pending(): Pick<Deck<QueryRequest>, "length" | "empty" | "peekHead">;
+    /** Terminal admission state; closing stops production and delivery. */
+    private closed;
+    /** Explicit default signer; null requires a unique local habitat. */
+    private hab;
+    /**
+     * Bind actual protocol and I/O collaborators; acquire no store or network lifetime.
+     *
+     * @param hby Borrowed local habitat collection and accepted-state database.
+     * @param protocol Borrowed same-database processor for incoming query replies.
+     * @param http Borrowed HTTP implementation selected by composition.
+     * @param clock Borrowed clock for transport deadlines; times are milliseconds.
+     * @param hab Optional default local signer; null requires an unambiguous sole habitat.
+     */
+    constructor(hby: Habery, protocol: ProtocolProcessor, http: HttpClient, clock: RuntimeClock, hab?: Hab | null);
+    /**
+     * Select the local habitat used when queued requests have no explicit signer.
+     *
+     * @param options Optional default signing habitat; omission/null clears the explicit selection.
+     */
+    configure({ hab }?: {
+        hab?: Hab | null;
+    }): void;
+    /** Deferred instructions and active sends are this sender's only pending work. */
+    hasPendingWork(): boolean;
+    /**
+     * Queue for later resolution/delivery: copy the top level/witness list only.
+     * Nested query values remain borrowed immutable data until consumption or joined close retires the record.
+     *
+     * @param request Typed request; signer names a local AID and src names a remote attester.
+     */
+    enqueue(request: QueryRequest): void;
+    /**
+     * Admit a routed query cue for sender-owned resolution and one concrete transport attempt.
+     *
+     * @param cue Typed query cue; missing route/subject produces no request.
+     * @param hab Optional local signer hint when the cue has no explicit signer.
+     */
+    enqueueCue(cue: QueryCue, hab?: Hab | null): void;
+    /** Include actual query I/O in convergence; pending instructions have their own queue. */
+    get hasPendingDelivery(): boolean;
+    /**
+     * Attempt at most the work present when this pass starts, preserving new work
+     * for a later pass. Unresolved records rotate to the tail. A recognized send
+     * failure ends the pass and throws after cleanup; remaining requests stay queued.
+     * Calling during an active pass or after close performs no work.
+     */
+    deliverOnce(): Operation<void>;
+    /**
+     * Own one joined output scope for the pass. Catch only the actual post attempt's
+     * TransportError/CesrHttpRefusal as expected send outcomes. Resolution and
+     * signing failures stay outside that catch even when they use the same error
+     * type; joined-scope teardown failures also escape background reporting.
+     */
+    private deliveryPass;
+    /**
+     * Use ordinary POST delivery for HTTP, draining successful bytes without
+     * parsing them. The independent mailbox/direct receiver accepts HTTP replies.
+     * TCP explicitly enables same-connection reply processing before completion.
+     *
+     * @param delivery Retained signed packet including introduction and destination.
+     * @param controller Sender attempt cancellation; its signal covers response parsing and cleanup.
+     */
+    private postQueryMessage;
+    /**
+     * Stop admission, abort/join active transport and parser cleanup, then discard
+     * unsigned pending work. Does not close borrowed collaborators or Baser.
+     * Repeating close is harmless; genuine cleanup failures remain visible.
+     */
+    close(): Operation<void>;
+    /**
+     * Long-lived sender worker, run once by composition. Report an expected send
+     * failure once, then continue remaining requests on a later turn. Unexpected
+     * preparation/cleanup faults terminate the worker. Caller cancellation joins
+     * the current attempt; it does not close the borrowed state or HTTP service.
+     */
+    deliverDo(): Operation<never>;
+    /**
+     * Resolve the habitat that is allowed to sign the outbound query.
+     *
+     * Resolution order:
+     * - explicitly selected local signer (unavailable means unresolved, never fallback)
+     * - runtime-configured habitat
+     * - sole local habitat
+     *
+     * @param signer Explicit local AID; if unavailable return null rather than falling back.
+     * @returns Explicit signer, configured habitat or sole local habitat; otherwise null.
+     */
+    private configuredHab;
+    /**
+     * Resolve/sign one selected query and introduction immediately before its attempt.
+     *
+     * @param request Deferred unsigned request; nested query values must remain immutable.
+     * @returns Prepared packet, or null when signer/attester evidence is unresolved.
+     * @throws A selected attester with no endpoint URL throws; source removal remains with the caller.
+     */
+    private prepareRequest;
+    /**
+     * Return the first eligible role’s attester IDs; preparation chooses one randomly.
+     *
+     * @param pre Subject AID whose accepted endpoint roles are consulted.
+     * @param options Optional local signer AID and remote witness/attester overrides; neither selects a transport implementation.
+     * @returns Eligible attester AIDs, or an empty array for an unknown subject or unresolved signer/role.
+     */
+    attestersFor(pre: string, { signer, wits }?: {
+        signer?: string;
+        wits?: string[];
+    }): string[];
+}
+//# sourceMappingURL=witness-inquisitor.d.ts.map

package/types/app/queries/witness-inquisitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-inquisitor.d.ts","sourceRoot":"","sources":["../../../src/app/queries/witness-inquisitor.ts"],"names":[],"mappings":"AAWA,OAAO,EAAQ,KAAK,SAAS,EAAY,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAoB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAM1C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AA+F9D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAiB;IAC5B,wDAAwD;IACxD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,gEAAgE;IAChE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,sDAAsD;IACtD,OAAO,CAAC,UAAU,CAAS;IAC3B,sDAAsD;IACtD,OAAO,CAAC,MAAM,CAAC,CAAkB;IACjC,2EAA2E;IAC3E,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IACrD,+EAA+E;IAC/E,IAAI,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,UAAU,CAAC,CAEvE;IACD,uEAAuE;IACvE,OAAO,CAAC,MAAM,CAAS;IACvB,qEAAqE;IACrE,OAAO,CAAC,GAAG,CAAa;IAExB;;;;;;;;OAQG;gBACS,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,GAAE,GAAG,GAAG,IAAW;IASnH;;;;OAIG;IACH,SAAS,CAAC,EAAE,GAAU,EAAE,GAAE;QAAE,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAA;KAAO,GAAG,IAAI;IAI1D,kFAAkF;IAClF,cAAc,IAAI,OAAO;IAIzB;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IASpC;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI;IAQjD,0FAA0F;IAC1F,IAAI,kBAAkB,IAAI,OAAO,CAEhC;IAED;;;;;OAKG;IACF,WAAW,IAAI,SAAS,CAAC,IAAI,CAAC;IAK/B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAyCpB;;;;;;;OAOG;IACH,OAAO,CAAE,gBAAgB;IAmBzB;;;;OAIG;IACF,KAAK,IAAI,SAAS,CAAC,IAAI,CAAC;IAOzB;;;;;OAKG;IACF,SAAS,IAAI,SAAS,CAAC,KAAK,CAAC;IAQ9B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAetB;;;;;;OAMG;IACH,YAAY,CACV,GAAG,EAAE,MAAM,EACX,EAAE,MAAM,EAAE,IAAI,EAAE,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO,GAC1D,MAAM,EAAE;CAoBZ"}

package/types/app/runtime/abortable.d.ts

@@ -0,0 +1,39 @@
+import { type Operation, type Scope } from "effection";
+/**
+ * Identify foreign failures while joining cancelled work, without throwing as a filter.
+ *
+ * @param error Failure from joined I/O, possibly an AggregateError.
+ * @param signal Owner whose exact cancellation reason may be removed.
+ * @returns Foreign failures, preserving unchanged aggregates and error identities.
+ */
+export declare function cleanupFailures(error: unknown, signal: AbortSignal): unknown[];
+/**
+ * Stop the containing race when an upstream signal aborts, including pre-abort.
+ *
+ * @param signal Actual caller cancellation; register before checking its current state.
+ * @throws The signal's exact reason. The operation never completes normally.
+ */
+export declare function throwOnAbort(signal: AbortSignal): Operation<never>;
+/**
+ * Preserve foreign cleanup failures, removing only this owner's exact abort reason.
+ *
+ * @param error Failure observed during joined cleanup.
+ * @param signal Owner signal whose exact reason may be suppressed.
+ * @throws The original foreign failure, or an AggregateError containing multiple remaining failures.
+ */
+export declare function rethrowCleanupFailure(error: unknown, signal: AbortSignal): void;
+/**
+ * Own one cancellable Promise leaf inside an Effection operation.
+ * The leaf must observe its signal; teardown aborts it and joins its cleanup before returning.
+ * An isolated call scope keeps cancellation abrupt even while finalization yields.
+ * Register dependent owner resources before this leaf so reverse teardown joins it before disposal.
+ * Owned concurrent work uses the supplied leaf scope, so its signal aborts before child cleanup joins.
+ * Borrow that scope only for work joined within the leaf, never for later operations.
+ *
+ * @param start Starts the Promise leaf with an owned signal and scope; must observe abort and join any work borrowed from that scope.
+ * @param upstream Optional caller cancellation combined with the leaf's own signal.
+ * @returns The leaf result after successful completion; scope teardown joins pending work.
+ * @throws The leaf error or a foreign cleanup failure; exact owned cancellation is filtered during cleanup.
+ */
+export declare function abortable<T>(start: (signal: AbortSignal, scope: Scope) => Promise<T>, upstream?: AbortSignal): Operation<T>;
+//# sourceMappingURL=abortable.d.ts.map

package/types/app/runtime/abortable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortable.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/abortable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,KAAK,EAAY,MAAM,WAAW,CAAC;AAkBnF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,EAAE,CAE9E;AAED;;;;;GAKG;AACH,wBAAiB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC,KAAK,CAAC,CAKnE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAI/E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,EACxD,QAAQ,CAAC,EAAE,WAAW,GACrB,SAAS,CAAC,CAAC,CAAC,CA+Bd"}

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