keri-ts 2.0.1 → 2.2.0

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

@@ -0,0 +1,532 @@
+/**
+ * In-memory `DBer` backend: one bytewise-sorted row array per table.
+ *
+ * ADR-0015 owns the semantics and `LMDBer` is the reference where the ADR is
+ * silent. Nothing here may reach `lmdb`, `node:` or the `Deno` global.
+ *
+ * Invariants:
+ * - each table's `rows` stay sorted by key, then by value on a dupsort table;
+ * - stored rows are immutable and every byte array entering or leaving is a
+ *   fresh copy, so callers can neither reach nor alias store state;
+ * - every mutation runs inside `transaction` and logs its exact inverse.
+ */
+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 __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 _MemStore_instances, _MemStore_name, _MemStore_base, _MemStore_temp, _MemStore_opened, _MemStore_created, _MemStore_tables, _MemStore_version, _MemStore_writeVersion, _MemStore_undo, _MemStore_depth, _MemStore_discard, _MemStore_walk, _MemStore_resolve, _MemStore_logRow, _MemStore_insert, _MemStore_removeAt, _MemStore_removeRange;
+import { b, bytesHex, t } from "cesr-ts";
+import { compareBytes, startsWith } from "../../core/bytes.js";
+import { DatabaseKeyError, DatabaseNotOpenError, DatabaseOperationError } from "../../core/errors.js";
+import { BaseDBer, MAX_KEY_BYTES } from "./dber.js";
+const DEFAULT_DB_VERSION = "1.0.0";
+const EMPTY = new Uint8Array(0);
+/** Copy into a plain `Uint8Array`; `slice` on a Node `Buffer` would alias its source. */
+function copyBytes(bytes) {
+    return new Uint8Array(bytes);
+}
+function assertWritableKey(key) {
+    if (key.length === 0 || key.length > MAX_KEY_BYTES) {
+        throw new DatabaseKeyError(`Key is empty, too big, or wrong size: ${key.length} bytes`);
+    }
+}
+function assertDupValueSize(val) {
+    if (val.length === 0 || val.length > MAX_KEY_BYTES) {
+        throw new DatabaseKeyError(`Duplicate value is empty or larger than ${MAX_KEY_BYTES} bytes: ${val.length} bytes`);
+    }
+}
+/** Point reads and deletes reject an empty key; an over-long key can only be absent. */
+function isStorableKey(key) {
+    if (key.length === 0)
+        throw new DatabaseKeyError("Key is empty, too big, or wrong size: 0 bytes");
+    return key.length <= MAX_KEY_BYTES;
+}
+function isThenable(value) {
+    return (typeof value === "object" || typeof value === "function") && value !== null
+        && typeof value.then === "function";
+}
+/** One named table. A plain table ignores values when ordering and identifying rows. */
+class MemTable {
+    constructor(name, dupsort, rows = []) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: name
+        });
+        Object.defineProperty(this, "dupsort", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: dupsort
+        });
+        Object.defineProperty(this, "rows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: rows
+        });
+    }
+    /** Binary search for the first row satisfying a predicate monotone in sort order. */
+    seek(isPast) {
+        let low = 0;
+        let high = this.rows.length;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            if (isPast(this.rows[mid])) {
+                high = mid;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+    compare(row, key, value) {
+        const order = compareBytes(row.key, key);
+        return order !== 0 || !this.dupsort || value === undefined ? order : compareBytes(row.value, value);
+    }
+    /** First row not below `(key, value)`; without a value, the key's first duplicate. */
+    lowerBound(key, value) {
+        return this.seek((row) => this.compare(row, key, value) >= 0);
+    }
+    /** First row above `(key, value)`; without a value, the row past every duplicate of the key. */
+    upperBound(key, value) {
+        return this.seek((row) => this.compare(row, key, value) > 0);
+    }
+    /** True when `index` holds exactly `(key, value)`, or `key` when no value is given. */
+    matches(index, key, value) {
+        return index < this.rows.length && this.compare(this.rows[index], key, value) === 0;
+    }
+    /** The `[low, high)` row range whose keys begin with `top`. */
+    branch(top) {
+        return [
+            this.lowerBound(top),
+            this.seek((row) => compareBytes(row.key, top) > 0 && !startsWith(row.key, top)),
+        ];
+    }
+}
+/**
+ * Sorted in-memory store with real commit and rollback.
+ *
+ * Contents belong to the instance. They survive `close` and `reopen` until
+ * `close(true)` or `reopen({ clear: true })`, including on a `temp` store,
+ * which is what `LMDBer` does with its reused temp path. Each reopen rebinds
+ * table handles, so a handle from before it is refused.
+ *
+ * Scans hold a position, not an index: each step re-seeks past the last row
+ * yielded, so a concurrent insert, delete or rollback cannot skip or repeat an
+ * untouched row. A scan inside a writer sees that writer's rows as they change.
+ */
+export class MemStore extends BaseDBer {
+    constructor(options = {}) {
+        super();
+        _MemStore_instances.add(this);
+        _MemStore_name.set(this, void 0);
+        _MemStore_base.set(this, void 0);
+        _MemStore_temp.set(this, void 0);
+        _MemStore_opened.set(this, false);
+        /** True once a writable open has created the contents, like LMDB's data file. */
+        _MemStore_created.set(this, false);
+        _MemStore_tables.set(this, new Map());
+        _MemStore_version.set(this, null);
+        _MemStore_writeVersion.set(this, 0);
+        /** One log for every transaction depth; a savepoint is just an index into it. */
+        _MemStore_undo.set(this, []);
+        _MemStore_depth.set(this, 0);
+        Object.defineProperty(this, "readonly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        __classPrivateFieldSet(this, _MemStore_name, options.name || "main", "f");
+        __classPrivateFieldSet(this, _MemStore_base, options.base || "", "f");
+        __classPrivateFieldSet(this, _MemStore_temp, options.temp ?? false, "f");
+        this.readonly = options.readonly ?? false;
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _MemStore_name, "f");
+    }
+    get base() {
+        return __classPrivateFieldGet(this, _MemStore_base, "f");
+    }
+    get opened() {
+        return __classPrivateFieldGet(this, _MemStore_opened, "f");
+    }
+    get temp() {
+        return __classPrivateFieldGet(this, _MemStore_temp, "f");
+    }
+    get inWriteTransaction() {
+        this.assertOpen();
+        return __classPrivateFieldGet(this, _MemStore_depth, "f") > 0;
+    }
+    /** Counts commits that wrote rows; it keeps counting across reopen of one instance. */
+    get writeVersion() {
+        this.assertOpen();
+        return __classPrivateFieldGet(this, _MemStore_writeVersion, "f");
+    }
+    /** Open or reopen the contents. A readonly open of never-created contents reports `false`. */
+    *reopen(options = {}) {
+        this.readonly = options.readonly ?? this.readonly;
+        __classPrivateFieldSet(this, _MemStore_temp, options.temp ?? __classPrivateFieldGet(this, _MemStore_temp, "f"), "f");
+        if (options.clear) {
+            __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_discard).call(this);
+        }
+        __classPrivateFieldSet(this, _MemStore_opened, false, "f");
+        if (this.readonly && !__classPrivateFieldGet(this, _MemStore_created, "f"))
+            return false;
+        const existed = __classPrivateFieldGet(this, _MemStore_created, "f");
+        __classPrivateFieldSet(this, _MemStore_tables, new Map([...__classPrivateFieldGet(this, _MemStore_tables, "f")].map(([name, table]) => [name, new MemTable(name, table.dupsort, table.rows)])), "f");
+        __classPrivateFieldSet(this, _MemStore_created, true, "f");
+        __classPrivateFieldSet(this, _MemStore_opened, true, "f");
+        if (!this.readonly && (!existed || __classPrivateFieldGet(this, _MemStore_temp, "f"))) {
+            this.setVer(DEFAULT_DB_VERSION);
+        }
+        return true;
+    }
+    /** Close the store, deleting its contents when `clear` is set. Repeating is harmless. */
+    *close(clear = false) {
+        if (clear) {
+            __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_discard).call(this);
+        }
+        __classPrivateFieldSet(this, _MemStore_opened, false, "f");
+        return true;
+    }
+    /**
+     * Bind a table, creating it on a writable store. The flag from creation wins
+     * over a later differing request. An absent table on a readonly store yields
+     * no handle, as `LMDBer` does, so optional bindings can probe `hasTable`.
+     */
+    openTable(name, options = {}) {
+        this.assertOpen();
+        if (!name)
+            throw new DatabaseKeyError("Table name must not be empty");
+        const existing = __classPrivateFieldGet(this, _MemStore_tables, "f").get(name);
+        if (existing)
+            return existing;
+        if (this.readonly)
+            return undefined;
+        const table = new MemTable(name, options.dupsort ?? false);
+        __classPrivateFieldGet(this, _MemStore_tables, "f").set(name, table);
+        if (__classPrivateFieldGet(this, _MemStore_depth, "f") > 0) {
+            __classPrivateFieldGet(this, _MemStore_undo, "f").push({ revert: () => __classPrivateFieldGet(this, _MemStore_tables, "f").delete(name) });
+        }
+        return table;
+    }
+    hasTable(name) {
+        this.assertOpen();
+        if (!name)
+            throw new DatabaseKeyError("Table name must not be empty");
+        return __classPrivateFieldGet(this, _MemStore_tables, "f").has(name);
+    }
+    /**
+     * Run `fn` atomically. Only the outermost commit publishes; a nested
+     * transaction is a savepoint, and any throw restores the state at its start.
+     * A thenable result is a caller-contract error, rolled back like a throw.
+     */
+    transaction(fn) {
+        this.assertOpen();
+        if (this.readonly)
+            throw new DatabaseOperationError(`Store "${__classPrivateFieldGet(this, _MemStore_name, "f")}" is read-only`);
+        const savepoint = __classPrivateFieldGet(this, _MemStore_undo, "f").length;
+        __classPrivateFieldSet(this, _MemStore_depth, __classPrivateFieldGet(this, _MemStore_depth, "f") + 1, "f");
+        try {
+            const result = fn();
+            if (isThenable(result))
+                throw new DatabaseOperationError("Transaction callback must be synchronous");
+            if (__classPrivateFieldGet(this, _MemStore_depth, "f") === 1) {
+                const changes = __classPrivateFieldGet(this, _MemStore_undo, "f").flatMap((entry) => entry.change ? [entry.change] : []);
+                if (changes.length > 0) {
+                    __classPrivateFieldSet(this, _MemStore_writeVersion, __classPrivateFieldGet(this, _MemStore_writeVersion, "f") + 1, "f");
+                    this.committed(changes);
+                }
+                __classPrivateFieldGet(this, _MemStore_undo, "f").length = 0;
+            }
+            return result;
+        }
+        catch (error) {
+            while (__classPrivateFieldGet(this, _MemStore_undo, "f").length > savepoint) {
+                __classPrivateFieldGet(this, _MemStore_undo, "f").pop().revert();
+            }
+            throw error;
+        }
+        finally {
+            __classPrivateFieldSet(this, _MemStore_depth, __classPrivateFieldGet(this, _MemStore_depth, "f") - 1, "f");
+        }
+    }
+    /** Told each outermost commit that wrote rows, in order. Nothing rolled back ever reaches it. */
+    committed(_changes) { }
+    /**
+     * Replace the contents with a persisted snapshot, for a backend that loads
+     * before `reopen`. Rows are copied and sorted here, so a backend's own order
+     * cannot break the sorted-row invariant; a repeated row identity is corrupt.
+     */
+    loadContents(tables, version) {
+        __classPrivateFieldSet(this, _MemStore_tables, new Map(tables.map(({ name, dupsort, rows }) => {
+            const table = new MemTable(name, dupsort, rows.map((row) => ({ key: copyBytes(row.key), value: copyBytes(row.value) })));
+            const order = (a, c) => compareBytes(a.key, c.key) || (dupsort ? compareBytes(a.value, c.value) : 0);
+            table.rows.sort(order);
+            if (table.rows.some((row, index) => index > 0 && order(table.rows[index - 1], row) === 0)) {
+                throw new DatabaseOperationError(`Persisted table "${name}" repeats a row`);
+            }
+            return [name, table];
+        })), "f");
+        __classPrivateFieldSet(this, _MemStore_version, version, "f");
+        __classPrivateFieldSet(this, _MemStore_created, version !== null || tables.length > 0, "f");
+    }
+    *flushed() {
+        this.assertOpen();
+    }
+    /** This backend retains no read view, so an open store has nothing to discard. */
+    refreshRead() {
+        this.assertOpen();
+    }
+    getVer() {
+        this.assertOpen();
+        return __classPrivateFieldGet(this, _MemStore_version, "f") || null;
+    }
+    setVer(val) {
+        this.transaction(() => {
+            const prior = __classPrivateFieldGet(this, _MemStore_version, "f");
+            __classPrivateFieldSet(this, _MemStore_version, t(b(val)), "f");
+            __classPrivateFieldGet(this, _MemStore_undo, "f").push({
+                change: { kind: "version", before: prior, after: __classPrivateFieldGet(this, _MemStore_version, "f") },
+                revert: () => __classPrivateFieldSet(this, _MemStore_version, prior, "f"),
+            });
+        });
+    }
+    *scan(table, options = {}) {
+        for (const row of __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_walk).call(this, table, options, false)) {
+            yield { key: copyBytes(row.key), value: copyBytes(row.value) };
+        }
+    }
+    *scanKeys(table, options = {}) {
+        for (const row of __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_walk).call(this, table, options, true)) {
+            yield copyBytes(row.key);
+        }
+    }
+    assertOpen() {
+        if (!__classPrivateFieldGet(this, _MemStore_opened, "f"))
+            throw new DatabaseNotOpenError(`Store "${__classPrivateFieldGet(this, _MemStore_name, "f")}" is not open`);
+    }
+    putRow(table, key, val) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        this.transaction(() => __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_insert).call(this, mem, key, val));
+    }
+    /** On a dupsort table `val` selects one duplicate; a plain table ignores it, as LMDB does. */
+    removeRow(table, key, val) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        return this.transaction(() => {
+            if (!isStorableKey(key))
+                return false;
+            if (val === undefined || !mem.dupsort)
+                return __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_removeRange).call(this, mem, mem.lowerBound(key), mem.upperBound(key));
+            if (val.length === 0)
+                return false; // an empty duplicate can never be stored
+            assertDupValueSize(val);
+            const index = mem.lowerBound(key, val);
+            if (!mem.matches(index, key, val))
+                return false;
+            __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_removeAt).call(this, mem, index);
+            return true;
+        });
+    }
+    /** Insert only when `key` is absent; on a dupsort table any existing duplicate counts. */
+    putVal(table, key, val) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        return this.transaction(() => {
+            assertWritableKey(key);
+            if (mem.matches(mem.lowerBound(key), key))
+                return false;
+            __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_insert).call(this, mem, key, val);
+            return true;
+        });
+    }
+    /** Overwrite a plain key's value; on a dupsort table this adds a duplicate. */
+    setVal(table, key, val) {
+        this.putRow(table, key, val);
+        return true;
+    }
+    getVal(table, key) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        if (!isStorableKey(key))
+            return null;
+        const index = mem.lowerBound(key);
+        return mem.matches(index, key) ? copyBytes(mem.rows[index].value) : null;
+    }
+    delVal(table, key, val) {
+        return this.removeRow(table, key, val);
+    }
+    cnt(table) {
+        return __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table).rows.length;
+    }
+    cntAll(table) {
+        return this.cnt(table);
+    }
+    cntTop(table, top = EMPTY) {
+        const [low, high] = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table).branch(top);
+        return high - low;
+    }
+    delTop(table, top = EMPTY) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        const [low, high] = mem.branch(top);
+        return high > low && this.transaction(() => __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_removeRange).call(this, mem, low, high));
+    }
+    *getTopItemIter(table, top = EMPTY) {
+        for (const row of __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_walk).call(this, table, { start: top }, false)) {
+            if (!startsWith(row.key, top))
+                return;
+            yield [copyBytes(row.key), copyBytes(row.value)];
+        }
+    }
+    /** Add each value not already present; reports `false` if any supplied value existed. */
+    putVals(table, key, vals) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        const existing = new Set(this.getVals(table, key).map((val) => bytesHex(val)));
+        let result = true;
+        this.transaction(() => {
+            for (const val of vals) {
+                const hex = bytesHex(val);
+                if (existing.has(hex)) {
+                    result = false;
+                    continue;
+                }
+                __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_insert).call(this, mem, key, val);
+                existing.add(hex);
+            }
+        });
+        return result;
+    }
+    addVal(table, key, val) {
+        return this.putVals(table, key, [val]);
+    }
+    /** Duplicate reads treat an empty or over-long key as simply absent, as `LMDBer` does. */
+    getVals(table, key) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        if (key.length === 0 || key.length > MAX_KEY_BYTES)
+            return [];
+        return mem.rows.slice(mem.lowerBound(key), mem.upperBound(key)).map((row) => copyBytes(row.value));
+    }
+    getValLast(table, key) {
+        return this.getVals(table, key).at(-1) ?? null;
+    }
+    *getValsIter(table, key) {
+        yield* this.getVals(table, key);
+    }
+    /** Count duplicates. Like LMDB, a plain table holding `key` refuses this dupsort-only call. */
+    cntVals(table, key) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        if (key.length === 0 || key.length > MAX_KEY_BYTES)
+            return 0;
+        const count = mem.upperBound(key) - mem.lowerBound(key);
+        if (count > 0 && !mem.dupsort)
+            throw new DatabaseOperationError("Duplicate count requires a dupsort table");
+        return count;
+    }
+    delVals(table, key) {
+        return this.removeRow(table, key);
+    }
+    /** First duplicate at `key` not below `start`; `start` is an unvalidated scan-style bound. */
+    seekVal(table, key, start) {
+        const mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        if (key.length === 0 || key.length > MAX_KEY_BYTES)
+            return null;
+        const bound = start?.length ? start : undefined;
+        const index = mem.lowerBound(key, bound);
+        if (!mem.matches(index, key))
+            return null;
+        if (bound !== undefined && !mem.dupsort) {
+            throw new DatabaseOperationError("Duplicate seek requires a dupsort table");
+        }
+        return copyBytes(mem.rows[index].value);
+    }
+}
+_MemStore_name = new WeakMap(), _MemStore_base = new WeakMap(), _MemStore_temp = new WeakMap(), _MemStore_opened = new WeakMap(), _MemStore_created = new WeakMap(), _MemStore_tables = new WeakMap(), _MemStore_version = new WeakMap(), _MemStore_writeVersion = new WeakMap(), _MemStore_undo = new WeakMap(), _MemStore_depth = new WeakMap(), _MemStore_instances = new WeakSet(), _MemStore_discard = function _MemStore_discard() {
+    __classPrivateFieldSet(this, _MemStore_tables, new Map(), "f");
+    __classPrivateFieldSet(this, _MemStore_version, null, "f");
+    __classPrivateFieldSet(this, _MemStore_created, false, "f");
+}, _MemStore_walk = function
+/**
+ * Walk rows in order, re-seeking from the last row after every yield so the
+ * table may change between steps. Empty bounds count as absent and a bound
+ * applies to the whole key, including all of its duplicates.
+ */
+* _MemStore_walk(table, options, distinct) {
+    const reverse = options.reverse ?? false;
+    const start = options.start?.length ? options.start : undefined;
+    const end = options.end?.length ? options.end : undefined;
+    let mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+    let index;
+    if (start === undefined) {
+        index = reverse ? mem.rows.length - 1 : 0;
+    }
+    else if (reverse) {
+        index = (options.exclusiveStart ? mem.lowerBound(start) : mem.upperBound(start)) - 1;
+    }
+    else {
+        index = options.exclusiveStart ? mem.upperBound(start) : mem.lowerBound(start);
+    }
+    for (let count = 0; options.limit === undefined || count < options.limit; count++) {
+        const row = mem.rows[index];
+        if (row === undefined)
+            return;
+        if (end !== undefined && (reverse ? compareBytes(row.key, end) <= 0 : compareBytes(row.key, end) >= 0))
+            return;
+        yield row;
+        mem = __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_resolve).call(this, table);
+        const value = distinct ? undefined : row.value;
+        index = reverse ? mem.lowerBound(row.key, value) - 1 : mem.upperBound(row.key, value);
+    }
+}, _MemStore_resolve = function _MemStore_resolve(table) {
+    this.assertOpen();
+    const mem = table;
+    if (!mem || __classPrivateFieldGet(this, _MemStore_tables, "f").get(mem.name) !== mem) {
+        throw new DatabaseOperationError("Table handle is not valid for this open store");
+    }
+    return mem;
+}, _MemStore_logRow = function _MemStore_logRow(mem, before, after, revert) {
+    const key = (before ?? after).key;
+    const [was, now] = [before?.value ?? null, after?.value ?? null];
+    __classPrivateFieldGet(this, _MemStore_undo, "f").push({
+        change: { kind: "row", table: mem.name, dupsort: mem.dupsort, key, before: was, after: now },
+        revert,
+    });
+}, _MemStore_insert = function _MemStore_insert(mem, key, val) {
+    assertWritableKey(key);
+    if (mem.dupsort) {
+        assertDupValueSize(val);
+    }
+    const index = mem.lowerBound(key, val);
+    const row = { key: copyBytes(key), value: copyBytes(val) };
+    if (!mem.matches(index, key, val)) {
+        mem.rows.splice(index, 0, row);
+        __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_logRow).call(this, mem, null, row, () => mem.rows.splice(index, 1));
+    }
+    else if (!mem.dupsort) {
+        const prior = mem.rows[index];
+        mem.rows[index] = row;
+        __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_logRow).call(this, mem, prior, row, () => mem.rows[index] = prior);
+    }
+}, _MemStore_removeAt = function _MemStore_removeAt(mem, index) {
+    const [row] = mem.rows.splice(index, 1);
+    __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_logRow).call(this, mem, row, null, () => mem.rows.splice(index, 0, row));
+}, _MemStore_removeRange = function _MemStore_removeRange(mem, low, high) {
+    for (let index = high - 1; index >= low; index--) {
+        __classPrivateFieldGet(this, _MemStore_instances, "m", _MemStore_removeAt).call(this, mem, index);
+    }
+    return high > low;
+};
+/** A `StoreOpener` of closed, independent in-memory stores. Place is meaningless here. */
+export class MemStoreOpener {
+    create(_family, identity) {
+        return new MemStore(identity);
+    }
+}