keri-ts 0.11.0 → 2.0.0

package/esm/keri/npm/src/db/subing.js

@@ -1,4 +1,4 @@
-import { b, Cipher, Matter, parseSerder, SerderKERI, Signer, smell, t, Verfer, } from "cesr-ts";
+import { b, Cipher, Matter, parseSerder, reapSerder, SerderKERI, Signer, smell, t, Verfer, } from "cesr-ts";
 import { Schemer } from "../core/scheming.js";
 function isKeysIterable(value) {
     return typeof value !== "string" && !(value instanceof Uint8Array);
@@ -185,10 +185,6 @@ export class Suber extends SuberBase {
     get(keys) {
         return this._des(this.db.getVal(this.sdb, this._tokey(keys)));
     }
-    /** Admit native row bytes before copying and decoding; caller owns copy/decoded credit. */
-    getBounded(keys, maxBytes, beforeCopy) {
-        return this._des(this.db.getValBounded(this.sdb, this._tokey(keys), maxBytes, beforeCopy));
-    }
     /** Remove one single-value record by its effective key. */
     rem(keys) {
         return this.db.delVal(this.sdb, this._tokey(keys));
@@ -324,10 +320,6 @@ export class OnSuber extends OnSuberBase {
  * bytes, so raw message bodies must use this adapter instead.
  */
 export class BytesSuber extends Suber {
-    /** Read bounded raw bytes with this table's key encoding and optional pre-copy admission. */
-    getBounded(keys, maxBytes, beforeCopy) {
-        return this._des(this.db.getValBounded(this.sdb, this._tokey(keys), maxBytes, beforeCopy));
-    }
     _ser(val) {
         return asUint8Array(val);
     }
@@ -907,8 +899,7 @@ export class SerderSuberBase extends Suber {
         if (val === null) {
             return null;
         }
-        const { smellage } = smell(val);
-        const serder = parseSerder(val, smellage);
+        const { serder } = reapSerder(val);
         if (!(serder instanceof this.ctor)) {
             throw new TypeError(`Expected ${this.ctor.name}, got ${serder.constructor.name}.`);
         }

package/esm/keri/npm/src/did/keri/resolving.js

@@ -1,23 +1,9 @@
-import { processRuntimeTurn } from "../../app/agent-runtime.js";
-import { ValidationError } from "../../core/errors.js";
 import { parseDidKeriIdentifier } from "../webs/dids.js";
 import { didResolutionResult, generateBareDidDocument, } from "../webs/documenting.js";
-/** Resolve one `did:keri` from current runtime state, resolving OOBIs first when supplied. */
-export function* resolveDidKeri(runtime, options) {
-    const parsed = parseDidKeriIdentifier(options.did);
-    for (const oobi of options.oobis ?? []) {
-        runtime.oobiery.resolve(oobi);
-    }
-    for (let i = 0; i < 5; i += 1) {
-        yield* processRuntimeTurn(runtime, { pollMailbox: false });
-        if (runtime.hby.db.getKever(parsed.aid, { refresh: true })) {
-            break;
-        }
-    }
-    if (!runtime.hby.db.getKever(parsed.aid, { refresh: true })) {
-        throw new ValidationError(`No accepted key state for ${parsed.aid}.`);
-    }
-    const document = generateBareDidDocument(runtime, parsed.canonical);
+/** Project one accepted `did:keri`; callers own introductions and worker lifetimes. */
+export function resolveDidKeri(hby, regery, did) {
+    const parsed = parseDidKeriIdentifier(did);
+    const document = generateBareDidDocument(hby, regery, parsed.canonical);
     return {
         did: parsed.canonical,
         document,

package/esm/keri/npm/src/did/webs/artifacts.js

@@ -7,33 +7,32 @@
 import { concatBytes } from "cesr-ts";
 import { ValidationError } from "../../core/errors.js";
 import { Roles } from "../../core/roles.js";
-import { Reger } from "../../db/reger.js";
 import { serializeCredential } from "../../vdr/credentialing.js";
 import { listActiveDesignatedAliasCredentials, pinDesignatedAliasesSchema } from "./designated-aliases.js";
 import { parseDidWebs } from "./dids.js";
 import { generateDidDocument } from "./documenting.js";
 /** Generate both hosted artifacts for one local AID. */
-export function generateDidWebsArtifacts(runtime, options) {
-    const { aid, hab, didJson } = prepareHostedJson(runtime, options);
-    return { aid, didJson, keriCesr: generateDidWebsCesr(runtime, aid, { hab }) };
+export function generateDidWebsArtifacts(rgy, options) {
+    const { aid, hab, didJson } = prepareHostedJson(rgy, options);
+    return { aid, didJson, keriCesr: generateDidWebsCesr(rgy, aid, { hab }) };
 }
 /** Generate only the hosted JSON artifact; never open the CESR replay history. */
-export function generateDidWebsJson(runtime, options) {
-    const { aid, didJson } = prepareHostedJson(runtime, options);
+export function generateDidWebsJson(rgy, options) {
+    const { aid, didJson } = prepareHostedJson(rgy, options);
     return { aid, didJson };
 }
 /** Preserve local-AID validation and document projection for both artifact entry points. */
-function prepareHostedJson(runtime, options) {
+function prepareHostedJson(rgy, options) {
     const parsed = parseDidWebs(options.did);
-    const hab = options.alias ? requireHab(runtime, options.alias) : runtime.hby.habs.get(parsed.aid);
+    const hab = options.alias ? requireHab(rgy.hby, options.alias) : rgy.hby.habs.get(parsed.aid);
     if (!hab?.pre) {
         throw new ValidationError(`No local AID found for did:webs AID ${parsed.aid}.`);
     }
     if (hab.pre !== parsed.aid) {
         throw new ValidationError(`DID ${options.did} embeds AID ${parsed.aid}, but alias ${hab.name} is ${hab.pre}.`);
     }
-    pinDesignatedAliasesSchema(runtime);
-    const document = generateDidDocument(runtime, options.did, {
+    pinDesignatedAliasesSchema(rgy.hby.db);
+    const document = generateDidDocument(rgy.hby, rgy, options.did, {
         hosted: true,
         metadata: options.metadata ?? false,
     });
@@ -44,22 +43,23 @@ function prepareHostedJson(runtime, options) {
     };
 }
 /** Generate the replay CESR stream for one local AID. */
-export function generateDidWebsCesr(runtime, aid, options = {}) {
-    const hab = options.hab ?? runtime.hby.habs.get(aid);
+export function generateDidWebsCesr(rgy, aid, options = {}) {
+    const hab = options.hab ?? rgy.hby.habs.get(aid);
     if (!hab?.pre) {
         throw new ValidationError(`No local AID found for ${aid}.`);
     }
-    const kever = runtime.hby.db.getKever(aid, { refresh: true });
+    const kever = rgy.hby.db.getKever(aid, { refresh: true });
     if (!kever) {
         throw new ValidationError(`No accepted key state for ${aid}.`);
     }
     const messages = [];
     if (kever.delegated) {
-        messages.push(...runtime.hby.db.cloneDelegation(kever));
+        messages.push(...rgy.hby.db.cloneDelegation(kever));
     }
-    messages.push(...runtime.hby.db.clonePreIter(aid));
+    messages.push(...rgy.hby.db.clonePreIter(aid));
     messages.push(...endpointMessages(hab, aid));
-    messages.push(...designatedAliasMessages(runtime, aid));
+    const regery = rgy;
+    messages.push(...designatedAliasMessages(regery, aid));
     return concatBytes(...messages.filter((message) => message.length > 0));
 }
 function endpointMessages(hab, aid) {
@@ -87,13 +87,10 @@ function storedEndpointMessages(hab, aid, role) {
     }
     return messages;
 }
-function designatedAliasMessages(runtime, aid) {
-    const reger = runtime.vdr.reger;
-    if (!(reger instanceof Reger)) {
-        throw new ValidationError("VDR runtime did not open Reger.");
-    }
+function designatedAliasMessages(regery, aid) {
+    const reger = regery.reger;
     const messages = [];
-    for (const item of listActiveDesignatedAliasCredentials(runtime, aid)) {
+    for (const item of listActiveDesignatedAliasCredentials(regery, aid)) {
         const creder = item.creder;
         if (!creder.regid || !creder.said) {
             continue;
@@ -105,8 +102,8 @@ function designatedAliasMessages(runtime, aid) {
     }
     return messages;
 }
-function requireHab(runtime, alias) {
-    const hab = runtime.hby.habByName(alias);
+function requireHab(hby, alias) {
+    const hab = hby.habByName(alias);
     if (!hab?.pre) {
         throw new ValidationError(`No local AID found for alias ${alias}.`);
     }

package/esm/keri/npm/src/did/webs/designated-aliases.js

@@ -7,24 +7,22 @@
  * - expose one active-state query shared by DID documents and CESR artifacts
  */
 import { DigDex, Ilks, Kinds, Saider, } from "cesr-ts";
-import { Verifier } from "../../app/verifying.js";
 import { ValidationError } from "../../core/errors.js";
 import { Schemer } from "../../core/scheming.js";
-import { Credentialer, CredentialWallet, Regery } from "../../vdr/credentialing.js";
-import { Tevery } from "../../vdr/eventing.js";
+import { Credentialer, CredentialWallet } from "../../vdr/credentialing.js";
 import DESIGNATED_ALIASES_SCHEMA_RESOURCE from "./designated-aliases-public-schema.js";
 import { isDidString, parseDid } from "./dids.js";
 export const DESIGNATED_ALIASES_SCHEMA_SAID = "EN6Oh5XSD5_q2Hgu-aqpdfbVepdpYpFlgz6zvJL5b_r5";
 export const DEFAULT_DESIGNATED_ALIASES_REGISTRY_NAME = "dws-designated-aliases";
-/** Pin the public DA schema into a Habery schema cache. */
-export function pinDesignatedAliasesSchema(runtime) {
+/** Pin the checked public DA schema into its concrete Baser schema cache. */
+export function pinDesignatedAliasesSchema(db) {
     const schemer = new Schemer({
         sed: cloneJsonObject(DESIGNATED_ALIASES_SCHEMA_RESOURCE),
     });
     if (schemer.said !== DESIGNATED_ALIASES_SCHEMA_SAID) {
         throw new ValidationError(`Embedded designated-alias schema SAID ${schemer.said} does not match ${DESIGNATED_ALIASES_SCHEMA_SAID}.`);
     }
-    runtime.hby.db.schema.pin(schemer.said, schemer);
+    db.schema.pin(schemer.said, schemer);
     return schemer;
 }
 /**
@@ -33,8 +31,8 @@ export function pinDesignatedAliasesSchema(runtime) {
  * Existing active DA credentials from the same issuer/schema are revoked before
  * the replacement credential is issued.
  */
-export function bindDesignatedAliases(runtime, options) {
-    const hab = requireHab(runtime, options.alias);
+export function bindDesignatedAliases(rgy, options) {
+    const hab = requireHab(rgy.hby, options.alias);
     const aid = hab.pre;
     const aliases = normalizeAliasList(options.dids);
     if (aliases.length === 0) {
@@ -43,21 +41,20 @@ export function bindDesignatedAliases(runtime, options) {
     for (const did of aliases) {
         validateAliasDidForAid(did, aid, options.allowExternalDid ?? false);
     }
-    pinDesignatedAliasesSchema(runtime);
-    const rgy = requireRegery(runtime);
-    const reger = requireReger(runtime);
+    pinDesignatedAliasesSchema(rgy.hby.db);
+    const reger = rgy.reger;
     const registryName = options.registryName ?? DEFAULT_DESIGNATED_ALIASES_REGISTRY_NAME;
     const registry = designatedAliasRegistry(rgy, registryName, hab, options.createRegistry ?? true);
-    const active = listActiveDesignatedAliasCredentials(runtime, aid);
+    const active = listActiveDesignatedAliasCredentials(rgy, aid);
     const revoked = [];
     for (const item of active) {
         const said = credentialSaid(item.creder);
-        registryForCredential(runtime, item.creder).revoke(said);
+        registryForCredential(rgy, item.creder).revoke(said);
         revoked.push(said);
     }
-    const credentialer = new Credentialer(runtime.hby, {
+    const credentialer = new Credentialer(rgy.hby, {
         reger,
-        vry: requireVerifier(runtime),
+        vry: rgy.vry,
     });
     const creder = credentialer.create({
         registry,
@@ -79,9 +76,8 @@ export function bindDesignatedAliases(runtime, options) {
     };
 }
 /** List active, unrevoked DA credentials issued by one AID. */
-export function listActiveDesignatedAliasCredentials(runtime, aid) {
-    const reger = requireReger(runtime);
-    const tvy = requireTevery(runtime);
+export function listActiveDesignatedAliasCredentials(regery, aid) {
+    const { reger, tvy } = regery;
     const wallet = new CredentialWallet(reger);
     const active = [];
     for (const said of wallet.list({
@@ -158,9 +154,8 @@ function validateAliasDidForAid(did, aid, allowExternalDid) {
 function normalizeAliasList(dids) {
     return [...new Set(dids.map((did) => did.trim()).filter((did) => did.length > 0))].sort();
 }
-function registryForCredential(runtime, creder) {
+function registryForCredential(rgy, creder) {
     const regid = creder.regid;
-    const rgy = requireRegery(runtime);
     for (const registry of rgy.registries.values()) {
         if (registry.regk === regid) {
             return registry;
@@ -187,7 +182,7 @@ function designatedAliasRegistry(rgy, registryName, hab, createRegistry) {
     if (!createRegistry) {
         throw new ValidationError(`Registry ${registryName} not found.`);
     }
-    return rgy.makeRegistry(registryName, hab, { noBackers: true });
+    return rgy.makeRegistry(registryName, hab);
 }
 function credentialSaid(creder) {
     if (!creder.said) {
@@ -195,38 +190,13 @@ function credentialSaid(creder) {
     }
     return creder.said;
 }
-function requireHab(runtime, alias) {
-    const hab = runtime.hby.habByName(alias);
+function requireHab(hby, alias) {
+    const hab = hby.habByName(alias);
     if (!hab?.pre) {
         throw new ValidationError(`No local AID found for alias ${alias}.`);
     }
     return hab;
 }
-function requireReger(runtime) {
-    const reger = runtime.vdr.reger;
-    if (!reger) {
-        throw new ValidationError("VDR runtime did not open Reger.");
-    }
-    return reger;
-}
-function requireRegery(runtime) {
-    if (!(runtime.vdr.rgy instanceof Regery)) {
-        throw new ValidationError("VDR runtime did not open Regery.");
-    }
-    return runtime.vdr.rgy;
-}
-function requireTevery(runtime) {
-    if (!(runtime.vdr.tvy instanceof Tevery)) {
-        throw new ValidationError("VDR runtime did not open Tevery.");
-    }
-    return runtime.vdr.tvy;
-}
-function requireVerifier(runtime) {
-    if (!(runtime.vdr.vry instanceof Verifier)) {
-        throw new ValidationError("VDR runtime did not open Verifier.");
-    }
-    return runtime.vdr.vry;
-}
 function cloneJsonObject(value) {
     return JSON.parse(JSON.stringify(value));
 }

package/esm/keri/npm/src/did/webs/documenting.js

@@ -2,9 +2,9 @@ import { ValidationError } from "../../core/errors.js";
 import { Roles } from "../../core/roles.js";
 import { listActiveDesignatedAliasCredentials } from "./designated-aliases.js";
 import { parseDid, parseDidWebs, toCanonicalDidWebs, toHostedDidWeb } from "./dids.js";
-/** Generate a DID document or DID Resolution Result from runtime state. */
-export function generateDidDocument(runtime, did, options = {}) {
-    const document = generateBareDidDocument(runtime, did, options);
+/** Project accepted key, endpoint and credential state into a DID document or result. */
+export function generateDidDocument(hby, regery, did, options = {}) {
+    const document = generateBareDidDocument(hby, regery, did, options);
     if (!options.metadata) {
         return document;
     }
@@ -16,11 +16,11 @@ export function generateDidDocument(runtime, did, options = {}) {
         didDocumentMetadata: {},
     };
 }
-/** Generate only the DID document body from runtime state. */
-export function generateBareDidDocument(runtime, did, options = {}) {
+/** Project accepted state into a DID document without owning intake or scheduling. */
+export function generateBareDidDocument(hby, regery, did, options = {}) {
     const parsed = parseDid(did);
     const aid = parsed.aid;
-    const kever = runtime.hby.db.getKever(aid, { refresh: true });
+    const kever = hby.db.getKever(aid, { refresh: true });
     if (!kever) {
         throw new ValidationError(`No accepted key state for ${aid}.`);
     }
@@ -31,8 +31,8 @@ export function generateBareDidDocument(runtime, did, options = {}) {
         : parsed.canonical;
     const methodEntries = verificationMethods(documentDid, kever);
     methodEntries.push(...thresholdVerificationMethods(documentDid, kever, methodEntries.map((entry) => entry.id)));
-    const services = serviceEntries(runtime.hby, aid);
-    const aliases = listActiveDesignatedAliasCredentials(runtime, aid)
+    const services = serviceEntries(hby, aid);
+    const aliases = listActiveDesignatedAliasCredentials(regery, aid)
         .flatMap((item) => item.aliases)
         .sort();
     return pruneEmpty({

package/esm/keri/npm/src/did/webs/resolving.js

@@ -1,41 +1,51 @@
-/**
- * Verified `did:webs` resolution.
- *
- * Resolution succeeds only when hosted `did.json` matches the DID document
- * regenerated from the fetched `keri.cesr` KERI/VDR stream.
- */
-import { ResourceAdmissionError } from "cesr-ts";
-import { call, resource } from "effection";
-import { abortable } from "../../app/abortable.js";
-import { collectBytes, streamBytes } from "../../app/byte-source.js";
-import { defaultRuntimeHttpClient } from "../../app/runtime-services.js";
+import { TransportError } from "../../app/transport/transport-error.js";
+import { call, resource, scoped } from "effection";
+import { abortable } from "../../app/runtime/abortable.js";
+import { collectBytes } from "../../app/transport/byte-source.js";
 import { ValidationError } from "../../core/errors.js";
 import { pinDesignatedAliasesSchema } from "./designated-aliases.js";
 import { didWebsArtifactUrls, normalizeHostedDidDocument, parseDidWebs } from "./dids.js";
 import { didResolutionResult, generateBareDidDocument, } from "./documenting.js";
-/** Resolve one `did:webs` by fetching and verifying hosted artifacts. */
-export function resolveDidWebs(runtime, options) {
-    return call(() => resolveArtifacts(runtime, options));
+/**
+ * Resolve one `did:webs` by fetching and verifying hosted artifacts.
+ *
+ * @param rgy Borrowed registry owner used to regenerate DID state.
+ * @param reactor Borrowed ingress owner for fetched KERI/VDR artifacts.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param options DID, resolution metadata and HTTP preference choices.
+ * @returns DID document verified against accepted artifact-derived state, plus resolution metadata.
+ */
+export function resolveDidWebs(rgy, reactor, http, options) {
+    return call(() => resolveArtifacts(rgy, reactor, http, options));
 }
-/** Keep finite JSON ownership local even when a long-lived caller resolves multiple DIDs. */
-function* resolveArtifacts(runtime, options) {
+/**
+ * Keep finite JSON ownership local even when a long-lived caller resolves multiple DIDs.
+ *
+ * @param rgy Borrowed registry owner used to regenerate DID state.
+ * @param reactor Borrowed ingress owner for fetched KERI/VDR artifacts.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param options DID, resolution metadata and HTTP preference choices.
+ * @returns DID document verified against accepted artifact-derived state, plus resolution metadata.
+ */
+function* resolveArtifacts(rgy, reactor, http, options) {
     const parsed = parseDidWebs(options.did);
     const urls = didWebsArtifactUrls(parsed, { scheme: "https" });
     const fallbackUrls = didWebsArtifactUrls(parsed, { scheme: "http" });
-    pinDesignatedAliasesSchema(runtime);
+    pinDesignatedAliasesSchema(rgy.hby.db);
     const preferHttp = options.insecureHttp ?? false;
     yield* call(function* () {
-        yield* holdArtifactCredit(runtime, 1024 ** 2);
-        yield* runtime.reactor.process((signal) => artifactBytes(runtime, urls.keriCesr, fallbackUrls.keriCesr, preferHttp, signal), { local: false });
+        const response = yield* artifactResponse(http, urls.keriCesr, fallbackUrls.keriCesr, preferHttp);
+        yield* reactor.process((signal) => response.body(signal), { local: false });
     });
     // EOF and parser cleanup precede convergence and any claim of a complete DID.
-    yield* runtime.reactor.processEscrowsOnce();
+    yield* reactor.protocol.processEscrowsOnce();
     // Preserve the second convergence turn previously run after settleRuntimeIngress's own pass.
-    yield* runtime.reactor.processEscrowsOnce();
-    // Generated/hosted plaintext, collection and comparison copies stay owned through this scope.
-    yield* holdArtifactCredit(runtime, 8 * 8 * 1024 ** 2, 1);
-    const expected = generateBareDidDocument(runtime, parsed.canonical);
-    const bytes = yield* abortable((signal) => collectBytes(artifactBytes(runtime, urls.didJson, fallbackUrls.didJson, preferHttp, signal), 8 * 1024 ** 2));
+    yield* reactor.protocol.processEscrowsOnce();
+    const expected = generateBareDidDocument(rgy.hby, rgy, parsed.canonical);
+    const bytes = yield* call(function* () {
+        const response = yield* artifactResponse(http, urls.didJson, fallbackUrls.didJson, preferHttp);
+        return yield* abortable((signal) => collectBytes(response.body(signal)));
+    });
     let hosted;
     try {
         hosted = JSON.parse(new TextDecoder().decode(bytes));
@@ -55,57 +65,46 @@ function* resolveArtifacts(runtime, options) {
         resolution,
     };
 }
-/** Hold request/copy allowance before fetch; enclosing cleanup joins before returning credit. */
-function* holdArtifactCredit(runtime, bytes, streams = 0) {
-    yield* resource(function* (provide) {
-        const admission = runtime.resources.reserve({ bytes, streams });
-        if (admission.kind === "refuse") {
-            throw new ResourceAdmissionError("DID artifact admission refused", admission.reason);
-        }
-        try {
-            yield* provide();
-        }
-        finally {
-            admission.reservation.release();
-        }
-    });
-}
-/** Native header transport fallback only; a started body never retries another artifact URL. */
-async function* artifactBytes(runtime, httpsUrl, httpUrl, preferHttp, signal) {
-    const urls = preferHttp ? [httpUrl, httpsUrl] : [httpsUrl, httpUrl];
-    let lastError;
-    for (const url of urls) {
-        signal.throwIfAborted();
-        let response;
-        try {
-            response = await runtime.services.http.fetch(url, { signal });
-        }
-        catch (error) {
-            signal.throwIfAborted();
-            // Injected clients can throw programmer/infrastructure TypeErrors; never recast those as transport.
-            if (runtime.services.http !== defaultRuntimeHttpClient || !(error instanceof TypeError))
-                throw error;
-            lastError = error;
-            continue;
-        }
-        let readerOwnsBody = false;
-        try {
-            signal.throwIfAborted();
-            if (!response.ok) {
-                lastError = new ValidationError(`Unable to fetch ${url}: HTTP ${response.status}.`);
-                continue;
+/**
+ * Try alternate artifact URLs only while opening headers; a borrowed body never starts another attempt.
+ *
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param httpsUrl HTTPS artifact candidate.
+ * @param httpUrl HTTP artifact candidate.
+ * @param preferHttp Try HTTP first when explicitly requested.
+ * @returns Scoped response borrowed until its enclosing operation closes.
+ * @throws Only opening TransportError/non-ok status permits alternate URL selection; body/parser/cleanup failures propagate.
+ */
+function artifactResponse(http, httpsUrl, httpUrl, preferHttp) {
+    return resource(function* (provide) {
+        const urls = preferHttp ? [httpUrl, httpsUrl] : [httpsUrl, httpUrl];
+        let lastError;
+        for (const url of urls) {
+            let receivedHeaders = false;
+            // Each unsuccessful request finishes cleanup before another URL may be attempted.
+            try {
+                const delivered = yield* scoped(function* () {
+                    const response = yield* http.open(url);
+                    receivedHeaders = true;
+                    if (!response.ok) {
+                        lastError = new ValidationError(`Unable to fetch ${url}: HTTP ${response.status}.`);
+                        return false;
+                    }
+                    // Keep the request open for protocol/JSON consumption, after the fallback decision.
+                    yield* provide(response);
+                    return true;
+                });
+                if (delivered)
+                    return;
+            }
+            catch (error) {
+                if (receivedHeaders || !(error instanceof TransportError))
+                    throw error;
+                lastError = error;
             }
-            readerOwnsBody = true;
-            yield* streamBytes(response.body, { signal });
-            return;
-        }
-        finally {
-            // The shared reader owns started-body cancellation; dispose only unacquired/failed headers here.
-            if (!readerOwnsBody && response.body)
-                await response.body.cancel();
         }
-    }
-    throw lastError;
+        throw lastError;
+    });
 }
 function hostedDidDocument(value) {
     if (!isRecord(value)) {

package/esm/keri/npm/src/library/index.js

@@ -10,5 +10,5 @@ export * from "../core/cues.js";
 export * from "../core/deck.js";
 export * from "../core/errors.js";
 export * from "../core/logger.js";
-export * from "../core/mailbox-topics.js";
+export * from "../core/mailbox/mailbox-topics.js";
 export * from "../core/roles.js";

package/esm/keri/npm/src/npm/cli.js

@@ -1,3 +1,3 @@
 /** npm subpath entrypoint for `keri-ts/cli`. */
 import "../_dnt.polyfills.js";
-export * from "../app/cli/index.js";
+export * from "../cli/index.js";

package/esm/keri/npm/src/npm/index.js

@@ -7,4 +7,4 @@
  */
 import "../_dnt.polyfills.js";
 export * from "../library/index.js";
-export { BUILD_METADATA, DISPLAY_VERSION, PACKAGE_VERSION, } from "../app/version.js";
+export { BUILD_METADATA, DISPLAY_VERSION, PACKAGE_VERSION, } from "../version.js";