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

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}`;
+    }
+}

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

@@ -0,0 +1,66 @@
+/**
+ * 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.
+ */
+import type { SqliteEncryptionErrorCode } from './errors.js';
+/** 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;
+    encryptionKey?: Uint8Array;
+} | {
+    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;
+    /**
+     * Set when the worker detected an encryption-shaped failure. The main thread
+     * uses this to re-throw the error as a {@link SqliteEncryptionError} with the
+     * matching code. Absent on non-encryption failures (untyped paths preserved).
+     */
+    encryptionCode?: SqliteEncryptionErrorCode;
+};
+export type WorkerRequestType = WorkerRequest['type'];
+//# sourceMappingURL=data:application/json;base64,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

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;AACH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D,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,CAAC;IAAC,aAAa,CAAC,EAAE,UAAU,CAAA;CAAE,GACpH;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;IACE,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,yBAAyB,CAAC;CAC5C,CAAC;AAEN,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.
+ */ 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=

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

@@ -0,0 +1 @@
+{"version":3,"file":"multi_map.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/multi_map.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;GAIG;AACH,qBAAa,uBAAuB,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,KAAK,CACjE,SAAQ,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAC/B,YAAW,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC;IAEpB,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBhD;IAEM,cAAc,CAAC,GAAG,EAAE,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAWtD;IAEK,kBAAkB,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAMhD;IAEK,WAAW,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/C;IAEc,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAK3C;CACF"}

package/dest/sqlite-opfs/multi_map.js

@@ -0,0 +1,67 @@
+import { hash } from 'ohash';
+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 class SQLiteOPFSAztecMultiMap extends SQLiteOPFSAztecMap {
+    async set(key, val) {
+        const valueHash = hash(val);
+        await this.store.transactionAsync(async ()=>{
+            const exists = await this.store.allAsync('SELECT 1 FROM data WHERE container = ? AND key = ? AND hash = ? LIMIT 1', [
+                this.container,
+                this.encodedKey(key),
+                valueHash
+            ]);
+            if (exists.length > 0) {
+                return;
+            }
+            const maxRow = await this.store.allAsync('SELECT MAX(key_count) FROM data WHERE container = ? AND key = ?', [
+                this.container,
+                this.encodedKey(key)
+            ]);
+            const count = Number(maxRow[0]?.[0] ?? 0);
+            await this.store.runAsync(`INSERT INTO data (slot, container, key, key_count, hash, value)
+         VALUES (?, ?, ?, ?, ?, ?)`, [
+                this.slot(key, count),
+                this.container,
+                this.encodedKey(key),
+                count + 1,
+                valueHash,
+                this.encoder.pack(val)
+            ]);
+        });
+    }
+    async *getValuesAsync(key) {
+        const rows = await this.store.allAsync('SELECT value FROM data WHERE container = ? AND key = ? ORDER BY key_count ASC', [
+            this.container,
+            this.encodedKey(key)
+        ]);
+        for (const row of rows){
+            const raw = row[0];
+            if (raw instanceof Uint8Array) {
+                yield this.decodeValue(raw);
+            }
+        }
+    }
+    async getValueCountAsync(key) {
+        const rows = await this.store.allAsync('SELECT COUNT(*) FROM data WHERE container = ? AND key = ?', [
+            this.container,
+            this.encodedKey(key)
+        ]);
+        return Number(rows[0]?.[0] ?? 0);
+    }
+    async deleteValue(key, val) {
+        await this.store.runAsync('DELETE FROM data WHERE container = ? AND key = ? AND hash = ?', [
+            this.container,
+            this.encodedKey(key),
+            hash(val)
+        ]);
+    }
+    async delete(key) {
+        await this.store.runAsync('DELETE FROM data WHERE container = ? AND key = ?', [
+            this.container,
+            this.encodedKey(key)
+        ]);
+    }
+}

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

@@ -0,0 +1,20 @@
+export declare const OPFS_QUARANTINE_ROOT_DIRECTORY = ".aztec-sqlite-quarantine";
+export interface DuplicatePoolAssociation {
+    logicalPath: string;
+    opaqueFileNames: string[];
+}
+export interface PoolQuarantineMetadata {
+    formatVersion: 1;
+    originalPoolDirectory: string;
+    quarantinedAt: string;
+    duplicateAssociations: DuplicatePoolAssociation[];
+}
+export interface PoolQuarantineResult extends PoolQuarantineMetadata {
+    quarantineDirectory: string;
+}
+/**
+ * Detects duplicate SAH logical-file associations and, if found, copies the complete pool into quarantine before
+ * removing the original. The caller must hold the pool's exclusive Web Lock for the whole operation.
+ */
+export declare function quarantineDuplicatePool(poolDirectory: string): Promise<PoolQuarantineResult | undefined>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9vbF9pbnRlZ3JpdHkuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUtb3Bmcy9wb29sX2ludGVncml0eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF5Q0EsZUFBTyxNQUFNLDhCQUE4Qiw2QkFBNkIsQ0FBQztBQUV6RSxNQUFNLFdBQVcsd0JBQXdCO0lBQ3ZDLFdBQVcsRUFBRSxNQUFNLENBQUM7SUFDcEIsZUFBZSxFQUFFLE1BQU0sRUFBRSxDQUFDO0NBQzNCO0FBRUQsTUFBTSxXQUFXLHNCQUFzQjtJQUNyQyxhQUFhLEVBQUUsQ0FBQyxDQUFDO0lBQ2pCLHFCQUFxQixFQUFFLE1BQU0sQ0FBQztJQUM5QixhQUFhLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLHFCQUFxQixFQUFFLHdCQUF3QixFQUFFLENBQUM7Q0FDbkQ7QUFFRCxNQUFNLFdBQVcsb0JBQXFCLFNBQVEsc0JBQXNCO0lBQ2xFLG1CQUFtQixFQUFFLE1BQU0sQ0FBQztDQUM3QjtBQUVEOzs7R0FHRztBQUNILHdCQUFzQix1QkFBdUIsQ0FBQyxhQUFhLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxvQkFBb0IsR0FBRyxTQUFTLENBQUMsQ0E2QzlHIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"pool_integrity.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/pool_integrity.ts"],"names":[],"mappings":"AAyCA,eAAO,MAAM,8BAA8B,6BAA6B,CAAC;AAEzE,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,CAAC,CAAC;IACjB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,EAAE,wBAAwB,EAAE,CAAC;CACnD;AAED,MAAM,WAAW,oBAAqB,SAAQ,sBAAsB;IAClE,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CA6C9G"}

package/dest/sqlite-opfs/pool_integrity.js

@@ -0,0 +1,282 @@
+import { normalizePoolDirectory } from './pool_lock.js';
+// The constants below mirror the opaque-file header format of the pinned opfs-sahpool VFS
+// (`yarn-project/sqlite3mc-wasm/vendor/jswasm/sqlite3.mjs`, class `OpfsSAHPool`). The pool names its files randomly
+// under `.opaque/` and prepends a header that maps each one back to its logical SQLite path:
+//
+//   bytes [0, 512)    logical path, NUL-terminated UTF-8 (HEADER_MAX_PATH_SIZE)
+//   bytes [512, 516)  SQLite open-flags of the file, big-endian uint32 (HEADER_FLAGS_SIZE)
+//   bytes [516, 524)  digest over the preceding 516 bytes, two uint32 words (HEADER_DIGEST_SIZE)
+//
+// Database content starts at byte 4096 (the pool's SECTOR_SIZE). We re-read the header ourselves rather than asking
+// the VFS because the upstream pool "repairs" anything it cannot validate by disassociating the file — destroying
+// exactly the evidence this module exists to quarantine. The browser regression test writes a real pool through the
+// pinned VFS before duplicating an opaque file, so a vendor upgrade that changes the layout breaks detection loudly
+// rather than silently.
+const OPAQUE_DIRECTORY = '.opaque';
+const HEADER_MAX_PATH_SIZE = 512;
+const HEADER_FLAGS_SIZE = 4;
+const HEADER_DIGEST_SIZE = 8;
+const HEADER_CORPUS_SIZE = HEADER_MAX_PATH_SIZE + HEADER_FLAGS_SIZE;
+const HEADER_SIZE = HEADER_CORPUS_SIZE + HEADER_DIGEST_SIZE;
+// Standard SQLite open-flag bit values (sqlite3.h). Restated as literals because the header stores them numerically
+// and this module runs on the main thread, without the sqlite3 WASM bundle that defines `capi.SQLITE_OPEN_*`.
+const SQLITE_OPEN_DELETEONCLOSE = 0x00000008;
+const SQLITE_OPEN_MEMORY = 0x00000080;
+const SQLITE_OPEN_MAIN_DB = 0x00000100;
+const SQLITE_OPEN_MAIN_JOURNAL = 0x00000800;
+const SQLITE_OPEN_SUPER_JOURNAL = 0x00004000;
+const SQLITE_OPEN_WAL = 0x00080000;
+// A live association must name one of the file types the pool persists; transient types (temp DBs, statement
+// journals) never survive in a valid header.
+const PERSISTENT_FILE_TYPES = SQLITE_OPEN_MAIN_DB | SQLITE_OPEN_MAIN_JOURNAL | SQLITE_OPEN_SUPER_JOURNAL | SQLITE_OPEN_WAL;
+// The upstream VFS repurposes SQLITE_OPEN_MEMORY — meaningless for a file that exists on disk — as a header version
+// marker: headers written with it set carry a real digest, while legacy headers leave it unset and store all-zero
+// digest words.
+const FLAG_COMPUTE_DIGEST_V2 = SQLITE_OPEN_MEMORY;
+export const OPFS_QUARANTINE_ROOT_DIRECTORY = '.aztec-sqlite-quarantine';
+/**
+ * Detects duplicate SAH logical-file associations and, if found, copies the complete pool into quarantine before
+ * removing the original. The caller must hold the pool's exclusive Web Lock for the whole operation.
+ */ export async function quarantineDuplicatePool(poolDirectory) {
+    poolDirectory = normalizePoolDirectory(poolDirectory);
+    const root = await navigator.storage.getDirectory();
+    const source = await getDirectory(root, poolDirectory);
+    if (!source) {
+        return undefined;
+    }
+    const opaque = await getChildDirectory(source, OPAQUE_DIRECTORY);
+    if (!opaque) {
+        return undefined;
+    }
+    const duplicateAssociations = await findDuplicateAssociations(opaque);
+    if (duplicateAssociations.length === 0) {
+        return undefined;
+    }
+    const quarantineRoot = await root.getDirectoryHandle(OPFS_QUARANTINE_ROOT_DIRECTORY, {
+        create: true
+    });
+    const quarantineName = createQuarantineName();
+    const destination = await quarantineRoot.getDirectoryHandle(quarantineName, {
+        create: true
+    });
+    const metadata = {
+        formatVersion: 1,
+        originalPoolDirectory: poolDirectory,
+        quarantinedAt: new Date().toISOString(),
+        duplicateAssociations
+    };
+    let quarantineComplete = false;
+    try {
+        await copyDirectory(source, destination);
+        await verifyDirectoryCopy(source, destination);
+        await writeJson(destination, 'quarantine.json', metadata);
+        quarantineComplete = true;
+        await removeDirectory(root, poolDirectory);
+    } catch (err) {
+        if (!quarantineComplete) {
+            await quarantineRoot.removeEntry(quarantineName, {
+                recursive: true
+            }).catch(()=>{});
+        }
+        throw err;
+    }
+    return {
+        ...metadata,
+        quarantineDirectory: `${OPFS_QUARANTINE_ROOT_DIRECTORY}/${quarantineName}`
+    };
+}
+async function findDuplicateAssociations(opaque) {
+    const associations = new Map();
+    for await (const [opaqueName, handle] of opaque.entries()){
+        if (handle.kind !== 'file') {
+            continue;
+        }
+        const logicalPath = await readAssociatedPath(handle);
+        if (logicalPath) {
+            const names = associations.get(logicalPath) ?? [];
+            names.push(opaqueName);
+            associations.set(logicalPath, names);
+        }
+    }
+    return [
+        ...associations.entries()
+    ].filter(([, names])=>names.length > 1).map(([logicalPath, opaqueFileNames])=>({
+            logicalPath,
+            opaqueFileNames: opaqueFileNames.sort()
+        })).sort((a, b)=>a.logicalPath.localeCompare(b.logicalPath));
+}
+/**
+ * Returns the logical SQLite path an opaque SAH file is associated with, or undefined if the file is not a live,
+ * valid association. Applies the same checks as the vendored pool's `getAssociatedPath`: a non-empty NUL-terminated
+ * path, open-flags naming a persistent file type without DELETEONCLOSE, and a matching header digest. Files failing
+ * any check are the pool's free-list or garbage entries — the VFS itself would disassociate them on open — so they
+ * cannot participate in a duplicate mapping.
+ */ async function readAssociatedPath(handle) {
+    const file = await handle.getFile();
+    if (file.size < HEADER_SIZE) {
+        return undefined;
+    }
+    const header = new Uint8Array(await file.slice(0, HEADER_SIZE).arrayBuffer());
+    const pathEnd = header.subarray(0, HEADER_MAX_PATH_SIZE).indexOf(0);
+    if (pathEnd <= 0) {
+        return undefined;
+    }
+    const dataView = new DataView(header.buffer, header.byteOffset, header.byteLength);
+    const flags = dataView.getUint32(HEADER_MAX_PATH_SIZE);
+    if ((flags & SQLITE_OPEN_DELETEONCLOSE) !== 0 || (flags & PERSISTENT_FILE_TYPES) === 0) {
+        return undefined;
+    }
+    if (!hasValidDigest(header, flags)) {
+        return undefined;
+    }
+    try {
+        return new TextDecoder('utf-8', {
+            fatal: true
+        }).decode(header.subarray(0, pathEnd));
+    } catch  {
+        return undefined;
+    }
+}
+/**
+ * Byte-for-byte port of the vendored pool's `computeDigest`, checked against the digest words stored in the header.
+ */ function hasValidDigest(header, flags) {
+    let expected0 = 0;
+    let expected1 = 0;
+    if ((flags & FLAG_COMPUTE_DIGEST_V2) !== 0) {
+        // These seeds (0xdeadbeef, 0x41c6ce57) and odd multipliers (2654435761, 104729) are the upstream author's choices
+        // (a cyrb53-hash variant) and carry no meaning here beyond having to match the vendored implementation bit for
+        // bit.
+        expected0 = 0xdeadbeef;
+        expected1 = 0x41c6ce57;
+        for (const value of header.subarray(0, HEADER_CORPUS_SIZE)){
+            expected0 = Math.imul(expected0 ^ value, 2654435761);
+            expected1 = Math.imul(expected1 ^ value, 104729);
+        }
+        expected0 >>>= 0;
+        expected1 >>>= 0;
+    }
+    const dataView = new DataView(header.buffer, header.byteOffset, header.byteLength);
+    return dataView.getUint32(HEADER_CORPUS_SIZE, true) === expected0 && dataView.getUint32(HEADER_CORPUS_SIZE + 4, true) === expected1;
+}
+async function getDirectory(root, path) {
+    let current = root;
+    try {
+        for (const segment of path.split('/')){
+            current = await current.getDirectoryHandle(segment);
+        }
+        return current;
+    } catch (err) {
+        if (err instanceof DOMException && err.name === 'NotFoundError') {
+            return undefined;
+        }
+        throw err;
+    }
+}
+async function getChildDirectory(parent, name) {
+    try {
+        return await parent.getDirectoryHandle(name);
+    } catch (err) {
+        if (err instanceof DOMException && err.name === 'NotFoundError') {
+            return undefined;
+        }
+        throw err;
+    }
+}
+async function removeDirectory(root, path) {
+    const segments = path.split('/');
+    const name = segments.pop();
+    let parent = root;
+    for (const segment of segments){
+        parent = await parent.getDirectoryHandle(segment);
+    }
+    await parent.removeEntry(name, {
+        recursive: true
+    });
+}
+async function copyDirectory(source, destination) {
+    for await (const [name, handle] of source.entries()){
+        if (handle.kind === 'directory') {
+            const childDestination = await destination.getDirectoryHandle(name, {
+                create: true
+            });
+            await copyDirectory(handle, childDestination);
+            continue;
+        }
+        const sourceFile = await handle.getFile();
+        const destinationHandle = await destination.getFileHandle(name, {
+            create: true
+        });
+        const writable = await destinationHandle.createWritable();
+        try {
+            await writable.write(sourceFile);
+            await writable.close();
+        } catch (err) {
+            await writable.abort().catch(()=>{});
+            throw err;
+        }
+    }
+}
+async function verifyDirectoryCopy(source, destination) {
+    const sourceEntries = await getSortedEntries(source);
+    const destinationEntries = await getSortedEntries(destination);
+    if (sourceEntries.length !== destinationEntries.length || sourceEntries.some(([name, handle], index)=>{
+        const destinationEntry = destinationEntries[index];
+        return name !== destinationEntry[0] || handle.kind !== destinationEntry[1].kind;
+    })) {
+        throw new Error('Failed to verify quarantined OPFS directory structure');
+    }
+    for(let i = 0; i < sourceEntries.length; i++){
+        const [, sourceHandle] = sourceEntries[i];
+        const [, destinationHandle] = destinationEntries[i];
+        if (sourceHandle.kind === 'directory') {
+            await verifyDirectoryCopy(sourceHandle, destinationHandle);
+        } else {
+            await verifyFilesEqual(sourceHandle, destinationHandle);
+        }
+    }
+}
+async function getSortedEntries(directory) {
+    const entries = [];
+    for await (const entry of directory.entries()){
+        entries.push(entry);
+    }
+    return entries.sort(([a], [b])=>a.localeCompare(b));
+}
+async function verifyFilesEqual(sourceHandle, destinationHandle) {
+    const source = await sourceHandle.getFile();
+    const destination = await destinationHandle.getFile();
+    if (source.size !== destination.size) {
+        throw new Error(`Failed to verify quarantined OPFS file "${source.name}"`);
+    }
+    const chunkSize = 1024 * 1024;
+    for(let offset = 0; offset < source.size; offset += chunkSize){
+        const [sourceChunk, destinationChunk] = await Promise.all([
+            source.slice(offset, offset + chunkSize).arrayBuffer(),
+            destination.slice(offset, offset + chunkSize).arrayBuffer()
+        ]);
+        const sourceBytes = new Uint8Array(sourceChunk);
+        const destinationBytes = new Uint8Array(destinationChunk);
+        if (sourceBytes.some((value, index)=>value !== destinationBytes[index])) {
+            throw new Error(`Failed to verify quarantined OPFS file "${source.name}"`);
+        }
+    }
+}
+async function writeJson(directory, name, value) {
+    const handle = await directory.getFileHandle(name, {
+        create: true
+    });
+    const writable = await handle.createWritable();
+    try {
+        await writable.write(JSON.stringify(value, undefined, 2));
+        await writable.close();
+    } catch (err) {
+        await writable.abort().catch(()=>{});
+        throw err;
+    }
+}
+function createQuarantineName() {
+    const random = globalThis.crypto.getRandomValues(new Uint8Array(8));
+    return `${Date.now()}-${[
+        ...random
+    ].map((byte)=>byte.toString(16).padStart(2, '0')).join('')}`;
+}

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

@@ -0,0 +1,8 @@
+export declare const DEFAULT_SAH_POOL_DIRECTORY = ".aztec-kv";
+export interface PoolLockLease {
+    release(): Promise<void>;
+}
+export declare function normalizePoolDirectory(poolDirectory?: string): string;
+export declare function acquirePoolLock(poolDirectory?: string): Promise<PoolLockLease>;
+export declare function withPoolLock<T>(poolDirectory: string, callback: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9vbF9sb2NrLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvcG9vbF9sb2NrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLGVBQU8sTUFBTSwwQkFBMEIsY0FBYyxDQUFDO0FBSXRELE1BQU0sV0FBVyxhQUFhO0lBQzVCLE9BQU8sSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7Q0FDMUI7QUFFRCx3QkFBZ0Isc0JBQXNCLENBQUMsYUFBYSxDQUFDLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FNckU7QUFFRCx3QkFBc0IsZUFBZSxDQUFDLGFBQWEsQ0FBQyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsYUFBYSxDQUFDLENBa0NwRjtBQUVELHdCQUFzQixZQUFZLENBQUMsQ0FBQyxFQUFFLGFBQWEsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLE1BQU0sT0FBTyxDQUFDLENBQUMsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FPbkcifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"pool_lock.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/pool_lock.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,0BAA0B,cAAc,CAAC;AAItD,MAAM,WAAW,aAAa;IAC5B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,wBAAgB,sBAAsB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAMrE;AAED,wBAAsB,eAAe,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAkCpF;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAOnG"}