keri-ts 0.11.0 → 1.0.0

package/esm/keri/npm/src/acdc/scheming.js

@@ -1,5 +1,5 @@
-/** Bounded v2 ACDC schema validation against the inspected 71438328 profile; no network resolution. */
-import { Diger, dumps, ParserError, ResourceLimitError } from "cesr-ts";
+/** Local v2 ACDC schema validation against the inspected 71438328 profile; no network resolution. */
+import { Diger, dumps, ParserError } from "cesr-ts";
 import Ajv2020 from "ajv/dist/2020.js";
 import { ValidationError } from "../core/errors.js";
 import { Schemer } from "../core/scheming.js";
@@ -39,57 +39,6 @@ const singles = [
 ];
 const maps = ["$defs", "properties", "patternProperties", "dependentSchemas"];
 const arrays = ["prefixItems", "allOf", "anyOf", "oneOf"];
-/** Admission counts values/depth as well as bytes before cloning or compiling; native row allocation remains separate. */
-class Credit {
-    constructor() {
-        Object.defineProperty(this, "bytes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 8 * 1024 ** 2
-        });
-        Object.defineProperty(this, "values", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 4096
-        });
-        Object.defineProperty(this, "refs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 4096
-        });
-    }
-    take(schema) {
-        const work = [[schema, 0]];
-        let characters = this.bytes;
-        while (work.length) {
-            const [value, depth] = work.pop();
-            if (--this.values < 0 || depth > 64)
-                throw new ResourceLimitError("ACDC schema value/depth credit exhausted");
-            if (typeof value === "string")
-                characters -= value.length;
-            if (characters < 0)
-                throw new ResourceLimitError("ACDC schema byte credit exhausted");
-            if (value && typeof value === "object") {
-                for (const key in value) {
-                    if (!Object.hasOwn(value, key))
-                        continue;
-                    characters -= key.length;
-                    if (characters < 0)
-                        throw new ResourceLimitError("ACDC schema byte credit exhausted");
-                    if (work.length >= this.values)
-                        throw new ResourceLimitError("ACDC schema value credit exhausted");
-                    work.push([value[key], depth + 1]);
-                }
-            }
-        }
-        this.bytes -= dumps(schema, "JSON").length;
-        if (this.bytes < 0)
-            throw new ResourceLimitError("ACDC schema byte credit exhausted");
-    }
-}
 /** Plain maps and booleans are the only JSON Schema resource/fragment targets. */
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -102,7 +51,7 @@ function digest(value) {
             return diger;
     }
     catch (error) {
-        if (!(error instanceof ParserError) || error instanceof ResourceLimitError)
+        if (!(error instanceof ParserError))
             throw error;
     }
     throw new InvalidSchema("Schema reference must contain a complete SAID");
@@ -213,9 +162,7 @@ function fragment(resource, value) {
 }
 /** Local static schema closure plus a synchronous Draft 2020-12 validator; legacy Schemer behavior is unchanged. */
 export function validateSchema(acdc, db, override) {
-    if (acdc.raw.length > 8 * 1024 ** 2)
-        throw new ResourceLimitError("ACDC schema input exceeds finite body limit");
-    const credit = new Credit(), resources = new Map(), roots = [];
+    const resources = new Map(), roots = [];
     const scopes = new Map(), refs = [];
     const work = [];
     let missing = null;
@@ -234,18 +181,14 @@ export function validateSchema(acdc, db, override) {
         }
         return add(cached.sed, true, said);
     }
-    /** Admit a complete original resource before charging dependent schemas or cloning it. */
+    /** Verify each original resource before cloning it for compilation. */
     function add(schema, root, expected) {
-        if (root)
-            credit.take(schema);
         const said = identity(schema, root);
         if (expected && said !== expected)
             throw new InvalidSchema("Cached schema does not match its lookup SAID");
         const existing = resources.get(said);
         if (existing)
             return existing;
-        if (resources.size >= 128)
-            throw new ResourceLimitError("ACDC schema resource credit exhausted");
         const resource = { said, schema, anchors: new Map() };
         resources.set(said, resource);
         if (root)
@@ -259,7 +202,7 @@ export function validateSchema(acdc, db, override) {
         if (!root) {
             return missing
                 ? { kind: "missing", said: missing }
-                : { kind: "invalid", reason: "Invalid ACDC schema field" };
+                : { kind: "invalid", subject: "schema", reason: "Invalid ACDC schema field" };
         }
         for (;;) {
             while (work.length) {
@@ -278,8 +221,6 @@ export function validateSchema(acdc, db, override) {
                 if (typeof node.$anchor === "string")
                     owner.anchors.set(node.$anchor, node);
                 if ("$ref" in node) {
-                    if (--credit.refs < 0)
-                        throw new ResourceLimitError("ACDC schema reference credit exhausted");
                     refs.push({ node, resource: owner, value: node.$ref });
                 }
                 for (const child of children(node))
@@ -344,20 +285,22 @@ export function validateSchema(acdc, db, override) {
         }
         catch (error) {
             if (error instanceof SyntaxError && error.message.includes("regular expression")) {
-                return { kind: "invalid", reason: error.message };
+                return { kind: "invalid", subject: "schema", reason: error.message };
             }
             if (error instanceof Error && /^reference "urn:said:[^"]+" resolves to more than one schema$/.test(error.message)) {
-                return { kind: "invalid", reason: error.message };
+                return { kind: "invalid", subject: "schema", reason: error.message };
             }
             throw error;
         }
         if (!validate)
             throw new Error("Admitted schema was not registered");
-        return validate(acdc.sad) ? { kind: "valid" } : { kind: "invalid", reason: validator.errorsText(validate.errors) };
+        return validate(acdc.sad)
+            ? { kind: "valid" }
+            : { kind: "invalid", subject: "credential", reason: validator.errorsText(validate.errors) };
     }
     catch (error) {
         if (error instanceof InvalidSchema)
-            return { kind: "invalid", reason: error.message };
+            return { kind: "invalid", subject: "schema", reason: error.message };
         throw error;
     }
 }

package/esm/keri/npm/src/app/abortable.js

@@ -1,4 +1,23 @@
-import { call, useScope } from "effection";
+import { call, ensure, useScope } from "effection";
+/** Remove only this operation's cancellation from joined I/O failures. */
+function remainingFailures(error, cancellation) {
+    if (error === cancellation)
+        return [];
+    if (!(error instanceof AggregateError))
+        return [error];
+    const remaining = error.errors.flatMap((child) => remainingFailures(child, cancellation));
+    return remaining.length === error.errors.length && remaining.every((child, index) => child === error.errors[index])
+        ? [error]
+        : remaining;
+}
+/** Preserve foreign cleanup failures, removing only this owner's exact abort reason. */
+export function rethrowCleanupFailure(error, signal) {
+    const failures = remainingFailures(error, signal.reason);
+    if (failures.length === 1)
+        throw failures[0];
+    if (failures.length)
+        throw new AggregateError(failures, "I/O cleanup failed during cancellation");
+}
 /**
  * Own one cancellable Promise leaf inside an Effection operation.
  * The leaf must observe its signal; teardown aborts it and joins its cleanup before returning.
@@ -12,16 +31,34 @@ export function abortable(start, upstream) {
         const controller = new AbortController();
         const signal = upstream ? AbortSignal.any([controller.signal, upstream]) : controller.signal;
         let pending;
+        let reported = false;
+        // Register joining before work children, so they halt before their pending Promise is joined.
+        yield* ensure(function* () {
+            if (pending) {
+                yield* call(async () => {
+                    try {
+                        await pending;
+                    }
+                    catch (error) {
+                        if (reported)
+                            return;
+                        rethrowCleanupFailure(error, signal);
+                    }
+                });
+            }
+        });
         try {
             signal.throwIfAborted();
             pending = start(signal, yield* useScope());
             return yield* call(() => pending);
         }
+        catch (error) {
+            reported = true;
+            throw error;
+        }
         finally {
+            // Abort before child teardown; joining is the registered resource's responsibility.
             controller.abort();
-            // Cancellation stops waiting at the yield, but the leaf still owns I/O until its Promise settles.
-            if (pending)
-                yield* call(() => pending.then(() => { }, () => { }));
         }
     });
 }

package/esm/keri/npm/src/app/agent-runtime.js

@@ -1,16 +1,15 @@
-import { call, resource, spawn } from "effection";
+import { call, resource, spawn, suspend } from "effection";
 import { createRegery as createAcdcRegery } from "../acdc/registraring.js";
-import { CueDeck } from "../core/cue-admission.js";
+import { Deck } from "../core/deck.js";
 import { DatabaseNotOpenError } from "../core/errors.js";
 import { CREDENTIAL_MAILBOX_TOPIC, DELEGATE_MAILBOX_TOPIC, RECEIPT_MAILBOX_TOPIC, REPLAY_MAILBOX_TOPIC, REPLY_MAILBOX_TOPIC, } from "../core/mailbox-topics.js";
 import { Mailboxer } from "../db/mailboxing.js";
 import { Noter } from "../db/noting.js";
-import { createReger, Reger } from "../db/reger.js";
+import { createReger } from "../db/reger.js";
 import { Regery as VdrRegery } from "../vdr/credentialing.js";
-import { Tevery } from "../vdr/eventing.js";
 import { Authenticator } from "./authenticating.js";
 import { loadChallengeHandlers } from "./challenging.js";
-import { cueDo, processCuesOnce } from "./cue-runtime.js";
+import { cueDo } from "./cue-runtime.js";
 import { Anchorer, loadDelegationHandlers } from "./delegating.js";
 import { ForwardHandler, MailboxPoller, mailboxTopicForRoute, Poster, } from "./forwarding.js";
 import { loadMultisigHandlers } from "./grouping.js";
@@ -23,42 +22,31 @@ import { QueryCoordinator } from "./querying.js";
 import { Reactor } from "./reactor.js";
 import { ReplyStreams } from "./reply-streams.js";
 import { Respondant } from "./respondant.js";
-import { RuntimeDeliveries } from "./runtime-deliveries.js";
 import { resolveRuntimeServices } from "./runtime-services.js";
 import { runtimeTurn } from "./runtime-turn.js";
 import { Signaler } from "./signaling.js";
-import { Verifier } from "./verifying.js";
 /**
  * Create the shared runtime composition root used by CLI commands and
  * `tufa agent`.
  *
  * Construction rule:
- * - every host mode uses the same shared cue deck and the same component
- *   classes
- * - hosting style changes where the runtime is run, not what it is
+ * - hosts choose concrete optional stores and borrow supplied dependencies
+ * - the composition owns only stores it constructs
  */
 export function* createAgentRuntime(hby, options = {}) {
-    const resources = hby.db.resources;
-    if ((options.resources && options.resources !== resources)
-        || (options.services?.resources && options.services.resources !== resources)) {
-        throw new RangeError("AgentRuntime requires the Habery Baser resource policy; supply it when opening Habery");
-    }
     const injectedSignaler = options.signaler ?? options.notifier?.signaler;
-    if ((injectedSignaler && injectedSignaler.resources !== resources)
-        || (options.notifier && options.notifier.hby !== hby)
+    if ((options.notifier && options.notifier.hby !== hby)
         || (options.signaler && options.notifier && options.signaler !== options.notifier.signaler)) {
-        throw new RangeError("AgentRuntime notification services require its exact Habery and resource policy");
+        throw new RangeError("AgentRuntime notification services require its exact Habery and Signaler");
     }
-    const mode = options.mode ?? "local";
-    const services = resolveRuntimeServices({ ...options.services, resources });
-    const enableMailboxStore = options.enableMailboxStore ?? mode === "indirect";
+    const services = resolveRuntimeServices(options.services);
     const mailboxer = options.mailboxer
-        ?? (enableMailboxStore ? (yield* openRuntimeMailboxer(hby)) : null);
+        ?? (options.enableMailboxStore ? (yield* openRuntimeMailboxer(hby)) : null);
     const ownsMailboxer = options.mailboxer === undefined && mailboxer !== null;
     const ownsSignaler = injectedSignaler === undefined && hby.signator !== null;
     const signaler = injectedSignaler ?? (ownsSignaler
         ? (yield* resource(function* (provide) {
-            const owned = new Signaler({ resources });
+            const owned = new Signaler();
             try {
                 yield* provide(owned);
             }
@@ -75,23 +63,14 @@ export function* createAgentRuntime(hby, options = {}) {
         && noter !== null;
     const notifier = options.notifier
         ?? (noter && signaler ? new Notifier(hby, { noter, signaler }) : null);
-    const vdr = { ...(options.vdr ?? {}) };
-    let ownsReger = false;
-    if (!vdr.reger && !hby.readonly) {
-        vdr.reger = yield* openRegerForHabery(hby);
-        ownsReger = true;
-    }
-    const reger = vdr.reger instanceof Reger ? vdr.reger : null;
-    const acdc = { ...(options.acdc ?? {}) };
-    let ownsAcdcRegery = false;
-    if (acdc.rgy == null && !hby.readonly) {
-        acdc.rgy = yield* openAcdcRegeryForHabery(hby);
-        ownsAcdcRegery = true;
-    }
-    const acdcRegery = acdc.rgy;
+    const reger = options.reger ?? (!hby.readonly ? (yield* openRegerForHabery(hby)) : null);
+    const ownsReger = options.reger === undefined && reger !== null;
+    const acdc = options.acdc ?? (!hby.readonly ? (yield* openAcdcRegeryForHabery(hby)) : null);
+    const ownsAcdcRegery = options.acdc === undefined && acdc !== null;
+    const acdcRegery = acdc;
     // Acquire after stores, before processors/consumers: reverse teardown joins consumers, clears cues, closes stores.
     const cues = yield* resource(function* (provide) {
-        const owned = new CueDeck(resources);
+        const owned = new Deck();
         try {
             yield* provide(owned);
         }
@@ -99,23 +78,11 @@ export function* createAgentRuntime(hby, options = {}) {
             owned.clear();
         }
     });
-    if (reger && !vdr.tvy) {
-        vdr.tvy = new Tevery({ db: hby.db, reger, cues });
-    }
-    if (reger && !vdr.vry) {
-        vdr.vry = new Verifier(hby, { reger, cues });
-    }
-    if (reger && vdr.tvy instanceof Tevery && vdr.vry instanceof Verifier && !vdr.rgy) {
-        vdr.rgy = new VdrRegery(hby, {
-            reger,
-            tvy: vdr.tvy,
-            vry: vdr.vry,
-            cues,
-        });
-    }
+    const protocolCues = new Deck();
+    const vdr = reger ? new VdrRegery(hby, { reger, cues: protocolCues }) : null;
     // Reverse scope teardown joins borrowed output evidence before its backing stores close.
     const replyStreams = yield* resource(function* (provide) {
-        const streams = new ReplyStreams(options.replyLimits, resources);
+        const streams = new ReplyStreams();
         try {
             yield* provide(streams);
         }
@@ -123,20 +90,12 @@ export function* createAgentRuntime(hby, options = {}) {
             streams.close();
         }
     });
-    const deliveries = yield* resource(function* (provide) {
-        const deliveries = new RuntimeDeliveries(resources);
-        try {
-            yield* provide(deliveries);
-        }
-        finally {
-            yield* deliveries.close();
-        }
-    });
     const reactor = new Reactor(hby, {
         cues,
-        vdr,
-        resources,
-        acdc,
+        protocolCues,
+        tevery: vdr?.tvy,
+        verifier: vdr?.vry,
+        registry: acdc ?? undefined,
         messagePolicy: options.messagePolicy,
         kram: options.kram,
         now: () => services.clock.now(),
@@ -155,13 +114,11 @@ export function* createAgentRuntime(hby, options = {}) {
     loadMultisigHandlers(hby, reactor.exchanger, { notifier });
     loadIpexHandlers(hby, reactor.exchanger, {
         notifier,
-        registry: acdc.rgy?.store ?? null,
+        registry: acdc?.store ?? null,
     });
     const mailboxDirector = yield* resource(function* (provide) {
         const director = new MailboxDirector(hby, {
             ...(mailboxer ? { mailboxer } : {}),
-            resources,
-            streamLimits: options.mailboxStreamLimits,
         });
         try {
             yield* provide(director);
@@ -171,7 +128,15 @@ export function* createAgentRuntime(hby, options = {}) {
         }
     });
     const poster = new Poster(hby, { mailboxer, services });
-    const respondant = new Respondant(hby, { poster, mailboxDirector });
+    const respondant = yield* resource(function* (provide) {
+        const respondant = new Respondant(hby, { poster, reactor, replyStreams });
+        try {
+            yield* provide(respondant);
+        }
+        finally {
+            yield* respondant.close();
+        }
+    });
     if (mailboxer) {
         reactor.exchanger.addHandler(new ForwardHandler(mailboxDirector));
     }
@@ -187,7 +152,6 @@ export function* createAgentRuntime(hby, options = {}) {
     const mailboxPoller = new MailboxPoller(hby, mailboxDirector, {
         services,
         pollTransport: options.mailboxPollTransport,
-        mailboxAdmission: options.mailboxAdmission,
     });
     for (const topic of [
         DELEGATE_MAILBOX_TOPIC,
@@ -199,7 +163,7 @@ export function* createAgentRuntime(hby, options = {}) {
         mailboxDirector.registerTopic(topic);
     }
     const querying = yield* resource(function* (provide) {
-        const coordinator = new QueryCoordinator(hby);
+        const coordinator = new QueryCoordinator(hby, { reactor, services });
         try {
             yield* provide(coordinator);
         }
@@ -207,14 +171,12 @@ export function* createAgentRuntime(hby, options = {}) {
             yield* coordinator.close();
         }
     });
-    const delegating = new Anchorer(hby, { poster, querying, services });
+    const delegating = new Anchorer(hby, { poster, querying, services, reactor });
     const oobiery = new Oobiery(hby, reactor, { cues, services });
     oobiery.registerReplyRoutes(reactor.router);
     const authenticator = new Authenticator(hby, { services });
     return {
         hby,
-        resources,
-        mode,
         mailboxer,
         noter,
         notifier,
@@ -230,7 +192,6 @@ export function* createAgentRuntime(hby, options = {}) {
         delegating,
         querying,
         replyStreams,
-        deliveries,
         vdr,
         acdc,
         services,
@@ -246,7 +207,7 @@ export function* createAgentRuntime(hby, options = {}) {
                         signaler?.close();
                 },
                 function* () {
-                    yield* deliveries.close();
+                    yield* respondant.close();
                 },
                 function* () {
                     yield* call(() => Promise.resolve(replyStreams.close()));
@@ -406,59 +367,6 @@ export function* settleMailboxPollBatch(runtime, batch) {
     }
     yield* runtime.reactor.processEscrowsOnce();
 }
-/**
- * Drain one bounded mailbox polling turn and settle each returned batch.
- *
- * This keeps mailbox polling ownership inside the shared runtime surface so
- * commands do not need to know how mailbox ingress is parsed and escrowed.
- */
-export function* processMailboxTurn(runtime, options = {}) {
-    runtime.mailboxPoller.configure({ hab: options.hab });
-    const batches = yield* runtime.mailboxPoller.processOnce({
-        budgetMs: options.budgetMs,
-    });
-    for (const batch of batches) {
-        yield* settleMailboxPollBatch(runtime, batch);
-    }
-    return batches;
-}
-/**
- * Drain one bounded runtime turn by delegating to component-owned flows.
- *
- * Turn order:
- * 1. `Reactor.processOnce()` drains queued ingress
- * 2. `Oobiery.processOnce()` resolves at most one durable OOBI record
- * 3. `Authenticator.processOnce()` advances one well-known auth step
- * 4. `processCuesOnce()` emits cues from fresh ingress/OOBI work into
- *    `QueryCoordinator`
- * 5. `QueryCoordinator.processPending()` resolves any newly correspondence-ready
- *    query work
- * 6. `Reactor.processEscrowsOnce()` runs KEL and reply escrow passes
- * 7. `processCuesOnce()` emits cues created during escrow progress
- * 8. `QueryCoordinator.processPending()` resolves any follow-on query work
- *
- * This helper remains because command-local CLI flows and focused tests need a
- * single deterministic step without having to spawn the long-lived doers.
- */
-export function* processRuntimeTurn(runtime, options = {}) {
-    runtime.querying.configure({ hab: options.hab, sink: options.sink });
-    yield* runtime.reactor.processOnce();
-    yield* runtime.oobiery.processOnce();
-    yield* runtime.authenticator.processOnce();
-    yield* runtime.poster.processPending(runtime);
-    yield* runtime.delegating.processAllOnce(runtime);
-    runtime.signaler?.processOnce();
-    if (options.pollMailbox ?? true) {
-        yield* processMailboxTurn(runtime, { hab: options.hab });
-    }
-    yield* processCuesOnce(runtime, { ...options, sink: runtime.querying });
-    yield* runtime.querying.processPending(runtime);
-    yield* runtime.reactor.processEscrowsOnce();
-    yield* runtime.delegating.processAllOnce(runtime);
-    yield* processCuesOnce(runtime, { ...options, sink: runtime.querying });
-    yield* runtime.querying.processPending(runtime);
-    yield* runtime.deliveries.process(runtime);
-}
 /**
  * Return the current pending-work summary for bounded command-local hosts.
  *
@@ -476,12 +384,11 @@ export function runtimePendingState(runtime) {
         multiPending: runtime.hby.db.moobi.cnt() > 0,
         authQueued: runtime.hby.db.woobi.cnt() > 0,
         authInFlight: runtime.hby.db.mfa.cnt() > 0,
-        outboxPending: runtime.poster.hasPendingWork(),
         delegationPending: runtime.hby.db.dpwe.cnt() > 0
             || runtime.hby.db.dune.cnt() > 0
             || runtime.hby.db.dpub.cnt() > 0,
         queriesPending: runtime.querying.hasPendingWork(),
-        deliveriesPending: runtime.deliveries.hasPending,
+        deliveriesPending: runtime.querying.hasPendingDelivery || runtime.respondant.hasPending,
     };
 }
 /** Return true when any command-local runtime work remains in flight. */
@@ -489,7 +396,7 @@ export function runtimeHasPendingWork(runtime) {
     const state = runtimePendingState(runtime);
     return state.ingress || state.cues || state.replyEscrow
         || state.oobiQueued || state.oobiInFlight || state.multiPending
-        || state.authQueued || state.authInFlight || state.outboxPending
+        || state.authQueued || state.authInFlight
         || state.delegationPending
         || state.queriesPending
         || state.deliveriesPending;
@@ -526,32 +433,35 @@ export function runtimeOobiTerminalState(runtime, url) {
     return { status: "pending", via: "none", record: null };
 }
 /**
- * Return true once one requested OOBI has reached a terminal state and all
- * related runtime work has drained.
+ * 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.
  */
 export function runtimeOobiConverged(runtime, url) {
+    const pending = runtimePendingState(runtime);
     return runtimeOobiTerminalState(runtime, url).status !== "pending"
-        && !runtimeHasPendingWork(runtime);
+        && !pending.ingress && !pending.cues && !pending.replyEscrow
+        && !pending.oobiQueued && !pending.oobiInFlight && !pending.multiPending
+        && !pending.authQueued && !pending.authInFlight && !pending.delegationPending
+        && !pending.queriesPending;
 }
-/**
- * Drive the shared runtime until the caller-provided completion predicate
- * succeeds or the bounded turn budget is exhausted.
- */
-export function* processRuntimeUntil(runtime, done, options = {}) {
-    const maxTurns = options.maxTurns ?? 64;
-    for (let turn = 0; turn < maxTurns; turn++) {
-        if (done()) {
-            return;
-        }
-        yield* processRuntimeTurn(runtime, options);
-        if (done()) {
-            return;
-        }
-        if (!runtimeHasPendingWork(runtime)) {
+/** Run the same component workers as a host until command state completes or its deadline expires. */
+export function* runAgentRuntimeUntil(runtime, done, options) {
+    if (done())
+        return;
+    const { timeoutMs, ...workerOptions } = options;
+    const deadline = Date.now() + timeoutMs;
+    const worker = yield* spawn(() => runAgentRuntime(runtime, workerOptions));
+    try {
+        while (!done()) {
+            if (Date.now() >= deadline)
+                throw new Error(`Runtime did not converge within ${timeoutMs}ms.`);
             yield* runtimeTurn();
         }
     }
-    throw new Error(`Runtime did not converge within ${maxTurns} turns.`);
+    finally {
+        yield* worker.halt();
+    }
 }
 /**
  * Yield cooperatively back to the host scheduler between runtime turns.
@@ -575,12 +485,12 @@ export { runtimeTurn } from "./runtime-turn.js";
  * doers and stays alive until the surrounding Effection scope halts.
  */
 export function* runAgentRuntime(runtime, options = {}) {
-    runtime.querying.configure({ hab: options.hab, sink: options.sink });
-    runtime.mailboxPoller.configure({ hab: options.hab });
+    runtime.querying.configure({ hab: options.hab });
     const tasks = [
         yield* spawn(function* () {
             while (true) {
-                yield* runtime.deliveries.process(runtime);
+                yield* runtime.querying.deliverOnce();
+                yield* runtime.respondant.process();
                 yield* runtimeTurn();
             }
         }),
@@ -588,7 +498,7 @@ export function* runAgentRuntime(runtime, options = {}) {
             yield* runtime.reactor.msgDo();
         }),
         yield* spawn(function* () {
-            yield* cueDo(runtime, { ...options, sink: runtime.querying });
+            yield* cueDo(runtime, options);
         }),
         yield* spawn(function* () {
             yield* runtime.reactor.escrowDo();
@@ -606,29 +516,25 @@ export function* runAgentRuntime(runtime, options = {}) {
                 }),
             ]
             : []),
+        ...(options.pollMailbox ?? true
+            ? [
+                yield* spawn(function* () {
+                    yield* runtime.mailboxPoller.pollDo((batch) => settleMailboxPollBatch(runtime, batch));
+                }),
+            ]
+            : []),
         yield* spawn(function* () {
             while (true) {
-                yield* runtime.poster.processPending(runtime);
-                yield* runtimeTurn();
-            }
-        }),
-        yield* spawn(function* () {
-            yield* runtime.mailboxPoller.pollDo((batch) => settleMailboxPollBatch(runtime, batch));
-        }),
-        yield* spawn(function* () {
-            while (true) {
-                yield* runtime.delegating.processAllOnce(runtime);
+                yield* runtime.delegating.processAllOnce();
                 yield* runtimeTurn();
             }
         }),
         yield* spawn(function* () {
-            yield* runtime.querying.queryDo(runtime);
+            yield* runtime.querying.queryDo();
         }),
     ];
     try {
-        while (true) {
-            yield* runtimeTurn();
-        }
+        return yield* suspend();
     }
     finally {
         for (const task of tasks.reverse()) {