keri-ts 2.0.0 → 2.1.0

package/esm/keri/npm/src/app/notifications/notifying.js

@@ -1,5 +1,6 @@
 import { ValidationError } from "../../core/errors.js";
-import { createNoter, Notice } from "../../db/noting.js";
+import { openOwner } from "../../db/core/store-owner.js";
+import { Noter, Notice } from "../../db/noting.js";
 import { Signaler } from "./signaling.js";
 export function notice(attrs, options = {}) {
     const dt = typeof options.dt === "string"
@@ -17,19 +18,14 @@ export function notice(attrs, options = {}) {
 /** Derive sidecar-open options from the owning `Habery` path/layout settings. */
 export function noterOptionsForHabery(hby, options = {}) {
     return {
-        name: hby.name,
-        base: hby.base,
-        temp: hby.temp,
-        headDirPath: hby.headDirPath,
-        compat: hby.compat,
-        readonly: hby.readonly,
-        reopen: true,
+        ...hby.storeIdentity(),
         ...options,
     };
 }
 /** Open the notification sidecar that belongs to one `Habery`. */
 export function* openNoterForHabery(hby, options = {}) {
-    return yield* createNoter(noterOptionsForHabery(hby, options));
+    const identity = noterOptionsForHabery(hby, options);
+    return yield* openOwner(new Noter(hby.opener.create(Noter.Family, identity)), "Noter", identity);
 }
 /**
  * Signed durable controller notifications with transient `/notification` pings.

package/esm/keri/npm/src/app/protocol/protocol-processing.js

@@ -1,11 +1,24 @@
 import { call } from "effection";
 import { Deck } from "../../core/deck.js";
+import { ValidationError } from "../../core/errors.js";
 import { Kevery } from "../../core/kel/eventing.js";
+import { consoleLogger } from "../../core/logger.js";
 import { BasicReplyRouteHandler, Revery } from "../../core/routing.js";
 import { Exchanger } from "../exchanges/exchanging.js";
 import { QueryReplies } from "../queries/query-replies.js";
 import { runtimeTurn } from "../runtime/runtime-turn.js";
 import { dispatchEnvelope, envelopeFromFrame, queryEnvelopeFromDispatch, } from "./parsering.js";
+/**
+ * Identify a refusal of one already-extracted message, which must not end its stream.
+ *
+ * KERIpy's parser resumes after any non-extraction exception. This is deliberately narrower:
+ * infrastructure failures, programmer errors and cancellation must still reach the input owner.
+ * A dispatch-side ParserError also propagates, because it indicates corrupt local state and
+ * skipping would advance a mailbox cursor past a message that was never processed.
+ */
+function isInvalidMessageError(error) {
+    return error instanceof ValidationError;
+}
 /**
  * Dispatch to synchronous semantic owners and publish their committed output.
  *
@@ -140,6 +153,8 @@ export class ProtocolProcessor {
      * @param options Local intake policy, hosted mailbox provenance and whether to advance escrows.
      * @param kvy Input-specific Kevery in this domain; defaults to the shared owner.
      * @returns Exact dispatch result and current mailbox authorization at its synchronous query decision.
+     *   A message refused by validation after extraction is an `invalidMessage` drop, so the caller
+     *   continues with the next frame as KERIpy's parser does.
      * @throws Domain mismatch, infrastructure/handler or cleanup errors propagate; publication still runs in the dispatch finalizer.
      */
     dispatch(frame, { local = this.kvy.local, mailboxAid, escrows = false } = {}, kvy = this.kvy) {
@@ -151,9 +166,26 @@ export class ProtocolProcessor {
         const self = this;
         return call(function* () {
             try {
-                const result = yield* dispatchEnvelope(envelopeFromFrame(frame, local), self.rvy, kvy, self.exc, self.tvy ?? undefined, self.vry ?? undefined, mailboxAid, self.kvy, // One authoritative v2 sender policy and KRAM intake across all inputs.
-                self.registry ?? undefined, self.qvy);
-                const mailboxQueryAuthorized = result.envelope.serder.route === "mbx"
+                const envelope = envelopeFromFrame(frame, local);
+                let result;
+                let invalid = false;
+                try {
+                    result = yield* dispatchEnvelope(envelope, self.rvy, kvy, self.exc, self.tvy ?? undefined, self.vry ?? undefined, mailboxAid, self.kvy, // One authoritative v2 sender policy and KRAM intake across all inputs.
+                    self.registry ?? undefined, self.qvy);
+                }
+                catch (error) {
+                    if (!isInvalidMessageError(error))
+                        throw error;
+                    invalid = true;
+                    consoleLogger.warn("Skipping invalid message", {
+                        said: envelope.serder.said,
+                        ilk: envelope.serder.ilk,
+                        route: envelope.serder.route,
+                        detail: error.message,
+                    });
+                    result = { envelope, decision: { kind: "drop", reason: "invalidMessage", detail: error.message } };
+                }
+                const mailboxQueryAuthorized = !invalid && result.envelope.serder.route === "mbx"
                     && kvy.isMailboxQueryAuthorized(queryEnvelopeFromDispatch(result.envelope));
                 // Capture this request's facts before optional escrows can suspend or change key state.
                 self.publishCues();

package/esm/keri/npm/src/app/queries/witness-inquisitor.js

@@ -19,7 +19,7 @@ import { introduce } from "../delivery/introducing.js";
 import { runtimeTurn } from "../runtime/runtime-turn.js";
 import { CesrHttpRefusal } from "../transport/cesr-egress.js";
 import { HTTPMessenger } from "../transport/http-messenger.js";
-import { TCPMessenger } from "../transport/tcp-messenger.js";
+import { requireTcpDialer } from "../transport/tcp-dialer.js";
 import { TransportError } from "../transport/transport-error.js";
 /** First eligible role used by KERIpy WitnessInquisitor before random endpoint selection. */
 const QUERY_ROLE_PRIORITY = [Roles.controller, Roles.agent, Roles.witness];
@@ -309,7 +309,7 @@ export class WitnessInquisitor {
         // Only this attempt owns signed bytes; failed attempts are never automatically resubmitted.
         const http = this.http, clock = this.clock;
         if (new URL(delivery.url).protocol === "tcp:") {
-            yield* new TCPMessenger(delivery.url, clock, this.protocol).send(delivery.body, {
+            yield* requireTcpDialer(http).messenger(delivery.url, clock, this.protocol).send(delivery.body, {
                 signal: controller.signal,
                 replies: true,
                 local: true,

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

@@ -11,9 +11,10 @@ import { Kevery } from "../../core/kel/eventing.js";
 import { Kramer } from "../../core/mailbox/kraming.js";
 import { CREDENTIAL_MAILBOX_TOPIC, DELEGATE_MAILBOX_TOPIC, RECEIPT_MAILBOX_TOPIC, REPLAY_MAILBOX_TOPIC, REPLY_MAILBOX_TOPIC, } from "../../core/mailbox/mailbox-topics.js";
 import { Revery } from "../../core/routing.js";
+import { openOwner } from "../../db/core/store-owner.js";
 import { Mailboxer } from "../../db/mailbox/mailboxing.js";
 import { Noter } from "../../db/noting.js";
-import { createReger } from "../../db/reger.js";
+import { Reger } from "../../db/reger.js";
 import { Regery as VdrRegery } from "../../vdr/credentialing.js";
 import { Tevery } from "../../vdr/eventing.js";
 import { Authenticator } from "../bootstrap/authenticating.js";
@@ -161,6 +162,7 @@ export function* createAgentRuntime(hby, http, clock, options = {}) {
     loadIpexHandlers(hby, exc, {
         notifier,
         registry: acdc?.store ?? null,
+        grantWalk: options.grantWalk,
     });
     // Construction adopts stored copies an earlier handler-less Exchanger left unescrowed.
     const registryRoot = options.registryRoots !== "refuse" && acdc ? new RegistryRoot(hby, acdc, notifier) : null;
@@ -324,7 +326,7 @@ export function* createAgentRuntime(hby, http, clock, options = {}) {
 function* openRuntimeNoter(hby) {
     return yield* resource(function* (provide) {
         const options = noterOptionsForHabery(hby);
-        const store = new Noter(options);
+        const store = new Noter(hby.opener.create(Noter.Family, options));
         try {
             if (!(yield* store.reopen(options)))
                 throw new DatabaseNotOpenError("Failed to open runtime Noter");
@@ -344,7 +346,7 @@ function* openRuntimeNoter(hby) {
 function* openRuntimeMailboxer(hby) {
     return yield* resource(function* (provide) {
         const options = mailboxerOptionsForHabery(hby);
-        const store = new Mailboxer(options);
+        const store = new Mailboxer(hby.opener.create(Mailboxer.Family, options));
         try {
             if (!(yield* store.reopen(options)))
                 throw new DatabaseNotOpenError("Failed to open runtime Mailboxer");
@@ -380,13 +382,8 @@ function* openAcdcRegeryForHabery(hby) {
  */
 function* openRegerForHabery(hby) {
     return yield* resource(function* (provide) {
-        const store = yield* call(() => createReger({
-            name: hby.name,
-            base: hby.base,
-            temp: hby.temp,
-            headDirPath: hby.headDirPath,
-            compat: hby.compat,
-        }));
+        const identity = { name: hby.name, base: hby.base, temp: hby.temp };
+        const store = yield* openOwner(new Reger(hby.opener.create(Reger.Family, identity)), "Reger", identity);
         try {
             yield* provide(store);
         }

package/esm/keri/npm/src/app/transport/byte-source.js

@@ -1,6 +1,8 @@
-/** Transport readers. Each operation owns its reader and joins cancellation. */
-/** Cancellation and chunk size for byte-array and file sources. */
-import * as dntShim from "../../_dnt.shims.js";
+/**
+ * Host-neutral transport readers. Each operation owns its reader and joins
+ * cancellation. The local-file reader lives in `file-bytes.ts` because it
+ * needs host file access.
+ */
 /**
  * Adapt an already resident finite value into independent bounded parser chunks.
  *
@@ -81,44 +83,6 @@ export async function* streamBytes(stream, { signal } = {}) {
             throw errors[0];
     }
 }
-/**
- * Stream a local file with fixed-size owned buffers and close it on break or abort.
- *
- * @param path Local filesystem path opened read-only for this iteration.
- * @param options Optional cancellation and positive read buffer size in bytes; defaults to 65536.
- * @yields Owned buffers up to the selected chunk size until file EOF.
- * @throws Open/read failures or cancellation; the file closes on EOF, break or failure.
- */
-export async function* fileBytes(path, { signal, maxChunkBytes = 64 * 1024 } = {}) {
-    checkLimit(maxChunkBytes);
-    signal?.throwIfAborted();
-    const file = await dntShim.Deno.open(path, { read: true });
-    let closed = false;
-    /** Interrupt a pending read and release the file exactly once. */
-    const close = () => {
-        if (!closed) {
-            closed = true;
-            file.close();
-        }
-    };
-    signal?.addEventListener("abort", close, { once: true });
-    try {
-        while (true) {
-            signal?.throwIfAborted();
-            const chunk = new Uint8Array(maxChunkBytes);
-            const size = await file.read(chunk);
-            signal?.throwIfAborted();
-            if (size === null)
-                return;
-            if (size > 0)
-                yield chunk.subarray(0, size);
-        }
-    }
-    finally {
-        signal?.removeEventListener("abort", close);
-        close();
-    }
-}
 /**
  * Collect an explicitly finite operation; bulk ingress should consume its source directly.
  *
@@ -147,7 +111,7 @@ export async function collectBytes(source) {
  * @param limit Requested per-chunk byte count.
  * @throws RangeError unless the count is a positive safe integer.
  */
-function checkLimit(limit) {
+export function checkLimit(limit) {
     if (!Number.isSafeInteger(limit) || limit < 1)
         throw new RangeError("Chunk size must be a positive safe integer");
 }

package/esm/keri/npm/src/app/transport/cesr-egress.js

@@ -5,15 +5,19 @@
  * caller consumes that body before leaving the enclosing scope. Neither path
  * implicitly feeds successful response bytes into protocol processing.
  *
- * Match KERIpy's detached-attachment POST contract while retaining the exact
- * signed body. Only the known pre-intake Falcon media refusal permits a second
- * request; authentication/application failures and network errors are not retries.
+ * Match KERIpy HTTPMessenger's two wire shapes. A JSON/CBOR/MGPK frame is one
+ * detached-attachment POST retaining the exact signed body; only the known
+ * pre-intake Falcon media refusal permits a second request, and
+ * authentication/application failures and network errors are not retries.
+ * A native CESR frame (counter-prefixed body, text or binary domain) is one
+ * whole opaque PUT of the serialized frame, as KERIpy sends since PR 1751,
+ * because a native body is not JSON and cannot travel in the detached form.
  */
-import { attachmentPayload, byteString, collectPayload, parse, } from "cesr-ts";
+import { attachmentPayload, byteString, collectPayload, framePayload, Kinds, parse, sniff, } from "cesr-ts";
 import { call, ensure, race, resource, scoped } from "effection";
 import { ValidationError } from "../../core/errors.js";
 import { abortable, cleanupFailures, throwOnAbort } from "../runtime/abortable.js";
-import { CESR_ATTACHMENT_HEADER, CESR_CONTENT_TYPE, CESR_DESTINATION_HEADER, KERIPY_CESR_JSON_CONTENT_TYPE, } from "./cesr-http.js";
+import { buildCesrStreamRequest, CESR_ATTACHMENT_HEADER, CESR_CONTENT_TYPE, CESR_DESTINATION_HEADER, KERIPY_CESR_JSON_CONTENT_TYPE, } from "./cesr-http.js";
 /** Positive remote HTTP refusal, distinct from source, transport, storage and cleanup failure. */
 export class CesrHttpRefusal extends ValidationError {
     /**
@@ -108,19 +112,79 @@ function openFrameResponse(url, frame, http, options) {
         }
     });
 }
+/**
+ * Recognize a frame whose body is native CESR rather than a JSON/CBOR/MGPK message.
+ * KERIpy HTTPMessenger decides by sniffing the message cold start for a counter in
+ * either domain; a hydrated native body carries kind CESR and its raw bytes begin
+ * with that fixed-field counter. Opaque fallback bodies without a counter stay ordinary.
+ *
+ * @param frame Parsed frame whose body kind and raw bytes decide the wire shape.
+ * @returns True when the frame must travel as one whole PUT instead of a detached POST.
+ */
+export function isNativeCesrFrame(frame) {
+    if (frame.body.kind !== Kinds.cesr)
+        return false;
+    const cold = sniff(frame.body.raw);
+    return cold === "txt" || cold === "bny";
+}
+/**
+ * Select the qualification domain for one native frame's PUT body.
+ * The parser hydrates native bodies as qualified text, so the admitted attachment
+ * wire is the remaining evidence of a binary source; a bare body stays text.
+ *
+ * @param frame Native frame whose attachments retain their admitted domain.
+ * @returns The source domain KERIpy would have forwarded unchanged.
+ */
+function nativeFrameDomain(frame) {
+    const evidence = frame.attachments[0]?.raw;
+    return evidence && sniff(evidence) === "bny" ? "bny" : "txt";
+}
+/**
+ * Prepare KERIpy HTTPMessenger's native-stream PUT for one frame.
+ * The shared serializer emits the frame's root genus selector, body and one
+ * attachment enclosure in the source domain, and that whole payload is the body
+ * with an explicit length, exactly as HTTPStreamMessenger sends a prepared stream.
+ * Detached CESR-ATTACHMENT/CESR-Genus headers do not apply and no legacy media
+ * fallback exists; caller authentication headers are retained.
+ *
+ * @param frame Native frame; its serialized bytes are the complete request body.
+ * @param options Destination, extra headers and optional cancellation.
+ * @returns One PUT request whose body is the serialized frame.
+ */
+function* nativeFrameRequest(frame, options) {
+    const domain = nativeFrameDomain(frame);
+    const bytes = yield* abortable((signal) => collectPayload(framePayload(frame, { domain }), signal), options.signal);
+    const prepared = buildCesrStreamRequest(bytes, { destination: options.destination });
+    const headers = new Headers(options.headers);
+    headers.delete(CESR_DESTINATION_HEADER);
+    headers.delete(CESR_ATTACHMENT_HEADER);
+    headers.delete("CESR-Genus");
+    for (const [key, value] of Object.entries(prepared.headers))
+        headers.set(key, value);
+    headers.set("Content-Length", String(bytes.byteLength));
+    return {
+        method: "PUT",
+        redirect: "manual",
+        headers,
+        signal: options.signal,
+        body: prepared.body,
+    };
+}
 /**
  * Prepare finite request bytes before opening any network attempt.
- * Ordinary POSTs put normalized text attachments in CESR-ATTACHMENT and send the
- * original body. CESR-Genus retains the observed counter context when stream framing is removed.
- * Requests retain
+ * A native frame yields exactly one whole PUT. Ordinary POSTs put normalized text
+ * attachments in CESR-ATTACHMENT and send the original body. CESR-Genus retains
+ * the observed counter context when stream framing is removed. Requests retain
  * caller authentication headers; sender-owned framing/destination headers replace
  * conflicting caller values. The fallback shares the prepared bytes.
  *
  * @param frame Parsed signed body and attachments; framing preserves the signed body bytes.
  * @param options Destination, extra headers and optional cancellation for ordinary signed-message POSTs.
- * @returns Current and legacy media choices sharing the same signed body.
+ * @returns One native PUT, or the current and legacy media choices sharing the same signed body.
  */
 function* frameRequests(frame, options) {
+    if (isNativeCesrFrame(frame))
+        return [yield* nativeFrameRequest(frame, options)];
     const header = byteString(yield* abortable((signal) => collectPayload(attachmentPayload(frame, { domain: "txt" }), signal), options.signal));
     const body = frame.body.raw;
     const types = [CESR_CONTENT_TYPE, KERIPY_CESR_JSON_CONTENT_TYPE];
@@ -202,8 +266,8 @@ function* sendFrame(url, frame, http, options) {
 }
 /**
  * Send a CESR source and throw on a completed peer refusal.
- * One parsed frame becomes one POST, and its request scope closes before the next
- * source pull. A refusal stops the sequence; prior frames may already be delivered.
+ * One parsed frame becomes one request (a detached POST, or one whole PUT for a
+ * native frame), and its request scope closes before the next source pull. A refusal stops the sequence; prior frames may already be delivered.
  * Cancellation aborts active work, joins any pending source pull and returns the
  * parser iterator before leaving. There is no automatic retry beyond media fallback.
  * A pending asynchronous source pull can finish after cancellation is requested;
@@ -224,8 +288,8 @@ export function* postCesr(url, source, http, options = {}) {
 }
 /**
  * Send frames sequentially and return a completed peer refusal as data.
- * One parsed frame becomes one POST, and its request scope closes before the next
- * source pull. A refusal stops the sequence; prior frames may already be delivered.
+ * One parsed frame becomes one request (a detached POST, or one whole PUT for a
+ * native frame), and its request scope closes before the next source pull. A refusal stops the sequence; prior frames may already be delivered.
  * Cancellation aborts active work, joins any pending source pull and returns the
  * parser iterator before leaving. There is no automatic retry beyond media fallback.
  *

package/esm/keri/npm/src/app/transport/file-bytes.js

@@ -0,0 +1,41 @@
+/** Local-file byte source. Host-only: it opens files through `Deno`. */
+import * as dntShim from "../../_dnt.shims.js";
+import { checkLimit } from "./byte-source.js";
+/**
+ * Stream a local file with fixed-size owned buffers and close it on break or abort.
+ *
+ * @param path Local filesystem path opened read-only for this iteration.
+ * @param options Optional cancellation and positive read buffer size in bytes; defaults to 65536.
+ * @yields Owned buffers up to the selected chunk size until file EOF.
+ * @throws Open/read failures or cancellation; the file closes on EOF, break or failure.
+ */
+export async function* fileBytes(path, { signal, maxChunkBytes = 64 * 1024 } = {}) {
+    checkLimit(maxChunkBytes);
+    signal?.throwIfAborted();
+    const file = await dntShim.Deno.open(path, { read: true });
+    let closed = false;
+    /** Interrupt a pending read and release the file exactly once. */
+    const close = () => {
+        if (!closed) {
+            closed = true;
+            file.close();
+        }
+    };
+    signal?.addEventListener("abort", close, { once: true });
+    try {
+        while (true) {
+            signal?.throwIfAborted();
+            const chunk = new Uint8Array(maxChunkBytes);
+            const size = await file.read(chunk);
+            signal?.throwIfAborted();
+            if (size === null)
+                return;
+            if (size > 0)
+                yield chunk.subarray(0, size);
+        }
+    }
+    finally {
+        signal?.removeEventListener("abort", close);
+        close();
+    }
+}

package/esm/keri/npm/src/app/transport/http-messenger.js

@@ -1,15 +1,18 @@
 import { chunkBytes } from "./byte-source.js";
 import { attemptPostCesr } from "./cesr-egress.js";
 /**
- * Send ordinary signed messages as ordered HTTP POSTs and finish response cleanup.
+ * Send ordinary signed messages as ordered HTTP requests and finish response cleanup.
  * Producers own preparation and Poster owns queued work. This component needs no
  * Habery, protocol processor, parser state, timer or response history.
  *
- * Corresponds to the ordinary POST role of KERIpy HTTPMessenger. Complete CESR
- * frames become separate POSTs: original signed body in the request body, text
- * attachments in CESR-ATTACHMENT. Only the recognized pre-intake media refusal
- * permits a second attempt with legacy media metadata. Successful response bytes
- * are drained and discarded; protocol receiving belongs to independent intake.
+ * Corresponds to KERIpy HTTPMessenger. Each complete CESR frame is one request,
+ * shaped by its body: a JSON/CBOR/MGPK frame is a POST with the original signed
+ * body in the request body and text attachments in CESR-ATTACHMENT, where only
+ * the recognized pre-intake media refusal permits a second attempt with legacy
+ * media metadata; a native CESR frame (counter-prefixed body) is one whole PUT of
+ * the serialized frame with Content-Length and CESR-DESTINATION, matching KERIpy
+ * since PR 1751 and without detached headers or media fallback. Successful response
+ * bytes are drained and discarded; protocol receiving belongs to independent intake.
  */
 export class HTTPMessenger {
     /** Bind one endpoint and request metadata; construction performs no I/O. */
@@ -42,9 +45,11 @@ export class HTTPMessenger {
         return this.sendSource((signal) => chunkBytes(msg, { signal }), options);
     }
     /**
-     * Iterate ordinary messages into POSTs; this is not whole-stream PUT delivery.
-     * A later malformed message cannot prevent an earlier valid POST. Parser,
-     * transport, source and cleanup failures propagate; HTTP refusal is typed data.
+     * Iterate messages into one request each; this is not whole-stream PUT delivery.
+     * A multi-message native stream becomes successive per-frame PUTs, not KERIpy's
+     * single bulk PUT. A later malformed message cannot prevent an earlier valid
+     * request. Parser, transport, source and cleanup failures propagate; HTTP
+     * refusal is typed data.
      */
     sendSource(source, options = {}) {
         return attemptPostCesr(this.url, source, this.http, { ...this.options, ...options });

package/esm/keri/npm/src/app/transport/message-source.js

@@ -12,7 +12,7 @@ import { rethrowCleanupFailure } from "../runtime/abortable.js";
  * @param protocol Borrowed dispatcher over synchronous domain commits and correlated cue publication.
  * @param kvy Input-owned KEL processor bound to the same store, reply verifier and cue flow.
  * @param options Dispatch policy and optional upstream cancellation; defaults follow the shared processor.
- * @throws Parsing, dispatch and cleanup failures propagate after the pending pull and iterator cleanup join.
+ * @throws Parsing, infrastructure dispatch and cleanup failures propagate after the pending pull and iterator cleanup join; one invalid message does not.
  */
 export function* processMessages(source, protocol, kvy, options = {}) {
     const input = call(function* () {

package/esm/keri/npm/src/app/transport/messengering.js

@@ -9,8 +9,7 @@
 import { ValidationError } from "../../core/errors.js";
 import { HTTPMessenger } from "./http-messenger.js";
 import { HTTPStreamMessenger } from "./http-stream-messenger.js";
-import { TCPMessenger } from "./tcp-messenger.js";
-import { TCPStreamMessenger } from "./tcp-stream-messenger.js";
+import { requireTcpDialer } from "./tcp-dialer.js";
 /** Choose HTTPS, HTTP, then TCP and reject a mismatched advertised scheme before I/O. */
 function endpointFrom(urls) {
     for (const scheme of ["https", "http", "tcp"]) {
@@ -43,7 +42,7 @@ function endpointFrom(urls) {
 export function messengerFrom(destination, urls, http, clock, headers) {
     const endpoint = endpointFrom(urls);
     if (endpoint.protocol === "tcp:")
-        return new TCPMessenger(endpoint.href, clock);
+        return requireTcpDialer(http).messenger(endpoint.href, clock);
     return new HTTPMessenger(endpoint.href, http, { destination, headers });
 }
 /**
@@ -63,6 +62,6 @@ export function messengerFrom(destination, urls, http, clock, headers) {
 export function streamMessengerFrom(destination, urls, payload, http, clock, headers) {
     const endpoint = endpointFrom(urls);
     if (endpoint.protocol === "tcp:")
-        return new TCPStreamMessenger(endpoint.href, clock, payload);
+        return requireTcpDialer(http).streamMessenger(endpoint.href, clock, payload);
     return new HTTPStreamMessenger(endpoint.href, http, payload, { destination, headers });
 }

package/esm/keri/npm/src/app/transport/node-http-client.js

@@ -0,0 +1,21 @@
+/** HTTP client plus TCP egress, for hosts with sockets. */
+import { FetchHttpClient } from "./http-client.js";
+import { TCPMessenger } from "./tcp-messenger.js";
+import { TCPStreamMessenger } from "./tcp-stream-messenger.js";
+/** Dials TCP endpoints through `node:net`. */
+export const nodeTcpDialer = {
+    messenger: (url, clock, protocol = null) => new TCPMessenger(url, clock, protocol),
+    streamMessenger: (url, clock, payload) => new TCPStreamMessenger(url, clock, payload),
+};
+/** A `FetchHttpClient` that can also reach `tcp:` endpoints. */
+export class NodeHttpClient extends FetchHttpClient {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "tcp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: nodeTcpDialer
+        });
+    }
+}

package/esm/keri/npm/src/app/transport/tcp-dialer.js

@@ -0,0 +1,14 @@
+/**
+ * Host seam for TCP egress.
+ *
+ * Browsers have no TCP, so `HttpClient` carries an optional dialer supplied by
+ * hosts that do. Code that reaches a `tcp:` endpoint asks for it here and fails
+ * clearly when this host cannot dial.
+ */
+import { ValidationError } from "../../core/errors.js";
+/** Return the host's dialer, or fail for a `tcp:` endpoint this host cannot reach. */
+export function requireTcpDialer(http) {
+    if (!http.tcp)
+        throw new ValidationError("TCP endpoints are unavailable on this host.");
+    return http.tcp;
+}

package/esm/keri/npm/src/app/witness/receipt-client.js

@@ -7,7 +7,7 @@ import { abortable } from "../runtime/abortable.js";
 import { collectBytes } from "../transport/byte-source.js";
 import { buildCesrRequest, CESR_CONTENT_TYPE, KERIPY_CESR_JSON_CONTENT_TYPE } from "../transport/cesr-http.js";
 import { HTTPMessenger } from "../transport/http-messenger.js";
-import { TCPMessenger } from "../transport/tcp-messenger.js";
+import { requireTcpDialer } from "../transport/tcp-dialer.js";
 import { inspectReceiptMessage } from "./receipt-messages.js";
 const WitnessReceiptPollAttempts = 20;
 const WitnessReceiptPollDelayMs = 100;
@@ -71,7 +71,7 @@ export function* sendWitnessMessage(hab, witness, bytes, http, clock, protocol,
     }
     const parsed = new URL(url);
     if (parsed.protocol === "tcp:") {
-        yield* new TCPMessenger(url, clock, protocol).send(bytes, {
+        yield* requireTcpDialer(http).messenger(url, clock, protocol).send(bytes, {
             replies: Boolean(protocol),
             local: true,
         });

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

@@ -1,6 +1,6 @@
 import { createAgentRuntime } from "../../app/runtime/agent-runtime.js";
 import { systemClock } from "../../app/runtime/runtime-clock.js";
-import { FetchHttpClient } from "../../app/transport/http-client.js";
+import { NodeHttpClient } from "../../app/transport/node-http-client.js";
 import { ValidationError } from "../../core/errors.js";
 import { setupHby } from "./existing.js";
 /** Open an existing Habery for one CLI command and close it after the callback. */
@@ -54,7 +54,7 @@ export function* withExistingHab(args, alias, options, use) {
  */
 export function* withAgentRuntime(args, options, use) {
     return yield* withExistingHabery(args, options, function* ({ hby }) {
-        const runtime = yield* (options.dependencies?.createAgentRuntime ?? createAgentRuntime)(hby, new FetchHttpClient(), systemClock, { kram: hby.cf?.get().kram });
+        const runtime = yield* (options.dependencies?.createAgentRuntime ?? createAgentRuntime)(hby, new NodeHttpClient(), systemClock, { kram: hby.cf?.get().kram });
         let failure;
         try {
             return yield* use({ hby, runtime });

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

@@ -1,6 +1,6 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { createHabery } from "../../app/identity/habbing.js";
-import { createKeeper, Keeper } from "../../db/keeping.js";
+import { createHabery } from "../../app/identity/lmdb-habery.js";
+import { createKeeper, lmdbKeeper } from "../../db/lmdb-stores.js";
 import { readPasscode } from "./passcode.js";
 /**
  * Return true when the named keeper already exists and contains keeper globals.
@@ -10,7 +10,7 @@ import { readPasscode } from "./passcode.js";
  * keystore" without mutating on-disk state during the probe.
  */
 function* keeperExists(name, base = "", temp = false, headDirPath, compat = false) {
-    const keeper = new Keeper({
+    const keeper = lmdbKeeper({
         name,
         base,
         temp,
@@ -22,8 +22,6 @@ function* keeperExists(name, base = "", temp = false, headDirPath, compat = fals
             name,
             base,
             temp,
-            headDirPath,
-            compat,
             reopen: true,
             readonly: true,
         });

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

@@ -9,7 +9,8 @@ import { isLocalGroupHab, localGroupMember } from "../../app/multisig/group-memb
 import { MULTISIG_EXN_ROUTE } from "../../app/multisig/grouping.js";
 import { abortable } from "../../app/runtime/abortable.js";
 import { runAgentRuntime, settleMailboxPollBatch } from "../../app/runtime/agent-runtime.js";
-import { chunkBytes, collectBytes, fileBytes } from "../../app/transport/byte-source.js";
+import { chunkBytes, collectBytes } from "../../app/transport/byte-source.js";
+import { fileBytes } from "../../app/transport/file-bytes.js";
 import { parseGvrsn } from "../../core/attachment-countering.js";
 import { ValidationError } from "../../core/errors.js";
 import { exchange } from "../../core/exchange/protocol-exchanging.js";

package/esm/keri/npm/src/cli/endpoints/oobi-clean.js

@@ -2,9 +2,10 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { call } from "effection";
 import { DatabaseOperationError, ValidationError } from "../../core/errors.js";
-import { baserDefaults } from "../../db/baser-defaults.js";
-import { createBaser } from "../../db/basing.js";
+import { Baser } from "../../db/basing.js";
+import { lmdbDefaultsFor } from "../../db/core/lmdb-opener.js";
 import { PathManager } from "../../db/core/path-manager.js";
+import { createBaser } from "../../db/lmdb-stores.js";
 import { parseBooleanOption, parseStringOption } from "../common/parsing.js";
 import { writeJsonLine } from "../common/rendering.js";
 /** Read a nonempty JSON list, preserving exact keys and first-seen order. */
@@ -56,7 +57,7 @@ export function* oobiCleanCommand(args) {
     const keys = yield* loadKeys(args.keyFile);
     // Resolve through ordinary path preparation before Baser can create data.mdb.
     // Empty directories are ordinary startup effects; missing databases still fail.
-    const paths = new PathManager(options, baserDefaults(options.compat));
+    const paths = new PathManager(options, lmdbDefaultsFor(Baser.Family, options.compat));
     paths.name = name;
     yield* paths.reopen();
     const path = paths.path;