keri-ts 2.0.0 → 2.1.0

package/esm/keri/npm/src/db/core/webdber.js

@@ -0,0 +1,252 @@
+/**
+ * Browser-capable `DBer`: a `MemStore` mirror with write-behind persistence.
+ *
+ * ADR-0015 owns the durability model. Reads and writes are synchronous against
+ * the mirror; each outermost commit enqueues one batch holding its net effect,
+ * and a queue shared by a composition applies batches one at a time in global
+ * commit order. Nothing here may reach `lmdb`, `node:` or the `Deno` global.
+ *
+ * Invariant: once the queue is joined with no failure, the mirror and the
+ * persisted rows are byte-identical, which is why `reopen` joins before it loads.
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _PersistenceQueue_instances, _PersistenceQueue_tail, _PersistenceQueue_failure, _PersistenceQueue_append, _PersistenceQueue_settled, _WebDBer_instances, _WebDBer_persistence, _WebDBer_queue, _WebDBer_pendingTables, _WebDBer_connected, _WebDBer_enqueue, _WebDBer_takePendingTables, _WebDBer_carryPendingTables;
+import { bytesEqual, bytesHex } from "cesr-ts";
+import { call, ensure } from "effection";
+import { DatabaseOperationError } from "../../core/errors.js";
+import { MemStore } from "./memstore.js";
+/**
+ * The persistence order of one composition. Tasks run strictly one at a time,
+ * outside any Effection scope, so cancelling a waiter never cancels a write.
+ *
+ * The first failure latches: every later task is skipped, because applying a
+ * later batch over a lost earlier one would break prefix durability.
+ */
+export class PersistenceQueue {
+    constructor() {
+        _PersistenceQueue_instances.add(this);
+        _PersistenceQueue_tail.set(this, Promise.resolve());
+        _PersistenceQueue_failure.set(this, null);
+    }
+    /** Append a task, which is skipped if an earlier one failed. */
+    enqueue(task) {
+        __classPrivateFieldGet(this, _PersistenceQueue_instances, "m", _PersistenceQueue_append).call(this, task, false);
+    }
+    /** Append connection teardown, which still runs after a failure so a handle is not left open. */
+    release(task) {
+        __classPrivateFieldGet(this, _PersistenceQueue_instances, "m", _PersistenceQueue_append).call(this, task, true);
+    }
+    /** Refuse new work once latched. The original failure is the cause. */
+    assertHealthy() {
+        if (__classPrivateFieldGet(this, _PersistenceQueue_failure, "f")) {
+            throw new DatabaseOperationError("Persistence failed; this composition accepts no more commits", {
+                cause: __classPrivateFieldGet(this, _PersistenceQueue_failure, "f").error,
+            });
+        }
+    }
+    /** Wait until everything enqueued before this call is durable. Halting cancels only the wait. */
+    *flushed() {
+        const settled = __classPrivateFieldGet(this, _PersistenceQueue_instances, "m", _PersistenceQueue_settled).call(this);
+        yield* call(() => settled);
+    }
+    /** Like `flushed`, but a halted caller still waits for the queue and still reports its failure. */
+    *joined() {
+        const settled = __classPrivateFieldGet(this, _PersistenceQueue_instances, "m", _PersistenceQueue_settled).call(this);
+        yield* call(function* () {
+            yield* ensure(() => call(() => settled));
+            yield* call(() => settled);
+        });
+    }
+}
+_PersistenceQueue_tail = new WeakMap(), _PersistenceQueue_failure = new WeakMap(), _PersistenceQueue_instances = new WeakSet(), _PersistenceQueue_append = function _PersistenceQueue_append(task, always) {
+    __classPrivateFieldSet(this, _PersistenceQueue_tail, __classPrivateFieldGet(this, _PersistenceQueue_tail, "f").then(async () => {
+        if (__classPrivateFieldGet(this, _PersistenceQueue_failure, "f") && !always)
+            return;
+        try {
+            await task();
+        }
+        catch (error) {
+            __classPrivateFieldSet(this, _PersistenceQueue_failure, __classPrivateFieldGet(this, _PersistenceQueue_failure, "f") ?? { error }, "f");
+        }
+    }), "f");
+}, _PersistenceQueue_settled = function _PersistenceQueue_settled() {
+    return __classPrivateFieldGet(this, _PersistenceQueue_tail, "f").then(() => {
+        if (__classPrivateFieldGet(this, _PersistenceQueue_failure, "f"))
+            throw __classPrivateFieldGet(this, _PersistenceQueue_failure, "f").error;
+    });
+};
+function sameValue(a, c) {
+    return a === null || c === null ? a === c : bytesEqual(a, c);
+}
+/** Collapse a commit's writes to the first prior and latest state of each row identity. */
+function netRows(changes) {
+    const net = new Map();
+    for (const change of changes) {
+        if (change.kind !== "row")
+            continue;
+        const duplicate = change.dupsort ? bytesHex((change.before ?? change.after)) : "";
+        const identity = `${bytesHex(change.key)}/${duplicate}/${change.table}`;
+        const seen = net.get(identity);
+        if (seen) {
+            seen.after = change.after;
+        }
+        else {
+            net.set(identity, { ...change });
+        }
+    }
+    return [...net.values()].filter((row) => !sameValue(row.before, row.after));
+}
+/** The version a commit leaves behind, or `undefined` when it ends where it began. */
+function netVersion(changes) {
+    const versions = changes.filter((change) => change.kind === "version");
+    const first = versions.at(0);
+    const last = versions.at(-1);
+    return first && last && first.before !== last.after ? last.after : undefined;
+}
+/**
+ * `MemStore` mirror whose commits persist through a `Persistence` adapter.
+ *
+ * After the queue latches, a commit already in the mirror stays there and stays
+ * readable even though it was never persisted, and every later transaction
+ * throws before touching the mirror, so the mirror stops changing. The durable
+ * state is a prefix of the commit sequence. Recovery is a new composition, with
+ * a new queue, loading that prefix; there is no retry.
+ */
+export class WebDBer extends MemStore {
+    constructor(options, persistence, queue) {
+        super(options);
+        _WebDBer_instances.add(this);
+        _WebDBer_persistence.set(this, void 0);
+        _WebDBer_queue.set(this, void 0);
+        /** Tables not yet carried by a batch, so an unwritten table still persists its dupsort flag. */
+        _WebDBer_pendingTables.set(this, new Map());
+        _WebDBer_connected.set(this, false);
+        __classPrivateFieldSet(this, _WebDBer_persistence, persistence, "f");
+        __classPrivateFieldSet(this, _WebDBer_queue, queue, "f");
+    }
+    /**
+     * Join the queue, then bulk-load every persisted table before returning, so
+     * reads never suspend. A latched queue refuses, reporting its failure.
+     */
+    *reopen(options = {}) {
+        yield* this.close(options.clear ?? false);
+        const persistence = __classPrivateFieldGet(this, _WebDBer_persistence, "f");
+        __classPrivateFieldSet(this, _WebDBer_connected, true, "f");
+        const meta = yield* call(() => persistence.meta());
+        const tables = [];
+        for (const { name, dupsort } of meta.tables) {
+            tables.push({ name, dupsort, rows: yield* call(() => persistence.load(name)) });
+        }
+        this.loadContents(tables, meta.version);
+        return yield* super.reopen(options);
+    }
+    /**
+     * Stop accepting work, drain and join the queue even when cancelled, and
+     * report any failure. A latched store is neither cleared nor reusable, and
+     * every later close reports the same failure.
+     */
+    *close(clear = false) {
+        if (clear) {
+            __classPrivateFieldGet(this, _WebDBer_pendingTables, "f").clear();
+        }
+        else if (this.opened && !this.readonly) {
+            __classPrivateFieldGet(this, _WebDBer_instances, "m", _WebDBer_carryPendingTables).call(this);
+        }
+        yield* super.close();
+        const persistence = __classPrivateFieldGet(this, _WebDBer_persistence, "f");
+        if (__classPrivateFieldGet(this, _WebDBer_connected, "f")) {
+            __classPrivateFieldSet(this, _WebDBer_connected, false, "f");
+            __classPrivateFieldGet(this, _WebDBer_queue, "f").release(() => persistence.close());
+        }
+        if (clear)
+            __classPrivateFieldGet(this, _WebDBer_queue, "f").enqueue(() => persistence.clear());
+        yield* __classPrivateFieldGet(this, _WebDBer_queue, "f").joined();
+        if (clear)
+            yield* super.close(true);
+        return true;
+    }
+    /** Bind a table; a new one is physically created by the batch that first carries it. */
+    openTable(name, options = {}) {
+        if (this.readonly || !this.opened || !name || this.hasTable(name))
+            return super.openTable(name, options);
+        __classPrivateFieldGet(this, _WebDBer_queue, "f").assertHealthy();
+        const table = super.openTable(name, options);
+        __classPrivateFieldGet(this, _WebDBer_pendingTables, "f").set(name, options.dupsort ?? false);
+        return table;
+    }
+    transaction(fn) {
+        this.assertOpen();
+        __classPrivateFieldGet(this, _WebDBer_queue, "f").assertHealthy();
+        return super.transaction(fn);
+    }
+    /** Completes when every earlier commit in this composition is durable, or fails with its recorded failure. */
+    *flushed() {
+        this.assertOpen();
+        if (!this.readonly)
+            __classPrivateFieldGet(this, _WebDBer_instances, "m", _WebDBer_carryPendingTables).call(this);
+        yield* __classPrivateFieldGet(this, _WebDBer_queue, "f").flushed();
+    }
+    committed(changes) {
+        const rows = netRows(changes);
+        const version = netVersion(changes);
+        if (rows.length === 0 && version === undefined)
+            return;
+        const copy = (bytes) => new Uint8Array(bytes);
+        __classPrivateFieldGet(this, _WebDBer_instances, "m", _WebDBer_enqueue).call(this, {
+            tables: __classPrivateFieldGet(this, _WebDBer_instances, "m", _WebDBer_takePendingTables).call(this),
+            ...(version === undefined ? {} : { version }),
+            puts: rows.filter(({ after }) => after !== null).map(({ table, key, after }) => ({
+                table,
+                key: copy(key),
+                value: copy(after),
+            })),
+            deletes: rows.filter(({ after }) => after === null).map(({ table, dupsort, key, before }) => ({
+                table,
+                key: copy(key),
+                ...(dupsort ? { value: copy(before) } : {}),
+            })),
+        });
+    }
+}
+_WebDBer_persistence = new WeakMap(), _WebDBer_queue = new WeakMap(), _WebDBer_pendingTables = new WeakMap(), _WebDBer_connected = new WeakMap(), _WebDBer_instances = new WeakSet(), _WebDBer_enqueue = function _WebDBer_enqueue(batch) {
+    const persistence = __classPrivateFieldGet(this, _WebDBer_persistence, "f");
+    __classPrivateFieldGet(this, _WebDBer_queue, "f").enqueue(() => persistence.write(batch));
+}, _WebDBer_takePendingTables = function _WebDBer_takePendingTables() {
+    const tables = [...__classPrivateFieldGet(this, _WebDBer_pendingTables, "f")].filter(([name]) => this.hasTable(name));
+    __classPrivateFieldGet(this, _WebDBer_pendingTables, "f").clear();
+    return tables.map(([name, dupsort]) => ({ name, dupsort }));
+}, _WebDBer_carryPendingTables = function _WebDBer_carryPendingTables() {
+    const tables = __classPrivateFieldGet(this, _WebDBer_instances, "m", _WebDBer_takePendingTables).call(this);
+    if (tables.length > 0)
+        __classPrivateFieldGet(this, _WebDBer_instances, "m", _WebDBer_enqueue).call(this, { tables, puts: [], deletes: [] });
+};
+/** A `StoreOpener` of `WebDBer`s bound to one queue, which is what makes a composition one commit order. */
+export class WebStoreOpener {
+    constructor(persistenceFor) {
+        Object.defineProperty(this, "persistenceFor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: persistenceFor
+        });
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new PersistenceQueue()
+        });
+    }
+    create(family, identity) {
+        return new WebDBer(identity, this.persistenceFor(family, identity), this.queue);
+    }
+}

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

@@ -155,7 +155,7 @@ export class Broker {
             if (!scan) {
                 const start = encode(`${typ}.`), ceiling = encode(`${typ}/`);
                 let tail;
-                for (const key of this.escrowdb.sdb.getKeys({ start: ceiling, end: start, reverse: true, limit: 1 })) {
+                for (const key of this.db.scanKeys(this.escrowdb.sdb, { start: ceiling, end: start, reverse: true, limit: 1 })) {
                     tail = key.slice();
                 }
                 if (!tail)
@@ -164,7 +164,7 @@ export class Broker {
                 this.retryScans.set(typ, scan);
             }
             const rows = [];
-            for (const key of this.escrowdb.sdb.getKeys({ start: scan.start, end: scan.end, limit: maxRows })) {
+            for (const key of this.db.scanKeys(this.escrowdb.sdb, { start: scan.start, end: scan.end, limit: maxRows })) {
                 rows.push(key.slice());
             }
             for (const key of rows) {

package/esm/keri/npm/src/db/exchange/exchange-nests.js

@@ -3,7 +3,7 @@ import { b, collectPayload, concatBytes, Counter, nestedPayload, parseBytes, t,
 import { suffix, unsuffix } from "../core/keys.js";
 /** Read one physical row and close the LMDB key cursor before any caller suspension. */
 function nextRow(db, table, said, ordinal) {
-    for (const key of table.sdb.getKeys({ start: suffix(b(said), ordinal) })) {
+    for (const key of db.scanKeys(table.sdb, { start: suffix(b(said), ordinal) })) {
         const [owner, index] = unsuffix(key);
         if (t(owner) !== said)
             return null;
@@ -16,8 +16,9 @@ function nextRow(db, table, said, ordinal) {
 }
 /** Test row presence without hydrating a potentially large wire value. */
 export function hasNests(db, said, ordinal = 0) {
-    for (const key of db.enst.sdb.getKeys({ start: suffix(b(said), ordinal) }))
+    for (const key of db.scanKeys(db.enst.sdb, { start: suffix(b(said), ordinal) })) {
         return t(unsuffix(key)[0]) === said;
+    }
     return false;
 }
 /** Serialize resident children before the caller enters its synchronous evidence writer. */

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

@@ -2,7 +2,7 @@ import { Cipher, MtrDex, NumberPrimitive, Prefixer, Salter, Signer, Verfer, } fr
 import { DatabaseNotOpenError, DatabaseOperationError } from "../core/errors.js";
 import { consoleLogger } from "../core/logger.js";
 import { RawRecord } from "../core/records.js";
-import { LMDBer } from "./core/lmdber.js";
+import { StoreOwner } from "./core/store-owner.js";
 import { Komer } from "./koming.js";
 import { CatCesrIoSetSuber, CesrSuber, CryptSignerSuber, Suber } from "./subing.js";
 /**
@@ -101,14 +101,9 @@ function reencryptSalt(salt, encrypter, decrypter) {
  *   named handles
  * - compatibility mode supports KERIpy `.keri/ks` layout visibility
  */
-export class Keeper {
-    constructor(options = {}) {
-        Object.defineProperty(this, "lmdber", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+export class Keeper extends StoreOwner {
+    constructor(store, logger = consoleLogger) {
+        super(store);
         Object.defineProperty(this, "logger", {
             enumerable: true,
             configurable: true,
@@ -192,42 +187,7 @@ export class Keeper {
             writable: true,
             value: void 0
         });
-        this.logger = options.logger ?? consoleLogger;
-        const compat = options.compat ?? false;
-        this.lmdber = new LMDBer(options, {
-            tailDirPath: Keeper.TailDirPath,
-            cleanTailDirPath: "keri/clean/ks",
-            altTailDirPath: compat
-                ? Keeper.CompatAltTailDirPath
-                : Keeper.AltTailDirPath,
-            altCleanTailDirPath: compat ? ".keri/clean/ks" : ".tufa/clean/ks",
-            tempPrefix: Keeper.TempPrefix,
-            maxNamedDBs: Keeper.MaxNamedDBs,
-        });
-    }
-    /** Expose the resolved keeper database name delegated from the root LMDBer. */
-    get name() {
-        return this.lmdber.name;
-    }
-    /** Expose the resolved keeper base prefix delegated from the root LMDBer. */
-    get base() {
-        return this.lmdber.base;
-    }
-    /** Report whether the keeper LMDB environment and named subdb surface are open. */
-    get opened() {
-        return this.lmdber.opened;
-    }
-    /** Report whether the keeper environment is opened in read-only mode. */
-    get readonly() {
-        return this.lmdber.readonly;
-    }
-    /** Report whether this keeper uses a temporary backing directory. */
-    get temp() {
-        return this.lmdber.temp;
-    }
-    /** Expose the resolved filesystem path for the keeper environment, when open. */
-    get path() {
-        return this.lmdber.path;
+        this.logger = logger;
     }
     /**
      * Reopen the keeper environment and bind the KERIpy-style named subdbs.
@@ -238,7 +198,7 @@ export class Keeper {
      * flows have not yet exercised it deeply.
      */
     *reopen(options = {}) {
-        const opened = yield* this.lmdber.reopen(options);
+        const opened = yield* this.store.reopen(options);
         if (!opened)
             return false;
         try {
@@ -246,62 +206,62 @@ export class Keeper {
             // `aeid` anchors the encrypter/decrypter used to protect salts and
             // private keys, while `pidx`, `algo`, `salt`, and `tier` capture the
             // default root key-management settings.
-            this.gbls = new Suber(this.lmdber, { subkey: "gbls." });
+            this.gbls = new Suber(this.store, { subkey: "gbls." });
             // Public-key to private-key secret material store.
             // Keys are fully qualified public keys and values are the corresponding
             // fully qualified private keys.
-            this.pris = new CryptSignerSuber(this.lmdber, { subkey: "pris." });
+            this.pris = new CryptSignerSuber(this.store, { subkey: "pris." });
             // Group signing member tuples for one multisig prefix.
             // The stored tuple shape mirrors KERIpy's `(Prefixer, Number)` member
             // identifier set used by GroupSignifyHab flows.
-            this.smids = new CatCesrIoSetSuber(this.lmdber, {
+            this.smids = new CatCesrIoSetSuber(this.store, {
                 subkey: "smids.",
                 ctor: [Prefixer, NumberPrimitive],
             });
             // Group rotating member tuples for one multisig prefix.
             // The stored tuple shape mirrors KERIpy's `(Prefixer, Number)` member
             // identifier set used by GroupSignifyHab flows.
-            this.rmids = new CatCesrIoSetSuber(this.lmdber, {
+            this.rmids = new CatCesrIoSetSuber(this.store, {
                 subkey: "rmids.",
                 ctor: [Prefixer, NumberPrimitive],
             });
             // Prefix index keyed by the first public key in a key sequence.
             // Values are the identifier prefix, or the first public key for
             // temporary prefixes, matching the KERIpy keeper index contract.
-            this.pres = new CesrSuber(this.lmdber, {
+            this.pres = new CesrSuber(this.store, {
                 subkey: "pres.",
                 ctor: Prefixer,
             });
             // Root derivation parameters for one managed identifier prefix.
-            this.prms = new Komer(this.lmdber, {
+            this.prms = new Komer(this.store, {
                 subkey: "prms.",
                 recordClass: PrePrm,
             });
             // Old/current/next key situation for one managed identifier prefix.
-            this.sits = new Komer(this.lmdber, {
+            this.sits = new Komer(this.store, {
                 subkey: "sits.",
                 recordClass: PreSit,
             });
             // Replayable public-key sets keyed by `(prefix, ridx)`.
             // This enables lookup of the current signing keys after each rotation so
             // establishment events can be replayed in order.
-            this.pubs = new Komer(this.lmdber, {
+            this.pubs = new Komer(this.store, {
                 subkey: "pubs.",
                 recordClass: PubSet,
             });
             // Encrypted next private keys used by group-signify keeper flows.
             // KERIpy notes these are not yet broadly exercised outside that path.
-            this.prxs = new CesrSuber(this.lmdber, {
+            this.prxs = new CesrSuber(this.store, {
                 subkey: "prxs.",
                 ctor: Cipher,
             });
             // Encrypted next-key commitments used by group-signify keeper flows.
             // KERIpy notes these are not yet broadly exercised outside that path.
-            this.nxts = new CesrSuber(this.lmdber, {
+            this.nxts = new CesrSuber(this.store, {
                 subkey: "nxts.",
                 ctor: Cipher,
             });
-            this.rroots = new CesrSuber(this.lmdber, { subkey: "rroots.", ctor: Cipher });
+            this.rroots = new CesrSuber(this.store, { subkey: "rroots.", ctor: Cipher });
             return true;
         }
         catch (error) {
@@ -311,7 +271,7 @@ export class Keeper {
     }
     /** Close the underlying keeper LMDB environment. */
     *close(clear = false) {
-        return yield* this.lmdber.close(clear);
+        return yield* this.store.close(clear);
     }
     /**
      * Read one keeper-global string value from `gbls.`.
@@ -337,13 +297,12 @@ export class Keeper {
     changeEncryption({ currentAeid, aeid, encrypter, decrypter }) {
         if (this.readonly)
             throw new DatabaseOperationError("Cannot change encryption in a read-only keeper");
-        const env = this.lmdber.env;
-        if (!env)
+        if (!this.store.opened)
             throw new DatabaseNotOpenError("Keeper environment is not open");
-        if (this.lmdber.inWriteTransaction) {
+        if (this.store.inWriteTransaction) {
             throw new DatabaseOperationError("Keeper encryption change must own its write transaction");
         }
-        env.transactionSync(() => {
+        this.store.transaction(() => {
             const storedAeid = this.getGbls("aeid");
             if ((storedAeid ?? "") !== currentAeid) {
                 throw new DatabaseOperationError("Keeper AEID changed before encryption migration; reopen the manager");
@@ -388,13 +347,12 @@ export class Keeper {
     retainRegistryRoot(keys, root, currentAeid, encrypter, decrypter) {
         if (this.readonly)
             throw new DatabaseOperationError("Cannot retain registry roots in a read-only keeper");
-        const env = this.lmdber.env;
-        if (!env)
+        if (!this.store.opened)
             throw new DatabaseNotOpenError("Keeper environment is not open");
-        if (this.lmdber.inWriteTransaction) {
+        if (this.store.inWriteTransaction) {
             throw new DatabaseOperationError("Registry root retention must own its write transaction");
         }
-        return env.transactionSync(() => {
+        return this.store.transaction(() => {
             if (this.getGbls("aeid") !== currentAeid) {
                 throw new DatabaseOperationError("Keeper AEID changed before registry root retention; reopen the manager");
             }
@@ -520,29 +478,12 @@ export class Keeper {
         return this.rmids.get(pre);
     }
 }
-Object.defineProperty(Keeper, "TailDirPath", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: "keri/ks"
-});
-Object.defineProperty(Keeper, "AltTailDirPath", {
+/** Placement of this store kind. */
+Object.defineProperty(Keeper, "Family", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: ".tufa/ks"
-});
-Object.defineProperty(Keeper, "CompatAltTailDirPath", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: ".keri/ks"
-});
-Object.defineProperty(Keeper, "TempPrefix", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: "keri_ks_"
+    value: { tail: "ks", maxTables: 24 }
 });
 Object.defineProperty(Keeper, "MaxNamedDBs", {
     enumerable: true,
@@ -550,38 +491,3 @@ Object.defineProperty(Keeper, "MaxNamedDBs", {
     writable: true,
     value: 24
 });
-/** Constructor-safe async factory for a fully reopened `Keeper`. */
-export function* createKeeper(options = {}) {
-    const keeper = new Keeper(options);
-    let delivered = false;
-    let failure;
-    try {
-        const opened = yield* keeper.reopen(options);
-        if (!opened) {
-            throw new DatabaseNotOpenError("Failed to open Keeper");
-        }
-        delivered = true;
-        return keeper;
-    }
-    catch (error) {
-        failure = { error };
-        throw error;
-    }
-    finally {
-        if (!delivered) {
-            try {
-                yield* keeper.close();
-            }
-            catch (error) {
-                if (failure) {
-                    // deno-lint-ignore no-unsafe-finally -- Preserve the operation failure alongside shutdown failure.
-                    throw new AggregateError([failure.error, error], "Database acquisition and close failed", {
-                        cause: failure.error,
-                    });
-                }
-                // deno-lint-ignore no-unsafe-finally -- A shutdown failure must propagate.
-                throw error;
-            }
-        }
-    }
-}

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

@@ -88,7 +88,7 @@ export class KomerBase {
             value: void 0
         });
         this.db = db;
-        this.sdb = this.db.openDB(subkey, dupsort);
+        this.sdb = this.db.openTable(subkey, { dupsort });
         this.sep = sep;
         this.kind = assertKomerKind(kind);
         this.recordClass = recordClass;

package/esm/keri/npm/src/db/lmdb-stores.js

@@ -0,0 +1,68 @@
+/**
+ * LMDB-backed construction of the domain stores.
+ *
+ * These helpers bind each `StoreOwner` to an `LMDBer` at its established paths.
+ * Everything here reaches the native addon; backend-neutral callers use the
+ * store classes with an injected `DBer` instead.
+ */
+import { RegBaser } from "../acdc/regbasing.js";
+import { adoptRegistry } from "../acdc/registering.js";
+import { ValidationError } from "../core/errors.js";
+import { Baser } from "./basing.js";
+import { lmdbDefaultsFor } from "./core/lmdb-opener.js";
+import { LMDBer } from "./core/lmdber.js";
+import { openOwner } from "./core/store-owner.js";
+import { Keeper } from "./keeping.js";
+import { Mailboxer } from "./mailbox/mailboxing.js";
+import { Noter } from "./noting.js";
+import { Reger } from "./reger.js";
+/** Construct a closed LMDB-backed `Baser` at its established paths. */
+export function lmdbBaser({ compat, ...options } = {}) {
+    return new Baser(new LMDBer(options, lmdbDefaultsFor(Baser.Family, compat)), options.logger);
+}
+/** Constructor-safe async factory for a fully reopened `Baser`. */
+export function* createBaser(options = {}) {
+    return yield* openOwner(lmdbBaser(options), "Baser", options);
+}
+/** Construct a closed LMDB-backed `Keeper` at its established paths. */
+export function lmdbKeeper({ compat, ...options } = {}) {
+    return new Keeper(new LMDBer(options, lmdbDefaultsFor(Keeper.Family, compat)), options.logger);
+}
+/** Constructor-safe async factory for a fully reopened `Keeper`. */
+export function* createKeeper(options = {}) {
+    return yield* openOwner(lmdbKeeper(options), "Keeper", options);
+}
+/** Construct a closed LMDB-backed `Noter` at its established paths. */
+export function lmdbNoter({ compat, ...options } = {}) {
+    return new Noter(new LMDBer(options, lmdbDefaultsFor(Noter.Family, compat)));
+}
+/** Open a notification sidecar and return the ready-to-use databaser. */
+export function* createNoter(options = {}) {
+    return yield* openOwner(lmdbNoter(options), "Noter", options);
+}
+/** Construct a closed LMDB-backed `Mailboxer` at its established paths. */
+export function lmdbMailboxer({ compat, ...options } = {}) {
+    return new Mailboxer(new LMDBer(options, lmdbDefaultsFor(Mailboxer.Family, compat)));
+}
+/**
+ * Open a mailbox environment and return the ready-to-use databaser.
+ *
+ * Compatibility rule:
+ * - explicit mailbox opens stay strict
+ * - missing additive sidecars are tolerated only by higher-level habery open
+ *   flows that are inspecting compat stores readonly
+ */
+export function* createMailboxer(options = {}) {
+    return yield* openOwner(lmdbMailboxer(options), "Mailboxer", options);
+}
+/** Transfer a ready `Reger` to its caller, closing unreturned acquisitions on failure or cancellation. */
+export function* createReger({ compat, ...options } = {}) {
+    const store = new LMDBer(options, lmdbDefaultsFor(Reger.Family, compat));
+    return yield* openOwner(new Reger(store), "Reger", options);
+}
+/** Open a registry store on LMDB at its established paths; the reference web backend remains unsupported. */
+export function* openLmdbRegistry({ web = false, reopen = true, compat, opener: _opener, ...options } = {}) {
+    if (web)
+        throw new ValidationError("web registry backend is not yet supported by V2 Regery");
+    return yield* adoptRegistry(new RegBaser(new LMDBer(options, lmdbDefaultsFor(RegBaser.Family, compat))), reopen);
+}

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

@@ -0,0 +1,6 @@
+/** LMDB backend surface: native stores, paths and the default opener. */
+export { createHabery } from "../app/identity/lmdb-habery.js";
+export * from "./core/lmdb-opener.js";
+export * from "./core/lmdber.js";
+export * from "./core/path-manager.js";
+export * from "./lmdb-stores.js";