keri-ts 1.0.0 → 2.0.0

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

@@ -1,9 +1,21 @@
-import { call } from "effection";
-import { closeResponseBody, fetchResponseHandle } from "./httping.js";
+import { call, scoped } from "effection";
+import { persistResolvedContact } from "../identity/organizing.js";
+import { runtimeTurn } from "../runtime/runtime-turn.js";
 import { isWellKnownOobiUrl, parseOobiUrl } from "./oobiery.js";
-import { persistResolvedContact } from "./organizing.js";
-import { defaultRuntimeServices } from "./runtime-services.js";
-import { runtimeTurn } from "./runtime-turn.js";
+/**
+ * Return true when a well-known URL has been authorized into `wkas.`.
+ *
+ * @param db Borrowed authentication records; this read acquires no runtime or I/O lifetime.
+ * @param url Exact requested OOBI/well-known URL whose durable state is inspected.
+ * @returns Whether the documented authentication/convergence predicate currently holds.
+ */
+export function hasWellKnownAuth(db, url) {
+    const cid = parseOobiUrl(url).cid;
+    if (!cid) {
+        return false;
+    }
+    return db.wkas.get(cid).some((record) => record.url === url);
+}
 /**
  * Well-known OOBI authenticator for one `Habery`.
  *
@@ -18,22 +30,29 @@ import { runtimeTurn } from "./runtime-turn.js";
  * - `wkas.` records successful `(cid, url)` authorizations
  */
 export class Authenticator {
-    constructor(hby, options = {}) {
+    /**
+     * Bind the local authentication store and its configured HTTP dependency.
+     *
+     * @param hby Borrowed local identities and accepted-state stores.
+     * @param http Borrowed HTTP implementation selected by composition.
+     */
+    constructor(hby, http) {
+        /** Borrowed local identities and durable well-known authentication records. */
         Object.defineProperty(this, "hby", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "services", {
+        /** HTTP implementation selected when this authenticator is composed. */
+        Object.defineProperty(this, "http", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        const services = options.services ?? defaultRuntimeServices;
         this.hby = hby;
-        this.services = services;
+        this.http = http;
     }
     /** Process one bounded auth step if queued well-known work exists. */
     *processOnce() {
@@ -100,16 +119,24 @@ export class Authenticator {
         }
         return null;
     }
-    /** Fetch one `mfa.` record and persist the terminal auth result. */
+    /**
+     * Fetch one `mfa.` record and persist the terminal auth result.
+     *
+     * @param url Exact pending well-known authentication URL.
+     * @param record Durable mfa record retained until response handling and cleanup establish terminal state.
+     */
     *processPendingAuth(url, record) {
         // Only HTTP status is needed; the response owner still joins body cleanup.
         const cid = record.cid
             ?? parseOobiUrl(url, record.oobialias ?? undefined).cid
             ?? null;
-        const response = yield* fetchAuthResponse(url, this.services);
+        const http = this.http;
+        const response = yield* scoped(function* () {
+            const response = yield* http.open(url);
+            return { ok: response.ok, status: response.status };
+        });
         const date = new Date().toISOString();
         const state = response.ok ? "resolved" : `http-${response.status}`;
-        yield* closeResponseBody(response);
         this.hby.db.mfa.rem(url);
         this.hby.db.rmfa.pin(url, {
             ...record,
@@ -126,9 +153,3 @@ export class Authenticator {
         }
     }
 }
-function* fetchAuthResponse(url, services) {
-    const { response } = yield* fetchResponseHandle(url, {}, {
-        services,
-    });
-    return response;
-}

package/esm/keri/npm/src/app/bootstrap/bootstrapping.js

@@ -0,0 +1,109 @@
+/** Finite introduction/authentication composition shared by environment creation and inception. */
+import { scoped, spawn } from "effection";
+import { createProtocolProcessor } from "../protocol/protocol-processing.js";
+import { runtimeTurn } from "../runtime/runtime-turn.js";
+import { Authenticator, hasWellKnownAuth } from "./authenticating.js";
+import { Oobiery, oobiTerminalState } from "./oobiery.js";
+/**
+ * Resolve this command's pending introductions and well-known authentication.
+ *
+ * The command is the sole OOBI/authentication worker owner for its borrowed Habery.
+ * Select existing oobis/coobi/moobi and woobi/mfa rows, then include children and
+ * introductions queued by processing them. Old terminal rows alone select no work.
+ * Surviving coobi/mfa/moobi rows resume through their ordinary component owners.
+ * A queued attempt takes precedence over any older terminal/authorization row.
+ * The actual table family selects its terminal evidence: a well-known URL may
+ * be an ordinary introduction, a separate authentication, or both.
+ *
+ * Like KERIpy init, compose Oobiery and Authenticator directly. Resolution means
+ * that Oobiery processed the response, not that all its protocol evidence was
+ * accepted. KEL/reply escrow processing lets evidence arriving in separate
+ * responses unlock introductions and authentication's required controller state.
+ * Escrow contents never determine bootstrap completion. Later operations must
+ * check the accepted evidence they actually require.
+ *
+ * @param hby Borrowed identities/configuration/Baser; kept open through cleanup.
+ * @param http Borrowed request implementation used by OOBIs and authentication.
+ * @param options Finite positive elapsed deadline, default 30 seconds.
+ * @returns Selected terminal success, refusal or deadline after all children/I/O join.
+ * @throws Invariant, parser, storage, transport and cleanup failures propagate unchanged.
+ */
+export function resolveBootstrap(hby, http, { timeoutMs = 30_000 } = {}) {
+    return scoped(function* bootstrapScope() {
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            throw new RangeError("Bootstrap timeout must be finite and positive");
+        }
+        const selected = { oobis: new Set(), woobi: new Set() };
+        collectPendingUrls(hby.db, selected);
+        if (selected.oobis.size === 0 && selected.woobi.size === 0)
+            return { kind: "complete" };
+        const protocol = createProtocolProcessor(hby);
+        const oobiery = new Oobiery(hby, protocol, protocol.rvy, http, protocol.cues);
+        oobiery.registerReplyRoutes();
+        const authenticator = new Authenticator(hby, http);
+        yield* spawn(() => oobiery.oobiDo());
+        yield* spawn(() => authenticator.authDo());
+        yield* spawn(function* () {
+            while (true) {
+                protocol.processKelReplyEscrowsOnce();
+                yield* runtimeTurn();
+            }
+        });
+        const deadline = performance.now() + timeoutMs;
+        while (true) {
+            collectPendingUrls(hby.db, selected);
+            const result = inspectBootstrap(hby.db, selected);
+            if (result)
+                return result;
+            if (performance.now() >= deadline) {
+                const pending = [];
+                for (const kind of ["oobis", "woobi"]) {
+                    for (const url of selected[kind])
+                        if (!bootstrapUrlComplete(hby.db, url, kind))
+                            pending.push(url);
+                }
+                return {
+                    kind: "timeout",
+                    pending: [...new Set(pending)],
+                };
+            }
+            yield* runtimeTurn();
+        }
+    });
+}
+/** Select actual queued/in-flight records; Oobiery owns multi-OOBI child completion. */
+function collectPendingUrls(db, selected) {
+    for (const store of [db.oobis, db.coobi, db.moobi]) {
+        for (const [keys] of store.getTopItemIter())
+            if (keys[0])
+                selected.oobis.add(keys[0]);
+    }
+    for (const store of [db.woobi, db.mfa]) {
+        for (const [keys] of store.getTopItemIter())
+            if (keys[0])
+                selected.woobi.add(keys[0]);
+    }
+}
+/** Require current terminal evidence; a saved authorization cannot mask a queued retry. */
+function bootstrapUrlComplete(db, url, kind) {
+    if (oobiTerminalState(db, url, kind).status !== "resolved")
+        return false;
+    return kind === "oobis" || hasWellKnownAuth(db, url);
+}
+/** Decide only from selected URLs; absence of queue rows alone never establishes success. */
+function inspectBootstrap(db, selected) {
+    const failures = [];
+    let pending = false;
+    for (const kind of ["oobis", "woobi"]) {
+        for (const url of selected[kind]) {
+            const terminal = oobiTerminalState(db, url, kind);
+            if (terminal.status === "failed")
+                failures.push({ url, state: terminal.record?.state ?? "failed" });
+            else if (!bootstrapUrlComplete(db, url, kind))
+                pending = true;
+        }
+    }
+    if (failures.length)
+        return { kind: "failed", failures };
+    return pending ? null : { kind: "complete" };
+}

package/esm/keri/npm/src/app/{oobi-replies.js → bootstrap/oobi-replies.js}

@@ -1,8 +1,9 @@
 /** Lazy OOBI output borrows its Hab/keeper/database; metadata capture begins only on iterator acquisition. */
-import { DatabaseOperationError } from "../core/errors.js";
-import { Roles } from "../core/roles.js";
-import { dgKey } from "../db/core/keys.js";
-import { loadStoredReply } from "./stored-replies.js";
+import { DatabaseOperationError } from "../../core/errors.js";
+import { genusFramed } from "../../core/genus-framing.js";
+import { Roles } from "../../core/roles.js";
+import { dgKey } from "../../db/core/keys.js";
+import { loadStoredReply } from "../delivery/stored-replies.js";
 /**
  * Capture primitive descriptors, then emit finite messages in the established OOBI order.
  * Selector inputs are borrowed and must stay immutable until acquisition under the caller's owner.
@@ -15,7 +16,8 @@ export function oobiReplyMessages(hab, cid, role, eids, scheme, requireReady) {
             const selected = [];
             for (let index = 0; index < count; index++)
                 selected.push(eids[index]);
-            return (function* () {
+            // KELs, other parties' stored replies and fresh replies may legitimately differ in genus.
+            return genusFramed((function* () {
                 const parts = [], cloned = new Set();
                 const clone = (pre) => {
                     if (!pre || cloned.has(pre))
@@ -105,7 +107,7 @@ export function oobiReplyMessages(hab, cid, role, eids, scheme, requireReady) {
                             : hab.makeEndRole(part.eid, part.role, true);
                     }
                 }
-            })();
+            })());
         },
     };
 }

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

@@ -1,19 +1,53 @@
 import { Ilks, Prefixer, SerderKERI } from "cesr-ts";
-import { call, resource } from "effection";
-import { Deck } 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 } from "./runtime-services.js";
-import { runtimeTurn } from "./runtime-turn.js";
+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`.
  *
@@ -28,45 +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();
-        this.services = services;
+        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);
     }
     /**
@@ -87,9 +155,9 @@ export class Oobiery {
      * 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() {
@@ -143,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];
             }
         }
@@ -177,9 +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;
+        const http = this.http;
         const meta = {
             ...parseOobiUrl(url, record.oobialias ?? undefined),
             ...record,
@@ -195,31 +264,50 @@ 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 publication.
-        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) {
-        if (!response.ok) {
-            yield* closeResponseBody(response);
-            const result = { ...queuedRecord, date: new Date().toISOString(), state: `http-${response.status}` };
-            const cues = [{ kin: "oobiFailed", url, reason: `HTTP ${response.status}` }];
-            this.remQueueStore(kind, url);
-            this.hby.db.eoobi.pin(url, result);
-            this.cues.extend(cues);
-            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;
         }
         const bytes = yield* readResponseBytes(response);
@@ -230,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",
@@ -262,7 +353,7 @@ export class Oobiery {
         };
         this.pinQueueStore(kind, url, queuedRecord);
         this.hby.db.coobi.pin(url, { ...queuedRecord, state: "streaming" });
-        yield* this.reactor.process((signal) => streamBytes(response.body, { signal }));
+        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 });
@@ -341,7 +432,7 @@ export class Oobiery {
         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
@@ -399,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") {
@@ -415,7 +508,7 @@ export class Oobiery {
         if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
             throw new ValidationError(`Invalid introduced OOBI scheme ${parsed.protocol}.`);
         }
-        const proof = this.reactor.revery.decideReply({
+        const proof = this.rvy.decideReply({
             serder: args.serder,
             saider: args.diger,
             route: args.route,
@@ -424,9 +517,9 @@ export class Oobiery {
             cigars: args.cigars,
             tsgs: args.tsgs,
         });
-        const queryCues = this.reactor.revery.cues;
+        const queryCues = this.rvy.cues;
         if (proof.kind === "unverified") {
-            this.reactor.revery.writeReply(proof);
+            this.rvy.writeReply(proof);
             if (proof.cues.length)
                 queryCues.extend(proof.cues);
             return unverifiedReplyDecision(`Unverified introduction reply ${args.serder.said ?? "<unknown>"}.`);
@@ -442,7 +535,7 @@ export class Oobiery {
             said: meta.said ?? null,
         };
         const cues = [{ kin: "oobiQueued", url: oobi }];
-        this.reactor.revery.writeReply(proof);
+        this.rvy.writeReply(proof);
         this.pinQueueStore(kind, oobi, record);
         if (proof.cues.length)
             queryCues.extend(proof.cues);
@@ -618,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;
-}
-/** Collect one finite OOBI document and join its reader on cancellation. */
 function* readResponseBytes(response) {
-    return yield* abortable((signal) => collectBytes(streamBytes(response.body, { signal })));
+    return yield* abortable((signal) => collectBytes(response.body(signal)));
 }