@aztec/kv-store 0.0.1-commit.d1da697d6 → 0.0.1-commit.d20b825a7

package/dest/bench/shared_map_bench.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '../interfaces/store.js';
+/** One benchmark measurement. */
+export type BenchResult = {
+    /** Benchmark name (includes the backend prefix for disambiguation). */
+    name: string;
+    value: number;
+    unit: 'ms' | 'us';
+};
+export type BenchReporter = (results: BenchResult[]) => void | Promise<void>;
+/**
+ * Runs the standard Map benchmark suite against any `AztecAsyncKVStore` backend,
+ * populates `results`, and calls `reporter` in `afterAll`.
+ *
+ * Kept free of Node-only deps (`fs`, `path`) so the same runner works under
+ * vitest-browser for IndexedDB and SQLite-OPFS.
+ */
+export declare function describeAztecMapBench(backendPrefix: string, getStore: () => Promise<AztecAsyncKVStore>, logger: Logger, reporter: BenchReporter): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkX21hcF9iZW5jaC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2JlbmNoL3NoYXJlZF9tYXBfYmVuY2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFLcEQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUVoRSxpQ0FBaUM7QUFDakMsTUFBTSxNQUFNLFdBQVcsR0FBRztJQUN4Qix1RUFBdUU7SUFDdkUsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLEtBQUssRUFBRSxNQUFNLENBQUM7SUFDZCxJQUFJLEVBQUUsSUFBSSxHQUFHLElBQUksQ0FBQztDQUNuQixDQUFDO0FBRUYsTUFBTSxNQUFNLGFBQWEsR0FBRyxDQUFDLE9BQU8sRUFBRSxXQUFXLEVBQUUsS0FBSyxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBRTdFOzs7Ozs7R0FNRztBQUNILHdCQUFnQixxQkFBcUIsQ0FDbkMsYUFBYSxFQUFFLE1BQU0sRUFDckIsUUFBUSxFQUFFLE1BQU0sT0FBTyxDQUFDLGlCQUFpQixDQUFDLEVBQzFDLE1BQU0sRUFBRSxNQUFNLEVBQ2QsUUFBUSxFQUFFLGFBQWEsUUFrRnhCIn0=

package/dest/bench/shared_map_bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared_map_bench.d.ts","sourceRoot":"","sources":["../../src/bench/shared_map_bench.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAKpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,iCAAiC;AACjC,MAAM,MAAM,WAAW,GAAG;IACxB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE7E;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,OAAO,CAAC,iBAAiB,CAAC,EAC1C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,aAAa,QAkFxB"}

package/dest/bench/shared_map_bench.js

@@ -0,0 +1,91 @@
+import { Timer } from '@aztec/foundation/timer';
+/**
+ * Runs the standard Map benchmark suite against any `AztecAsyncKVStore` backend,
+ * populates `results`, and calls `reporter` in `afterAll`.
+ *
+ * Kept free of Node-only deps (`fs`, `path`) so the same runner works under
+ * vitest-browser for IndexedDB and SQLite-OPFS.
+ */ export function describeAztecMapBench(backendPrefix, getStore, logger, reporter) {
+    describe(`${backendPrefix} Map benchmarks`, ()=>{
+        let store;
+        let map;
+        const results = [];
+        const generateKeyValuePairs = (count, offset = 0)=>{
+            const keys = Array.from({
+                length: count
+            }, (_, i)=>`key-${i + offset}`);
+            const values = Array.from({
+                length: count
+            }, (_, i)=>`value-${i + offset}`);
+            return keys.map((key, i)=>({
+                    key,
+                    value: values[i]
+                }));
+        };
+        const record = (name, value, unit)=>{
+            results.push({
+                name: `${backendPrefix}/Map/${name}`,
+                value,
+                unit
+            });
+        };
+        beforeEach(async ()=>{
+            store = await getStore();
+            map = store.openMap('test');
+        });
+        afterEach(async ()=>{
+            await store.delete();
+        });
+        afterAll(async ()=>{
+            const pretty = results.map((r)=>`${r.name}: ${r.value.toFixed(2)} ${r.unit}`).join('\n');
+            logger.info(`\n${pretty}\n`);
+            await reporter(results);
+        });
+        it('adds individual values', async ()=>{
+            const pairs = generateKeyValuePairs(1000);
+            const timer = new Timer();
+            for (const pair of pairs){
+                await map.set(pair.key, pair.value);
+            }
+            record('Individual insertion', timer.ms() / pairs.length, 'ms');
+        });
+        it('adds batched values', async ()=>{
+            const batches = Array.from({
+                length: 100
+            }, (_, i)=>generateKeyValuePairs(1000, i * 1000));
+            const timer = new Timer();
+            for (const batch of batches){
+                await map.setMany(batch);
+            }
+            record(`Batch insertion of ${batches[0].length} items`, timer.ms() / batches.length, 'ms');
+        });
+        it('reads individual values', async ()=>{
+            const pairs = generateKeyValuePairs(10000);
+            await map.setMany(pairs);
+            const timer = new Timer();
+            for (const pair of pairs){
+                await map.getAsync(pair.key);
+            }
+            record('Individual read', timer.ms() * 1000 / pairs.length, 'us');
+        });
+        it('reads via a cursor', async ()=>{
+            const pairs = generateKeyValuePairs(10000);
+            await map.setMany(pairs);
+            const timer = new Timer();
+            for await (const _ of map.entriesAsync()){
+            // consume
+            }
+            record(`Iterator per item read of ${pairs.length} items`, timer.ms() * 1000 / pairs.length, 'us');
+        });
+        it('reads the size of the map', async ()=>{
+            const numIterations = 1000;
+            const pairs = generateKeyValuePairs(10000);
+            await map.setMany(pairs);
+            const timer = new Timer();
+            for(let i = 0; i < numIterations; i++){
+                await map.sizeAsync();
+            }
+            record(`Read size of ${pairs.length} items`, timer.ms() * 1000 / numIterations, 'us');
+        });
+    });
+}

package/dest/lmdb-v2/read_transaction.js

@@ -51,18 +51,19 @@ export class ReadTransaction {
     }
     async *#iterate(db, startKey, endKey, reverse, limit, map) {
         this.assertIsOpen();
-        const response = await this.channel.sendMessage(LMDBMessageType.START_CURSOR, {
-            key: startKey,
-            reverse,
-            count: typeof limit === 'number' ? Math.min(limit, CURSOR_PAGE_SIZE) : CURSOR_PAGE_SIZE,
-            onePage: typeof limit === 'number' && limit < CURSOR_PAGE_SIZE,
-            db
-        });
-        const cursor = response.cursor;
-        let entries = response.entries;
-        let done = typeof cursor !== 'number';
-        let count = 0;
+        let cursor;
         try {
+            const response = await this.channel.sendMessage(LMDBMessageType.START_CURSOR, {
+                key: startKey,
+                reverse,
+                count: typeof limit === 'number' ? Math.min(limit, CURSOR_PAGE_SIZE) : CURSOR_PAGE_SIZE,
+                onePage: typeof limit === 'number' && limit < CURSOR_PAGE_SIZE,
+                db
+            });
+            cursor = response.cursor ?? undefined;
+            let entries = response.entries;
+            let done = typeof cursor !== 'number';
+            let count = 0;
             // emit the first page and any subsequent pages in a while loop
             // NB: end contition is in the middle of the while loop
             while(entries.length > 0){
@@ -106,15 +107,16 @@ export class ReadTransaction {
     }
     async #countEntries(db, startKey, endKey, reverse) {
         this.assertIsOpen();
-        const response = await this.channel.sendMessage(LMDBMessageType.START_CURSOR, {
-            key: startKey,
-            reverse,
-            count: 0,
-            onePage: false,
-            db
-        });
-        const cursor = response.cursor;
+        let cursor;
         try {
+            const response = await this.channel.sendMessage(LMDBMessageType.START_CURSOR, {
+                key: startKey,
+                reverse,
+                count: 0,
+                onePage: false,
+                db
+            });
+            cursor = response.cursor ?? undefined;
             if (!cursor) {
                 return 0;
             }

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

@@ -0,0 +1,21 @@
+import type { AztecAsyncArray } from '../interfaces/array.js';
+import type { Value } from '../interfaces/common.js';
+import type { AztecSQLiteOPFSStore } from './store.js';
+/**
+ * Persistent array backed by SQLite. Entries share a common `key` (the array name)
+ * and are ordered by `key_count`, which doubles as the 1-indexed slot number.
+ */
+export declare class SQLiteOPFSAztecArray<T extends Value> implements AztecAsyncArray<T> {
+    #private;
+    private readonly store;
+    constructor(store: AztecSQLiteOPFSStore, name: string);
+    lengthAsync(): Promise<number>;
+    push(...vals: T[]): Promise<number>;
+    pop(): Promise<T | undefined>;
+    atAsync(index: number): Promise<T | undefined>;
+    setAt(index: number, val: T): Promise<boolean>;
+    entriesAsync(): AsyncIterableIterator<[number, T]>;
+    valuesAsync(): AsyncIterableIterator<T>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUtb3Bmcy9hcnJheS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUV2RDs7O0dBR0c7QUFDSCxxQkFBYSxvQkFBb0IsQ0FBQyxDQUFDLFNBQVMsS0FBSyxDQUFFLFlBQVcsZUFBZSxDQUFDLENBQUMsQ0FBQzs7SUFNNUUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLO0lBRHhCLFlBQ21CLEtBQUssRUFBRSxvQkFBb0IsRUFDNUMsSUFBSSxFQUFFLE1BQU0sRUFJYjtJQUVLLFdBQVcsSUFBSSxPQUFPLENBQUMsTUFBTSxDQUFDLENBTW5DO0lBRUssSUFBSSxDQUFDLEdBQUcsSUFBSSxFQUFFLENBQUMsRUFBRSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FnQnhDO0lBRUssR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLENBWWxDO0lBRUssT0FBTyxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLENBQUMsR0FBRyxTQUFTLENBQUMsQ0FTbkQ7SUFFSyxLQUFLLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FjbkQ7SUFFTSxZQUFZLElBQUkscUJBQXFCLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FZeEQ7SUFFTSxXQUFXLElBQUkscUJBQXFCLENBQUMsQ0FBQyxDQUFDLENBSTdDO0lBRUQsQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLElBQUkscUJBQXFCLENBQUMsQ0FBQyxDQUFDLENBRWpEO0NBU0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/array.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;GAGG;AACH,qBAAa,oBAAoB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,eAAe,CAAC,CAAC,CAAC;;IAM5E,OAAO,CAAC,QAAQ,CAAC,KAAK;IADxB,YACmB,KAAK,EAAE,oBAAoB,EAC5C,IAAI,EAAE,MAAM,EAIb;IAEK,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAMnC;IAEK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBxC;IAEK,GAAG,IAAI,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAYlC;IAEK,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CASnD;IAEK,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAcnD;IAEM,YAAY,IAAI,qBAAqB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAYxD;IAEM,WAAW,IAAI,qBAAqB,CAAC,CAAC,CAAC,CAI7C;IAED,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,qBAAqB,CAAC,CAAC,CAAC,CAEjD;CASF"}

package/dest/sqlite-opfs/array.js

@@ -0,0 +1,128 @@
+var _computedKey;
+import { Encoder } from 'msgpackr';
+import { hash } from 'ohash';
+import { toBufferKey } from 'ordered-binary';
+_computedKey = Symbol.asyncIterator;
+/**
+ * Persistent array backed by SQLite. Entries share a common `key` (the array name)
+ * and are ordered by `key_count`, which doubles as the 1-indexed slot number.
+ */ export class SQLiteOPFSAztecArray {
+    store;
+    #name;
+    #container;
+    #encoder;
+    constructor(store, name){
+        this.store = store;
+        this.#encoder = new Encoder();
+        this.#name = name;
+        this.#container = `array:${name}`;
+    }
+    async lengthAsync() {
+        const rows = await this.store.allAsync('SELECT COUNT(*) FROM data WHERE container = ? AND key = ?', [
+            this.#container,
+            this.#encodedKey()
+        ]);
+        return Number(rows[0]?.[0] ?? 0);
+    }
+    async push(...vals) {
+        if (vals.length === 0) {
+            return this.lengthAsync();
+        }
+        return await this.store.transactionAsync(async ()=>{
+            let length = await this.lengthAsync();
+            for (const val of vals){
+                await this.store.runAsync(`INSERT INTO data (slot, container, key, key_count, hash, value)
+           VALUES (?, ?, ?, ?, ?, ?)`, [
+                    this.#slot(length),
+                    this.#container,
+                    this.#encodedKey(),
+                    length + 1,
+                    hash(val),
+                    this.#encoder.pack(val)
+                ]);
+                length += 1;
+            }
+            return length;
+        });
+    }
+    async pop() {
+        return await this.store.transactionAsync(async ()=>{
+            const length = await this.lengthAsync();
+            if (length === 0) {
+                return undefined;
+            }
+            const slot = this.#slot(length - 1);
+            const rows = await this.store.allAsync('SELECT value FROM data WHERE slot = ? LIMIT 1', [
+                slot
+            ]);
+            await this.store.runAsync('DELETE FROM data WHERE slot = ?', [
+                slot
+            ]);
+            const raw = rows[0]?.[0];
+            return raw instanceof Uint8Array ? this.#encoder.unpack(raw) : undefined;
+        });
+    }
+    async atAsync(index) {
+        const length = await this.lengthAsync();
+        const resolved = index < 0 ? length + index : index;
+        if (resolved < 0 || resolved >= length) {
+            return undefined;
+        }
+        const rows = await this.store.allAsync('SELECT value FROM data WHERE slot = ? LIMIT 1', [
+            this.#slot(resolved)
+        ]);
+        const raw = rows[0]?.[0];
+        return raw instanceof Uint8Array ? this.#encoder.unpack(raw) : undefined;
+    }
+    async setAt(index, val) {
+        return await this.store.transactionAsync(async ()=>{
+            const length = await this.lengthAsync();
+            const resolved = index < 0 ? length + index : index;
+            if (resolved < 0 || resolved >= length) {
+                return false;
+            }
+            await this.store.runAsync(`INSERT OR REPLACE INTO data (slot, container, key, key_count, hash, value)
+         VALUES (?, ?, ?, ?, ?, ?)`, [
+                this.#slot(resolved),
+                this.#container,
+                this.#encodedKey(),
+                resolved + 1,
+                hash(val),
+                this.#encoder.pack(val)
+            ]);
+            return true;
+        });
+    }
+    async *entriesAsync() {
+        const rows = await this.store.allAsync('SELECT key_count, value FROM data WHERE container = ? AND key = ? ORDER BY key_count ASC', [
+            this.#container,
+            this.#encodedKey()
+        ]);
+        for (const row of rows){
+            const keyCount = Number(row[0]);
+            const raw = row[1];
+            if (raw instanceof Uint8Array) {
+                yield [
+                    keyCount - 1,
+                    this.#encoder.unpack(raw)
+                ];
+            }
+        }
+    }
+    async *valuesAsync() {
+        for await (const [, val] of this.entriesAsync()){
+            yield val;
+        }
+    }
+    [_computedKey]() {
+        return this.valuesAsync();
+    }
+    #encodedKey() {
+        return toBufferKey([
+            this.#name
+        ]);
+    }
+    #slot(index) {
+        return `array:${this.#name}:slot:${index}`;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { type Logger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
+import { AztecSQLiteOPFSStore } from './store.js';
+export { AztecSQLiteOPFSStore } from './store.js';
+export declare function createStore(name: string, config: DataStoreConfig, schemaVersion?: number | undefined, log?: Logger): Promise<AztecSQLiteOPFSStore>;
+export declare function openTmpStore(ephemeral?: boolean): Promise<AztecSQLiteOPFSStore>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUtb3Bmcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFHOUQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRWxELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVsRCx3QkFBc0IsV0FBVyxDQUMvQixJQUFJLEVBQUUsTUFBTSxFQUNaLE1BQU0sRUFBRSxlQUFlLEVBQ3ZCLGFBQWEsR0FBRSxNQUFNLEdBQUcsU0FBcUIsRUFDN0MsR0FBRyxHQUFFLE1BQWlDLGlDQVV2QztBQUVELHdCQUFnQixZQUFZLENBQUMsU0FBUyxHQUFFLE9BQWUsR0FBRyxPQUFPLENBQUMsb0JBQW9CLENBQUMsQ0FFdEYifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElD,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,aAAa,GAAE,MAAM,GAAG,SAAqB,EAC7C,GAAG,GAAE,MAAiC,iCAUvC;AAED,wBAAgB,YAAY,CAAC,SAAS,GAAE,OAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAEtF"}

package/dest/sqlite-opfs/index.js

@@ -0,0 +1,13 @@
+import { createLogger } from '@aztec/foundation/log';
+import { initStoreForRollupAndSchemaVersion } from '../utils.js';
+import { AztecSQLiteOPFSStore } from './store.js';
+export { AztecSQLiteOPFSStore } from './store.js';
+export async function createStore(name, config, schemaVersion = undefined, log = createLogger('kv-store')) {
+    const { dataDirectory } = config;
+    log.info(dataDirectory ? `Creating ${name} SQLite-OPFS data store with map size ${config.dataStoreMapSizeKb} KB` : `Creating ${name} ephemeral SQLite-OPFS data store with map size ${config.dataStoreMapSizeKb} KB`);
+    const store = await AztecSQLiteOPFSStore.open(createLogger('kv-store:sqlite-opfs'), name, false);
+    return initStoreForRollupAndSchemaVersion(store, schemaVersion, config.l1Contracts?.rollupAddress, log);
+}
+export function openTmpStore(ephemeral = false) {
+    return AztecSQLiteOPFSStore.open(createLogger('kv-store:sqlite-opfs'), undefined, ephemeral);
+}

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

@@ -0,0 +1,35 @@
+import { Buffer } from 'buffer';
+import { Encoder } from 'msgpackr';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvbWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDaEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUluQyxPQUFPLEtBQUssRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzFELE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUM5QyxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUV2RCxtRUFBbUU7QUFDbkUscUJBQWEsa0JBQWtCLENBQUMsQ0FBQyxTQUFTLEdBQUcsRUFBRSxDQUFDLFNBQVMsS0FBSyxDQUFFLFlBQVcsYUFBYSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUM7SUFNMUYsU0FBUyxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsb0JBQW9CO0lBTGhELFNBQVMsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNoQyxTQUFTLENBQUMsUUFBUSxDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDckMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxPQUFPLFVBQWlCO0lBRTNDLFlBQ3FCLEtBQUssRUFBRSxvQkFBb0IsRUFDOUMsT0FBTyxFQUFFLE1BQU0sRUFJaEI7SUFFSyxRQUFRLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQU83QztJQUVLLFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FHdkM7SUFFSyxTQUFTLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUdqQztJQUVLLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQU12QztJQUVLLE9BQU8sQ0FBQyxPQUFPLEVBQUU7UUFBRSxHQUFHLEVBQUUsQ0FBQyxDQUFDO1FBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQTtLQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBUzVEO0lBRUQsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxTQUFTLEtBQUssQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFM0Q7SUFFSyxjQUFjLENBQUMsR0FBRyxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FRckQ7SUFFSyxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRWxDO0lBRU0sWUFBWSxDQUFDLEtBQUssR0FBRSxLQUFLLENBQUMsQ0FBQyxDQUFNLEdBQUcscUJBQXFCLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FTdkU7SUFFTSxXQUFXLENBQUMsS0FBSyxHQUFFLEtBQUssQ0FBQyxDQUFDLENBQU0sR0FBRyxxQkFBcUIsQ0FBQyxDQUFDLENBQUMsQ0FJakU7SUFFTSxTQUFTLENBQUMsS0FBSyxHQUFFLEtBQUssQ0FBQyxDQUFDLENBQU0sR0FBRyxxQkFBcUIsQ0FBQyxDQUFDLENBQUMsQ0FJL0Q7SUFFRCxVQUFnQixVQUFVLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsTUFBTSxFQUFFLFVBQVUsRUFBRSxVQUFVLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQXVCbkc7SUFFRCxTQUFTLENBQUMsV0FBVyxDQUFDLEdBQUcsRUFBRSxRQUFRLEdBQUcsQ0FBQyxDQWF0QztJQUVELFNBQVMsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLFVBQVUsR0FBRyxDQUFDLENBTXRDO0lBRUQsU0FBUyxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLE1BQU0sQ0FFbkM7SUFFRCxTQUFTLENBQUMsWUFBWSxDQUFDLEdBQUcsRUFBRSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEdBQUcsTUFBTSxHQUFHLFVBQVUsQ0FBQyxFQUFFLENBRS9EO0lBRUQsU0FBUyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxFQUFFLEtBQUssR0FBRSxNQUFVLEdBQUcsTUFBTSxDQUVoRDtDQUNGIn0=

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,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAInC,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 { Buffer } from 'buffer';
+import { Encoder } from 'msgpackr';
+import { hash } from 'ohash';
+import { fromBufferKey, toBufferKey } from 'ordered-binary';
+/** 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}`;
+    }
+}

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

@@ -0,0 +1,58 @@
+/**
+ * RPC protocol between the main thread and the SQLite worker.
+ * All requests carry a unique `id`; responses echo the same id so the main thread
+ * can resolve the right pending promise.
+ */
+/** Matches `@sqlite.org/sqlite-wasm`'s internal SqlValue type. Boolean is not a native SQLite type. */
+export type SqlValue = string | number | bigint | null | Uint8Array;
+/** A row returned in 'array' rowMode — one value per column, in select order. */
+export type ResultRow = SqlValue[];
+export type WorkerRequest = {
+    type: 'init';
+    id: number;
+    dbName: string;
+    ephemeral: boolean;
+    poolDirectory?: string;
+} | {
+    type: 'close';
+    id: number;
+} | {
+    type: 'deleteDb';
+    id: number;
+    dbName: string;
+} | {
+    type: 'run';
+    id: number;
+    sql: string;
+    bind?: SqlValue[];
+} | {
+    type: 'all';
+    id: number;
+    sql: string;
+    bind?: SqlValue[];
+} | {
+    type: 'export';
+    id: number;
+} | {
+    type: 'begin';
+    id: number;
+} | {
+    type: 'commit';
+    id: number;
+} | {
+    type: 'rollback';
+    id: number;
+};
+export type WorkerResponse = {
+    type: 'ok';
+    id: number;
+    rows?: ResultRow[];
+    changes?: number;
+    bytes?: Uint8Array;
+} | {
+    type: 'err';
+    id: number;
+    message: string;
+};
+export type WorkerRequestType = WorkerRequest['type'];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUtb3Bmcy9tZXNzYWdlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBRUgsdUdBQXVHO0FBQ3ZHLE1BQU0sTUFBTSxRQUFRLEdBQUcsTUFBTSxHQUFHLE1BQU0sR0FBRyxNQUFNLEdBQUcsSUFBSSxHQUFHLFVBQVUsQ0FBQztBQUVwRSxtRkFBaUY7QUFDakYsTUFBTSxNQUFNLFNBQVMsR0FBRyxRQUFRLEVBQUUsQ0FBQztBQUVuQyxNQUFNLE1BQU0sYUFBYSxHQUNyQjtJQUFFLElBQUksRUFBRSxNQUFNLENBQUM7SUFBQyxFQUFFLEVBQUUsTUFBTSxDQUFDO0lBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQztJQUFDLFNBQVMsRUFBRSxPQUFPLENBQUM7SUFBQyxhQUFhLENBQUMsRUFBRSxNQUFNLENBQUE7Q0FBRSxHQUN4RjtJQUFFLElBQUksRUFBRSxPQUFPLENBQUM7SUFBQyxFQUFFLEVBQUUsTUFBTSxDQUFBO0NBQUUsR0FDN0I7SUFBRSxJQUFJLEVBQUUsVUFBVSxDQUFDO0lBQUMsRUFBRSxFQUFFLE1BQU0sQ0FBQztJQUFDLE1BQU0sRUFBRSxNQUFNLENBQUE7Q0FBRSxHQUNoRDtJQUFFLElBQUksRUFBRSxLQUFLLENBQUM7SUFBQyxFQUFFLEVBQUUsTUFBTSxDQUFDO0lBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQztJQUFDLElBQUksQ0FBQyxFQUFFLFFBQVEsRUFBRSxDQUFBO0NBQUUsR0FDM0Q7SUFBRSxJQUFJLEVBQUUsS0FBSyxDQUFDO0lBQUMsRUFBRSxFQUFFLE1BQU0sQ0FBQztJQUFDLEdBQUcsRUFBRSxNQUFNLENBQUM7SUFBQyxJQUFJLENBQUMsRUFBRSxRQUFRLEVBQUUsQ0FBQTtDQUFFLEdBQzNEO0lBQUUsSUFBSSxFQUFFLFFBQVEsQ0FBQztJQUFDLEVBQUUsRUFBRSxNQUFNLENBQUE7Q0FBRSxHQUM5QjtJQUFFLElBQUksRUFBRSxPQUFPLENBQUM7SUFBQyxFQUFFLEVBQUUsTUFBTSxDQUFBO0NBQUUsR0FDN0I7SUFBRSxJQUFJLEVBQUUsUUFBUSxDQUFDO0lBQUMsRUFBRSxFQUFFLE1BQU0sQ0FBQTtDQUFFLEdBQzlCO0lBQUUsSUFBSSxFQUFFLFVBQVUsQ0FBQztJQUFDLEVBQUUsRUFBRSxNQUFNLENBQUE7Q0FBRSxDQUFDO0FBRXJDLE1BQU0sTUFBTSxjQUFjLEdBQ3RCO0lBQUUsSUFBSSxFQUFFLElBQUksQ0FBQztJQUFDLEVBQUUsRUFBRSxNQUFNLENBQUM7SUFBQyxJQUFJLENBQUMsRUFBRSxTQUFTLEVBQUUsQ0FBQztJQUFDLE9BQU8sQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUFDLEtBQUssQ0FBQyxFQUFFLFVBQVUsQ0FBQTtDQUFFLEdBQ3BGO0lBQUUsSUFBSSxFQUFFLEtBQUssQ0FBQztJQUFDLEVBQUUsRUFBRSxNQUFNLENBQUM7SUFBQyxPQUFPLEVBQUUsTUFBTSxDQUFBO0NBQUUsQ0FBQztBQUVqRCxNQUFNLE1BQU0saUJBQWlCLEdBQUcsYUFBYSxDQUFDLE1BQU0sQ0FBQyxDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/messages.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,uGAAuG;AACvG,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,UAAU,CAAC;AAEpE,mFAAiF;AACjF,MAAM,MAAM,SAAS,GAAG,QAAQ,EAAE,CAAC;AAEnC,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,GACxF;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAErC,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,UAAU,CAAA;CAAE,GACpF;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC"}

package/dest/sqlite-opfs/messages.js

@@ -0,0 +1,5 @@
+/**
+ * RPC protocol between the main thread and the SQLite worker.
+ * All requests carry a unique `id`; responses echo the same id so the main thread
+ * can resolve the right pending promise.
+ */ /** Matches `@sqlite.org/sqlite-wasm`'s internal SqlValue type. Boolean is not a native SQLite type. */ export { };

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

@@ -0,0 +1,16 @@
+import type { Key, Value } from '../interfaces/common.js';
+import type { AztecAsyncMultiMap } from '../interfaces/multi_map.js';
+import { SQLiteOPFSAztecMap } from './map.js';
+/**
+ * Multi-map backed by SQLite. Extends the base map with always-incrementing
+ * `key_count` per-key so the same slot is never reused across deletions — this
+ * matches the IndexedDB backend's sparse-multi-map semantics.
+ */
+export declare class SQLiteOPFSAztecMultiMap<K extends Key, V extends Value> extends SQLiteOPFSAztecMap<K, V> implements AztecAsyncMultiMap<K, V> {
+    set(key: K, val: V): Promise<void>;
+    getValuesAsync(key: K): AsyncIterableIterator<V>;
+    getValueCountAsync(key: K): Promise<number>;
+    deleteValue(key: K, val: V): Promise<void>;
+    delete(key: K): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsdGlfbWFwLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvbXVsdGlfbWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMxRCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ3JFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUU5Qzs7OztHQUlHO0FBQ0gscUJBQWEsdUJBQXVCLENBQUMsQ0FBQyxTQUFTLEdBQUcsRUFBRSxDQUFDLFNBQVMsS0FBSyxDQUNqRSxTQUFRLGtCQUFrQixDQUFDLENBQUMsRUFBRSxDQUFDLENBQy9CLFlBQVcsa0JBQWtCLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUVwQixHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FxQmhEO0lBRU0sY0FBYyxDQUFDLEdBQUcsRUFBRSxDQUFDLEdBQUcscUJBQXFCLENBQUMsQ0FBQyxDQUFDLENBV3REO0lBRUssa0JBQWtCLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLENBTWhEO0lBRUssV0FBVyxDQUFDLEdBQUcsRUFBRSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBTS9DO0lBRWMsTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUszQztDQUNGIn0=