@aztec/kv-store 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/dest/sqlite-opfs/pool_lock.js

@@ -0,0 +1,47 @@
+import { SqlitePoolBusyError, SqliteWebLocksUnavailableError } from './errors.js';
+export const DEFAULT_SAH_POOL_DIRECTORY = '.aztec-kv';
+const WEB_LOCK_PREFIX = 'aztec.sqlite-opfs.pool:';
+export function normalizePoolDirectory(poolDirectory) {
+    const path = poolDirectory?.split('/').filter((segment)=>segment.length > 0).join('/');
+    return path || DEFAULT_SAH_POOL_DIRECTORY;
+}
+export async function acquirePoolLock(poolDirectory) {
+    if (!navigator.locks) {
+        throw new SqliteWebLocksUnavailableError();
+    }
+    const normalizedDirectory = normalizePoolDirectory(poolDirectory);
+    const acquired = Promise.withResolvers();
+    const hold = Promise.withResolvers();
+    const request = navigator.locks.request(`${WEB_LOCK_PREFIX}${normalizedDirectory}`, {
+        mode: 'exclusive',
+        ifAvailable: true
+    }, async (lock)=>{
+        acquired.resolve(lock);
+        if (lock) {
+            await hold.promise;
+        }
+    });
+    request.catch(acquired.reject);
+    if (!await acquired.promise) {
+        await request;
+        throw new SqlitePoolBusyError(normalizedDirectory);
+    }
+    let released = false;
+    return {
+        release: async ()=>{
+            if (!released) {
+                released = true;
+                hold.resolve();
+            }
+            await request;
+        }
+    };
+}
+export async function withPoolLock(poolDirectory, callback) {
+    const lease = await acquirePoolLock(poolDirectory);
+    try {
+        return await callback();
+    } finally{
+        await lease.release();
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { Key, Range } from '../interfaces/common.js';
+import type { AztecAsyncSet } from '../interfaces/set.js';
+import type { AztecSQLiteOPFSStore } from './store.js';
+/** Set backed by SQLite. Composes a Map<K, true>. */
+export declare class SQLiteOPFSAztecSet<K extends Key> implements AztecAsyncSet<K> {
+    #private;
+    constructor(store: AztecSQLiteOPFSStore, name: string);
+    hasAsync(key: K): Promise<boolean>;
+    add(key: K): Promise<void>;
+    delete(key: K): Promise<void>;
+    entriesAsync(range?: Range<K>): AsyncIterableIterator<K>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvc2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMxRCxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUUxRCxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUV2RCxxREFBcUQ7QUFDckQscUJBQWEsa0JBQWtCLENBQUMsQ0FBQyxTQUFTLEdBQUcsQ0FBRSxZQUFXLGFBQWEsQ0FBQyxDQUFDLENBQUM7O0lBR3hFLFlBQVksS0FBSyxFQUFFLG9CQUFvQixFQUFFLElBQUksRUFBRSxNQUFNLEVBRXBEO0lBRUQsUUFBUSxDQUFDLEdBQUcsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUVqQztJQUVELEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFekI7SUFFRCxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRTVCO0lBRU0sWUFBWSxDQUFDLEtBQUssR0FBRSxLQUFLLENBQUMsQ0FBQyxDQUFNLEdBQUcscUJBQXFCLENBQUMsQ0FBQyxDQUFDLENBRWxFO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/set.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,qDAAqD;AACrD,qBAAa,kBAAkB,CAAC,CAAC,SAAS,GAAG,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;;IAGxE,YAAY,KAAK,EAAE,oBAAoB,EAAE,IAAI,EAAE,MAAM,EAEpD;IAED,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAEjC;IAED,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzB;IAED,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5B;IAEM,YAAY,CAAC,KAAK,GAAE,KAAK,CAAC,CAAC,CAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAElE;CACF"}

package/dest/sqlite-opfs/set.js

@@ -0,0 +1,19 @@
+import { SQLiteOPFSAztecMap } from './map.js';
+/** Set backed by SQLite. Composes a Map<K, true>. */ export class SQLiteOPFSAztecSet {
+    #map;
+    constructor(store, name){
+        this.#map = new SQLiteOPFSAztecMap(store, name);
+    }
+    hasAsync(key) {
+        return this.#map.hasAsync(key);
+    }
+    add(key) {
+        return this.#map.set(key, true);
+    }
+    delete(key) {
+        return this.#map.delete(key);
+    }
+    async *entriesAsync(range = {}) {
+        yield* this.#map.keysAsync(range);
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { Value } from '../interfaces/common.js';
+import type { AztecAsyncSingleton } from '../interfaces/singleton.js';
+import type { AztecSQLiteOPFSStore } from './store.js';
+/** Stores a single value identified by `name`. */
+export declare class SQLiteOPFSAztecSingleton<T extends Value> implements AztecAsyncSingleton<T> {
+    #private;
+    private readonly store;
+    constructor(store: AztecSQLiteOPFSStore, name: string);
+    getAsync(): Promise<T | undefined>;
+    set(val: T): Promise<boolean>;
+    delete(): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xldG9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvc2luZ2xldG9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDdEUsT0FBTyxLQUFLLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFdkQsa0RBQWtEO0FBQ2xELHFCQUFhLHdCQUF3QixDQUFDLENBQUMsU0FBUyxLQUFLLENBQUUsWUFBVyxtQkFBbUIsQ0FBQyxDQUFDLENBQUM7O0lBTXBGLE9BQU8sQ0FBQyxRQUFRLENBQUMsS0FBSztJQUR4QixZQUNtQixLQUFLLEVBQUUsb0JBQW9CLEVBQzVDLElBQUksRUFBRSxNQUFNLEVBSWI7SUFFSyxRQUFRLElBQUksT0FBTyxDQUFDLENBQUMsR0FBRyxTQUFTLENBQUMsQ0FVdkM7SUFFSyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBT2xDO0lBRUssTUFBTSxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FHL0I7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/singleton.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,kDAAkD;AAClD,qBAAa,wBAAwB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,mBAAmB,CAAC,CAAC,CAAC;;IAMpF,OAAO,CAAC,QAAQ,CAAC,KAAK;IADxB,YACmB,KAAK,EAAE,oBAAoB,EAC5C,IAAI,EAAE,MAAM,EAIb;IAEK,QAAQ,IAAI,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAUvC;IAEK,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAOlC;IAEK,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAG/B;CACF"}

package/dest/sqlite-opfs/singleton.js

@@ -0,0 +1,48 @@
+import { Encoder } from '#msgpackr';
+import { toBufferKey } from '#ordered-binary';
+import { hash } from 'ohash';
+/** Stores a single value identified by `name`. */ export class SQLiteOPFSAztecSingleton {
+    store;
+    #container;
+    #slot;
+    #encoder;
+    constructor(store, name){
+        this.store = store;
+        this.#encoder = new Encoder();
+        this.#container = `singleton:${name}`;
+        this.#slot = `singleton:${name}:value`;
+    }
+    async getAsync() {
+        const rows = await this.store.allAsync('SELECT value FROM data WHERE slot = ? LIMIT 1', [
+            this.#slot
+        ]);
+        if (rows.length === 0) {
+            return undefined;
+        }
+        const raw = rows[0][0];
+        if (raw instanceof Uint8Array) {
+            return this.#encoder.unpack(raw);
+        }
+        return undefined;
+    }
+    async set(val) {
+        const { changes } = await this.store.runAsync(`INSERT OR REPLACE INTO data (slot, container, key, key_count, hash, value)
+       VALUES (?, ?, ?, ?, ?, ?)`, [
+            this.#slot,
+            this.#container,
+            toBufferKey([
+                this.#slot
+            ]),
+            1,
+            hash(val),
+            this.#encoder.pack(val)
+        ]);
+        return changes > 0;
+    }
+    async delete() {
+        await this.store.runAsync('DELETE FROM data WHERE slot = ?', [
+            this.#slot
+        ]);
+        return true;
+    }
+}

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

@@ -0,0 +1,84 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { AztecAsyncArray } from '../interfaces/array.js';
+import type { Key, StoreSize, Value } from '../interfaces/common.js';
+import type { AztecAsyncCounter } from '../interfaces/counter.js';
+import type { AztecAsyncMap } from '../interfaces/map.js';
+import type { AztecAsyncMultiMap } from '../interfaces/multi_map.js';
+import type { AztecAsyncSet } from '../interfaces/set.js';
+import type { AztecAsyncSingleton } from '../interfaces/singleton.js';
+import type { AztecAsyncKVStore } from '../interfaces/store.js';
+import type { ResultRow, SqlValue } from './messages.js';
+/**
+ * Main-thread handle for a SQLite database persisted to OPFS via the `opfs-sahpool`
+ * VFS. Owns a dedicated Web Worker (the SAH Pool VFS requires Worker context) and
+ * routes every SQL op through it via typed postMessage RPC.
+ *
+ * Transaction ordering is guaranteed by a `SerialQueue` on the main thread combined
+ * with an `#inTx` flag: outside a `transactionAsync` block, each op acquires the
+ * queue for its own auto-commit; inside a block, the outer call holds the queue and
+ * nested ops bypass it to avoid deadlock.
+ */
+export declare class AztecSQLiteOPFSStore implements AztecAsyncKVStore {
+    #private;
+    readonly isEphemeral: boolean;
+    private readonly poolLock?;
+    private constructor();
+    /**
+     * Opens (or creates) a SQLite database stored in the OPFS SAH Pool. When `ephemeral`
+     * is true the database lives only in memory and is lost when the worker terminates.
+     * Pass `poolDirectory` to place the SAH Pool in a non-default OPFS subdirectory —
+     * required when multiple stores coexist in the same tab, because the SAH Pool holds
+     * an exclusive lock on its directory.
+     *
+     * Persistent stores hold an origin-wide Web Lock for the pool directory until close
+     * or delete. If another store instance already owns it, open fails immediately with
+     * `SqlitePoolBusyError`.
+     *
+     * Pass `encryptionKey` (exactly 32 bytes) to enable at-rest encryption via sqlite3mc's
+     * ChaCha20 page cipher. The key buffer is **transferred** to the worker — its
+     * ArrayBuffer detaches on the caller side after `postMessage`. This is intentional:
+     * the API encodes a one-key-one-owner invariant. A caller that wants to use the same
+     * key for multiple stores must explicitly clone it per call (e.g.
+     * `new Uint8Array(savedKey)`), making the duplication a visible, deliberate decision
+     * rather than a silent structured-clone operation. The default path (one `.open()`,
+     * one consumption of the key) leaves zero key bytes on the main thread after the call.
+     */
+    static open(log: Logger, name?: string, ephemeral?: boolean, poolDirectory?: string, encryptionKey?: Uint8Array): Promise<AztecSQLiteOPFSStore>;
+    openMap<K extends Key, V extends Value>(name: string): AztecAsyncMap<K, V>;
+    openSet<K extends Key>(name: string): AztecAsyncSet<K>;
+    openMultiMap<K extends Key, V extends Value>(name: string): AztecAsyncMultiMap<K, V>;
+    openCounter<K extends Key>(_name: string): AztecAsyncCounter<K>;
+    openArray<T extends Value>(name: string): AztecAsyncArray<T>;
+    openSingleton<T extends Value>(name: string): AztecAsyncSingleton<T>;
+    transactionAsync<T>(callback: () => Promise<T>): Promise<T>;
+    clear(): Promise<void>;
+    delete(): Promise<void>;
+    /**
+     * Placeholder — returns zeros to mirror the IndexedDB backend. SQLite exposes real
+     * numbers cheaply via `PRAGMA page_count` / `page_size` / `freelist_count` and
+     * `SELECT COUNT(*) FROM data`, which would populate `physicalFileSize`, `actualSize`,
+     * and `numItems` meaningfully (`mappingSize` stays 0 — it's an LMDB mmap concept).
+     * Upgrade when any caller actually consumes these values; all current consumers
+     * tolerate zeros.
+     */
+    estimateSize(): Promise<StoreSize>;
+    close(): Promise<void>;
+    backupTo(_dstPath: string, _compact?: boolean): Promise<void>;
+    /**
+     * Returns a raw SQLite image (bytes suitable for writing as a `.sqlite` file and
+     * opening in any SQLite tool). Works only for non-ephemeral DBs because the OPFS
+     * SAH Pool has to be initialized. Useful for inspection/debugging.
+     */
+    exportDb(): Promise<Uint8Array>;
+    /**
+     * Runs a write statement (INSERT/UPDATE/DELETE/DDL). If called inside a
+     * `transactionAsync` block, bypasses the queue; otherwise acquires it so the
+     * op runs in its own auto-commit.
+     */
+    runAsync(sql: string, bind?: SqlValue[]): Promise<{
+        changes: number;
+    }>;
+    /** Runs a SELECT statement and returns rows in array row-mode. */
+    allAsync(sql: string, bind?: SqlValue[]): Promise<ResultRow[]>;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAIhE,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAiC,MAAM,eAAe,CAAC;AAOxF;;;;;;;;;GASG;AACH,qBAAa,oBAAqB,YAAW,iBAAiB;;aAe1C,WAAW,EAAE,OAAO;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAL5B,OAAO,eA0BN;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAa,IAAI,CACf,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,EACb,SAAS,GAAE,OAAe,EAC1B,aAAa,CAAC,EAAE,MAAM,EACtB,aAAa,CAAC,EAAE,UAAU,GACzB,OAAO,CAAC,oBAAoB,CAAC,CA2C/B;IAED,OAAO,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAEzE;IAED,OAAO,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAErD;IAED,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAEnF;IAED,WAAW,CAAC,CAAC,SAAS,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAE9D;IAED,SAAS,CAAC,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,CAE3D;IAED,aAAa,CAAC,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAEnE;IAED,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAwB1D;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAEK,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAe5B;IAED;;;;;;;OAOG;IACH,YAAY,IAAI,OAAO,CAAC,SAAS,CAAC,CAEjC;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAa3B;IAED,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5D;IAED;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC,CAMpC;IAED;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAMrE;IAED,kEAAkE;IAClE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAI7D;CAuDF"}

package/dest/sqlite-opfs/store.js

@@ -0,0 +1,317 @@
+import { SerialQueue } from '@aztec/foundation/queue';
+import { SQLiteOPFSAztecArray } from './array.js';
+import { SqliteCorruptionError, SqliteEncryptionError, isCorruptionMessage } from './errors.js';
+import { SQLiteOPFSAztecMap } from './map.js';
+import { SQLiteOPFSAztecMultiMap } from './multi_map.js';
+import { quarantineDuplicatePool } from './pool_integrity.js';
+import { acquirePoolLock, normalizePoolDirectory } from './pool_lock.js';
+import { SQLiteOPFSAztecSet } from './set.js';
+import { SQLiteOPFSAztecSingleton } from './singleton.js';
+/**
+ * Main-thread handle for a SQLite database persisted to OPFS via the `opfs-sahpool`
+ * VFS. Owns a dedicated Web Worker (the SAH Pool VFS requires Worker context) and
+ * routes every SQL op through it via typed postMessage RPC.
+ *
+ * Transaction ordering is guaranteed by a `SerialQueue` on the main thread combined
+ * with an `#inTx` flag: outside a `transactionAsync` block, each op acquires the
+ * queue for its own auto-commit; inside a block, the outer call holds the queue and
+ * nested ops bypass it to avoid deadlock.
+ */ export class AztecSQLiteOPFSStore {
+    isEphemeral;
+    poolLock;
+    #worker;
+    #pending;
+    #txQueue;
+    #name;
+    #log;
+    #nextId;
+    #inTx;
+    #closed;
+    #workerFailed;
+    constructor(worker, name, log, isEphemeral, poolLock){
+        this.isEphemeral = isEphemeral;
+        this.poolLock = poolLock;
+        this.#pending = new Map();
+        this.#txQueue = new SerialQueue();
+        this.#nextId = 0;
+        this.#inTx = false;
+        this.#closed = false;
+        this.#workerFailed = false;
+        this.#worker = worker;
+        this.#name = name;
+        this.#log = log;
+        this.#worker.onmessage = (ev)=>{
+            const { id } = ev.data;
+            const handler = this.#pending.get(id);
+            if (!handler) {
+                this.#log.warn(`SQLite worker: no pending handler for id ${id}`);
+                return;
+            }
+            this.#pending.delete(id);
+            handler.resolve(ev.data);
+        };
+        this.#worker.onerror = (ev)=>{
+            this.#workerFailed = true;
+            this.#log.error(`SQLite worker crashed: ${ev.message}`);
+            this.#rejectPending(`SQLite worker crashed: ${ev.message}`);
+        };
+        this.#txQueue.start();
+    }
+    /**
+   * Opens (or creates) a SQLite database stored in the OPFS SAH Pool. When `ephemeral`
+   * is true the database lives only in memory and is lost when the worker terminates.
+   * Pass `poolDirectory` to place the SAH Pool in a non-default OPFS subdirectory —
+   * required when multiple stores coexist in the same tab, because the SAH Pool holds
+   * an exclusive lock on its directory.
+   *
+   * Persistent stores hold an origin-wide Web Lock for the pool directory until close
+   * or delete. If another store instance already owns it, open fails immediately with
+   * `SqlitePoolBusyError`.
+   *
+   * Pass `encryptionKey` (exactly 32 bytes) to enable at-rest encryption via sqlite3mc's
+   * ChaCha20 page cipher. The key buffer is **transferred** to the worker — its
+   * ArrayBuffer detaches on the caller side after `postMessage`. This is intentional:
+   * the API encodes a one-key-one-owner invariant. A caller that wants to use the same
+   * key for multiple stores must explicitly clone it per call (e.g.
+   * `new Uint8Array(savedKey)`), making the duplication a visible, deliberate decision
+   * rather than a silent structured-clone operation. The default path (one `.open()`,
+   * one consumption of the key) leaves zero key bytes on the main thread after the call.
+   */ static async open(log, name, ephemeral = false, poolDirectory, encryptionKey) {
+        if (encryptionKey !== undefined && encryptionKey.length !== 32) {
+            throw new SqliteEncryptionError('invalid_key_length', `encryptionKey must be 32 bytes (got ${encryptionKey.length})`);
+        }
+        if (encryptionKey !== undefined && ephemeral) {
+            throw new SqliteEncryptionError('encryption_not_supported_for_ephemeral', 'encryptionKey is not supported for ephemeral (:memory:) stores');
+        }
+        const dbName = name && !ephemeral ? name : `tmp-${globalThis.crypto.getRandomValues(new Uint8Array(8)).join('')}`;
+        log.debug(`Opening SQLite-OPFS ${ephemeral ? 'ephemeral ' : ''}${encryptionKey ? 'encrypted ' : ''}database ${dbName}`);
+        const effectivePoolDirectory = ephemeral ? undefined : normalizePoolDirectory(poolDirectory);
+        const poolLock = effectivePoolDirectory ? await acquirePoolLock(effectivePoolDirectory) : undefined;
+        let worker;
+        try {
+            if (effectivePoolDirectory) {
+                const quarantine = await quarantineDuplicatePool(effectivePoolDirectory);
+                if (quarantine) {
+                    log.warn(`Quarantined SQLite-OPFS pool with duplicate logical file mappings`, quarantine);
+                }
+            }
+            worker = new Worker(new URL('./worker.js', import.meta.url), {
+                type: 'module'
+            });
+            const store = new AztecSQLiteOPFSStore(worker, dbName, log, ephemeral, poolLock);
+            // Transfer (not clone) the key buffer to the worker so we don't leave a
+            // second copy on the main thread. Caveat: this detaches the caller's
+            // encryptionKey.buffer — subsequent reads from the same Uint8Array are empty.
+            const transfer = encryptionKey ? [
+                encryptionKey.buffer
+            ] : undefined;
+            await store.#sendRequest({
+                type: 'init',
+                id: store.#allocId(),
+                dbName,
+                ephemeral,
+                poolDirectory: effectivePoolDirectory,
+                encryptionKey
+            }, transfer);
+            return store;
+        } catch (err) {
+            worker?.terminate();
+            await poolLock?.release();
+            throw err;
+        }
+    }
+    openMap(name) {
+        return new SQLiteOPFSAztecMap(this, name);
+    }
+    openSet(name) {
+        return new SQLiteOPFSAztecSet(this, name);
+    }
+    openMultiMap(name) {
+        return new SQLiteOPFSAztecMultiMap(this, name);
+    }
+    openCounter(_name) {
+        throw new Error('Method not implemented.');
+    }
+    openArray(name) {
+        return new SQLiteOPFSAztecArray(this, name);
+    }
+    openSingleton(name) {
+        return new SQLiteOPFSAztecSingleton(this, name);
+    }
+    transactionAsync(callback) {
+        // Nested calls join the outer transaction — SQLite does not support nested BEGIN,
+        // and re-acquiring the SerialQueue while the outer call holds it would deadlock.
+        // Errors in the nested callback propagate to the outer catch, which rolls back the
+        // whole thing (the standard "nested tx = savepoint-free join" semantic).
+        if (this.#inTx) {
+            return callback();
+        }
+        return this.#txQueue.put(async ()=>{
+            this.#inTx = true;
+            await this.#sendRequest({
+                type: 'begin',
+                id: this.#allocId()
+            });
+            try {
+                const result = await callback();
+                await this.#sendRequest({
+                    type: 'commit',
+                    id: this.#allocId()
+                });
+                return result;
+            } catch (err) {
+                await this.#sendRequest({
+                    type: 'rollback',
+                    id: this.#allocId()
+                }).catch((rollbackErr)=>this.#log.warn(`SQLite ROLLBACK failed: ${rollbackErr instanceof Error ? rollbackErr.message : rollbackErr}`));
+                throw err;
+            } finally{
+                this.#inTx = false;
+            }
+        });
+    }
+    async clear() {
+        await this.runAsync('DELETE FROM data');
+    }
+    async delete() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        try {
+            await this.#txQueue.end();
+            await this.#sendRequest({
+                type: 'deleteDb',
+                id: this.#allocId(),
+                dbName: this.#name
+            }).catch((err)=>this.#log.warn(`SQLite deleteDb failed: ${err instanceof Error ? err.message : err}`));
+        } finally{
+            this.#worker.terminate();
+            this.#rejectPending('SQLite store deleted');
+            await this.poolLock?.release();
+        }
+    }
+    /**
+   * Placeholder — returns zeros to mirror the IndexedDB backend. SQLite exposes real
+   * numbers cheaply via `PRAGMA page_count` / `page_size` / `freelist_count` and
+   * `SELECT COUNT(*) FROM data`, which would populate `physicalFileSize`, `actualSize`,
+   * and `numItems` meaningfully (`mappingSize` stays 0 — it's an LMDB mmap concept).
+   * Upgrade when any caller actually consumes these values; all current consumers
+   * tolerate zeros.
+   */ estimateSize() {
+        return Promise.resolve({
+            mappingSize: 0,
+            physicalFileSize: 0,
+            actualSize: 0,
+            numItems: 0
+        });
+    }
+    async close() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        try {
+            await this.#txQueue.end();
+            await this.#sendRequest({
+                type: 'close',
+                id: this.#allocId()
+            }).catch(()=>{});
+        } finally{
+            this.#worker.terminate();
+            this.#rejectPending('SQLite store closed');
+            await this.poolLock?.release();
+        }
+    }
+    backupTo(_dstPath, _compact) {
+        throw new Error('Method not implemented.');
+    }
+    /**
+   * Returns a raw SQLite image (bytes suitable for writing as a `.sqlite` file and
+   * opening in any SQLite tool). Works only for non-ephemeral DBs because the OPFS
+   * SAH Pool has to be initialized. Useful for inspection/debugging.
+   */ async exportDb() {
+        const resp = await this.#sendRequest({
+            type: 'export',
+            id: this.#allocId()
+        });
+        if (!('bytes' in resp) || !resp.bytes) {
+            throw new Error('exportDb: worker returned no bytes');
+        }
+        return resp.bytes;
+    }
+    /**
+   * Runs a write statement (INSERT/UPDATE/DELETE/DDL). If called inside a
+   * `transactionAsync` block, bypasses the queue; otherwise acquires it so the
+   * op runs in its own auto-commit.
+   */ runAsync(sql, bind) {
+        const send = ()=>this.#sendRequest({
+                type: 'run',
+                id: this.#allocId(),
+                sql,
+                bind
+            }).then((r)=>({
+                    changes: 'changes' in r ? r.changes ?? 0 : 0
+                }));
+        return this.#inTx ? send() : this.#txQueue.put(send);
+    }
+    /** Runs a SELECT statement and returns rows in array row-mode. */ allAsync(sql, bind) {
+        const send = ()=>this.#sendRequest({
+                type: 'all',
+                id: this.#allocId(),
+                sql,
+                bind
+            }).then((r)=>'rows' in r ? r.rows ?? [] : []);
+        return this.#inTx ? send() : this.#txQueue.put(send);
+    }
+    #allocId() {
+        return ++this.#nextId;
+    }
+    /**
+   * Reject any in-flight requests with `reason`, so callers awaiting a response to a
+   * request sent to a now-terminated worker don't hang forever. Called from
+   * close()/delete() and from the worker.onerror handler.
+   */ #rejectPending(reason) {
+        if (this.#pending.size === 0) {
+            return;
+        }
+        const err = new Error(reason);
+        for (const { reject } of this.#pending.values()){
+            reject(err);
+        }
+        this.#pending.clear();
+    }
+    #sendRequest(req, transfer) {
+        if (this.#workerFailed) {
+            return Promise.reject(new Error('SQLite worker has crashed'));
+        }
+        return new Promise((resolve, reject)=>{
+            this.#pending.set(req.id, {
+                resolve: (resp)=>{
+                    if (resp.type === 'err') {
+                        // Re-hydrate typed errors so consumers can pattern-match on
+                        // `instanceof`. Encryption is tagged on the wire (some cases are
+                        // pre-flight throws with no message to match); corruption is a
+                        // single unambiguous message, so we classify it here rather than
+                        // adding a redundant wire field. Everything else stays a plain Error.
+                        if (resp.encryptionCode !== undefined) {
+                            reject(new SqliteEncryptionError(resp.encryptionCode, resp.message));
+                        } else if (isCorruptionMessage(resp.message)) {
+                            reject(new SqliteCorruptionError(resp.message));
+                        } else {
+                            reject(new Error(resp.message));
+                        }
+                    } else {
+                        resolve(resp);
+                    }
+                },
+                reject
+            });
+            if (transfer && transfer.length > 0) {
+                this.#worker.postMessage(req, transfer);
+            } else {
+                this.#worker.postMessage(req);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvd29ya2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/worker.ts"],"names":[],"mappings":""}