keri-ts 0.11.0 → 2.0.0

package/esm/keri/npm/src/app/{oobiery.js → bootstrap/oobiery.js}

@@ -1,20 +1,53 @@
-import { Ilks, Prefixer, ResourceAdmissionError, SerderKERI } from "cesr-ts";
-import { call, resource } from "effection";
-import { CueDeck } from "../core/cue-admission.js";
-import { Deck, DeckFullError } from "../core/deck.js";
-import { ValidationError } from "../core/errors.js";
-import { OOBI_MAILBOX_TOPIC } from "../core/mailbox-topics.js";
-import { exchange } from "../core/protocol-exchanging.js";
-import { Roles } from "../core/roles.js";
-import { acceptReplyDecision, unverifiedReplyDecision } from "../core/routing.js";
-import { Schemer } from "../core/scheming.js";
-import { abortable } from "./abortable.js";
-import { collectBytes, streamBytes } from "./byte-source.js";
-import { closeResponseBody, fetchResponseHandle } from "./httping.js";
-import { persistResolvedContact } from "./organizing.js";
-import { defaultRuntimeServices, resolveRuntimeServices } from "./runtime-services.js";
-import { runtimeTurn } from "./runtime-turn.js";
+import { Ilks, Prefixer, SerderKERI } from "cesr-ts";
+import { call, resource, scoped } from "effection";
+import { ValidationError } from "../../core/errors.js";
+import { exchange } from "../../core/exchange/protocol-exchanging.js";
+import { OOBI_MAILBOX_TOPIC } from "../../core/mailbox/mailbox-topics.js";
+import { Roles } from "../../core/roles.js";
+import { acceptReplyDecision, unverifiedReplyDecision } from "../../core/routing.js";
+import { Schemer } from "../../core/scheming.js";
+import { persistResolvedContact } from "../identity/organizing.js";
+import { abortable } from "../runtime/abortable.js";
+import { runtimeTurn } from "../runtime/runtime-turn.js";
+import { collectBytes } from "../transport/byte-source.js";
+import { processMessages } from "../transport/message-source.js";
 export const OOBI_REQUEST_ROUTE = "/oobis";
+/**
+ * Return the current terminal state projection for one requested OOBI URL.
+ *
+ * @param db Borrowed OOBI/authentication records; this read starts no workers or I/O.
+ * @param url Exact requested OOBI/well-known URL whose durable state is inspected.
+ * @param kind Actual queued family; ordinary CLI resolution infers it from the URL.
+ * Configuration may put the same well-known URL in introduction and auth queues.
+ * @returns Current durable terminal projection for that family.
+ */
+export function oobiTerminalState(db, url, kind = queueKindFor(url)) {
+    if (kind === "woobi") {
+        if (db.woobi.get(url) || db.mfa.get(url))
+            return { status: "pending", via: "none", record: null };
+        const record = db.rmfa.get(url);
+        if (!record) {
+            return { status: "pending", via: "none", record: null };
+        }
+        return {
+            status: record.state === "resolved" ? "resolved" : "failed",
+            via: "rmfa",
+            record,
+        };
+    }
+    if (db.oobis.get(url) || db.coobi.get(url) || db.moobi.get(url)) {
+        return { status: "pending", via: "none", record: null };
+    }
+    const failed = db.eoobi.get(url);
+    if (failed) {
+        return { status: "failed", via: "eoobi", record: failed };
+    }
+    const resolved = db.roobi.get(url);
+    if (resolved) {
+        return { status: "resolved", via: "roobi", record: resolved };
+    }
+    return { status: "pending", via: "none", record: null };
+}
 /**
  * Durable OOBI processing component for one `Habery`.
  *
@@ -29,46 +62,79 @@ export const OOBI_REQUEST_ROUTE = "/oobis";
  *   leak back to the `AgentRuntime` root
  */
 export class Oobiery {
-    constructor(hby, reactor, options = {}) {
+    /**
+     * Bind byte intake and the actual reply verifier used by OOBI proof persistence.
+     *
+     * @param hby Borrowed local identities and accepted-state stores.
+     * @param protocol Borrowed shared semantic owner; this component owns its fetched byte-input context.
+     * @param rvy Actual shared reply verifier used for OOBI reply proof persistence.
+     * @param http Borrowed HTTP implementation selected by composition.
+     * @param cues Required application result Deck supplied by composition.
+     */
+    constructor(hby, protocol, 
+    /** Borrowed reply verifier; route installation and proof writes share this owner. */
+    rvy, http, cues) {
+        Object.defineProperty(this, "protocol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: protocol
+        });
+        Object.defineProperty(this, "rvy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: rvy
+        });
+        /** Borrowed local identities and durable OOBI job stores. */
         Object.defineProperty(this, "hby", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "reactor", {
+        /** Input-specific KEL policy sharing accepted state and the composed reply verifier. */
+        Object.defineProperty(this, "kvy", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** OOBI completion/query observations consumed by the composed application flow. */
         Object.defineProperty(this, "cues", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "services", {
+        /** Borrowed HTTP client; no network service is discovered through ingress. */
+        Object.defineProperty(this, "http", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** Prevent overlapping passes over this owner's durable job queue. */
         Object.defineProperty(this, "active", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
-        const { cues, services = defaultRuntimeServices } = options;
         this.hby = hby;
-        this.reactor = reactor;
-        this.cues = cues ?? new Deck();
-        // The Reactor owns admission; injected clock/HTTP services borrow its exact ledger.
-        this.services = resolveRuntimeServices({ ...services, resources: reactor.resources });
+        this.kvy = protocol.makeKevery();
+        if (this.kvy.db !== hby.db || this.kvy.rvy !== rvy) {
+            throw new TypeError("Oobiery requires the same accepted-state store and reply verifier");
+        }
+        this.cues = cues;
+        this.http = http;
     }
-    /** Register `/introduce` on the shared reply router. */
-    registerReplyRoutes(router = this.reactor.router) {
+    /**
+     * Register `/introduce` on the shared reply router.
+     *
+     * @param router Shared reply router on which /introduce is registered.
+     */
+    registerReplyRoutes(router = this.rvy.rtr) {
         router.addRoute("/introduce", this);
     }
     /**
@@ -79,33 +145,23 @@ export class Oobiery {
      * - unlike the older bootstrap runtime, there is no root in-memory OOBI deck
      */
     resolve(url, alias) {
-        this.cues.checkSpace();
         const meta = parseOobiUrl(url, alias);
         const kind = queueKindFor(url), record = this.queuedRecord(meta);
         const cues = [{ kin: "oobiQueued", url, alias: meta.alias }];
-        const batch = this.cues instanceof CueDeck ? this.cues.prepare(cues) : undefined;
-        try {
-            this.pinQueueStore(kind, url, record);
-            if (batch)
-                batch.publish();
-            else
-                this.cues.extend(cues);
-        }
-        finally {
-            batch?.release();
-        }
+        this.pinQueueStore(kind, url, record);
+        this.cues.extend(cues);
     }
     /**
      * Process one queued durable OOBI record, if any.
      *
      * Behavior:
-     * - reads the next queued `oobis.` / `woobi.` record
+     * - reads the next queued `oobis.` record or resumes a surviving `coobi.` row
      * - fetches it under Effection cancellation control
-     * - routes any returned KERI bytes through `Reactor`
+     * - parses fetched KERI bytes through this owner's Kevery and shared semantic handlers
      * - transitions the durable record into `eoobi.` or `roobi.`
      */
     *processOnce() {
-        if (this.active || this.cues.length === this.cues.capacity)
+        if (this.active)
             return;
         const item = this.nextQueued();
         if (item) {
@@ -116,15 +172,7 @@ export class Oobiery {
         const multi = this.nextReadyMoobi();
         if (multi) {
             const [url, record] = multi;
-            try {
-                this.completeMultiOobi(url, record);
-            }
-            catch (error) {
-                if (!(error instanceof DeckFullError || (error instanceof ResourceAdmissionError && error.reason === "busy"))) {
-                    throw error;
-                }
-                // The parent keeps its durable moobi owner until a later turn can admit its result.
-            }
+            this.completeMultiOobi(url, record);
         }
     }
     /** Hold job ownership before work so cancellation joins every response/parser owner before retry. */
@@ -132,7 +180,7 @@ export class Oobiery {
         // deno-lint-ignore no-this-alias -- The callback borrows this OOBI worker's durable queue.
         const self = this;
         return call(function* () {
-            const admitted = yield* resource(function* (provide) {
+            const started = yield* resource(function* (provide) {
                 if (self.active) {
                     yield* provide(false);
                     return;
@@ -145,20 +193,10 @@ export class Oobiery {
                     self.active = false;
                 }
             });
-            if (!admitted)
+            if (!started)
                 return;
-            try {
-                // Each finite child joins its body, fetch and parser before releasing the earlier job owner.
-                yield* call(() => self.processJob(kind, url, record));
-            }
-            catch (error) {
-                if (!(error instanceof DeckFullError || (error instanceof ResourceAdmissionError && error.reason === "busy"))) {
-                    throw error;
-                }
-                // Temporary cue/resource saturation leaves durable work for the existing worker's later turn.
-                self.hby.db.coobi.rem(url);
-                self.pinQueueStore(kind, url, record);
-            }
+            // Each finite child joins its body, fetch and parser before the earlier job owner ends.
+            yield* call(() => self.processJob(kind, url, record));
         });
     }
     /**
@@ -173,27 +211,24 @@ export class Oobiery {
             yield* runtimeTurn();
         }
     }
-    /** Return the next queued durable OOBI record, if any. */
+    /** Select queued work, including a surviving in-flight row whose former process is gone. */
     nextQueued() {
-        for (const [keys, record] of this.hby.db.oobis.getTopItemIter()) {
-            const url = keys[0];
-            if (!url) {
-                continue;
+        for (const store of [this.hby.db.oobis, this.hby.db.coobi]) {
+            for (const [keys, record] of store.getTopItemIter()) {
+                const url = keys[0];
+                if (url)
+                    return ["oobis", url, record];
             }
-            return ["oobis", url, record];
         }
         return null;
     }
-    /** Return one multi-OOBI parent whose child URLs have all settled. */
+    /** Select a parent only after its current child attempts, including authentication, settle. */
     nextReadyMoobi() {
         for (const [keys, record] of this.hby.db.moobi.getTopItemIter()) {
             const url = keys[0];
-            if (!url) {
+            if (!url)
                 continue;
-            }
-            const urls = record.urls ?? [];
-            if (urls.length === 0
-                || urls.every((childUrl) => !!this.hby.db.roobi.get(childUrl) || !!this.hby.db.eoobi.get(childUrl))) {
+            if ((record.urls ?? []).every(child => oobiTerminalState(this.hby.db, child).status !== "pending")) {
                 return [url, record];
             }
         }
@@ -207,22 +242,13 @@ export class Oobiery {
      * - `coobi.` while a fetched response is being processed
      * - `eoobi.` on HTTP failure
      * - `roobi.` after parser/routing success
+     *
+     * @param kind Durable OOBI queue family identifying the job path.
+     * @param url Exact OOBI URL used as the durable job key.
+     * @param record Pending durable job; retained through failure and joined cleanup.
      */
     *processJob(kind, url, record) {
-        const services = this.services;
-        yield* resource(function* (provide) {
-            // A finite minimum charge bounds pending GET handles; Reactor owns the one active body stream slot.
-            const admission = services.resources.reserve({ bytes: 1024 ** 2 });
-            if (admission.kind === "refuse") {
-                throw new ResourceAdmissionError("OOBI response admission refused", admission.reason);
-            }
-            try {
-                yield* provide();
-            }
-            finally {
-                admission.reservation.release();
-            }
-        });
+        const http = this.http;
         const meta = {
             ...parseOobiUrl(url, record.oobialias ?? undefined),
             ...record,
@@ -238,57 +264,52 @@ export class Oobiery {
             oobialias: meta.alias ?? meta.oobialias ?? null,
             said: meta.said ?? null,
         };
-        // Stage attempt metadata only; the original queue row stays owned until result admission.
-        const response = yield* fetchOobiResponse(url, services);
+        // A new or resumed attempt supersedes old terminal facts, but keeps its
+        // queued row until intake succeeds. Cancellation can therefore retry it.
+        this.hby.db.env.transactionSync(() => {
+            this.pinQueueStore(kind, url, queuedRecord);
+            this.hby.db.eoobi.rem(url);
+            this.hby.db.roobi.rem(url);
+        });
+        const consume = this.processResponse.bind(this);
         try {
-            yield* this.processResponse(kind, url, queuedRecord, meta, response);
+            const refused = yield* scoped(function* () {
+                const response = yield* http.open(url);
+                if (!response.ok)
+                    return response.status;
+                yield* consume(kind, url, queuedRecord, meta, response);
+                return null;
+            });
+            if (refused === null)
+                this.remQueueStore(kind, url);
+            else {
+                // The response has closed before its terminal HTTP outcome is persisted.
+                const result = { ...queuedRecord, date: new Date().toISOString(), state: `http-${refused}` };
+                this.remQueueStore(kind, url);
+                this.hby.db.eoobi.pin(url, result);
+                this.cues.push({ kin: "oobiFailed", url, reason: `HTTP ${refused}` });
+            }
         }
         finally {
             this.hby.db.coobi.rem(url);
         }
     }
-    /** Consume one owned response; queued ownership ends only after a terminal result is persisted. */
+    /**
+     * Consume one owned response; queued ownership ends only after a terminal result is persisted.
+     *
+     * @param kind Durable OOBI queue family identifying the job path.
+     * @param url Exact OOBI URL used as the durable job key.
+     * @param queuedRecord Original durable job metadata retained until terminal publication.
+     * @param meta Parsed OOBI URL metadata selecting the response interpretation.
+     * @param response Borrowed scoped HTTP response; complete processing precedes terminal state.
+     */
     *processResponse(kind, url, queuedRecord, meta, response) {
-        const services = this.services;
-        if (!response.ok) {
-            yield* closeResponseBody(response);
-            this.cues.checkSpace();
-            const result = { ...queuedRecord, date: new Date().toISOString(), state: `http-${response.status}` };
-            const cues = [{ kin: "oobiFailed", url, reason: `HTTP ${response.status}` }];
-            const batch = this.cues instanceof CueDeck ? this.cues.prepare(cues) : undefined;
-            try {
-                this.remQueueStore(kind, url);
-                this.hby.db.eoobi.pin(url, result);
-                if (batch)
-                    batch.publish();
-                else
-                    this.cues.extend(cues);
-            }
-            finally {
-                batch?.release();
-            }
-            return;
-        }
         const type = mediaType(response.headers.get("content-type") ?? "");
         if (isCesrMediaType(type) || !type.includes("json")) {
             // Keep durable retry ownership throughout partial acceptance and joined cancellation.
             yield* this.resolveCesrOobiResponse(kind, url, queuedRecord, meta, response);
-            this.remQueueStore(kind, url);
             return;
         }
-        yield* resource(function* (provide) {
-            // Finite JSON/schema collection and decoding remain bounded document work, not a replay collector.
-            const admission = services.resources.reserve({ bytes: 8 * 8 * 1024 ** 2 });
-            if (admission.kind === "refuse") {
-                throw new ResourceAdmissionError("OOBI document admission refused", admission.reason);
-            }
-            try {
-                yield* provide();
-            }
-            finally {
-                admission.reservation.release();
-            }
-        });
         const bytes = yield* readResponseBytes(response);
         this.hby.db.coobi.pin(url, {
             ...queuedRecord,
@@ -297,28 +318,31 @@ export class Oobiery {
         });
         if (type === "application/schema+json") {
             if (this.processSchemaOobiResponse(url, queuedRecord, bytes)) {
-                this.remQueueStore(kind, url);
                 return;
             }
             this.failFetchedOobi(url, queuedRecord, "invalid-schema-oobi");
-            this.remQueueStore(kind, url);
             return;
         }
         if (type.includes("json")) {
             if (this.processSchemaOobiResponse(url, queuedRecord, bytes)) {
-                this.remQueueStore(kind, url);
                 return;
             }
             if (this.processJsonOobiResponse(url, queuedRecord, bytes)) {
-                this.remQueueStore(kind, url);
                 return;
             }
             this.failFetchedOobi(url, queuedRecord, "invalid-json-oobi");
-            this.remQueueStore(kind, url);
             return;
         }
     }
-    /** Mark an OOBI resolved only after its complete CESR response has been dispatched. */
+    /**
+     * Mark an OOBI resolved only after its complete CESR response has been dispatched.
+     *
+     * @param kind Durable OOBI queue family identifying the job path.
+     * @param url Exact OOBI URL used as the durable job key.
+     * @param queuedRecord Original durable job metadata retained until terminal publication.
+     * @param meta Parsed OOBI URL metadata selecting the response interpretation.
+     * @param response Borrowed scoped HTTP response; complete processing precedes terminal state.
+     */
     *resolveCesrOobiResponse(kind, url, queuedRecord, meta, response) {
         const cue = {
             kin: "oobiResolved",
@@ -327,34 +351,13 @@ export class Oobiery {
             role: meta.role ?? undefined,
             eid: meta.eid ?? undefined,
         };
-        const batch = yield* this.holdResolvedOobi(cue);
         this.pinQueueStore(kind, url, queuedRecord);
         this.hby.db.coobi.pin(url, { ...queuedRecord, state: "streaming" });
-        yield* this.reactor.process((signal) => streamBytes(response.body, { signal }));
-        if (!batch)
-            this.cues.checkSpace(); // Preserve the ordinary Deck's existing post-intake guard.
+        yield* processMessages((signal) => response.body(signal), this.protocol, this.kvy);
         this.hby.db.coobi.rem(url);
         this.hby.db.roobi.pin(url, { ...queuedRecord, date: new Date().toISOString(), state: "resolved" });
         persistResolvedContact(this.hby, meta.cid, { alias: queuedRecord.oobialias, oobi: url });
-        if (batch)
-            batch.publish();
-        else
-            this.cues.push(cue);
-    }
-    /** Keep prospective CESR result credit until all later body/parser owners join cleanup. */
-    *holdResolvedOobi(cue) {
-        const deck = this.cues;
-        if (!(deck instanceof CueDeck))
-            return undefined;
-        return yield* resource(function* (provide) {
-            const batch = deck.prepare([cue]);
-            try {
-                yield* provide(batch);
-            }
-            finally {
-                batch.release();
-            }
-        });
+        this.cues.push(cue);
     }
     /** Handle schema data-OOBIs before generic JSON reply handling. */
     processSchemaOobiResponse(url, record, bytes) {
@@ -371,22 +374,12 @@ export class Oobiery {
         if (schemer.said !== record.said) {
             return false;
         }
-        this.cues.checkSpace();
         const result = { ...record, date: new Date().toISOString(), state: "resolved" };
         const cues = [{ kin: "oobiResolved", url }];
-        const batch = this.cues instanceof CueDeck ? this.cues.prepare(cues) : undefined;
-        try {
-            this.hby.db.schema.pin(schemer.said, schemer);
-            this.hby.db.coobi.rem(url);
-            this.hby.db.roobi.pin(url, result);
-            if (batch)
-                batch.publish();
-            else
-                this.cues.extend(cues);
-        }
-        finally {
-            batch?.release();
-        }
+        this.hby.db.schema.pin(schemer.said, schemer);
+        this.hby.db.coobi.rem(url);
+        this.hby.db.roobi.pin(url, result);
+        this.cues.extend(cues);
         return true;
     }
     /** Handle JSON OOBI responses that carry reply bodies instead of CESR streams. */
@@ -421,7 +414,6 @@ export class Oobiery {
             this.failFetchedOobi(url, record, "invalid-multi-oobi");
             return;
         }
-        this.cues.checkSpace(urls.length);
         // Normalize every child before the first queue write; malformed later URLs cannot leave partial fanout.
         const children = urls.map((childUrl) => {
             const meta = parseOobiUrl(childUrl, record.oobialias ?? undefined);
@@ -429,28 +421,18 @@ export class Oobiery {
         });
         const cues = children.map(({ url, meta }) => ({ kin: "oobiQueued", url, alias: meta.alias }));
         const parent = { ...record, cid, date: new Date().toISOString(), state: "pending-multi-oobi", urls };
-        const batch = this.cues instanceof CueDeck ? this.cues.prepare(cues) : undefined;
-        try {
-            for (const child of children)
-                this.pinQueueStore(child.kind, child.url, child.record);
-            this.hby.db.coobi.rem(url);
-            this.hby.db.moobi.pin(url, parent);
-            if (batch)
-                batch.publish();
-            else
-                this.cues.extend(cues);
-        }
-        finally {
-            batch?.release();
-        }
+        for (const child of children)
+            this.pinQueueStore(child.kind, child.url, child.record);
+        this.hby.db.coobi.rem(url);
+        this.hby.db.moobi.pin(url, parent);
+        this.cues.extend(cues);
     }
     /** Finalize one parent multi-OOBI after its child URLs all reach terminal state. */
     completeMultiOobi(url, record) {
-        this.cues.checkSpace();
         const urls = record.urls ?? [];
         const date = new Date().toISOString();
         const failed = urls.length === 0
-            || urls.some((childUrl) => !!this.hby.db.eoobi.get(childUrl));
+            || urls.some(childUrl => oobiTerminalState(this.hby.db, childUrl).status === "failed");
         const state = failed ? (urls.length === 0 ? "invalid-multi-oobi" : "child-failed") : "resolved";
         const result = { ...record, date, state };
         const cues = failed
@@ -466,41 +448,22 @@ export class Oobiery {
                     role: record.role ?? undefined,
                     eid: record.eid ?? undefined,
                 }];
-        const batch = this.cues instanceof CueDeck ? this.cues.prepare(cues) : undefined;
-        try {
-            this.hby.db.moobi.rem(url);
-            if (failed)
-                this.hby.db.eoobi.pin(url, result);
-            else {
-                this.hby.db.roobi.pin(url, result);
-                persistResolvedContact(this.hby, record.cid ?? null, { alias: record.oobialias, oobi: url });
-            }
-            if (batch)
-                batch.publish();
-            else
-                this.cues.extend(cues);
-        }
-        finally {
-            batch?.release();
+        this.hby.db.moobi.rem(url);
+        if (failed)
+            this.hby.db.eoobi.pin(url, result);
+        else {
+            this.hby.db.roobi.pin(url, result);
+            persistResolvedContact(this.hby, record.cid ?? null, { alias: record.oobialias, oobi: url });
         }
+        this.cues.extend(cues);
     }
     /** Mark one fetched OOBI as terminal failure and clear its in-flight state. */
     failFetchedOobi(url, record, state) {
-        this.cues.checkSpace();
         const result = { ...record, date: new Date().toISOString(), state };
         const cues = [{ kin: "oobiFailed", url, reason: state }];
-        const batch = this.cues instanceof CueDeck ? this.cues.prepare(cues) : undefined;
-        try {
-            this.hby.db.coobi.rem(url);
-            this.hby.db.eoobi.pin(url, result);
-            if (batch)
-                batch.publish();
-            else
-                this.cues.extend(cues);
-        }
-        finally {
-            batch?.release();
-        }
+        this.hby.db.coobi.rem(url);
+        this.hby.db.eoobi.pin(url, result);
+        this.cues.extend(cues);
     }
     /** Persist one queued record into the selected durable queue. */
     pinQueueStore(kind, url, record) {
@@ -527,6 +490,8 @@ export class Oobiery {
     /**
      * Process one `/introduce` reply and enqueue the introduced OOBI into the
      * ordinary durable resolver path.
+     *
+     * @param args Verified reply route input and signature evidence used to persist introduction results.
      */
     processReply(args) {
         if (args.route !== "/introduce") {
@@ -543,9 +508,7 @@ export class Oobiery {
         if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
             throw new ValidationError(`Invalid introduced OOBI scheme ${parsed.protocol}.`);
         }
-        if (!(this.cues instanceof CueDeck))
-            this.cues.checkSpace((args.tsgs?.length ?? 0) + 1);
-        const proof = this.reactor.revery.prepareReply({
+        const proof = this.rvy.decideReply({
             serder: args.serder,
             saider: args.diger,
             route: args.route,
@@ -554,42 +517,30 @@ export class Oobiery {
             cigars: args.cigars,
             tsgs: args.tsgs,
         });
-        try {
-            if (proof.decision.kind === "unverified") {
-                proof.applyProofs();
-                proof.publishQueries();
-                return unverifiedReplyDecision(`Unverified introduction reply ${args.serder.said ?? "<unknown>"}.`);
-            }
-            const meta = parseOobiUrl(oobi), kind = queueKindFor(oobi);
-            const record = {
-                date: dt,
-                state: "queued",
-                cid: cid ?? meta.cid ?? null,
-                eid: meta.eid ?? null,
-                role: meta.role ?? null,
-                oobialias: meta.alias ?? null,
-                said: meta.said ?? null,
-            };
-            const cues = [{ kin: "oobiQueued", url: oobi }];
-            this.cues.checkSpace(cues.length);
-            const batch = this.cues instanceof CueDeck ? this.cues.prepare(cues) : undefined;
-            try {
-                proof.applyProofs();
-                this.pinQueueStore(kind, oobi, record);
-                proof.publishQueries();
-                if (batch)
-                    batch.publish();
-                else
-                    this.cues.extend(cues);
-                return acceptReplyDecision();
-            }
-            finally {
-                batch?.release();
-            }
-        }
-        finally {
-            proof.release();
-        }
+        const queryCues = this.rvy.cues;
+        if (proof.kind === "unverified") {
+            this.rvy.writeReply(proof);
+            if (proof.cues.length)
+                queryCues.extend(proof.cues);
+            return unverifiedReplyDecision(`Unverified introduction reply ${args.serder.said ?? "<unknown>"}.`);
+        }
+        const meta = parseOobiUrl(oobi), kind = queueKindFor(oobi);
+        const record = {
+            date: dt,
+            state: "queued",
+            cid: cid ?? meta.cid ?? null,
+            eid: meta.eid ?? null,
+            role: meta.role ?? null,
+            oobialias: meta.alias ?? null,
+            said: meta.said ?? null,
+        };
+        const cues = [{ kin: "oobiQueued", url: oobi }];
+        this.rvy.writeReply(proof);
+        this.pinQueueStore(kind, oobi, record);
+        if (proof.cues.length)
+            queryCues.extend(proof.cues);
+        this.cues.extend(cues);
+        return acceptReplyDecision();
     }
 }
 export function loadOobiHandlers(hby, exchanger, notifier = null) {
@@ -760,18 +711,11 @@ function isCesrMediaType(type) {
 }
 export { OOBI_MAILBOX_TOPIC };
 /**
- * Fetch one OOBI URL under Effection cancellation control.
+ * Collect one finite OOBI document and join its reader on cancellation.
  *
- * This is the real promise-adaptation boundary for remote OOBI retrieval. The
- * surrounding runtime stays operation-native.
+ * @param response Borrowed finite OOBI document response.
+ * @returns Collected bytes after reader cleanup joins.
  */
-function* fetchOobiResponse(url, services = defaultRuntimeServices) {
-    const { response } = yield* fetchResponseHandle(url, {}, {
-        services,
-    });
-    return response;
-}
-/** Admit at most 8 MiB for the existing finite OOBI/document consumer and join its reader on cancellation. */
 function* readResponseBytes(response) {
-    return yield* abortable((signal) => collectBytes(streamBytes(response.body, { signal }), 8 * 1024 * 1024));
+    return yield* abortable((signal) => collectBytes(response.body(signal)));
 }