keri-ts 0.10.0 → 0.10.2

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

@@ -0,0 +1,436 @@
+import { decode as decodeMsgpack, encode as encodeMsgpack } from "@msgpack/msgpack";
+import { b, decodeKeriCbor, encodeKeriCbor, Kinds, t } from "cesr-ts";
+function assertKomerKind(kind) {
+    if (kind !== Kinds.json
+        && kind !== Kinds.cbor
+        && kind !== Kinds.mgpk) {
+        throw new Error(`Unsupported Komer serialization kind=${String(kind)}. Expected JSON, CBOR, or MGPK.`);
+    }
+    return kind;
+}
+function toUint8Array(bytes) {
+    return bytes instanceof Uint8Array
+        && Object.getPrototypeOf(bytes) === Uint8Array.prototype
+        ? bytes
+        : new Uint8Array(bytes);
+}
+function asIterable(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (Symbol.iterator in Object(value)
+        && typeof value !== "string"
+        && !(value instanceof Uint8Array)) {
+        return [...value];
+    }
+    return [value];
+}
+/**
+ * Shared keyspace/object-mapper substrate for `Komer` variants.
+ *
+ * Responsibilities:
+ * - open one named LMDB subdb and manage its key separator policy
+ * - convert tuple-like keyspace paths to/from stored LMDB keys
+ * - select JSON/CBOR/MGPK serializer functions for one record payload shape
+ * - hydrate stored payloads through one record class and serialize them back
+ * - expose KERIpy-style branch iteration and trim helpers used by subclasses
+ *
+ * KERIpy correspondence:
+ * - mirrors `keri.db.koming.KomerBase`
+ *
+ * Current `keri-ts` differences:
+ * - callers may still write either a record instance or constructor-input
+ *   shape, but the public model is the record class rather than arbitrary
+ *   hydrator/normalizer hooks
+ */
+export class KomerBase {
+    constructor(db, { subkey, sep = KomerBase.Sep, kind = Kinds.json, dupsort = false, recordClass, }) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sdb", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "recordClass", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_ser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_des", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.db = db;
+        this.sdb = this.db.openDB(subkey, dupsort);
+        this.sep = sep;
+        this.kind = assertKomerKind(kind);
+        this.recordClass = recordClass;
+        this._ser = this._serializer(this.kind);
+        this._des = this._deserializer(this.kind);
+    }
+    /**
+     * Converts a key path to one LMDB key, optionally forcing a trailing
+     * separator for top-branch scans.
+     */
+    _tokey(keys, topive = false) {
+        if (typeof keys === "string") {
+            return b(keys);
+        }
+        if (keys instanceof Uint8Array) {
+            return keys;
+        }
+        const parts = [...keys].map((part) => typeof part === "string" ? part : t(part));
+        if (topive && parts.at(-1) !== "") {
+            parts.push("");
+        }
+        return b(parts.join(this.sep));
+    }
+    /** Converts one LMDB key back into its separator-delimited key path. */
+    _tokeys(key) {
+        return t(key).split(this.sep);
+    }
+    /** Materialize one caller-supplied value into the canonical record class. */
+    coerceRecord(val) {
+        return val instanceof this.recordClass
+            ? val
+            : this.recordClass.fromDict(val);
+    }
+    /** Project one normalized record into its persisted object representation. */
+    toStoredValue(val) {
+        return this.coerceRecord(val).asDict();
+    }
+    /** Rebuild one caller-facing record from a decoded stored object. */
+    fromStoredValue(val) {
+        return this.recordClass.fromDict(val);
+    }
+    /** Returns the serializer function for the requested storage encoding kind. */
+    _serializer(kind) {
+        switch (assertKomerKind(kind)) {
+            case Kinds.mgpk:
+                return this.serializeMGPK.bind(this);
+            case Kinds.cbor:
+                return this.serializeCBOR.bind(this);
+            case Kinds.json:
+                return this.serializeJSON.bind(this);
+        }
+    }
+    /** Returns the deserializer function for the requested storage encoding kind. */
+    _deserializer(kind) {
+        switch (assertKomerKind(kind)) {
+            case Kinds.mgpk:
+                return this.deserializeMGPK.bind(this);
+            case Kinds.cbor:
+                return this.deserializeCBOR.bind(this);
+            case Kinds.json:
+                return this.deserializeJSON.bind(this);
+        }
+    }
+    /** Encode one logical record as UTF-8 JSON bytes. */
+    serializeJSON(val) {
+        return b(JSON.stringify(this.toStoredValue(val)));
+    }
+    /** Encode one logical record as MGPK/MessagePack bytes. */
+    serializeMGPK(val) {
+        return toUint8Array(encodeMsgpack(this.toStoredValue(val)));
+    }
+    /** Encode one logical record as KERI-compatible CBOR bytes. */
+    serializeCBOR(val) {
+        return encodeKeriCbor(this.toStoredValue(val));
+    }
+    /** Decode one JSON byte payload into the logical record type. */
+    deserializeJSON(val) {
+        if (val === null) {
+            return null;
+        }
+        return this.fromStoredValue(JSON.parse(t(val)));
+    }
+    /** Decode one MGPK/MessagePack payload into the logical record type. */
+    deserializeMGPK(val) {
+        if (val === null) {
+            return null;
+        }
+        return this.fromStoredValue(decodeMsgpack(val));
+    }
+    /** Decode one KERI-compatible CBOR payload into the logical record type. */
+    deserializeCBOR(val) {
+        if (val === null) {
+            return null;
+        }
+        return this.fromStoredValue(decodeKeriCbor(val));
+    }
+    /**
+     * Removes every entry whose key starts with the provided branch prefix.
+     *
+     * This mirrors KERIpy `trim`, including the `topive` flag for forcing a
+     * branch separator when the caller passes a partial key path.
+     */
+    trim(keys = "", { topive = false } = {}) {
+        return this.db.delTop(this.sdb, this._tokey(keys, topive));
+    }
+    /** Convenience alias matching the KERIpy API surface. */
+    remTop(keys = "", { topive = false } = {}) {
+        return this.trim(keys, { topive });
+    }
+    /**
+     * Iterates decoded records for one top-branch keyspace prefix.
+     *
+     * Subclasses that add hidden ordinal suffixes or other key/value transforms
+     * should override this method and strip those hidden storage details.
+     */
+    *getTopItemIter(keys = "", { topive = false } = {}) {
+        for (const [key, val] of this.db.getTopItemIter(this.sdb, this._tokey(keys, topive))) {
+            const record = this._des(val);
+            if (record === null) {
+                continue;
+            }
+            yield [this._tokeys(key), record];
+        }
+    }
+    /**
+     * Returns full stored items for debugging or testing.
+     *
+     * This is currently identical to `getTopItemIter()` because the single-value
+     * `Komer` path has no hidden suffixes or value proems yet.
+     */
+    *getFullItemIter(keys = "", { topive = false } = {}) {
+        yield* this.getTopItemIter(keys, { topive });
+    }
+}
+Object.defineProperty(KomerBase, "Sep", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "."
+});
+/**
+ * Single-record keyspace/object mapper for one value per effective key.
+ *
+ * Responsibilities:
+ * - expose the KERIpy `Komer` CRUD/count API for non-duplicate subdbs
+ * - keep the active `Baser` and `Keeper` JSON-backed records on the KERIpy
+ *   object-mapper path rather than raw LMDB access
+ *
+ * KERIpy correspondence:
+ * - mirrors `keri.db.koming.Komer`
+ *
+ * Current `keri-ts` differences:
+ * - JSON remains the live-store default even though CBOR and MGPK are available
+ * - callers may write constructor-input shapes directly, but reads always
+ *   return hydrated record instances
+ */
+export class Komer extends KomerBase {
+    constructor(db, { subkey, sep = KomerBase.Sep, kind = Kinds.json, ...options }) {
+        super(db, { subkey, sep, kind, dupsort: false, ...options });
+    }
+    /** Insert one record value at its effective key if absent. */
+    put(keys, val) {
+        return this.db.putVal(this.sdb, this._tokey(keys), this._ser(val));
+    }
+    /** Upsert one record value at its effective key. */
+    pin(keys, val) {
+        return this.db.setVal(this.sdb, this._tokey(keys), this._ser(val));
+    }
+    /** Read one record value by its effective key. */
+    get(keys) {
+        return this._des(this.db.getVal(this.sdb, this._tokey(keys)));
+    }
+    /**
+     * Return the plain stored-object shape for one record.
+     *
+     * This mirrors KERIpy `getDict` for persisted record shapes even when reads
+     * normally hydrate into richer record instances.
+     */
+    getDict(keys) {
+        const val = this.get(keys);
+        if (val === null) {
+            return null;
+        }
+        return val.asDict();
+    }
+    /** Remove one record value by its effective key. */
+    rem(keys) {
+        return this.db.delVal(this.sdb, this._tokey(keys));
+    }
+    /** Count all stored records in this `Komer` subdb. */
+    cnt() {
+        return this.db.cntAll(this.sdb);
+    }
+    /** Alias matching the normalized KERIpy counting surface. */
+    cntAll() {
+        return this.cnt();
+    }
+}
+/**
+ * Insertion-ordered set mapper for record payloads (`IoSetKomer`).
+ *
+ * KERIpy correspondence:
+ * - mirrors `keri.db.koming.IoSetKomer`
+ */
+export class IoSetKomer extends KomerBase {
+    constructor(db, { subkey, sep = KomerBase.Sep, kind = Kinds.json, ...options }) {
+        super(db, { subkey, sep, kind, dupsort: false, ...options });
+    }
+    /**
+     * Insert an insertion-ordered set of records for one effective key if absent.
+     *
+     * Each logical member becomes its own physical key through the `IoSet*`
+     * storage model; duplicate values are deduplicated by the underlying LMDB
+     * helper family.
+     */
+    put(keys, vals = null) {
+        return this.db.putIoSetVals(this.sdb, this._tokey(keys), asIterable(vals).map((val) => this._ser(val)), b(this.sep));
+    }
+    /** Upsert an insertion-ordered set of records for one effective key. */
+    pin(keys, vals = null) {
+        return this.db.pinIoSetVals(this.sdb, this._tokey(keys), asIterable(vals).map((val) => this._ser(val)), b(this.sep));
+    }
+    /** Append one record member to the insertion-ordered set for an effective key. */
+    add(keys, val) {
+        return this.db.addIoSetVal(this.sdb, this._tokey(keys), this._ser(val), b(this.sep));
+    }
+    /** Read all logical members for one effective key in insertion order. */
+    get(keys, { ion = 0 } = {}) {
+        const out = [];
+        for (const [, val] of this.db.getIoSetItemIter(this.sdb, this._tokey(keys), ion, b(this.sep))) {
+            const record = this._des(val);
+            if (record !== null) {
+                out.push(record);
+            }
+        }
+        return out;
+    }
+    /** Read the last logical member for one effective key. */
+    getLast(keys) {
+        const item = this.db.getIoSetLastItem(this.sdb, this._tokey(keys), b(this.sep));
+        if (item === null) {
+            return null;
+        }
+        return this._des(item[1]);
+    }
+    /** Iterate logical members for one effective key in insertion order. */
+    *getIter(keys) {
+        for (const [, val] of this.db.getIoSetItemIter(this.sdb, this._tokey(keys), 0, b(this.sep))) {
+            const record = this._des(val);
+            if (record !== null) {
+                yield record;
+            }
+        }
+    }
+    /** Remove one member, or all members when `val` is `null`, for an effective key. */
+    rem(keys, val = null) {
+        return this.db.remIoSetVal(this.sdb, this._tokey(keys), val === null ? null : this._ser(val), b(this.sep));
+    }
+    /** Count stored members for one effective key or the whole subdb. */
+    cnt(keys = "", { ion = 0 } = {}) {
+        if ((typeof keys === "string" && keys.length === 0)
+            || (keys instanceof Uint8Array && keys.length === 0)) {
+            return this.db.cntAll(this.sdb);
+        }
+        return this.db.cntIoSet(this.sdb, this._tokey(keys), ion, b(this.sep));
+    }
+    /** Iterate branch members while hiding the synthetic insertion-order suffix. */
+    *getTopItemIter(keys = "", { topive = false } = {}) {
+        for (const [key, val] of this.db.getTopIoSetItemIter(this.sdb, this._tokey(keys, topive), b(this.sep))) {
+            const record = this._des(val);
+            if (record !== null) {
+                yield [this._tokeys(key), record];
+            }
+        }
+    }
+}
+/**
+ * Native duplicate-key object mapper (`DupKomer`).
+ *
+ * KERIpy correspondence:
+ * - mirrors `keri.db.koming.DupKomer`
+ *
+ * Ordering rule:
+ * - duplicates are kept in LMDB duplicate-sort order, not insertion order
+ * - values must remain under LMDB's dupsort value-size limits
+ */
+export class DupKomer extends KomerBase {
+    constructor(db, { subkey, sep = KomerBase.Sep, kind = Kinds.json, ...options }) {
+        super(db, { subkey, sep, kind, dupsort: true, ...options });
+    }
+    /** Insert duplicate members at one effective key without overwriting existing values. */
+    put(keys, vals = null) {
+        return this.db.putVals(this.sdb, this._tokey(keys), asIterable(vals).map((val) => this._ser(val)));
+    }
+    /** Add one duplicate member if that exact stored value is absent. */
+    add(keys, val) {
+        return this.db.addVal(this.sdb, this._tokey(keys), this._ser(val));
+    }
+    /** Replace the full duplicate set for one effective key. */
+    pin(keys, vals = null) {
+        const key = this._tokey(keys);
+        this.db.delVals(this.sdb, key);
+        return this.db.putVals(this.sdb, key, asIterable(vals).map((val) => this._ser(val)));
+    }
+    /** Read all duplicate members for one effective key. */
+    get(keys) {
+        const out = [];
+        for (const val of this.db.getValsIter(this.sdb, this._tokey(keys))) {
+            const record = this._des(val);
+            if (record !== null) {
+                out.push(record);
+            }
+        }
+        return out;
+    }
+    /** Read the lexicographically last duplicate member for one effective key. */
+    getLast(keys) {
+        return this._des(this.db.getValLast(this.sdb, this._tokey(keys)));
+    }
+    /** Iterate duplicate members at one effective key in LMDB duplicate order. */
+    *getIter(keys) {
+        for (const val of this.db.getValsIter(this.sdb, this._tokey(keys))) {
+            const record = this._des(val);
+            if (record !== null) {
+                yield record;
+            }
+        }
+    }
+    /** Count duplicate members at one effective key or across the whole subdb. */
+    cnt(keys = "") {
+        if ((typeof keys === "string" && keys.length === 0)
+            || (keys instanceof Uint8Array && keys.length === 0)) {
+            return this.db.cntAll(this.sdb);
+        }
+        return this.db.cntVals(this.sdb, this._tokey(keys));
+    }
+    /** Remove one duplicate member, or the entire duplicate set when `val` is `null`. */
+    rem(keys, val = null) {
+        const key = this._tokey(keys);
+        if (val === null) {
+            return this.db.delVals(this.sdb, key);
+        }
+        return this.db.delVal(this.sdb, key, this._ser(val));
+    }
+}

package/esm/keri/npm/src/db/mailbox-inbox.js

@@ -0,0 +1,206 @@
+import { Diger } from "cesr-ts";
+import { Buffer } from "node:buffer";
+import { RawRecord } from "../core/records.js";
+import { Komer } from "./koming.js";
+/** Transport policy failure; corrupt durable state and database failures remain invariant errors. */
+export class MailboxAdmissionError extends Error {
+    constructor(kind, message) {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kind
+        });
+        this.name = "MailboxAdmissionError";
+    }
+}
+/** Persisted consumer inbox row, distinct from provider-side mailbox storage. */
+class MailboxInboxRecord extends RawRecord {
+}
+export const DEFAULT_MAILBOX_INBOX_LIMITS = Object.freeze({
+    maxRecordBytes: 4 * 1024 * 1024,
+    maxBatchBytes: 16 * 1024 * 1024,
+    maxBatchRecords: 256,
+    maxRetainedBytes: 64 * 1024 * 1024,
+    maxRetainedRecords: 4096,
+});
+/** Atomic transport admission, retained replay and explicit consumer disposition in one Baser env. */
+export class MailboxInbox {
+    constructor(db, tops) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: db
+        });
+        Object.defineProperty(this, "tops", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tops
+        });
+        Object.defineProperty(this, "rows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.rows = new Komer(db, { subkey: "mbin.", recordClass: MailboxInboxRecord });
+    }
+    /** Snapshot retained pending records; deadletters require explicit inspection/disposition. */
+    pending(options = {}) {
+        return this.readRows().filter(([, row]) => row.state === "pending" && (!options.pre || row.pre === options.pre) && (!options.eid || row.eid === options.eid)
+            && (!options.topics || options.topics.has(row.topic)) && !options.exclude?.has(row.id)).sort(([, a], [, b]) => a.pre.localeCompare(b.pre) || a.eid.localeCompare(b.eid) || a.topic.localeCompare(b.topic) || a.idx - b.idx).map(([, row]) => ({
+            delivery: this.identity(row),
+            msg: this.decode(row),
+        }));
+    }
+    /** Admit exact source bytes and tops together; failed admission leaves both unchanged. */
+    admit(pre, eid, messages, limits = DEFAULT_MAILBOX_INBOX_LIMITS) {
+        for (const value of Object.values(limits)) {
+            if (!Number.isSafeInteger(value) || value < 1) {
+                throw new MailboxAdmissionError("invalid-input", "Invalid mailbox inbox limit");
+            }
+        }
+        if (!/^[A-Za-z0-9_-]+$/.test(pre) || !/^[A-Za-z0-9_-]+$/.test(eid) || pre.length > 512 || eid.length > 512) {
+            throw new MailboxAdmissionError("invalid-input", "Invalid mailbox source");
+        }
+        if (messages.length > limits.maxBatchRecords) {
+            throw new MailboxAdmissionError("capacity", "Mailbox batch record limit");
+        }
+        let batchBytes = 0;
+        const prepared = messages.map(({ topic, idx, msg }) => {
+            if (!topic || topic.length > 256 || !Number.isSafeInteger(idx) || idx < 0) {
+                throw new MailboxAdmissionError("invalid-input", "Invalid mailbox ordinal/topic");
+            }
+            if (msg.length > limits.maxRecordBytes)
+                throw new MailboxAdmissionError("capacity", "Mailbox record byte limit");
+            batchBytes += msg.length;
+            if (batchBytes > limits.maxBatchBytes)
+                throw new MailboxAdmissionError("capacity", "Mailbox batch byte limit");
+            const id = new Diger({
+                code: "E",
+                raw: Diger.digest(new TextEncoder().encode(JSON.stringify([pre, eid, topic, idx])), "E"),
+            }).qb64;
+            return {
+                version: 1,
+                id,
+                pre,
+                eid,
+                topic,
+                idx,
+                digest: new Diger({ code: "E", raw: Diger.digest(msg, "E") }).qb64,
+                payload: Buffer.from(msg).toString("base64"),
+                size: msg.length,
+                receivedAt: new Date().toISOString(),
+                state: "pending",
+            };
+        });
+        if (!this.db.env)
+            throw new Error("Mailbox inbox database closed");
+        return this.db.env.transactionSync(() => {
+            const existingRows = this.readRows();
+            let count = existingRows.length, bytes = existingRows.reduce((n, [, row]) => n + row.size, 0);
+            const topics = { ...(this.tops.get([pre, eid])?.topics ?? {}) };
+            const admitted = [];
+            for (const row of prepared) {
+                const prior = this.rows.get([row.id]);
+                if (prior) {
+                    this.validate(prior, row.id);
+                    if (prior.digest !== row.digest || prior.payload !== row.payload) {
+                        throw new MailboxAdmissionError("conflict", "Conflicting mailbox source bytes");
+                    }
+                    admitted.push(this.identity(prior));
+                    continue;
+                }
+                if (row.idx !== (Object.hasOwn(topics, row.topic) ? topics[row.topic] : -1) + 1) {
+                    throw new MailboxAdmissionError("gap", "Mailbox ordinal is disposed, reordered or leaves a gap");
+                }
+                if (++count > limits.maxRetainedRecords || (bytes += row.size) > limits.maxRetainedBytes) {
+                    throw new MailboxAdmissionError("capacity", "Mailbox retained inbox capacity");
+                }
+                this.rows.put([row.id], row);
+                Object.defineProperty(topics, row.topic, {
+                    value: row.idx,
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                });
+                admitted.push(this.identity(row));
+            }
+            this.tops.pin([pre, eid], { topics });
+            return admitted;
+        });
+    }
+    /** Explicit durable consumer transfer deletes bytes; poison records remain bounded deadletters. */
+    dispose(delivery, disposition) {
+        if (!disposition.reason || disposition.reason.length > 256
+            || !["acknowledged", "deadletter"].includes(disposition.kind))
+            throw new Error("Explicit mailbox disposition required");
+        if (!this.db.env)
+            throw new Error("Mailbox inbox database closed");
+        this.db.env.transactionSync(() => {
+            const row = this.rows.get([delivery.id]);
+            if (row) {
+                this.validate(row, delivery.id);
+                this.decode(row);
+            }
+            if (!row || JSON.stringify(this.identity(row)) !== JSON.stringify(this.identity(delivery))) {
+                throw new Error("Mailbox delivery identity mismatch");
+            }
+            if (disposition.kind === "acknowledged")
+                this.rows.rem([delivery.id]);
+            else
+                this.rows.pin([delivery.id], { ...row.asDict(), state: "deadletter", reason: disposition.reason });
+        });
+    }
+    /** Inspect retained metadata including deadletters without inferring application completion. */
+    retained() {
+        return this.readRows().map(([, row]) => {
+            this.decode(row);
+            return row;
+        });
+    }
+    readRows() {
+        return [...this.rows.getTopItemIter()].map(([keys, row]) => {
+            this.validate(row, keys[0]);
+            return [keys, row];
+        });
+    }
+    validate(row, id) {
+        if (row.version !== 1 || !["pending", "deadletter"].includes(row.state)
+            || !Number.isSafeInteger(row.size) || row.size < 0
+            || typeof row.payload !== "string" || row.payload.length % 4 !== 0
+            || !/^[A-Za-z0-9+/]*={0,2}$/.test(row.payload)
+            || row.payload.length / 4 * 3 - (row.payload.endsWith("==") ? 2 : row.payload.endsWith("=") ? 1 : 0) !== row.size
+            || typeof row.pre !== "string" || !/^[A-Za-z0-9_-]+$/.test(row.pre) || row.pre.length > 512
+            || typeof row.eid !== "string" || !/^[A-Za-z0-9_-]+$/.test(row.eid) || row.eid.length > 512
+            || typeof row.topic !== "string" || !row.topic || row.topic.length > 256
+            || !Number.isSafeInteger(row.idx) || row.idx < 0
+            || typeof row.digest !== "string" || typeof row.receivedAt !== "string" || row.receivedAt.length > 64
+            || !Number.isFinite(Date.parse(row.receivedAt))
+            || (row.state === "deadletter" && (typeof row.reason !== "string" || !row.reason || row.reason.length > 256))) {
+            throw new Error("Invalid or unsupported mailbox inbox record");
+        }
+        const expected = new Diger({
+            code: "E",
+            raw: Diger.digest(new TextEncoder().encode(JSON.stringify([row.pre, row.eid, row.topic, row.idx])), "E"),
+        }).qb64;
+        if (row.id !== id || row.id !== expected)
+            throw new Error("Mailbox inbox source identity corruption");
+        const digest = new Diger({ qb64: row.digest });
+        if (digest.code !== "E" || digest.qb64 !== row.digest)
+            throw new Error("Invalid mailbox inbox digest");
+    }
+    decode(row) {
+        const bytes = new Uint8Array(Buffer.from(row.payload, "base64"));
+        if (Buffer.from(bytes).toString("base64") !== row.payload || !new Diger({ qb64: row.digest }).verify(bytes)) {
+            throw new Error("Mailbox inbox payload corruption");
+        }
+        return bytes;
+    }
+    identity(row) {
+        return { id: row.id, pre: row.pre, eid: row.eid, topic: row.topic, idx: row.idx, digest: row.digest };
+    }
+}