@aztec/kv-store 0.0.1-commit.b6e433891 → 0.0.1-commit.b9865e97

package/dest/sqlite-opfs/internal/ordered-binary-browser.js

@@ -0,0 +1,448 @@
+/* eslint-disable */ /**
+ * Vendored from `ordered-binary@1.5.3/index.js` with one targeted edit:
+ * the `readString` definition (originally a dynamically-generated
+ * unrolled-loop function) is replaced with a hand-written interpreted
+ * equivalent that does the same work without code-generation-from-strings.
+ *
+ * Why vendor: upstream has no CSP-safe build, and the codegen is a
+ * module-init-time string-passed-to-evaluator that trips MV3 CSP
+ * (`script-src 'self' 'wasm-unsafe-eval'`). The codegen is a perf
+ * optimization on the string-decoding path only — the interpreted
+ * version is functionally identical, just slower per call.
+ *
+ * Parity with upstream is enforced by `ordered-binary-browser.test.ts`,
+ * which compares byte-exact output for a representative key set on every
+ * Node-mode test run. If `ordered-binary` is bumped, re-vendor by
+ * recopying upstream and reapplying the patch in the section marked
+ * `// CSP PATCH BEGIN` ... `// CSP PATCH END`.
+ */ /*
+control character types:
+1 - metadata
+2 - symbols
+6 - false
+7 - true
+8- 16 - negative doubles
+16-24 positive doubles
+27 - String starts with a character 27 or less or is an empty string
+0 - multipart separator
+> 27 normal string characters
+*/ /*
+ * Convert arbitrary scalar values to buffer bytes with type preservation and type-appropriate ordering
+ */ const float64Array = new Float64Array(2);
+const int32Array = new Int32Array(float64Array.buffer, 0, 4);
+let nullTerminate = false;
+let textEncoder;
+try {
+    textEncoder = new TextEncoder();
+} catch (error) {}
+/*
+ * Convert arbitrary scalar values to buffer bytes with type preservation and type-appropriate ordering
+ */ export function writeKey(key, target, position, inSequence) {
+    let targetView = target.dataView;
+    if (!targetView) {
+        targetView = target.dataView = new DataView(target.buffer, target.byteOffset, target.byteLength + 3 >> 2 << 2);
+    }
+    switch(typeof key){
+        case 'string':
+            let strLength = key.length;
+            let c1 = key.charCodeAt(0);
+            if (!(c1 >= 28)) {
+                // escape character
+                target[position++] = 27;
+            }
+            if (strLength < 0x40) {
+                let i, c2;
+                for(i = 0; i < strLength; i++){
+                    c1 = key.charCodeAt(i);
+                    if (c1 <= 4) {
+                        target[position++] = 4;
+                        target[position++] = c1;
+                    } else if (c1 < 0x80) {
+                        target[position++] = c1;
+                    } else if (c1 < 0x800) {
+                        target[position++] = c1 >> 6 | 0xc0;
+                        target[position++] = c1 & 0x3f | 0x80;
+                    } else if ((c1 & 0xfc00) === 0xd800 && ((c2 = key.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
+                        c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
+                        i++;
+                        target[position++] = c1 >> 18 | 0xf0;
+                        target[position++] = c1 >> 12 & 0x3f | 0x80;
+                        target[position++] = c1 >> 6 & 0x3f | 0x80;
+                        target[position++] = c1 & 0x3f | 0x80;
+                    } else {
+                        target[position++] = c1 >> 12 | 0xe0;
+                        target[position++] = c1 >> 6 & 0x3f | 0x80;
+                        target[position++] = c1 & 0x3f | 0x80;
+                    }
+                }
+            } else {
+                if (target.utf8Write) {
+                    position += target.utf8Write(key, position, target.byteLength - position);
+                } else {
+                    position += textEncoder.encodeInto(key, target.subarray(position)).written;
+                }
+                if (position > target.length - 4) {
+                    throw new RangeError('String does not fit in target buffer');
+                }
+            }
+            break;
+        case 'number':
+            float64Array[0] = key;
+            let lowInt = int32Array[0];
+            let highInt = int32Array[1];
+            let length;
+            if (key < 0) {
+                targetView.setInt32(position + 4, ~(lowInt >>> 4 | highInt << 28));
+                targetView.setInt32(position + 0, (highInt ^ 0x7fffffff) >>> 4);
+                targetView.setInt32(position + 8, (lowInt & 0xf ^ 0xf) << 4, true); // just always do the null termination here
+                return position + 9;
+            } else if (lowInt & 0xf || inSequence) {
+                length = 9;
+            } else if (lowInt & 0xfffff) {
+                length = 8;
+            } else if (lowInt || highInt & 0xf) {
+                length = 6;
+            } else {
+                length = 4;
+            }
+            // switching order to go to little endian
+            targetView.setInt32(position + 0, highInt >>> 4 | 0x10000000);
+            targetView.setInt32(position + 4, lowInt >>> 4 | highInt << 28);
+            // if (length == 9 || nullTerminate)
+            targetView.setInt32(position + 8, (lowInt & 0xf) << 4, true);
+            return position + length;
+        case 'object':
+            if (key) {
+                if (Array.isArray(key)) {
+                    for(let i = 0, l = key.length; i < l; i++){
+                        if (i > 0) {
+                            target[position++] = 0;
+                        }
+                        position = writeKey(key[i], target, position, true);
+                    }
+                    break;
+                } else if (key instanceof Uint8Array) {
+                    target.set(key, position);
+                    position += key.length;
+                    break;
+                } else {
+                    throw new Error('Unable to serialize object as a key: ' + JSON.stringify(key));
+                }
+            } else {
+                target[position++] = 0;
+            }
+            break;
+        case 'boolean':
+            targetView.setUint32(position++, key ? 7 : 6, true);
+            return position;
+        case 'bigint':
+            let asFloat = Number(key);
+            if (BigInt(asFloat) > key) {
+                float64Array[0] = asFloat;
+                if (asFloat > 0) {
+                    if (int32Array[0]) {
+                        int32Array[0]--;
+                    } else {
+                        int32Array[1]--;
+                        int32Array[0] = 0xffffffff;
+                    }
+                } else {
+                    if (int32Array[0] < 0xffffffff) {
+                        int32Array[0]++;
+                    } else {
+                        int32Array[1]++;
+                        int32Array[0] = 0;
+                    }
+                }
+                asFloat = float64Array[0];
+            }
+            let difference = key - BigInt(asFloat);
+            if (difference === 0n) {
+                return writeKey(asFloat, target, position, inSequence);
+            }
+            writeKey(asFloat, target, position, inSequence);
+            position += 9; // always increment by 9 if we are adding fractional bits
+            let exponent = BigInt((int32Array[1] >> 20 & 0x7ff) - 1079);
+            let nextByte = difference >> exponent;
+            target[position - 1] |= Number(nextByte);
+            difference -= nextByte << exponent;
+            let first = true;
+            while(difference || first){
+                first = false;
+                exponent -= 7n;
+                let nextByte = difference >> exponent;
+                target[position++] = Number(nextByte) | 0x80;
+                difference -= nextByte << exponent;
+            }
+            return position;
+        case 'undefined':
+            return position;
+        // undefined is interpreted as the absence of a key, signified by zero length
+        case 'symbol':
+            target[position++] = 2;
+            return writeKey(key.description, target, position, inSequence);
+        default:
+            throw new Error('Can not serialize key of type ' + typeof key);
+    }
+    if (nullTerminate && !inSequence) {
+        targetView.setUint32(position, 0);
+    }
+    return position;
+}
+let position;
+export function readKey(buffer, start, end, inSequence) {
+    position = start;
+    let controlByte = buffer[position];
+    let value;
+    if (controlByte < 24) {
+        if (controlByte < 8) {
+            position++;
+            if (controlByte == 6) {
+                value = false;
+            } else if (controlByte == 7) {
+                value = true;
+            } else if (controlByte == 0) {
+                value = null;
+            } else if (controlByte == 2) {
+                value = Symbol.for(readStringSafely(buffer, end));
+            } else {
+                return Uint8Array.prototype.slice.call(buffer, start, end);
+            }
+        } else {
+            let dataView;
+            try {
+                dataView = buffer.dataView || (buffer.dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength + 3 >> 2 << 2));
+            } catch (error) {
+                // if it is write at the end of the ArrayBuffer, we may need to retry with the exact remaining bytes
+                dataView = buffer.dataView || (buffer.dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.buffer.byteLength - buffer.byteOffset));
+            }
+            let highInt = dataView.getInt32(position) << 4;
+            let size = end - position;
+            let lowInt;
+            if (size > 4) {
+                lowInt = dataView.getInt32(position + 4);
+                highInt |= lowInt >>> 28;
+                if (size <= 6) {
+                    // clear the last bits
+                    lowInt &= -0x10000;
+                }
+                lowInt = lowInt << 4;
+                if (size > 8) {
+                    lowInt = lowInt | buffer[position + 8] >> 4;
+                }
+            } else {
+                lowInt = 0;
+            }
+            if (controlByte < 16) {
+                // negative gets negated
+                highInt = highInt ^ 0x7fffffff;
+                lowInt = ~lowInt;
+            }
+            int32Array[1] = highInt;
+            int32Array[0] = lowInt;
+            value = float64Array[0];
+            position += 9;
+            if (size > 9 && buffer[position] > 0) {
+                // convert the float to bigint, and then we will add precision as we enumerate through the
+                // extra bytes
+                value = BigInt(value);
+                let exponent = highInt >> 20 & 0x7ff;
+                let next_byte = buffer[position - 1] & 0xf;
+                value += BigInt(next_byte) << BigInt(exponent - 1079);
+                while((next_byte = buffer[position]) > 0 && position++ < end){
+                    value += BigInt(next_byte & 0x7f) << BigInt((start - position) * 7 + exponent - 1016);
+                }
+            }
+        }
+    } else {
+        if (controlByte == 27) {
+            position++;
+        }
+        value = readStringSafely(buffer, end);
+    }
+    while(position < end){
+        if (buffer[position] === 0) {
+            position++;
+        }
+        if (inSequence) {
+            encoder.position = position;
+            return value;
+        }
+        let nextValue = readKey(buffer, position, end, true);
+        if (value instanceof Array) {
+            value.push(nextValue);
+        } else {
+            value = [
+                value,
+                nextValue
+            ];
+        }
+    }
+    return value;
+}
+export const enableNullTermination = ()=>nullTerminate = true;
+export const encoder = {
+    writeKey,
+    readKey,
+    enableNullTermination
+};
+let targetBuffer = [];
+let targetPosition = 0;
+const hasNodeBuffer = typeof Buffer !== 'undefined';
+const ByteArrayAllocate = hasNodeBuffer ? Buffer.allocUnsafeSlow : Uint8Array;
+export const toBufferKey = (key)=>{
+    let newBuffer;
+    if (targetPosition + 100 > targetBuffer.length) {
+        targetBuffer = new ByteArrayAllocate(8192);
+        targetPosition = 0;
+        newBuffer = true;
+    }
+    try {
+        let result = targetBuffer.slice(targetPosition, targetPosition = writeKey(key, targetBuffer, targetPosition));
+        if (targetPosition > targetBuffer.length) {
+            if (newBuffer) {
+                throw new Error('Key is too large');
+            }
+            return toBufferKey(key);
+        }
+        return result;
+    } catch (error) {
+        if (newBuffer) {
+            throw error;
+        }
+        targetPosition = targetBuffer.length;
+        return toBufferKey(key);
+    }
+};
+export const fromBufferKey = (sourceBuffer)=>{
+    return readKey(sourceBuffer, 0, sourceBuffer.length);
+};
+const fromCharCode = String.fromCharCode;
+let pendingSurrogate;
+function finishUtf8(byte1, src) {
+    if ((byte1 & 0xe0) === 0xc0) {
+        // 2 bytes
+        const byte2 = src[position++] & 0x3f;
+        return (byte1 & 0x1f) << 6 | byte2;
+    } else if ((byte1 & 0xf0) === 0xe0) {
+        // 3 bytes
+        const byte2 = src[position++] & 0x3f;
+        const byte3 = src[position++] & 0x3f;
+        return (byte1 & 0x1f) << 12 | byte2 << 6 | byte3;
+    } else if ((byte1 & 0xf8) === 0xf0) {
+        // 4 bytes
+        if (pendingSurrogate) {
+            byte1 = pendingSurrogate;
+            pendingSurrogate = null;
+            position += 3;
+            return byte1;
+        }
+        const byte2 = src[position++] & 0x3f;
+        const byte3 = src[position++] & 0x3f;
+        const byte4 = src[position++] & 0x3f;
+        let unit = (byte1 & 0x07) << 0x12 | byte2 << 0x0c | byte3 << 0x06 | byte4;
+        if (unit > 0xffff) {
+            pendingSurrogate = 0xdc00 | unit & 0x3ff;
+            unit = unit - 0x10000 >>> 10 & 0x3ff | 0xd800;
+            position -= 4; // reset so we can return the next part of the surrogate pair
+        }
+        return unit;
+    } else {
+        return byte1;
+    }
+}
+// CSP PATCH BEGIN — replaces upstream's module-init dynamic-codegen with
+// an interpreted equivalent. The original `makeStringBuilder()` produces
+// a function string that unrolls 0x30 iterations of the loop below for
+// perf; this version does the same work as a real loop, slower per call
+// but CSP-safe (no module-init code generation from strings).
+const readString = function makeReadString() {
+    function readStr(source) {
+        const codes = [];
+        while(codes.length < 0x30){
+            let v = source[position++];
+            if (v > 4) {
+                if (v >= 0x80) {
+                    v = finishUtf8(v, source);
+                }
+            } else if (v === 4) {
+                v = source[position++];
+            } else {
+                return fromCharCode.apply(null, codes);
+            }
+            codes.push(v);
+        }
+        return fromCharCode.apply(null, codes) + readStr(source);
+    }
+    return readStr;
+}();
+// CSP PATCH END
+function readStringSafely(source, end) {
+    if (source[end] > 0) {
+        let previous = source[end];
+        try {
+            // read string expects a null terminator, that is a 0 or undefined from reading past the end of the buffer, so we
+            // have to ensure that, but do so safely, restoring the buffer to its original state
+            source[end] = 0;
+            return readString(source);
+        } finally{
+            source[end] = previous;
+        }
+    } else {
+        return readString(source);
+    }
+}
+export function compareKeys(a, b) {
+    // compare with type consistency that matches binary comparison
+    if (typeof a == 'object') {
+        if (!a) {
+            return b == null ? 0 : -1;
+        }
+        if (a.compare) {
+            if (b == null) {
+                return 1;
+            } else if (b.compare) {
+                return a.compare(b);
+            } else {
+                return -1;
+            }
+        }
+        let arrayComparison;
+        if (b instanceof Array) {
+            let i = 0;
+            while((arrayComparison = compareKeys(a[i], b[i])) == 0 && i <= a.length){
+                i++;
+            }
+            return arrayComparison;
+        }
+        arrayComparison = compareKeys(a[0], b);
+        if (arrayComparison == 0 && a.length > 1) {
+            return 1;
+        }
+        return arrayComparison;
+    } else if (typeof a == typeof b) {
+        if (typeof a === 'symbol') {
+            a = Symbol.keyFor(a);
+            b = Symbol.keyFor(b);
+        }
+        return a < b ? -1 : a === b ? 0 : 1;
+    } else if (typeof b == 'object') {
+        if (b instanceof Array) {
+            return -compareKeys(b, a);
+        }
+        return 1;
+    } else {
+        return typeOrder[typeof a] < typeOrder[typeof b] ? -1 : 1;
+    }
+}
+const typeOrder = {
+    symbol: 0,
+    undefined: 1,
+    boolean: 2,
+    number: 3,
+    string: 4
+};
+export const MINIMUM_KEY = null;
+export const MAXIMUM_KEY = new Uint8Array([
+    0xff
+]);

package/dest/sqlite-opfs/map.d.ts

@@ -0,0 +1,35 @@
+import { Encoder } from '#msgpackr';
+import { Buffer } from 'buffer';
+import type { Key, Range, Value } from '../interfaces/common.js';
+import type { AztecAsyncMap } from '../interfaces/map.js';
+import type { SqlValue } from './messages.js';
+import type { AztecSQLiteOPFSStore } from './store.js';
+/** A map backed by SQLite in OPFS. Mirrors `IndexedDBAztecMap`. */
+export declare class SQLiteOPFSAztecMap<K extends Key, V extends Value> implements AztecAsyncMap<K, V> {
+    protected readonly store: AztecSQLiteOPFSStore;
+    protected readonly name: string;
+    protected readonly container: string;
+    protected readonly encoder: Encoder;
+    constructor(store: AztecSQLiteOPFSStore, mapName: string);
+    getAsync(key: K): Promise<V | undefined>;
+    hasAsync(key: K): Promise<boolean>;
+    sizeAsync(): Promise<number>;
+    set(key: K, val: V): Promise<void>;
+    setMany(entries: {
+        key: K;
+        value: V;
+    }[]): Promise<void>;
+    swap(_key: K, _fn: (val: V | undefined) => V): Promise<void>;
+    setIfNotExists(key: K, val: V): Promise<boolean>;
+    delete(key: K): Promise<void>;
+    entriesAsync(range?: Range<K>): AsyncIterableIterator<[K, V]>;
+    valuesAsync(range?: Range<K>): AsyncIterableIterator<V>;
+    keysAsync(range?: Range<K>): AsyncIterableIterator<K>;
+    protected rangeQuery(range: Range<K>): Promise<Array<[string, Uint8Array, Uint8Array | null]>>;
+    protected decodeValue(val: SqlValue): V;
+    protected decodeKey(raw: Uint8Array): K;
+    protected encodedKey(key: K): Buffer;
+    protected normalizeKey(key: K): (string | number | Uint8Array)[];
+    protected slot(key: K, index?: number): string;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/sqlite-opfs/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,mEAAmE;AACnE,qBAAa,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,KAAK,CAAE,YAAW,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC;IAM1F,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,oBAAoB;IALhD,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IACrC,SAAS,CAAC,QAAQ,CAAC,OAAO,UAAiB;IAE3C,YACqB,KAAK,EAAE,oBAAoB,EAC9C,OAAO,EAAE,MAAM,EAIhB;IAEK,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAO7C;IAEK,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAGvC;IAEK,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAGjC;IAEK,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAMvC;IAEK,OAAO,CAAC,OAAO,EAAE;QAAE,GAAG,EAAE,CAAC,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAS5D;IAED,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3D;IAEK,cAAc,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAQrD;IAEK,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAElC;IAEM,YAAY,CAAC,KAAK,GAAE,KAAK,CAAC,CAAC,CAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CASvE;IAEM,WAAW,CAAC,KAAK,GAAE,KAAK,CAAC,CAAC,CAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAIjE;IAEM,SAAS,CAAC,KAAK,GAAE,KAAK,CAAC,CAAC,CAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAI/D;IAED,UAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,CAuBnG;IAED,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,CAAC,CAatC;IAED,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,CAAC,CAMtC;IAED,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM,CAEnC;IAED,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC,EAAE,CAE/D;IAED,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,CAEhD;CACF"}

package/dest/sqlite-opfs/map.js

@@ -0,0 +1,163 @@
+import { Encoder } from '#msgpackr';
+import { fromBufferKey, toBufferKey } from '#ordered-binary';
+import { Buffer } from 'buffer';
+import { hash } from 'ohash';
+/** A map backed by SQLite in OPFS. Mirrors `IndexedDBAztecMap`. */ export class SQLiteOPFSAztecMap {
+    store;
+    name;
+    container;
+    encoder;
+    constructor(store, mapName){
+        this.store = store;
+        this.encoder = new Encoder();
+        this.name = mapName;
+        this.container = `map:${mapName}`;
+    }
+    async getAsync(key) {
+        const rows = await this.store.allAsync('SELECT value FROM data WHERE slot = ? LIMIT 1', [
+            this.slot(key)
+        ]);
+        if (rows.length === 0) {
+            return undefined;
+        }
+        const raw = rows[0][0];
+        return raw == null ? undefined : this.decodeValue(raw);
+    }
+    async hasAsync(key) {
+        const rows = await this.store.allAsync('SELECT 1 FROM data WHERE slot = ? LIMIT 1', [
+            this.slot(key)
+        ]);
+        return rows.length > 0;
+    }
+    async sizeAsync() {
+        const rows = await this.store.allAsync('SELECT COUNT(*) FROM data WHERE container = ?', [
+            this.container
+        ]);
+        return Number(rows[0]?.[0] ?? 0);
+    }
+    async set(key, val) {
+        await this.store.runAsync(`INSERT OR REPLACE INTO data (slot, container, key, key_count, hash, value)
+       VALUES (?, ?, ?, ?, ?, ?)`, [
+            this.slot(key),
+            this.container,
+            this.encodedKey(key),
+            1,
+            hash(val),
+            this.encoder.pack(val)
+        ]);
+    }
+    async setMany(entries) {
+        if (entries.length === 0) {
+            return;
+        }
+        await this.store.transactionAsync(async ()=>{
+            for (const { key, value } of entries){
+                await this.set(key, value);
+            }
+        });
+    }
+    swap(_key, _fn) {
+        throw new Error('Not implemented');
+    }
+    async setIfNotExists(key, val) {
+        return await this.store.transactionAsync(async ()=>{
+            if (await this.hasAsync(key)) {
+                return false;
+            }
+            await this.set(key, val);
+            return true;
+        });
+    }
+    async delete(key) {
+        await this.store.runAsync('DELETE FROM data WHERE slot = ?', [
+            this.slot(key)
+        ]);
+    }
+    async *entriesAsync(range = {}) {
+        const rows = await this.rangeQuery(range);
+        for (const row of rows){
+            const [_slot, keyBlob, value] = row;
+            if (keyBlob == null || value == null) {
+                continue;
+            }
+            yield [
+                this.decodeKey(keyBlob),
+                this.decodeValue(value)
+            ];
+        }
+    }
+    async *valuesAsync(range = {}) {
+        for await (const [, value] of this.entriesAsync(range)){
+            yield value;
+        }
+    }
+    async *keysAsync(range = {}) {
+        for await (const [key] of this.entriesAsync(range)){
+            yield key;
+        }
+    }
+    async rangeQuery(range) {
+        // Inclusivity flips with direction to match the IndexedDB backend:
+        //   forward: [start, end)     reverse: (start, end]
+        // That asymmetry is load-bearing — tests pin the exact inclusivity at boundaries.
+        const reverse = !!range.reverse;
+        const parts = [
+            'container = ?'
+        ];
+        const bind = [
+            this.container
+        ];
+        if (range.start !== undefined) {
+            parts.push(reverse ? 'key > ?' : 'key >= ?');
+            bind.push(this.encodedKey(range.start));
+        }
+        if (range.end !== undefined) {
+            parts.push(reverse ? 'key <= ?' : 'key < ?');
+            bind.push(this.encodedKey(range.end));
+        }
+        const order = reverse ? 'DESC' : 'ASC';
+        let sql = `SELECT slot, key, value FROM data WHERE ${parts.join(' AND ')} ORDER BY key ${order}, key_count ${order}`;
+        if (range.limit !== undefined) {
+            sql += ' LIMIT ?';
+            bind.push(range.limit);
+        }
+        const rows = await this.store.allAsync(sql, bind);
+        return rows.map((r)=>[
+                String(r[0]),
+                r[1],
+                r[2]
+            ]);
+    }
+    decodeValue(val) {
+        if (!(val instanceof Uint8Array)) {
+            return val;
+        }
+        const unpacked = this.encoder.unpack(val);
+        // msgpackr returns plain Uint8Array in browsers for packed Buffers. Callers that
+        // stored Buffers (walletDB uses Buffer.from(...).toString('utf8') round-trips)
+        // rely on Buffer-flavored behavior — re-wrap at the storage boundary, mirroring
+        // IndexedDBAztecMap.restoreBuffers.
+        if (unpacked instanceof Uint8Array && !Buffer.isBuffer(unpacked)) {
+            return Buffer.from(unpacked);
+        }
+        return unpacked;
+    }
+    decodeKey(raw) {
+        const parsed = fromBufferKey(Buffer.from(raw));
+        if (Array.isArray(parsed)) {
+            return parsed.length > 1 ? parsed : parsed[0];
+        }
+        return parsed;
+    }
+    encodedKey(key) {
+        return toBufferKey(this.normalizeKey(key));
+    }
+    normalizeKey(key) {
+        return Array.isArray(key) ? key : [
+            key
+        ];
+    }
+    slot(key, index = 0) {
+        return `map:${this.name}:slot:${this.normalizeKey(key)}:${index}`;
+    }
+}