@aztec/kv-store 0.0.1-commit.b8a057fa → 0.0.1-commit.be03c316

package/dest/deprecated/indexeddb/index.d.ts

@@ -1,13 +1,7 @@
-import { type Logger } from '@aztec/foundation/log';
-import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import { AztecIndexedDBStore } from './store.js';
 export { AztecIndexedDBStore } from './store.js';
-/**
- * @deprecated The IndexedDB backend is being retired. Use `@aztec/kv-store/sqlite-opfs` instead.
- */
-export declare function createStore(name: string, config: DataStoreConfig, schemaVersion?: number | undefined, log?: Logger): Promise<AztecIndexedDBStore>;
 /**
  * @deprecated The IndexedDB backend is being retired. Use `@aztec/kv-store/sqlite-opfs` instead.
  */
 export declare function openTmpStore(ephemeral?: boolean): Promise<AztecIndexedDBStore>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZXByZWNhdGVkL2luZGV4ZWRkYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFHOUQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRWpELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVqRDs7R0FFRztBQUNILHdCQUFzQixXQUFXLENBQy9CLElBQUksRUFBRSxNQUFNLEVBQ1osTUFBTSxFQUFFLGVBQWUsRUFDdkIsYUFBYSxHQUFFLE1BQU0sR0FBRyxTQUFxQixFQUM3QyxHQUFHLEdBQUUsTUFBaUMsZ0NBY3ZDO0FBRUQ7O0dBRUc7QUFDSCx3QkFBZ0IsWUFBWSxDQUFDLFNBQVMsR0FBRSxPQUFlLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBRXJGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZXByZWNhdGVkL2luZGV4ZWRkYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFakQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRWpEOztHQUVHO0FBQ0gsd0JBQWdCLFlBQVksQ0FBQyxTQUFTLEdBQUUsT0FBZSxHQUFHLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUVyRiJ9

package/dest/deprecated/indexeddb/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/deprecated/indexeddb/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,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,aAAa,GAAE,MAAM,GAAG,SAAqB,EAC7C,GAAG,GAAE,MAAiC,gCAcvC;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,GAAE,OAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAErF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/deprecated/indexeddb/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjD;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,GAAE,OAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAErF"}

package/dest/deprecated/indexeddb/index.js

@@ -1,18 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
-import { initStoreForRollupAndSchemaVersion } from '../../utils.js';
 import { AztecIndexedDBStore } from './store.js';
 export { AztecIndexedDBStore } from './store.js';
-/**
- * @deprecated The IndexedDB backend is being retired. Use `@aztec/kv-store/sqlite-opfs` instead.
- */ export async function createStore(name, config, schemaVersion = undefined, log = createLogger('kv-store')) {
-    let { dataDirectory } = config;
-    if (typeof dataDirectory !== 'undefined') {
-        dataDirectory = `${dataDirectory}/${name}`;
-    }
-    log.info(dataDirectory ? `Creating ${name} data store at directory ${dataDirectory} with map size ${config.dataStoreMapSizeKb} KB` : `Creating ${name} ephemeral data store with map size ${config.dataStoreMapSizeKb} KB`);
-    const store = await AztecIndexedDBStore.open(createLogger('kv-store:indexeddb'), dataDirectory ?? '', false);
-    return initStoreForRollupAndSchemaVersion(store, schemaVersion, config.rollupAddress, log);
-}
 /**
  * @deprecated The IndexedDB backend is being retired. Use `@aztec/kv-store/sqlite-opfs` instead.
  */ export function openTmpStore(ephemeral = false) {

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

@@ -24,4 +24,31 @@ export declare class SqliteEncryptionError extends Error {
  * strings.
  **/
 export declare function isDecryptFailureMessage(message: string): boolean;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLE1BQU0seUJBQXlCLEdBQ2pDLG9CQUFvQixHQUNwQix3Q0FBd0MsR0FDeEMsZ0JBQWdCLENBQUM7QUFFckI7O0lBRUk7QUFDSixxQkFBYSxxQkFBc0IsU0FBUSxLQUFLO0lBQzlDLFFBQVEsQ0FBQyxJQUFJLEVBQUUseUJBQXlCLENBQUM7SUFFekMsWUFBWSxJQUFJLEVBQUUseUJBQXlCLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRTtRQUFFLEtBQUssQ0FBQyxFQUFFLE9BQU8sQ0FBQTtLQUFFLEVBSXZGO0NBQ0Y7QUFVRDs7O0lBR0k7QUFDSix3QkFBZ0IsdUJBQXVCLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBRWhFIn0=
+/**
+ * Error thrown by sqlite-opfs when the on-disk database image is corrupt
+ * (`SQLITE_CORRUPT`, result code 11 — "database disk image is malformed").
+ *
+ * Distinct from {@link SqliteEncryptionError}: no key recovers a corrupt image,
+ * so there is nothing to retry. The only escape is to delete the store and start
+ * fresh, so consumers pattern-match on `instanceof SqliteCorruptionError` to wipe
+ * and reopen rather than surfacing a dead-end error.
+ **/
+export declare class SqliteCorruptionError extends Error {
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
+}
+/** Error thrown when another browser context already owns a store's OPFS pool. */
+export declare class SqlitePoolBusyError extends Error {
+    readonly poolDirectory: string;
+    constructor(poolDirectory: string);
+}
+/** Error thrown when the browser context does not expose the Web Locks API required by the OPFS SAH pool. */
+export declare class SqliteWebLocksUnavailableError extends Error {
+    constructor();
+}
+/**
+ * Returns `true` if `message` matches one of the known SQLite corruption strings.
+ **/
+export declare function isCorruptionMessage(message: string): boolean;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLE1BQU0seUJBQXlCLEdBQ2pDLG9CQUFvQixHQUNwQix3Q0FBd0MsR0FDeEMsZ0JBQWdCLENBQUM7QUFFckI7O0lBRUk7QUFDSixxQkFBYSxxQkFBc0IsU0FBUSxLQUFLO0lBQzlDLFFBQVEsQ0FBQyxJQUFJLEVBQUUseUJBQXlCLENBQUM7SUFFekMsWUFBWSxJQUFJLEVBQUUseUJBQXlCLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRTtRQUFFLEtBQUssQ0FBQyxFQUFFLE9BQU8sQ0FBQTtLQUFFLEVBSXZGO0NBQ0Y7QUFVRDs7O0lBR0k7QUFDSix3QkFBZ0IsdUJBQXVCLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBRWhFO0FBRUQ7Ozs7Ozs7O0lBUUk7QUFDSixxQkFBYSxxQkFBc0IsU0FBUSxLQUFLO0lBQzlDLFlBQVksT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRTtRQUFFLEtBQUssQ0FBQyxFQUFFLE9BQU8sQ0FBQTtLQUFFLEVBR3REO0NBQ0Y7QUFFRCxrRkFBa0Y7QUFDbEYscUJBQWEsbUJBQW9CLFNBQVEsS0FBSzthQUNoQixhQUFhLEVBQUUsTUFBTTtJQUFqRCxZQUE0QixhQUFhLEVBQUUsTUFBTSxFQUdoRDtDQUNGO0FBRUQsNkdBQTZHO0FBQzdHLHFCQUFhLDhCQUErQixTQUFRLEtBQUs7SUFDdkQsY0FHQztDQUNGO0FBYUQ7O0lBRUk7QUFDSix3QkFBZ0IsbUJBQW1CLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBRTVEIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,yBAAyB,GACjC,oBAAoB,GACpB,wCAAwC,GACxC,gBAAgB,CAAC;AAErB;;IAEI;AACJ,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IAEzC,YAAY,IAAI,EAAE,yBAAyB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAIvF;CACF;AAUD;;;IAGI;AACJ,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEhE"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,yBAAyB,GACjC,oBAAoB,GACpB,wCAAwC,GACxC,gBAAgB,CAAC;AAErB;;IAEI;AACJ,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IAEzC,YAAY,IAAI,EAAE,yBAAyB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAIvF;CACF;AAUD;;;IAGI;AACJ,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;;;;;;;IAQI;AACJ,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAGtD;CACF;AAED,kFAAkF;AAClF,qBAAa,mBAAoB,SAAQ,KAAK;aAChB,aAAa,EAAE,MAAM;IAAjD,YAA4B,aAAa,EAAE,MAAM,EAGhD;CACF;AAED,6GAA6G;AAC7G,qBAAa,8BAA+B,SAAQ,KAAK;IACvD,cAGC;CACF;AAaD;;IAEI;AACJ,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D"}

package/dest/sqlite-opfs/errors.js

@@ -32,3 +32,46 @@
  **/ export function isDecryptFailureMessage(message) {
     return SQLITE3MC_DECRYPT_ERROR_PATTERNS.some((p)=>p.test(message));
 }
+/**
+ * Error thrown by sqlite-opfs when the on-disk database image is corrupt
+ * (`SQLITE_CORRUPT`, result code 11 — "database disk image is malformed").
+ *
+ * Distinct from {@link SqliteEncryptionError}: no key recovers a corrupt image,
+ * so there is nothing to retry. The only escape is to delete the store and start
+ * fresh, so consumers pattern-match on `instanceof SqliteCorruptionError` to wipe
+ * and reopen rather than surfacing a dead-end error.
+ **/ export class SqliteCorruptionError extends Error {
+    constructor(message, opts){
+        super(message, opts?.cause !== undefined ? {
+            cause: opts.cause
+        } : undefined);
+        this.name = 'SqliteCorruptionError';
+    }
+}
+/** Error thrown when another browser context already owns a store's OPFS pool. */ export class SqlitePoolBusyError extends Error {
+    poolDirectory;
+    constructor(poolDirectory){
+        super(`SQLite-OPFS pool "${poolDirectory}" is already in use by another store instance`), this.poolDirectory = poolDirectory;
+        this.name = 'SqlitePoolBusyError';
+    }
+}
+/** Error thrown when the browser context does not expose the Web Locks API required by the OPFS SAH pool. */ export class SqliteWebLocksUnavailableError extends Error {
+    constructor(){
+        super('SQLite-OPFS requires the Web Locks API, but it is unavailable in this browser context');
+        this.name = 'SqliteWebLocksUnavailableError';
+    }
+}
+/**
+ * Strings/codes raised by SQLite when a database image is corrupt. Kept disjoint
+ * from {@link SQLITE3MC_DECRYPT_ERROR_PATTERNS}: "file is not a database"
+ * (SQLITE_NOTADB) is the decrypt signal, whereas a malformed image is the
+ * genuinely-unrecoverable SQLITE_CORRUPT.
+ **/ const SQLITE_CORRUPTION_ERROR_PATTERNS = [
+    /database disk image is malformed/i,
+    /\bSQLITE_CORRUPT\b/i
+];
+/**
+ * Returns `true` if `message` matches one of the known SQLite corruption strings.
+ **/ export function isCorruptionMessage(message) {
+    return SQLITE_CORRUPTION_ERROR_PATTERNS.some((p)=>p.test(message));
+}

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

@@ -1,10 +1,8 @@
-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 { SqliteEncryptionError } from './errors.js';
+export { SqliteCorruptionError, SqliteEncryptionError, SqlitePoolBusyError, SqliteWebLocksUnavailableError, } from './errors.js';
 export type { SqliteEncryptionErrorCode } from './errors.js';
-export declare function createStore(name: string, config: DataStoreConfig, schemaVersion?: number | undefined, log?: Logger): Promise<AztecSQLiteOPFSStore>;
+export { OPFS_POOL_DIR_PREFIX, deletePoolDirectory, deleteStore, listStores, storePoolDirectory } from './manage.js';
 export declare function openTmpStore(ephemeral?: boolean): Promise<AztecSQLiteOPFSStore>;
 /**
  * Convenience helper for tests and consumers that want an encrypted sqlite-opfs
@@ -13,4 +11,4 @@ export declare function openTmpStore(ephemeral?: boolean): Promise<AztecSQLiteOP
  * on ephemeral `:memory:` databases) in an auto-generated OPFS directory.
  */
 export declare function openEncryptedStore(encryptionKey: Uint8Array, name?: string, poolDirectory?: string): Promise<AztecSQLiteOPFSStore>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUtb3Bmcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFHOUQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRWxELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUNsRCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDcEQsWUFBWSxFQUFFLHlCQUF5QixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRTdELHdCQUFzQixXQUFXLENBQy9CLElBQUksRUFBRSxNQUFNLEVBQ1osTUFBTSxFQUFFLGVBQWUsRUFDdkIsYUFBYSxHQUFFLE1BQU0sR0FBRyxTQUFxQixFQUM3QyxHQUFHLEdBQUUsTUFBaUMsaUNBVXZDO0FBRUQsd0JBQWdCLFlBQVksQ0FBQyxTQUFTLEdBQUUsT0FBZSxHQUFHLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQyxDQUV0RjtBQUVEOzs7OztHQUtHO0FBQ0gsd0JBQWdCLGtCQUFrQixDQUFDLGFBQWEsRUFBRSxVQUFVLEVBQUUsSUFBSSxDQUFDLEVBQUUsTUFBTSxFQUFFLGFBQWEsQ0FBQyxFQUFFLE1BQU0saUNBRWxHIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUtb3Bmcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFbEQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQ2xELE9BQU8sRUFDTCxxQkFBcUIsRUFDckIscUJBQXFCLEVBQ3JCLG1CQUFtQixFQUNuQiw4QkFBOEIsR0FDL0IsTUFBTSxhQUFhLENBQUM7QUFDckIsWUFBWSxFQUFFLHlCQUF5QixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQzdELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxtQkFBbUIsRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLGtCQUFrQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRXJILHdCQUFnQixZQUFZLENBQUMsU0FBUyxHQUFFLE9BQWUsR0FBRyxPQUFPLENBQUMsb0JBQW9CLENBQUMsQ0FFdEY7QUFFRDs7Ozs7R0FLRztBQUNILHdCQUFnQixrQkFBa0IsQ0FBQyxhQUFhLEVBQUUsVUFBVSxFQUFFLElBQUksQ0FBQyxFQUFFLE1BQU0sRUFBRSxhQUFhLENBQUMsRUFBRSxNQUFNLGlDQUVsRyJ9

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

@@ -1 +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;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D,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;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,iCAElG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,8BAA8B,GAC/B,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,WAAW,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAErH,wBAAgB,YAAY,CAAC,SAAS,GAAE,OAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAEtF;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,iCAElG"}

package/dest/sqlite-opfs/index.js

@@ -1,14 +1,8 @@
 import { createLogger } from '@aztec/foundation/log';
-import { initStoreForRollupAndSchemaVersion } from '../utils.js';
 import { AztecSQLiteOPFSStore } from './store.js';
 export { AztecSQLiteOPFSStore } from './store.js';
-export { SqliteEncryptionError } from './errors.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.rollupAddress, log);
-}
+export { SqliteCorruptionError, SqliteEncryptionError, SqlitePoolBusyError, SqliteWebLocksUnavailableError } from './errors.js';
+export { OPFS_POOL_DIR_PREFIX, deletePoolDirectory, deleteStore, listStores, storePoolDirectory } from './manage.js';
 export function openTmpStore(ephemeral = false) {
     return AztecSQLiteOPFSStore.open(createLogger('kv-store:sqlite-opfs'), undefined, ephemeral);
 }

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

@@ -0,0 +1,22 @@
+/** Prefix for the per-store OPFS SAH pool directories owned by this package. */
+export declare const OPFS_POOL_DIR_PREFIX = ".aztec-kv-";
+/**
+ * OPFS directory holding a store's SAH pool. One directory per store: the SAH-pool VFS allows only one
+ * concurrent instance per directory and its capacity does not grow automatically, so sharing a pool across
+ * stores would make concurrently opened stores contend for locks and orphaned stores exhaust pool slots.
+ */
+export declare function storePoolDirectory(effectiveName: string): string;
+/**
+ * Lists the names of every persistent sqlite-opfs store in this origin, by enumerating the per-store pool
+ * directories. Includes stores other than the current one, so wallets can surface and clean up data for
+ * networks/versions no longer in use.
+ */
+export declare function listStores(): Promise<string[]>;
+/**
+ * Permanently deletes a store by effective name (as returned by {@link listStores}). The store must be closed:
+ * an open store holds the directory's Web Lock and the removal will reject with `SqlitePoolBusyError`.
+ */
+export declare function deleteStore(effectiveName: string): Promise<void>;
+/** Permanently deletes one OPFS SAH-pool directory after exclusively locking it. */
+export declare function deletePoolDirectory(poolDirectory: string): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuYWdlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvbWFuYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLGdGQUFnRjtBQUNoRixlQUFPLE1BQU0sb0JBQW9CLGVBQWUsQ0FBQztBQUVqRDs7OztHQUlHO0FBQ0gsd0JBQWdCLGtCQUFrQixDQUFDLGFBQWEsRUFBRSxNQUFNLEdBQUcsTUFBTSxDQUVoRTtBQUVEOzs7O0dBSUc7QUFDSCx3QkFBc0IsVUFBVSxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQVNwRDtBQUVEOzs7R0FHRztBQUNILHdCQUFzQixXQUFXLENBQUMsYUFBYSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRXRFO0FBRUQsb0ZBQW9GO0FBQ3BGLHdCQUFzQixtQkFBbUIsQ0FBQyxhQUFhLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FNOUUifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"manage.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/manage.ts"],"names":[],"mappings":"AAEA,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED;;;;GAIG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CASpD;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtE;AAED,oFAAoF;AACpF,wBAAsB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM9E"}

package/dest/sqlite-opfs/manage.js

@@ -0,0 +1,38 @@
+import { normalizePoolDirectory, withPoolLock } from './pool_lock.js';
+/** Prefix for the per-store OPFS SAH pool directories owned by this package. */ export const OPFS_POOL_DIR_PREFIX = '.aztec-kv-';
+/**
+ * OPFS directory holding a store's SAH pool. One directory per store: the SAH-pool VFS allows only one
+ * concurrent instance per directory and its capacity does not grow automatically, so sharing a pool across
+ * stores would make concurrently opened stores contend for locks and orphaned stores exhaust pool slots.
+ */ export function storePoolDirectory(effectiveName) {
+    return `${OPFS_POOL_DIR_PREFIX}${effectiveName}`;
+}
+/**
+ * Lists the names of every persistent sqlite-opfs store in this origin, by enumerating the per-store pool
+ * directories. Includes stores other than the current one, so wallets can surface and clean up data for
+ * networks/versions no longer in use.
+ */ export async function listStores() {
+    const root = await navigator.storage.getDirectory();
+    const names = [];
+    for await (const [entryName, handle] of root.entries()){
+        if (handle.kind === 'directory' && entryName.startsWith(OPFS_POOL_DIR_PREFIX)) {
+            names.push(entryName.slice(OPFS_POOL_DIR_PREFIX.length));
+        }
+    }
+    return names;
+}
+/**
+ * Permanently deletes a store by effective name (as returned by {@link listStores}). The store must be closed:
+ * an open store holds the directory's Web Lock and the removal will reject with `SqlitePoolBusyError`.
+ */ export async function deleteStore(effectiveName) {
+    await deletePoolDirectory(storePoolDirectory(effectiveName));
+}
+/** Permanently deletes one OPFS SAH-pool directory after exclusively locking it. */ export async function deletePoolDirectory(poolDirectory) {
+    poolDirectory = normalizePoolDirectory(poolDirectory);
+    await withPoolLock(poolDirectory, async ()=>{
+        const root = await navigator.storage.getDirectory();
+        await root.removeEntry(poolDirectory, {
+            recursive: true
+        });
+    });
+}

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"}

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();
+    }
+}