@powersync/web 1.10.2 → 1.12.0

package/dist/worker/node_modules_journeyapps_wa-sqlite_src_examples_IDBBatchAtomicVFS_js.umd.js

@@ -1,6 +1,529 @@
 "use strict";
 (self["webpackChunksdk_web"] = self["webpackChunksdk_web"] || []).push([["node_modules_journeyapps_wa-sqlite_src_examples_IDBBatchAtomicVFS_js"],{
 
+/***/ "../../node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js":
+/*!******************************************************************!*\
+  !*** ../../node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js ***!
+  \******************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   FacadeVFS: () => (/* binding */ FacadeVFS)
+/* harmony export */ });
+/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./VFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+
+
+const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+
+// Convenience base class for a JavaScript VFS.
+// The raw xOpen, xRead, etc. function signatures receive only C primitives
+// which aren't easy to work with. This class provides corresponding calls
+// like jOpen, jRead, etc., which receive JavaScript-friendlier arguments
+// such as string, Uint8Array, and DataView.
+class FacadeVFS extends _VFS_js__WEBPACK_IMPORTED_MODULE_0__.Base {
+  /**
+   * @param {string} name 
+   * @param {object} module 
+   */
+  constructor(name, module) {
+    super(name, module);
+  }
+
+  /**
+   * Override to indicate which methods are asynchronous.
+   * @param {string} methodName 
+   * @returns {boolean}
+   */
+  hasAsyncMethod(methodName) {
+    // The input argument is a string like "xOpen", so convert to "jOpen".
+    // Then check if the method exists and is async.
+    const jMethodName = `j${methodName.slice(1)}`;
+    return this[jMethodName] instanceof AsyncFunction;
+  }
+  
+  /**
+   * Return the filename for a file id for use by mixins.
+   * @param {number} pFile 
+   * @returns {string}
+   */
+  getFilename(pFile) {
+    throw new Error('unimplemented');
+  }
+
+  /**
+   * @param {string?} filename 
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @param {DataView} pOutFlags 
+   * @returns {number|Promise<number>}
+   */
+  jOpen(filename, pFile, flags, pOutFlags) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN;
+  }
+
+  /**
+   * @param {string} filename 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
+   */
+  jDelete(filename, syncDir) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {string} filename 
+   * @param {number} flags 
+   * @param {DataView} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  jAccess(filename, flags, pResOut) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {string} filename 
+   * @param {Uint8Array} zOut 
+   * @returns {number|Promise<number>}
+   */
+  jFullPathname(filename, zOut) {
+    // Copy the filename to the output buffer.
+    const { read, written } = new TextEncoder().encodeInto(filename, zOut);
+    if (read < filename.length) return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+    if (written >= zOut.length) return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+    zOut[written] = 0;
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {Uint8Array} zBuf 
+   * @returns {number|Promise<number>}
+   */
+  jGetLastError(zBuf) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  jClose(pFile) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset 
+   * @returns {number|Promise<number>}
+   */
+  jRead(pFile, pData, iOffset) {
+    pData.fill(0);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SHORT_READ;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset 
+   * @returns {number|Promise<number>}
+   */
+  jWrite(pFile, pData, iOffset) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_WRITE;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} size 
+   * @returns {number|Promise<number>}
+   */
+  jTruncate(pFile, size) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @returns {number|Promise<number>}
+   */
+  jSync(pFile, flags) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {DataView} pSize
+   * @returns {number|Promise<number>}
+   */
+  jFileSize(pFile, pSize) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  jLock(pFile, lockType) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  jUnlock(pFile, lockType) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {DataView} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  jCheckReservedLock(pFile, pResOut) {
+    pResOut.setInt32(0, 0, true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile
+   * @param {number} op
+   * @param {DataView} pArg
+   * @returns {number|Promise<number>}
+   */
+  jFileControl(pFile, op, pArg) {
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND;
+  }
+
+  /**
+   * @param {number} pFile
+   * @returns {number|Promise<number>}
+   */
+  jSectorSize(pFile) {
+    return super.xSectorSize(pFile);
+  }
+
+  /**
+   * @param {number} pFile
+   * @returns {number|Promise<number>}
+   */
+  jDeviceCharacteristics(pFile) {
+    return 0;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @param {number} pOutFlags 
+   * @returns {number|Promise<number>}
+   */
+  xOpen(pVfs, zName, pFile, flags, pOutFlags) {
+    const filename = this.#decodeFilename(zName, flags);
+    const pOutFlagsView = this.#makeTypedDataView('Int32', pOutFlags);
+    this['log']?.('jOpen', filename, pFile, '0x' + flags.toString(16));
+    return this.jOpen(filename, pFile, flags, pOutFlagsView);
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
+   */
+  xDelete(pVfs, zName, syncDir) {
+    const filename = this._module.UTF8ToString(zName);
+    this['log']?.('jDelete', filename, syncDir);
+    return this.jDelete(filename, syncDir);
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} flags 
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  xAccess(pVfs, zName, flags, pResOut) {
+    const filename = this._module.UTF8ToString(zName);
+    const pResOutView = this.#makeTypedDataView('Int32', pResOut);
+    this['log']?.('jAccess', filename, flags);
+    return this.jAccess(filename, flags, pResOutView);
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} nOut 
+   * @param {number} zOut 
+   * @returns {number|Promise<number>}
+   */
+  xFullPathname(pVfs, zName, nOut, zOut) {
+    const filename = this._module.UTF8ToString(zName);
+    const zOutArray = this._module.HEAPU8.subarray(zOut, zOut + nOut);
+    this['log']?.('jFullPathname', filename, nOut);
+    return this.jFullPathname(filename, zOutArray);
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} nBuf 
+   * @param {number} zBuf 
+   * @returns {number|Promise<number>}
+   */
+  xGetLastError(pVfs, nBuf, zBuf) {
+    const zBufArray = this._module.HEAPU8.subarray(zBuf, zBuf + nBuf);
+    this['log']?.('jGetLastError', nBuf);
+    return this.jGetLastError(zBufArray);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xClose(pFile) {
+    this['log']?.('jClose', pFile);
+    return this.jClose(pFile);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pData 
+   * @param {number} iAmt 
+   * @param {number} iOffsetLo 
+   * @param {number} iOffsetHi 
+   * @returns {number|Promise<number>}
+   */
+  xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
+    const pDataArray = this.#makeDataArray(pData, iAmt);
+    const iOffset = delegalize(iOffsetLo, iOffsetHi);
+    this['log']?.('jRead', pFile, iAmt, iOffset);
+    return this.jRead(pFile, pDataArray, iOffset);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pData 
+   * @param {number} iAmt 
+   * @param {number} iOffsetLo 
+   * @param {number} iOffsetHi 
+   * @returns {number|Promise<number>}
+   */
+  xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
+    const pDataArray = this.#makeDataArray(pData, iAmt);
+    const iOffset = delegalize(iOffsetLo, iOffsetHi);
+    this['log']?.('jWrite', pFile, pDataArray, iOffset);
+    return this.jWrite(pFile, pDataArray, iOffset);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} sizeLo 
+   * @param {number} sizeHi 
+   * @returns {number|Promise<number>}
+   */
+  xTruncate(pFile, sizeLo, sizeHi) {
+    const size = delegalize(sizeLo, sizeHi);
+    this['log']?.('jTruncate', pFile, size);
+    return this.jTruncate(pFile, size);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @returns {number|Promise<number>}
+   */
+  xSync(pFile, flags) {
+    this['log']?.('jSync', pFile, flags);
+    return this.jSync(pFile, flags);
+  }
+
+  /**
+   * 
+   * @param {number} pFile 
+   * @param {number} pSize 
+   * @returns {number|Promise<number>}
+   */
+  xFileSize(pFile, pSize) {
+    const pSizeView = this.#makeTypedDataView('BigInt64', pSize);
+    this['log']?.('jFileSize', pFile);
+    return this.jFileSize(pFile, pSizeView);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  xLock(pFile, lockType) {
+    this['log']?.('jLock', pFile, lockType);
+    return this.jLock(pFile, lockType);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  xUnlock(pFile, lockType) {
+    this['log']?.('jUnlock', pFile, lockType);
+    return this.jUnlock(pFile, lockType);
+  } 
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  xCheckReservedLock(pFile, pResOut) {
+    const pResOutView = this.#makeTypedDataView('Int32', pResOut);
+    this['log']?.('jCheckReservedLock', pFile);
+    return this.jCheckReservedLock(pFile, pResOutView);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} op 
+   * @param {number} pArg 
+   * @returns {number|Promise<number>}
+   */
+  xFileControl(pFile, op, pArg) {
+    const pArgView = new DataView(
+      this._module.HEAPU8.buffer,
+      this._module.HEAPU8.byteOffset + pArg);
+    this['log']?.('jFileControl', pFile, op, pArgView);
+    return this.jFileControl(pFile, op, pArgView);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xSectorSize(pFile) {
+    this['log']?.('jSectorSize', pFile);
+    return this.jSectorSize(pFile);
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xDeviceCharacteristics(pFile) {
+    this['log']?.('jDeviceCharacteristics', pFile);
+    return this.jDeviceCharacteristics(pFile);
+  }
+
+  /**
+   * Wrapped DataView for pointer arguments.
+   * Pointers to a single value are passed using DataView. A Proxy
+   * wrapper prevents use of incorrect type or endianness.
+   * @param {'Int32'|'BigInt64'} type 
+   * @param {number} byteOffset 
+   * @returns {DataView}
+   */
+  #makeTypedDataView(type, byteOffset) {
+    const byteLength = type === 'Int32' ? 4 : 8;
+    const getter = `get${type}`;
+    const setter = `set${type}`;
+    const makeDataView = () => new DataView(
+      this._module.HEAPU8.buffer,
+      this._module.HEAPU8.byteOffset + byteOffset,
+      byteLength);
+    let dataView = makeDataView();
+    return new Proxy(dataView, {
+      get(_, prop) {
+        if (dataView.buffer.byteLength === 0) {
+          // WebAssembly memory resize detached the buffer.
+          dataView = makeDataView();
+        }
+        if (prop === getter) {
+          return function(byteOffset, littleEndian) {
+            if (!littleEndian) throw new Error('must be little endian');
+            return dataView[prop](byteOffset, littleEndian);
+          }
+        }
+        if (prop === setter) {
+          return function(byteOffset, value, littleEndian) {
+            if (!littleEndian) throw new Error('must be little endian');
+            return dataView[prop](byteOffset, value, littleEndian);
+          }
+        }
+        if (typeof prop === 'string' && (prop.match(/^(get)|(set)/))) {
+          throw new Error('invalid type');
+        }
+        const result = dataView[prop];
+        return typeof result === 'function' ? result.bind(dataView) : result;
+      }
+    });
+  }
+
+  /**
+   * @param {number} byteOffset 
+   * @param {number} byteLength 
+   */
+  #makeDataArray(byteOffset, byteLength) {
+    let target = this._module.HEAPU8.subarray(byteOffset, byteOffset + byteLength);
+    return new Proxy(target, {
+      get: (_, prop, receiver) => {
+        if (target.buffer.byteLength === 0) {
+          // WebAssembly memory resize detached the buffer.
+          target = this._module.HEAPU8.subarray(byteOffset, byteOffset + byteLength);
+        }
+        const result = target[prop];
+        return typeof result === 'function' ? result.bind(target) : result;
+      }
+    });
+  }
+
+  #decodeFilename(zName, flags) {
+    if (flags & _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_URI) {
+      // The first null-terminated string is the URI path. Subsequent
+      // strings are query parameter keys and values.
+      // https://www.sqlite.org/c3ref/open.html#urifilenamesinsqlite3open
+      let pName = zName;
+      let state = 1;
+      const charCodes = [];
+      while (state) {
+        const charCode = this._module.HEAPU8[pName++];
+        if (charCode) {
+          charCodes.push(charCode);
+        } else {
+          if (!this._module.HEAPU8[pName]) state = null;
+          switch (state) {
+            case 1: // path
+              charCodes.push('?'.charCodeAt(0));
+              state = 2;
+              break;
+            case 2: // key
+              charCodes.push('='.charCodeAt(0));
+              state = 3;
+              break;
+            case 3: // value
+              charCodes.push('&'.charCodeAt(0));
+              state = 2;
+              break;
+          }
+        }
+      }
+      return  new TextDecoder().decode(new Uint8Array(charCodes));
+    }
+    return zName ? this._module.UTF8ToString(zName) : null;
+  }
+}
+
+// Emscripten "legalizes" 64-bit integer arguments by passing them as
+// two 32-bit signed integers.
+function delegalize(lo32, hi32) {
+  return (hi32 * 0x100000000) + lo32 + (lo32 < 0 ? 2**32 : 0);
+}
+
+
+/***/ }),
+
 /***/ "../../node_modules/@journeyapps/wa-sqlite/src/VFS.js":
 /*!************************************************************!*\
   !*** ../../node_modules/@journeyapps/wa-sqlite/src/VFS.js ***!
@@ -215,6 +738,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   SQLITE_OPEN_WAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_WAL),
 /* harmony export */   SQLITE_PERM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PERM),
 /* harmony export */   SQLITE_PRAGMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PRAGMA),
+/* harmony export */   SQLITE_PREPARE_NORMALIZED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_NORMALIZED),
+/* harmony export */   SQLITE_PREPARE_NO_VTAB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_NO_VTAB),
+/* harmony export */   SQLITE_PREPARE_PERSISTENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_PERSISTENT),
 /* harmony export */   SQLITE_PROTOCOL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PROTOCOL),
 /* harmony export */   SQLITE_RANGE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RANGE),
 /* harmony export */   SQLITE_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_READ),
@@ -242,166 +768,215 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   SQLITE_WARNING: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_WARNING)
 /* harmony export */ });
 /* harmony import */ var _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sqlite-constants.js */ "../../node_modules/@journeyapps/wa-sqlite/src/sqlite-constants.js");
-// Copyright 2022 Roy T. Hashimoto. All Rights Reserved.
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+
 
 
+const DEFAULT_SECTOR_SIZE = 512;
 
 // Base class for a VFS.
 class Base {
-  mxPathName = 64;
+  name;
+  mxPathname = 64;
+  _module;
 
   /**
-   * @param {number} fileId 
-   * @returns {number}
+   * @param {string} name 
+   * @param {object} module 
    */
-  xClose(fileId) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  constructor(name, module) {
+    this.name = name;
+    this._module = module;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {Uint8Array} pData 
-   * @param {number} iOffset
-   * @returns {number}
+   * @returns {void|Promise<void>} 
    */
-  xRead(fileId, pData, iOffset) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  close() {
   }
 
   /**
-   * @param {number} fileId 
-   * @param {Uint8Array} pData 
-   * @param {number} iOffset
-   * @returns {number}
+   * @returns {boolean|Promise<boolean>}
    */
-  xWrite(fileId, pData, iOffset) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  isReady() {
+    return true;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {number} iSize 
-   * @returns {number}
+   * Overload in subclasses to indicate which methods are asynchronous.
+   * @param {string} methodName 
+   * @returns {boolean}
    */
-  xTruncate(fileId, iSize) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  hasAsyncMethod(methodName) {
+    return false;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {*} flags 
-   * @returns {number}
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} pFile 
+   * @param {number} flags 
+   * @param {number} pOutFlags 
+   * @returns {number|Promise<number>}
    */
-  xSync(fileId, flags) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  xOpen(pVfs, zName, pFile, flags, pOutFlags) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {DataView} pSize64 
-   * @returns {number}
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
    */
-  xFileSize(fileId, pSize64) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  xDelete(pVfs, zName, syncDir) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
+   * @param {number} pVfs 
+   * @param {number} zName 
    * @param {number} flags 
-   * @returns {number}
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
    */
-  xLock(fileId, flags) {
+  xAccess(pVfs, zName, flags, pResOut) {
     return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {number} flags 
-   * @returns {number}
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} nOut 
+   * @param {number} zOut 
+   * @returns {number|Promise<number>}
    */
-  xUnlock(fileId, flags) {
+  xFullPathname(pVfs, zName, nOut, zOut) {
     return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {DataView} pResOut 
-   * @returns {number}
+   * @param {number} pVfs 
+   * @param {number} nBuf 
+   * @param {number} zBuf 
+   * @returns {number|Promise<number>}
    */
-  xCheckReservedLock(fileId, pResOut) {
-    pResOut.setInt32(0, 0, true);
+  xGetLastError(pVfs, nBuf, zBuf) {
     return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {number} op 
-   * @param {DataView} pArg 
-   * @returns {number}
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
    */
-  xFileControl(fileId, op, pArg) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND;
+  xClose(pFile) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @returns {number}
+   * @param {number} pFile 
+   * @param {number} pData 
+   * @param {number} iAmt 
+   * @param {number} iOffsetLo 
+   * @param {number} iOffsetHi 
+   * @returns {number|Promise<number>}
    */
-  xSectorSize(fileId) {
-    return 512;
+  xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @returns {number}
+   * @param {number} pFile 
+   * @param {number} pData 
+   * @param {number} iAmt 
+   * @param {number} iOffsetLo 
+   * @param {number} iOffsetHi 
+   * @returns {number|Promise<number>}
    */
-  xDeviceCharacteristics(fileId) {
-    return 0;
+  xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {string?} name 
-   * @param {number} fileId 
+   * @param {number} pFile 
+   * @param {number} sizeLo 
+   * @param {number} sizeHi 
+   * @returns {number|Promise<number>}
+   */
+  xTruncate(pFile, sizeLo, sizeHi) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
    * @param {number} flags 
-   * @param {DataView} pOutFlags 
-   * @returns {number}
+   * @returns {number|Promise<number>}
    */
-  xOpen(name, fileId, flags, pOutFlags) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN;
+  xSync(pFile, flags) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {string} name 
-   * @param {number} syncDir 
-   * @returns {number}
+   * 
+   * @param {number} pFile 
+   * @param {number} pSize 
+   * @returns {number|Promise<number>}
    */
-  xDelete(name, syncDir) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  xFileSize(pFile, pSize) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {string} name 
-   * @param {number} flags 
-   * @param {DataView} pResOut 
-   * @returns {number}
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
    */
-  xAccess(name, flags, pResOut) {
-    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  xLock(pFile, lockType) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * Handle asynchronous operation. This implementation will be overriden on
-   * registration by an Asyncify build.
-   * @param {function(): Promise<number>} f 
-   * @returns {number}
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  xUnlock(pFile, lockType) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  } 
+
+  /**
+   * @param {number} pFile 
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
    */
-  handleAsync(f) {
-    // This default implementation deliberately does not match the
-    // declared signature. It will be used in testing VFS classes
-    // separately from SQLite. This will work acceptably for methods
-    // that simply return the handleAsync() result without using it.
-    // @ts-ignore
-    return f();
+  xCheckReservedLock(pFile, pResOut) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} op 
+   * @param {number} pArg 
+   * @returns {number|Promise<number>}
+   */
+  xFileControl(pFile, op, pArg) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xSectorSize(pFile) {
+    return DEFAULT_SECTOR_SIZE;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xDeviceCharacteristics(pFile) {
+    return 0;
   }
 }
 
@@ -412,1514 +987,1274 @@ const FILE_TYPE_MASK = [
   _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_JOURNAL,
   _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TRANSIENT_DB,
   _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUBJOURNAL,
-  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUPER_JOURNAL
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUPER_JOURNAL,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_WAL
 ].reduce((mask, element) => mask | element);
 
 /***/ }),
 
-/***/ "../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js":
-/*!***********************************************************************************!*\
-  !*** ../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js ***!
-  \***********************************************************************************/
+/***/ "../../node_modules/@journeyapps/wa-sqlite/src/WebLocksMixin.js":
+/*!**********************************************************************!*\
+  !*** ../../node_modules/@journeyapps/wa-sqlite/src/WebLocksMixin.js ***!
+  \**********************************************************************/
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   IDBBatchAtomicVFS: () => (/* binding */ IDBBatchAtomicVFS)
+/* harmony export */   WebLocksMixin: () => (/* binding */ WebLocksMixin)
 /* harmony export */ });
-/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../VFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/VFS.js");
-/* harmony import */ var _WebLocks_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./WebLocks.js */ "../../node_modules/@journeyapps/wa-sqlite/src/examples/WebLocks.js");
-/* harmony import */ var _IDBContext_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./IDBContext.js */ "../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBContext.js");
-// Copyright 2022 Roy T. Hashimoto. All Rights Reserved.
+/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./VFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/VFS.js");
 
 
+// Options for navigator.locks.request().
+/** @type {LockOptions} */ const SHARED = { mode: 'shared' };
+/** @type {LockOptions} */ const POLL_SHARED = { ifAvailable: true, mode: 'shared' };
+/** @type {LockOptions} */ const POLL_EXCLUSIVE = { ifAvailable: true, mode: 'exclusive' };
 
-
-const SECTOR_SIZE = 512;
-const MAX_TASK_MILLIS = 3000;
+const POLICIES = ['exclusive', 'shared', 'shared+hint'];
 
 /**
- * @typedef VFSOptions
- * @property {"default"|"strict"|"relaxed"} [durability]
- * @property {"deferred"|"manual"} [purge]
- * @property {number} [purgeAtLeast]
+ * @typedef LockState
+ * @property {string} baseName
+ * @property {number} type
+ * @property {boolean} writeHint
+ * 
+ * These properties are functions that release a specific lock.
+ * @property {(() => void)?} [gate]
+ * @property {(() => void)?} [access]
+ * @property {(() => void)?} [reserved]
+ * @property {(() => void)?} [hint]
  */
 
-/** @type {VFSOptions} */
-const DEFAULT_OPTIONS = {
-  durability: "default",
-  purge: "deferred",
-  purgeAtLeast: 16
-};
-
-function log(...args) {
-  // console.debug(...args);
-}
-
-/**
- * @typedef FileBlock IndexedDB object with key [path, offset, version]
- * @property {string} path
- * @property {number} offset negative of position in file
- * @property {number} version
- * @property {Uint8Array} data
- *
- * @property {number} [fileSize] Only present on block 0
-*/
-
 /**
- * @typedef OpenedFileEntry
- * @property {string} path
- * @property {number} flags
- * @property {FileBlock} block0
- * @property {boolean} isMetadataChanged
- * @property {WebLocks} locks
- * 
- * @property {Set<number>} [changedPages]
- * @property {boolean} [overwrite]
+ * Mix-in for FacadeVFS that implements the SQLite VFS locking protocol.
+ * @param {*} superclass FacadeVFS (or subclass)
+ * @returns 
  */
-
-// This sample VFS stores optionally versioned writes to IndexedDB, which
-// it uses with the SQLite xFileControl() batch atomic write feature.
-class IDBBatchAtomicVFS extends _VFS_js__WEBPACK_IMPORTED_MODULE_0__.Base {
-  #options;
-  /** @type {Map<number, OpenedFileEntry>} */ #mapIdToFile = new Map();
-
-  /** @type {IDBContext} */ #idb;
-  /** @type {Set<string>} */ #pendingPurges = new Set();
-
-  #taskTimestamp = performance.now();
-  #pendingAsync = new Set();
-
-  // Asyncify can grow WebAssembly memory during an asynchronous call.
-  // If this happens, then any array buffer arguments will be detached.
-  // The workaround is when finding a detached buffer, set this handler
-  // function to process the new buffer outside handlerAsync().
-  #growthHandler = null;
-
-  constructor(idbDatabaseName = 'wa-sqlite', options = DEFAULT_OPTIONS) {
-    super();
-    this.name = idbDatabaseName;
-    this.#options = Object.assign({}, DEFAULT_OPTIONS, options);
-    this.#idb = new _IDBContext_js__WEBPACK_IMPORTED_MODULE_2__.IDBContext(openDatabase(idbDatabaseName), {
-      durability: this.#options.durability
-    });
-  }
-
-  async close() {
-    for (const fileId of this.#mapIdToFile.keys()) {
-      await this.xClose(fileId);
+const WebLocksMixin = superclass => class extends superclass {
+  #options = {
+    lockPolicy: 'exclusive',
+    lockTimeout: Infinity
+  };
+
+  /** @type {Map<number, LockState>} */ #mapIdToState = new Map();
+
+  constructor(name, module, options) {
+    super(name, module, options);
+    Object.assign(this.#options, options);
+    if (POLICIES.indexOf(this.#options.lockPolicy) === -1) {
+      throw new Error(`WebLocksMixin: invalid lock mode: ${options.lockPolicy}`);
     }
-
-    await this.#idb?.close();
-    this.#idb = null;
   }
 
   /**
-   * @param {string?} name 
    * @param {number} fileId 
-   * @param {number} flags 
-   * @param {DataView} pOutFlags 
-   * @returns {number}
+   * @param {number} lockType 
+   * @returns {Promise<number>}
    */
-  xOpen(name, fileId, flags, pOutFlags) {
-    const result = this.handleAsync(async () => {
-      if (name === null) name = `null_${fileId}`;
-      log(`xOpen ${name} 0x${fileId.toString(16)} 0x${flags.toString(16)}`);
-
-      try {
-        // Filenames can be URLs, possibly with query parameters.
-        const url = new URL(name, 'http://localhost/');
-        /** @type {OpenedFileEntry} */ const file = {
-          path: url.pathname,
-          flags,
-          block0: null,
-          isMetadataChanged: true,
-          locks: new _WebLocks_js__WEBPACK_IMPORTED_MODULE_1__.WebLocksExclusive(url.pathname)
+  async jLock(fileId, lockType) {
+    try {
+      // Create state on first lock.
+      if (!this.#mapIdToState.has(fileId)) {
+        const name = this.getFilename(fileId);
+        const state = {
+          baseName: name,
+          type: _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE,
+          writeHint: false
         };
-        this.#mapIdToFile.set(fileId, file);
-
-        // Read the first block, which also contains the file metadata.
-        await this.#idb.run('readwrite', async ({blocks}) => {
-          file.block0 = await blocks.get(this.#bound(file, 0));
-          if (!file.block0) {
-            if (flags & _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_CREATE) {
-              file.block0 = {
-                path: file.path,
-                offset: 0,
-                version: 0,
-                data: new Uint8Array(0),
-                fileSize: 0
-              };
-              blocks.put(file.block0);
-            } else {
-              throw new Error(`file not found: ${file.path}`);
-            }
-          }
-        });
-
-        // @ts-ignore
-        if (pOutFlags.buffer.detached || !pOutFlags.buffer.byteLength) {
-          pOutFlags = new DataView(new ArrayBuffer(4));
-          this.#growthHandler = (pOutFlagsNew) => {
-            pOutFlagsNew.setInt32(0, pOutFlags.getInt32(0, true), true);
-          };
-        }
-        pOutFlags.setInt32(0, flags & _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READONLY, true);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-      } catch (e) {
-        console.error(e);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN;
+        this.#mapIdToState.set(fileId, state);
       }
-    });
 
-    this.#growthHandler?.(pOutFlags);
-    this.#growthHandler = null;
-    return result;
+      const lockState = this.#mapIdToState.get(fileId);
+      if (lockType <= lockState.type) return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  
+      switch (this.#options.lockPolicy) {
+        case 'exclusive':
+          return await this.#lockExclusive(lockState, lockType);
+        case 'shared':
+        case 'shared+hint':
+          return await this.#lockShared(lockState, lockType);
+      }
+    } catch (e) {
+      console.error('WebLocksMixin: lock error', e);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_LOCK;
+    }
   }
-
+  
   /**
    * @param {number} fileId 
-   * @returns {number}
+   * @param {number} lockType 
+   * @returns {Promise<number>}
    */
-  xClose(fileId) {
-    return this.handleAsync(async () => {
-      try {
-        const file = this.#mapIdToFile.get(fileId);
-        if (file) {
-          log(`xClose ${file.path}`);
-
-          this.#mapIdToFile.delete(fileId);
-          if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_DELETEONCLOSE) {
-            this.#idb.run('readwrite', ({blocks}) => {
-              blocks.delete(IDBKeyRange.bound([file.path], [file.path, []]));
-            });
-          }
-        }
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-      } catch (e) {
-        console.error(e);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  async jUnlock(fileId, lockType) {
+    try {
+      const lockState = this.#mapIdToState.get(fileId);
+      if (lockType >= lockState.type) return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  
+      switch (this.#options.lockPolicy) {
+        case 'exclusive':
+          return await this.#unlockExclusive(lockState, lockType);
+        case 'shared':
+        case 'shared+hint':
+            return await this.#unlockShared(lockState, lockType);
       }
-    });
+    } catch (e) {
+      console.error('WebLocksMixin: unlock error', e);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_UNLOCK;
+    }
   }
 
   /**
    * @param {number} fileId 
-   * @param {Uint8Array} pData 
-   * @param {number} iOffset
-   * @returns {number}
+   * @param {DataView} pResOut 
+   * @returns {Promise<number>}
    */
-  xRead(fileId, pData, iOffset) {
-    const byteLength = pData.byteLength;
-    const result = this.handleAsync(async () => {
-      const file = this.#mapIdToFile.get(fileId);
-      log(`xRead ${file.path} ${pData.byteLength} ${iOffset}`);
-
-      try {
-        // Read as many blocks as necessary to satisfy the read request.
-        // Usually a read fits within a single write but there is at least
-        // one case - rollback after journal spill - where reads cross
-        // write boundaries so we have to allow for that.
-        const result = await this.#idb.run('readonly', async ({blocks}) => {
-          // @ts-ignore
-          if (pData.buffer.detached || !pData.buffer.byteLength) {
-            // WebAssembly memory has grown, invalidating our buffer. Use
-            // a temporary buffer and copy after this asynchronous call
-            // completes.
-            pData = new Uint8Array(byteLength);
-            this.#growthHandler = (pDataNew) => pDataNew.set(pData);
-          }
-
-          let pDataOffset = 0;
-          while (pDataOffset < pData.byteLength) {
-            // Fetch the IndexedDB block for this file location.
-            const fileOffset = iOffset + pDataOffset;
-            /** @type {FileBlock} */
-            const block = fileOffset < file.block0.data.byteLength ?
-              file.block0 :
-              await blocks.get(this.#bound(file, -fileOffset));
-
-            if (!block || block.data.byteLength - block.offset <= fileOffset) {
-              pData.fill(0, pDataOffset);
-              return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SHORT_READ;
-            }
-
-            const buffer = pData.subarray(pDataOffset);
-            const blockOffset = fileOffset + block.offset;
-            const nBytesToCopy = Math.min(
-              Math.max(block.data.byteLength - blockOffset, 0), // source bytes
-              buffer.byteLength);                               // destination bytes
-            buffer.set(block.data.subarray(blockOffset, blockOffset + nBytesToCopy));
-            pDataOffset += nBytesToCopy;
-          }
-          return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-        });
-        return result;
-      } catch (e) {
-        console.error(e);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  async jCheckReservedLock(fileId, pResOut) {
+    try {
+      const lockState = this.#mapIdToState.get(fileId);
+      switch (this.#options.lockPolicy) {
+        case 'exclusive':
+          return this.#checkReservedExclusive(lockState, pResOut);
+        case 'shared':
+        case 'shared+hint':
+          return await this.#checkReservedShared(lockState, pResOut);
       }
-    });
-
-    this.#growthHandler?.(pData);
-    this.#growthHandler = null;
-    return result;
+    } catch (e) {
+      console.error('WebLocksMixin: check reserved lock error', e);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_CHECKRESERVEDLOCK;
+    }
+    pResOut.setInt32(0, 0, true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {Uint8Array} pData 
-   * @param {number} iOffset
-   * @returns {number}
+   * @param {number} pFile
+   * @param {number} op
+   * @param {DataView} pArg
+   * @returns {number|Promise<number>}
    */
-  xWrite(fileId, pData, iOffset) {
-    // Handle asynchronously every MAX_TASK_MILLIS milliseconds. This is
-    // tricky because Asyncify calls asynchronous methods twice: once
-    // to initiate the call and unwinds the stack, then rewinds the
-    // stack and calls again to retrieve the completed result.
-    const rewound = this.#pendingAsync.has(fileId);
-    if (rewound || performance.now() - this.#taskTimestamp > MAX_TASK_MILLIS) {
-      const result = this.handleAsync(async () => {
-        if (this.handleAsync !== super.handleAsync) {
-          this.#pendingAsync.add(fileId);
-        }
-        await new Promise(resolve => setTimeout(resolve));
-
-        const result = this.#xWriteHelper(fileId, pData.slice(), iOffset);
-        this.#taskTimestamp = performance.now();
-        return result;
-      });
-
-      if (rewound) this.#pendingAsync.delete(fileId);
-      return result;
+  jFileControl(pFile, op, pArg) {
+    const lockState = this.#mapIdToState.get(pFile) ??
+      (() => {
+        // Call jLock() to create the lock state.
+        this.jLock(pFile, _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE);
+        return this.#mapIdToState.get(pFile);
+      })();
+    if (op === WebLocksMixin.WRITE_HINT_OP_CODE &&
+        this.#options.lockPolicy === 'shared+hint'){
+      lockState.writeHint = true;
     }
-    return this.#xWriteHelper(fileId, pData, iOffset);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {Uint8Array} pData 
-   * @param {number} iOffset
-   * @returns {number}
+   * @param {LockState} lockState 
+   * @param {number} lockType 
+   * @returns 
    */
-  #xWriteHelper(fileId, pData, iOffset) {
-    const file = this.#mapIdToFile.get(fileId);
-    log(`xWrite ${file.path} ${pData.byteLength} ${iOffset}`);
-
-    try {
-      // Update file size if appending.
-      const prevFileSize = file.block0.fileSize;
-      if (file.block0.fileSize < iOffset + pData.byteLength) {
-        file.block0.fileSize = iOffset + pData.byteLength;
-        file.isMetadataChanged = true;
-      }
-
-      // Convert the write directly into an IndexedDB object. Our assumption
-      // is that SQLite will only overwrite data with an xWrite of the same
-      // offset and size unless the database page size changes, except when
-      // changing database page size which is handled by #reblockIfNeeded().
-      const block = iOffset === 0 ? file.block0 : {
-        path: file.path,
-        offset: -iOffset,
-        version: file.block0.version,
-        data: null
-      };
-      block.data = pData.slice();
-
-      if (file.changedPages) {
-        // This write is part of a batch atomic write. All writes in the
-        // batch have a new version, so update the changed list to allow
-        // old versions to be eventually deleted.
-        if (prevFileSize === file.block0.fileSize) {
-          file.changedPages.add(-iOffset);
-        }
-
-        // Defer writing block 0 to IndexedDB until batch commit.
-        if (iOffset !== 0) {
-          this.#idb.run('readwrite', ({blocks}) => blocks.put(block));
-        }
-      } else {
-        // Not a batch atomic write so write through.
-        this.#idb.run('readwrite', ({blocks}) => blocks.put(block));
+  async #lockExclusive(lockState, lockType) {
+    if (!lockState.access) {
+      if (!await this.#acquire(lockState, 'access')) {
+        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
       }
-
-      // Clear dirty flag if page 0 was written.
-      file.isMetadataChanged = iOffset === 0 ? false : file.isMetadataChanged;
-      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-    } catch (e) {
-      console.error(e);
-      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+      console.assert(!!lockState.access);
     }
+    lockState.type = lockType;
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {number} iSize 
+   * @param {LockState} lockState 
+   * @param {number} lockType 
    * @returns {number}
    */
-  xTruncate(fileId, iSize) {
-    const file = this.#mapIdToFile.get(fileId);
-    log(`xTruncate ${file.path} ${iSize}`);
-
-    try {
-      Object.assign(file.block0, {
-        fileSize: iSize,
-        data: file.block0.data.slice(0, iSize)
-      });
-
-      // Delete all blocks beyond the file size and update metadata.
-      // This is never called within a transaction.
-      const block0 = Object.assign({}, file.block0);
-      this.#idb.run('readwrite', ({blocks})=> {
-        blocks.delete(this.#bound(file, -Infinity, -iSize));
-        blocks.put(block0);
-      });
-      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-    } catch (e) {
-      console.error(e);
-      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
+  #unlockExclusive(lockState, lockType) {
+    if (lockType === _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE) {
+      lockState.access?.();
+      console.assert(!lockState.access);
     }
+    lockState.type = lockType;
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {number} flags 
+   * @param {LockState} lockState 
+   * @param {DataView} pResOut 
    * @returns {number}
    */
-  xSync(fileId, flags) {
-    // Skip IndexedDB sync if durability is relaxed and the last
-    // sync was recent enough.
-    const rewound = this.#pendingAsync.has(fileId);
-    if (rewound || this.#options.durability !== 'relaxed' ||
-        performance.now() - this.#taskTimestamp > MAX_TASK_MILLIS) {
-      const result = this.handleAsync(async () => {
-        if (this.handleAsync !== super.handleAsync) {
-          this.#pendingAsync.add(fileId);
+  #checkReservedExclusive(lockState, pResOut) {
+    pResOut.setInt32(0, 0, true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {LockState} lockState 
+   * @param {number} lockType 
+   * @returns 
+   */
+  async #lockShared(lockState, lockType) {
+    switch (lockState.type) {
+      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE:
+        switch (lockType) {
+          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED:
+            if (lockState.writeHint) {
+              // xFileControl() has hinted that this transaction will
+              // write. Acquire the hint lock, which is required to reach
+              // the RESERVED state.
+              if (!await this.#acquire(lockState, 'hint')) {
+                // Timeout before lock acquired.
+                return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
+              }
+            }
+
+            // Must have the gate lock to request the access lock.
+            if (!await this.#acquire(lockState, 'gate', SHARED)) {
+                // Timeout before lock acquired.
+                lockState.hint?.();
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
+            }
+            await this.#acquire(lockState, 'access', SHARED);
+            lockState.gate();
+            console.assert(!lockState.gate);
+            console.assert(!!lockState.access);
+            console.assert(!lockState.reserved);
+            break;
+
+          default:
+            throw new Error('unsupported lock transition');
         }
+        break;
+      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED:
+        switch (lockType) {
+          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED:
+            if (this.#options.lockPolicy === 'shared+hint') {
+              // Ideally we should already have the hint lock, but if not
+              // poll for it here.
+              if (!lockState.hint &&
+                !await this.#acquire(lockState, 'hint', POLL_EXCLUSIVE)) {
+                // Another connection has the hint lock so this is a
+                // deadlock. This connection must retry.
+                return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
+              }
+            }
 
-        const result = await this.#xSyncHelper(fileId, flags);
-        this.#taskTimestamp = performance.now();
-        return result;
-      });
+            // Poll for the reserved lock. This should always succeed
+            // if all clients use the 'shared+hint' policy.
+            if (!await this.#acquire(lockState, 'reserved', POLL_EXCLUSIVE)) {
+              // This is a deadlock. The connection holding the reserved
+              // lock blocks us, and it can't acquire an exclusive access
+              // lock because we hold a shared access lock. This connection
+              // must retry.
+              lockState.hint?.();
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
+            }
+            lockState.access();
+            console.assert(!lockState.gate);
+            console.assert(!lockState.access);
+            console.assert(!!lockState.reserved);
+            break;
 
-      if (rewound) this.#pendingAsync.delete(fileId);
-      return result;
-    }
+          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE:
+            // Jumping directly from SHARED to EXCLUSIVE without passing
+            // through RESERVED is only done with a hot journal.
+            if (!await this.#acquire(lockState, 'gate')) {
+              // Timeout before lock acquired.
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
+            }
+            lockState.access();
+            if (!await this.#acquire(lockState, 'access')) {
+              // Timeout before lock acquired.
+              lockState.gate();
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
+            }
+            console.assert(!!lockState.gate);
+            console.assert(!!lockState.access);
+            console.assert(!lockState.reserved);
+            break;
+
+          default:
+            throw new Error('unsupported lock transition');
+        }
+        break;
+      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED:
+        switch (lockType) {
+          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE:
+            // Prevent other connections from entering the SHARED state.
+            if (!await this.#acquire(lockState, 'gate')) {
+              // Timeout before lock acquired.
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
+            }
 
-    const file = this.#mapIdToFile.get(fileId);
-    log(`xSync ${file.path} ${flags}`);
+            // Block until all other connections exit the SHARED state.
+            if (!await this.#acquire(lockState, 'access')) {
+              // Timeout before lock acquired.
+              lockState.gate();
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
+            }
+            console.assert(!!lockState.gate);
+            console.assert(!!lockState.access);
+            console.assert(!!lockState.reserved);
+            break;
+
+          default:
+            throw new Error('unsupported lock transition');
+        }
+        break;
+    }
+    lockState.type = lockType;
     return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {number} flags 
-   * @returns {Promise<number>}
+   * @param {LockState} lockState 
+   * @param {number} lockType 
+   * @returns 
    */
-  async #xSyncHelper(fileId, flags) {
-    const file = this.#mapIdToFile.get(fileId);
-    log(`xSync ${file.path} ${flags}`);
-    try {
-      if (file.isMetadataChanged) {
-        // Metadata has changed so write block 0 to IndexedDB.
-        this.#idb.run('readwrite', async ({blocks}) => {
-          await blocks.put(file.block0);
-        }); 
-        file.isMetadataChanged = false;
+  async #unlockShared(lockState, lockType) {
+    // lockType can only be SQLITE_LOCK_SHARED or SQLITE_LOCK_NONE.
+    if (lockType === _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE) {
+      lockState.access?.();
+      lockState.gate?.();
+      lockState.reserved?.();
+      lockState.hint?.();
+      lockState.writeHint = false;
+      console.assert(!lockState.access);
+      console.assert(!lockState.gate);
+      console.assert(!lockState.reserved);
+      console.assert(!lockState.hint);
+    } else { // lockType === VFS.SQLITE_LOCK_SHARED
+      switch (lockState.type) {
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE:
+          // Release our exclusive access lock and reacquire it with a
+          // shared lock. This should always succeed because we hold
+          // the gate lock.
+          lockState.access();
+          await this.#acquire(lockState, 'access', SHARED);
+
+          // Release our gate and reserved locks. We might not have a
+          // reserved lock if we were handling a hot journal.
+          lockState.gate();
+          lockState.reserved?.();
+          lockState.hint?.();
+          console.assert(!!lockState.access);
+          console.assert(!lockState.gate);
+          console.assert(!lockState.reserved);
+          break;
+
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED:
+          // This transition is rare, probably only on an I/O error
+          // while writing to a journal file.
+          await this.#acquire(lockState, 'access', SHARED);
+          lockState.reserved();
+          lockState.hint?.();
+          console.assert(!!lockState.access);
+          console.assert(!lockState.gate);
+          console.assert(!lockState.reserved);
+          break;
       }
-      await this.#idb.sync();
-    } catch (e) {
-      console.error(e);
-      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
     }
+    lockState.type = lockType;
     return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {DataView} pSize64 
-   * @returns {number}
+   * @param {LockState} lockState 
+   * @param {DataView} pResOut 
+   * @returns {Promise<number>}
    */
-  xFileSize(fileId, pSize64) {
-    const file = this.#mapIdToFile.get(fileId);
-    log(`xFileSize ${file.path}`);
-
-    pSize64.setBigInt64(0, BigInt(file.block0.fileSize), true)
+  async #checkReservedShared(lockState, pResOut) {
+    if (await this.#acquire(lockState, 'reserved', POLL_SHARED)) {
+      // We were able to get the lock so it was not reserved.
+      lockState.reserved();
+      pResOut.setInt32(0, 0, true);
+    } else {
+      pResOut.setInt32(0, 1, true);
+    }
     return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
   }
 
   /**
-   * @param {number} fileId 
-   * @param {number} flags 
-   * @returns {number}
+   * @param {LockState} lockState 
+   * @param {'gate'|'access'|'reserved'|'hint'} name
+   * @param {LockOptions} options 
+   * @returns {Promise<boolean>}
    */
-  xLock(fileId, flags) {
-    return this.handleAsync(async () => {
-      const file = this.#mapIdToFile.get(fileId);
-      log(`xLock ${file.path} ${flags}`);
+  #acquire(lockState, name, options = {}) {
+    console.assert(!lockState[name]);
+    return new Promise(resolve => {
+      if (!options.ifAvailable && this.#options.lockTimeout < Infinity) {
+        // Add a timeout to the lock request.
+        const controller = new AbortController();
+        options = Object.assign({}, options, { signal: controller.signal });
+        setTimeout(() => {
+          controller.abort();
+          resolve?.(false);
+        }, this.#options.lockTimeout);
+      }
 
-      try {
-        // Acquire the lock.
-        const result = await file.locks.lock(flags);
-        if (result === _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK && file.locks.state === _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED) {
-          // Update block 0 in case another connection changed it.
-          file.block0 = await this.#idb.run('readonly', ({blocks}) => {
-            return blocks.get(this.#bound(file, 0));
+      const lockName = `lock##${lockState.baseName}##${name}`;
+      navigator.locks.request(lockName, options, lock => {
+        if (lock) {
+          return new Promise(release => {
+            lockState[name] = () => {
+              release();
+              lockState[name] = null;
+            };
+            resolve(true);
+            resolve = null;
           });
+        } else {
+          lockState[name] = null;
+          resolve(false);
+          resolve = null;
         }
-        return result;
-      } catch (e) {
-        console.error(e);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-      }
+      }).catch(e => {
+        if (e.name !== 'AbortError') throw e;
+      });
     });
   }
+}
 
-  /**
-   * @param {number} fileId 
-   * @param {number} flags 
-   * @returns {number}
-   */
-  xUnlock(fileId, flags) {
-    return this.handleAsync(async () => {
-      const file = this.#mapIdToFile.get(fileId);
-      log(`xUnlock ${file.path} ${flags}`);
-      
-      try {
-        return file.locks.unlock(flags);
-      } catch(e) {
-        console.error(e);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-      }
-    });
-  }
+WebLocksMixin.WRITE_HINT_OP_CODE = -9999;
 
-  /**
-   * @param {number} fileId 
-   * @param {DataView} pResOut 
-   * @returns {number}
-   */
-  xCheckReservedLock(fileId, pResOut) {
-    const result = this.handleAsync(async () => {
-      const file = this.#mapIdToFile.get(fileId);
-      log(`xCheckReservedLock ${file.path}`);
+/***/ }),
 
-      const isReserved = await file.locks.isSomewhereReserved();
-      function setOutput(pResOut) {
-      };
+/***/ "../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js":
+/*!***********************************************************************************!*\
+  !*** ../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js ***!
+  \***********************************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
-      // @ts-ignore
-      if (pResOut.buffer.detached || !pResOut.buffer.byteLength) {
-        pResOut = new DataView(new ArrayBuffer(4));
-        this.#growthHandler = (pResOutNew) => {
-          pResOutNew.setInt32(0, pResOut.getInt32(0, true), true);
-        };
-      }
-      pResOut.setInt32(0, isReserved ? 1 : 0, true);
-      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-    });
-
-    this.#growthHandler?.(pResOut);
-    this.#growthHandler = null;
-    return result;
-  }
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   IDBBatchAtomicVFS: () => (/* binding */ IDBBatchAtomicVFS),
+/* harmony export */   IDBContext: () => (/* binding */ IDBContext)
+/* harmony export */ });
+/* harmony import */ var _FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../FacadeVFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js");
+/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../VFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+/* harmony import */ var _WebLocksMixin_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../WebLocksMixin.js */ "../../node_modules/@journeyapps/wa-sqlite/src/WebLocksMixin.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
 
-  /**
-   * @param {number} fileId 
-   * @returns {number}
-   */
-  xSectorSize(fileId) {
-    log('xSectorSize');
-    return SECTOR_SIZE;
-  }
 
-  /**
-   * @param {number} fileId 
-   * @returns {number}
-   */
-  xDeviceCharacteristics(fileId) {
-    log('xDeviceCharacteristics');
-    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_BATCH_ATOMIC |
-           _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_SAFE_APPEND |
-           _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_SEQUENTIAL |
-           _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
-  }
 
-  /**
-   * @param {number} fileId 
-   * @param {number} op 
-   * @param {DataView} pArg 
-   * @returns {number}
-   */
-  xFileControl(fileId, op, pArg) {
-    const file = this.#mapIdToFile.get(fileId);
-    log(`xFileControl ${file.path} ${op}`);
-
-    switch (op) {
-      case 11: //SQLITE_FCNTL_OVERWRITE
-        // This called on VACUUM. Set a flag so we know whether to check
-        // later if the page size changed.
-        file.overwrite = true;
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-
-      case 21: // SQLITE_FCNTL_SYNC
-        // This is called at the end of each database transaction, whether
-        // it is batch atomic or not. Handle page size changes here.
-        if (file.overwrite) {
-          // As an optimization we only check for and handle a page file
-          // changes if we know a VACUUM has been done because handleAsync()
-          // has to unwind and rewind the stack. We must be sure to follow
-          // the same conditional path in both calls.
-          try {
-            return this.handleAsync(async () => {
-              await this.#reblockIfNeeded(file);
-              return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-            });
-          } catch (e) {
-            console.error(e);
-            return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-          }
-        }
 
-        if (file.isMetadataChanged) {
-          // Metadata has changed so write block 0 to IndexedDB.
-          try {
-            this.#idb.run('readwrite', async ({blocks}) => {
-              await blocks.put(file.block0);
-            });
-            file.isMetadataChanged = false;
-          } catch (e) {
-            console.error(e);
-            return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-          }
-        }
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-
-      case 22: // SQLITE_FCNTL_COMMIT_PHASETWO
-        // This is called after a commit is completed.
-        file.overwrite = false;
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-
-      case 31: // SQLITE_FCNTL_BEGIN_ATOMIC_WRITE
-        return this.handleAsync(async () => {
-          try {
-            // Prepare a new version for IndexedDB blocks.
-            file.block0.version--;
-            file.changedPages = new Set();
-
-            // Clear blocks from abandoned transactions that would conflict
-            // with the new transaction.
-            this.#idb.run('readwrite', async ({blocks}) => {
-              const keys = await blocks.index('version').getAllKeys(IDBKeyRange.bound(
-                [file.path],
-                [file.path, file.block0.version]));
-              for (const key of keys) {
-                blocks.delete(key);
-              }
-            });
-            return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-          } catch (e) {
-            console.error(e);
-            return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-          }
-        });
+/**
+ * @typedef Metadata
+ * @property {string} name
+ * @property {number} fileSize
+ * @property {number} version
+ * @property {number} [pendingVersion]
+ */
 
-      case 32: // SQLITE_FCNTL_COMMIT_ATOMIC_WRITE
-        try {
-          const block0 = Object.assign({}, file.block0);
-          block0.data = block0.data.slice();
-          const changedPages = file.changedPages;
-          file.changedPages = null;
-          file.isMetadataChanged = false;
-          this.#idb.run('readwrite', async ({blocks})=> {
-            // Write block 0 to commit the new version.
-            blocks.put(block0);
-
-            // Blocks to purge are saved in a special IndexedDB object with
-            // an "index" of "purge". Add pages changed by this transaction.
-            const purgeBlock = await blocks.get([file.path, 'purge', 0]) ?? {
-              path: file.path,
-              offset: 'purge',
-              version: 0,
-              data: new Map(),
-              count: 0
-            };
+class File {
+  /** @type {string} */ path;
+  /** @type {number} */ flags;
 
-            purgeBlock.count += changedPages.size;
-            for (const pageIndex of changedPages) {
-              purgeBlock.data.set(pageIndex, block0.version);
-            }
+  /** @type {Metadata} */ metadata;
+  /** @type {number} */ fileSize = 0;
 
-            blocks.put(purgeBlock);
-            this.#maybePurge(file.path, purgeBlock.count);
-          });
-          return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-        } catch (e) {
-          console.error(e);
-          return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-        }
+  /** @type {boolean} */ needsMetadataSync = false;
+  /** @type {Metadata} */ rollback = null;
+  /** @type {Set<number>} */ changedPages = new Set();
 
-      case 33: // SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE
-        return this.handleAsync(async () => {
-          try {
-            // Restore original state. Objects for the abandoned version will
-            // be left in IndexedDB to be removed by the next atomic write
-            // transaction.
-            file.changedPages = null;
-            file.isMetadataChanged = false;
-            file.block0 = await this.#idb.run('readonly', ({blocks}) => {
-              return blocks.get([file.path, 0, file.block0.version + 1]);
-            });
-            return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-          } catch (e) {
-            console.error(e);
-            return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-          }
-        });
+  /** @type {string} */ synchronous = 'full';
+  /** @type {IDBTransactionOptions} */ txOptions = { durability: 'strict' };
 
-      default:
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND;
-    }
+  constructor(path, flags, metadata) {
+    this.path = path;
+    this.flags = flags;
+    this.metadata = metadata;
   }
+}
 
-  /**
-   * @param {string} name 
-   * @param {number} flags 
-   * @param {DataView} pResOut 
-   * @returns {number}
-   */
-  xAccess(name, flags, pResOut) {
-    const result = this.handleAsync(async () => {
-      try {
-        const path = new URL(name, 'file://localhost/').pathname;
-        log(`xAccess ${path} ${flags}`);
+class IDBBatchAtomicVFS extends (0,_WebLocksMixin_js__WEBPACK_IMPORTED_MODULE_2__.WebLocksMixin)(_FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__.FacadeVFS) {
+  /** @type {Map<number, File>} */ mapIdToFile = new Map();
+  lastError = null;
 
-        // Check if block 0 exists.
-        const key = await this.#idb.run('readonly', ({blocks}) => {
-          return blocks.getKey(this.#bound({path}, 0));
-        });
+  log = null; // console.log
 
-        // @ts-ignore
-        if (pResOut.buffer.detached || !pResOut.buffer.byteLength) {
-          pResOut = new DataView(new ArrayBuffer(4));
-          this.#growthHandler = (pResOutNew) => {
-            pResOutNew.setInt32(0, pResOut.getInt32(0, true), true);
-          }
-        }
-        pResOut.setInt32(0, key ? 1 : 0, true);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-      } catch (e) {
-        console.error(e);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-      }
-    });
+  /** @type {Promise} */ #isReady;
+  /** @type {IDBContext} */ #idb;
 
-    this.#growthHandler?.(pResOut);
-    this.#growthHandler = null;
-    return result;
+  static async create(name, module, options) {
+    const vfs = new IDBBatchAtomicVFS(name, module, options);
+    await vfs.isReady();
+    return vfs;
   }
 
-  /**
-   * @param {string} name 
-   * @param {number} syncDir 
-   * @returns {number}
-   */
-  xDelete(name, syncDir) {
-    return this.handleAsync(async () => {
-      const path = new URL(name, 'file://localhost/').pathname;
-      log(`xDelete ${path} ${syncDir}`);
-
-      try {
-        this.#idb.run('readwrite', ({blocks}) => {
-          return blocks.delete(IDBKeyRange.bound([path], [path, []]));
-        });
-        if (syncDir) {
-          await this.#idb.sync();
-        }
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-      } catch (e) {
-        console.error(e);
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR;
-      }
-    });
+  constructor(name, module, options = {}) {
+    super(name, module, options);
+    this.#isReady = this.#initialize(options.idbName ?? name);
   }
 
-  /**
-   * Purge obsolete blocks from a database file.
-   * @param {string} path 
-   */
-  async purge(path) {
-    const start = Date.now();
-    await this.#idb.run('readwrite', async ({blocks}) => {
-      const purgeBlock = await blocks.get([path, 'purge', 0]);
-      if (purgeBlock) {
-        for (const [pageOffset, version] of purgeBlock.data) {
-          blocks.delete(IDBKeyRange.bound(
-            [path, pageOffset, version],
-            [path, pageOffset, Infinity],
-            true, false));
-        }
-        await blocks.delete([path, 'purge', 0]);
-      }
-      log(`purge ${path} ${purgeBlock?.data.size ?? 0} pages in ${Date.now() - start} ms`);
-    });
+  async #initialize(name) {
+    this.#idb = await IDBContext.create(name);
   }
 
-  /**
-   * Conditionally schedule a purge task.
-   * @param {string} path 
-   * @param {number} nPages 
-   */
-  #maybePurge(path, nPages) {
-    if (this.#options.purge === 'manual' ||
-        this.#pendingPurges.has(path) ||
-        nPages < this.#options.purgeAtLeast) {
-      // No purge needed.
-      return;
-    }
-    
-    if (globalThis.requestIdleCallback) {
-      globalThis.requestIdleCallback(() => {
-        this.purge(path);
-        this.#pendingPurges.delete(path)
-      });
-    } else {
-      setTimeout(() => {
-        this.purge(path);
-        this.#pendingPurges.delete(path)
-      });
-    }
-    this.#pendingPurges.add(path);
-  }
-
-  #bound(file, begin, end = 0) {
-    // Fetch newest block 0. For other blocks, use block 0 version.
-    const version = !begin || -begin < file.block0.data.length ?
-      -Infinity :
-      file.block0.version;
-    return IDBKeyRange.bound(
-      [file.path, begin, version],
-      [file.path, end, Infinity]);
-  }
-
-  // The database page size can be changed with PRAGMA page_size and VACUUM.
-  // The updated file will be overwritten with a regular transaction using
-  // the old page size. After that it will be read and written using the
-  // new page size, so the IndexedDB objects must be combined or split
-  // appropriately.
-  async #reblockIfNeeded(file) {
-    const oldPageSize = file.block0.data.length;
-    if (oldPageSize < 18) return; // no page size defined
-
-    const view = new DataView(file.block0.data.buffer, file.block0.data.byteOffset);
-    let newPageSize = view.getUint16(16);
-    if (newPageSize === 1) newPageSize = 65536;
-    if (newPageSize === oldPageSize) return; // no page size change
-
-    const maxPageSize = Math.max(oldPageSize, newPageSize);
-    const nOldPages = maxPageSize / oldPageSize;
-    const nNewPages = maxPageSize / newPageSize;
-
-    const newPageCount = view.getUint32(28);
-    const fileSize = newPageCount * newPageSize;
-
-    const version = file.block0.version;
-    await this.#idb.run('readwrite', async ({blocks}) => {
-      // When the block size changes, the entire file is rewritten. Delete
-      // all blocks older than block 0 to leave a single version at every
-      // offset.
-      const keys = await blocks.index('version').getAllKeys(IDBKeyRange.bound(
-        [file.path, version + 1],
-        [file.path, Infinity]
-      ));
-      for (const key of keys) {
-        blocks.delete(key);
-      }
-      blocks.delete([file.path, 'purge', 0]);
-
-      // Do the conversion in chunks of the larger of the page sizes.
-      for (let iOffset = 0; iOffset < fileSize; iOffset += maxPageSize) {
-        // Fetch nOldPages. They can be fetched in one request because
-        // there is now a single version in the file.
-        const oldPages = await blocks.getAll(
-          IDBKeyRange.lowerBound([file.path, -(iOffset + maxPageSize), Infinity]),
-          nOldPages);
-        for (const oldPage of oldPages) {
-          blocks.delete([oldPage.path, oldPage.offset, oldPage.version]);
-        }
-
-        // Convert to new pages.
-        if (nNewPages === 1) {
-          // Combine nOldPages old pages into a new page.
-          const buffer = new Uint8Array(newPageSize);
-          for (const oldPage of oldPages) {
-            buffer.set(oldPage.data, -(iOffset + oldPage.offset));
-          }
-          const newPage = {
-            path: file.path,
-            offset: -iOffset,
-            version,
-            data: buffer
-          };
-          if (newPage.offset === 0) {
-            newPage.fileSize = fileSize;
-            file.block0 = newPage;
-          }
-          blocks.put(newPage);
-        } else {
-          // Split an old page into nNewPages new pages.
-          const oldPage = oldPages[0];
-          for (let i = 0; i < nNewPages; ++i) {
-            const offset = -(iOffset + i * newPageSize);
-            if (-offset >= fileSize) break;
-            const newPage = {
-              path: oldPage.path,
-              offset,
-              version,
-              data: oldPage.data.subarray(i * newPageSize, (i + 1) * newPageSize)
-            }
-            if (newPage.offset === 0) {
-              newPage.fileSize = fileSize;
-              file.block0 = newPage;
-            }
-            blocks.put(newPage);
-          }
-        }
-      }
-    });
+  close() {
+    this.#idb.close();
   }
-}
-
-function openDatabase(idbDatabaseName) {
-  return new Promise((resolve, reject) => {
-    const request = globalThis.indexedDB.open(idbDatabaseName, 5);
-    request.addEventListener('upgradeneeded', function() {
-      const blocks = request.result.createObjectStore('blocks', {
-        keyPath: ['path', 'offset', 'version']
-      });
-      blocks.createIndex('version', ['path', 'version']);
-    });
-    request.addEventListener('success', () => {
-      resolve(request.result);
-    });
-    request.addEventListener('error', () => {
-      reject(request.error);
-    });
-  });
-}
-
-/***/ }),
-
-/***/ "../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBContext.js":
-/*!****************************************************************************!*\
-  !*** ../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBContext.js ***!
-  \****************************************************************************/
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   IDBContext: () => (/* binding */ IDBContext)
-/* harmony export */ });
-// Copyright 2022 Roy T. Hashimoto. All Rights Reserved.
-
-// IndexedDB transactions older than this will be replaced.
-const MAX_TRANSACTION_LIFETIME_MILLIS = 5_000;
-
-// For debugging.
-let nextTxId = 0;
-const mapTxToId = new WeakMap();
-function log(...args) {
-  // console.debug(...args);
-}
-
-// This class manages IDBTransaction and IDBRequest instances. It tries
-// to reuse transactions to minimize transaction overhead.
-class IDBContext {
-  /** @type {IDBDatabase} */ #db;
-  /** @type {Promise<IDBDatabase>} */ #dbReady;
-  #txOptions;
-
-  /** @type {IDBTransaction} */ #tx = null;
-  #txTimestamp = 0;
-  #runChain = Promise.resolve();
-  #putChain = Promise.resolve();
-
-  /**
-   * @param {IDBDatabase|Promise<IDBDatabase>} idbDatabase
-   */
-  constructor(idbDatabase, txOptions = { durability: 'default' }) {
-    this.#dbReady = Promise.resolve(idbDatabase).then(db => this.#db = db);
-    this.#txOptions = txOptions;
+  
+  async isReady() {
+    await super.isReady();
+    await this.#isReady;
   }
 
-  async close() {
-    const db = this.#db ?? await this.#dbReady;
-    await this.#runChain;
-    await this.sync();
-    db.close();
+  getFilename(fileId) {
+    const pathname = this.mapIdToFile.get(fileId).path;
+    return `IDB(${this.name}):${pathname}`
   }
   
   /**
-   * Run a function with the provided object stores. The function
-   * should be idempotent in case it is passed an expired transaction.
-   * @param {IDBTransactionMode} mode
-   * @param {(stores: Object.<string, ObjectStore>) => any} f 
-   */
-  async run(mode, f) {
-    // Ensure that functions run sequentially.
-    const result = this.#runChain.then(() => this.#run(mode, f));
-    this.#runChain = result.catch(() => {});
-    return result;
-  }
-
-  /**
-   * @param {IDBTransactionMode} mode
-   * @param {(stores: Object.<string, ObjectStore>) => any} f 
-   * @returns 
+   * @param {string?} zName 
+   * @param {number} fileId 
+   * @param {number} flags 
+   * @param {DataView} pOutFlags 
+   * @returns {Promise<number>}
    */
-  async #run(mode, f) {
-    const db = this.#db ?? await this.#dbReady;
-    if (mode === 'readwrite' && this.#tx?.mode === 'readonly') {
-      // Mode requires a new transaction.
-      this.#tx = null;
-    } else if (performance.now() - this.#txTimestamp > MAX_TRANSACTION_LIFETIME_MILLIS) {
-      // Chrome times out transactions after 60 seconds so refresh preemptively.
-      try {
-        this.#tx?.commit();
-      } catch (e) {
-        // Explicit commit can fail but this can be ignored if it will
-        // auto-commit anyway.
-        if (e.name !== 'InvalidStateError') throw e;
+  async jOpen(zName, fileId, flags, pOutFlags) {
+    try {
+      const url = new URL(zName || Math.random().toString(36).slice(2), 'file://');
+      const path = url.pathname;
+
+      let meta = await this.#idb.q(({ metadata }) => metadata.get(path));
+      if (!meta && (flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_CREATE)) {
+        meta = {
+          name: path,
+          fileSize: 0,
+          version: 0
+        };
+        await this.#idb.q(({ metadata }) => metadata.put(meta), 'rw');
       }
-
-      // Skip to the next task to allow processing.
-      await new Promise(resolve => setTimeout(resolve));
-      this.#tx = null;
-    }
-
-    // Run the user function with a retry in case the transaction is invalid.
-    for (let i = 0; i < 2; ++i) {
-      if (!this.#tx) {
-        // @ts-ignore
-        this.#tx = db.transaction(db.objectStoreNames, mode, this.#txOptions);
-        const timestamp = this.#txTimestamp = performance.now();
-
-        // Chain the result of every transaction. If any transaction is
-        // aborted then the next sync() call will throw.
-        this.#putChain = this.#putChain.then(() => {
-          return new Promise((resolve, reject) => {
-            this.#tx.addEventListener('complete', event => {
-              resolve();
-              if (this.#tx === event.target) {
-                this.#tx = null;
-              }
-              log(`transaction ${mapTxToId.get(event.target)} complete`);
-            });
-            this.#tx.addEventListener('abort', event => {
-              console.warn('tx abort', (performance.now() - timestamp)/1000);
-              // @ts-ignore
-              const e = event.target.error;
-              reject(e);
-              if (this.#tx === event.target) {
-                this.#tx = null;
-              }
-              log(`transaction ${mapTxToId.get(event.target)} aborted`, e);
-            });
-          });
-        });
-
-        log(`new transaction ${nextTxId} ${mode}`);
-        mapTxToId.set(this.#tx, nextTxId++);
+      
+      if (!meta) {
+        throw new Error(`File ${path} not found`);
       }
 
-      try {
-        const stores = Object.fromEntries(Array.from(db.objectStoreNames, name => {
-          return [name, new ObjectStore(this.#tx.objectStore(name))];
-        }));
-        return await f(stores);
-      } catch (e) {
-        this.#tx = null;
-        if (i) throw e;
-        // console.warn('retrying with new transaction');
-      }
+      const file = new File(path, flags, meta);
+      this.mapIdToFile.set(fileId, file);
+      pOutFlags.setInt32(0, flags, true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_CANTOPEN;
     }
   }
 
-  async sync() {
-    // Wait until all transactions since the previous sync have committed.
-    // Throw if any transaction failed.
-    await this.#runChain;
-    await this.#putChain;
-    this.#putChain = Promise.resolve();
-  }
-}
-
-/**
- * Helper to convert IDBRequest to Promise.
- * @param {IDBRequest} request 
- * @returns {Promise}
- */
-function wrapRequest(request) {
-  return new Promise((resolve, reject) => {
-    request.addEventListener('success', () => resolve(request.result));
-    request.addEventListener('error', () => reject(request.error));
-  });
-}
-
-// IDBObjectStore wrapper passed to IDBContext run functions.
-class ObjectStore {
-  #objectStore;
-
   /**
-   * @param {IDBObjectStore} objectStore 
+   * @param {string} zName 
+   * @param {number} syncDir 
+   * @returns {Promise<number>}
    */
-  constructor(objectStore) {
-    this.#objectStore = objectStore;
-  }
+  async jDelete(zName, syncDir) {
+    try {
+      const url = new URL(zName, 'file://');
+      const path = url.pathname;
 
-  /**
-   * @param {IDBValidKey|IDBKeyRange} query 
-   * @returns {Promise}
-   */
-  get(query) {
-    log(`get ${this.#objectStore.name}`, query);
-    const request = this.#objectStore.get(query);
-    return wrapRequest(request);
-  }
+      this.#idb.q(({ metadata, blocks }) => {
+        const range = IDBKeyRange.bound([path, -Infinity], [path, Infinity]);
+        blocks.delete(range);
+        metadata.delete(path);
+      }, 'rw');
 
-  /**
-   * @param {IDBValidKey|IDBKeyRange} query 
-   * @param {number} [count]
-   * @returns {Promise}
-   */
-   getAll(query, count) {
-    log(`getAll ${this.#objectStore.name}`, query, count);
-    const request = this.#objectStore.getAll(query, count);
-    return wrapRequest(request);
-  }
-
-  /**
-   * @param {IDBValidKey|IDBKeyRange} query 
-   * @returns {Promise<IDBValidKey>}
-   */
-  getKey(query) {
-    log(`getKey ${this.#objectStore.name}`, query);
-    const request = this.#objectStore.getKey(query);
-    return wrapRequest(request);
+      if (syncDir) {
+        await this.#idb.sync(false);
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_DELETE;
+    }
   }
 
   /**
-   * @param {IDBValidKey|IDBKeyRange} query 
-   * @param {number} [count]
-   * @returns {Promise}
+   * @param {string} zName 
+   * @param {number} flags 
+   * @param {DataView} pResOut 
+   * @returns {Promise<number>}
    */
-   getAllKeys(query, count) {
-    log(`getAllKeys ${this.#objectStore.name}`, query, count);
-    const request = this.#objectStore.getAllKeys(query, count);
-    return wrapRequest(request);
-  }
+  async jAccess(zName, flags, pResOut) {
+    try {
+      const url = new URL(zName, 'file://');
+      const path = url.pathname;
 
-  /**
-   * @param {any} value
-   * @param {IDBValidKey} [key] 
-   * @returns {Promise}
-   */
-   put(value, key) {
-    log(`put ${this.#objectStore.name}`, value, key);
-    const request = this.#objectStore.put(value, key);
-    return wrapRequest(request);
+      const meta = await this.#idb.q(({ metadata }) => metadata.get(path));
+      pResOut.setInt32(0, meta ? 1 : 0, true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_ACCESS;
+    } 
   }
 
   /**
-   * @param {IDBValidKey|IDBKeyRange} query 
-   * @returns {Promise}
+   * @param {number} fileId 
+   * @returns {Promise<number>}
    */
-   delete(query) {
-    log(`delete ${this.#objectStore.name}`, query);
-    const request = this.#objectStore.delete(query);
-    return wrapRequest(request);
-  }
-
-  clear() {
-    log(`clear ${this.#objectStore.name}`);
-    const request = this.#objectStore.clear();
-    return wrapRequest(request);
-  }
+  async jClose(fileId) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      this.mapIdToFile.delete(fileId);
+
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_DELETEONCLOSE) {
+        await this.#idb.q(({ metadata, blocks }) => {
+          metadata.delete(file.path);
+          blocks.delete(IDBKeyRange.bound([file.path, 0], [file.path, Infinity]));
+        }, 'rw');        
+      }
 
-  index(name) {
-    return new Index(this.#objectStore.index(name));
+      if (file.needsMetadataSync) {
+        this.#idb.q(({ metadata }) => metadata.put(file.metadata), 'rw');
+      }
+      await this.#idb.sync(file.synchronous === 'full');
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_CLOSE;
+    }
   }
-}
-
-class Index {
-  /** @type {IDBIndex} */ #index;
 
   /**
-   * @param {IDBIndex} index 
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {Promise<number>}
    */
-   constructor(index) {
-    this.#index = index;
+  async jRead(fileId, pData, iOffset) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+
+      let pDataOffset = 0;
+      while (pDataOffset < pData.byteLength) {
+        // Fetch the IndexedDB block for this file location.
+        const fileOffset = iOffset + pDataOffset;
+        const block = await this.#idb.q(({ blocks }) => {
+          const range = IDBKeyRange.bound([file.path, -fileOffset], [file.path, Infinity]);
+          return blocks.get(range);
+        });       
+        
+        if (!block || block.data.byteLength - block.offset <= fileOffset) {
+          pData.fill(0, pDataOffset);
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_SHORT_READ;
+        }
+
+        // Copy block data.
+        const dst = pData.subarray(pDataOffset);
+        const srcOffset = fileOffset + block.offset;
+        const nBytesToCopy = Math.min(
+          Math.max(block.data.byteLength - srcOffset, 0),
+          dst.byteLength);
+        dst.set(block.data.subarray(srcOffset, srcOffset + nBytesToCopy));
+        pDataOffset += nBytesToCopy;
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_READ;
+    }
   }
 
   /**
-   * @param {IDBValidKey|IDBKeyRange} query 
-   * @param {number} [count]
-   * @returns {Promise<IDBValidKey[]>}
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number}
    */
-  getAllKeys(query, count) {
-    log(`IDBIndex.getAllKeys ${this.#index.objectStore.name}<${this.#index.name}>`, query, count);
-    const request = this.#index.getAllKeys(query, count);
-    return wrapRequest(request);
-  }
-}
-
-/***/ }),
-
-/***/ "../../node_modules/@journeyapps/wa-sqlite/src/examples/WebLocks.js":
-/*!**************************************************************************!*\
-  !*** ../../node_modules/@journeyapps/wa-sqlite/src/examples/WebLocks.js ***!
-  \**************************************************************************/
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   WebLocksBase: () => (/* binding */ WebLocksBase),
-/* harmony export */   WebLocksExclusive: () => (/* binding */ WebLocksExclusive),
-/* harmony export */   WebLocksShared: () => (/* binding */ WebLocksShared)
-/* harmony export */ });
-/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../VFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/VFS.js");
-// Copyright 2022 Roy T. Hashimoto. All Rights Reserved.
+  jWrite(fileId, pData, iOffset) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        if (!file.rollback) {
+          // Begin a new write transaction.
+          // Add pendingVersion to the metadata in IndexedDB. If we crash
+          // during the transaction, this lets subsequent connections
+          // know to remove blocks from the failed transaction.
+          const pending = Object.assign(
+            { pendingVersion: file.metadata.version - 1 },
+            file.metadata);
+          this.#idb.q(({ metadata }) => metadata.put(pending), 'rw', file.txOptions);
+
+          file.rollback = Object.assign({}, file.metadata);
+          file.metadata.version--;
+        }
+      }
 
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        file.changedPages.add(iOffset);
+      }
 
-const LOCK_TYPE_MASK =
-  _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE |
-  _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED |
-  _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED |
-  _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_PENDING |
-  _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE;
+      const data = pData.slice();
+      const version = file.metadata.version;
+      const isOverwrite = iOffset < file.metadata.fileSize;
+      if (!isOverwrite ||
+          file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB ||
+          file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_TEMP_DB) {
+        const block = {
+          path: file.path,
+          offset: -iOffset,
+          version: version,
+          data: pData.slice()
+        };
+        this.#idb.q(({ blocks }) => {
+          blocks.put(block);
+          file.changedPages.add(iOffset);
+        }, 'rw', file.txOptions);
+      } else {
+        this.#idb.q(async ({ blocks }) => {
+          // Read the existing block.
+          const range = IDBKeyRange.bound(
+            [file.path, -iOffset],
+            [file.path, Infinity]);
+          const block = await blocks.get(range);
+
+          // Modify the block data.
+          // @ts-ignore
+          block.data.subarray(iOffset + block.offset).set(data);
 
-class WebLocksBase {
-  get state() { return this.#state; }
-  #state = _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE;
+          // Write back.
+          blocks.put(block);
+        }, 'rw', file.txOptions);
 
-  timeoutMillis = 0;
+      }
 
-  /** @type {Map<string, (value: any) => void>} */ #releasers = new Map();
-  /** @type {Promise<0|5|3850>} */ #pending = Promise.resolve(0);
+      if (file.metadata.fileSize < iOffset + pData.length) {
+        file.metadata.fileSize = iOffset + pData.length;
+        file.needsMetadataSync = true;
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_WRITE;
+    }
+  }
 
   /**
-   * @param {number} flags 
-   * @returns {Promise<0|5|3850>} SQLITE_OK, SQLITE_BUSY, SQLITE_IOERR_LOCK
+   * @param {number} fileId 
+   * @param {number} iSize 
+   * @returns {number}
    */
-  async lock(flags) {
-    return this.#apply(this.#lock, flags);
+  jTruncate(fileId, iSize) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (iSize < file.metadata.fileSize) {
+        this.#idb.q(({ blocks }) => {
+          const range = IDBKeyRange.bound(
+            [file.path, -Infinity],
+            [file.path, -iSize, Infinity]);
+          blocks.delete(range);
+        }, 'rw', file.txOptions);
+        file.metadata.fileSize = iSize;
+        file.needsMetadataSync = true;
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_TRUNCATE;
+    }
   }
 
   /**
+   * @param {number} fileId 
    * @param {number} flags 
-   * @returns {Promise<0|5|3850>} SQLITE_OK, SQLITE_IOERR_LOCK
+   * @returns {Promise<number>}
    */
-  async unlock(flags) {
-    return this.#apply(this.#unlock, flags);
-  }
+  async jSync(fileId, flags) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file.needsMetadataSync) {
+        this.#idb.q(({ metadata }) => metadata.put(file.metadata), 'rw', file.txOptions);
+        file.needsMetadataSync = false;
+      }
 
-  /**
-   * @returns {Promise<boolean>}
-   */
-  async isSomewhereReserved() {
-    throw new Error('unimplemented');
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        // Sync is only needed here for durability. Visibility for other
+        // connections is ensured in jUnlock().
+        if (file.synchronous === 'full') {
+          await this.#idb.sync(true);
+        }
+      } else {
+        await this.#idb.sync(file.synchronous === 'full');
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_FSYNC;
+    }
   }
 
   /**
-   * 
-   * @param {(targetState: number) => void} method 
-   * @param {number} flags 
+   * @param {number} fileId 
+   * @param {DataView} pSize64 
+   * @returns {number}
    */
-  async #apply(method, flags) {
-    const targetState = flags & LOCK_TYPE_MASK;
+  jFileSize(fileId, pSize64) {
     try {
-      // Force locks and unlocks to run sequentially. This allows not
-      // waiting for unlocks to complete.
-      const call = () => method.call(this, targetState);
-      await (this.#pending = this.#pending.then(call, call));
-      this.#state = targetState;
-      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+      const file = this.mapIdToFile.get(fileId);
+      pSize64.setBigInt64(0, BigInt(file.metadata.fileSize), true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
     } catch (e) {
-      if (e.name === 'AbortError') {
-        return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY;
-      }
-      console.error(e);
-      return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_LOCK;
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_FSTAT;
     }
   }
 
-  async #lock(targetState) {
-    if (targetState === this.#state) return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-    switch (this.#state) {
-      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE:
-        switch (targetState) {
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED:
-            return this._NONEtoSHARED();
-          default:
-            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);
-        }
+  /**
+   * @param {number} fileId 
+   * @param {number} lockType 
+   * @returns {Promise<number>}
+   */
+  async jLock(fileId, lockType) {
+    // Call the actual lock implementation.
+    const file = this.mapIdToFile.get(fileId);
+    const result = await super.jLock(fileId, lockType);
+
+    if (lockType === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_SHARED) {
+      // Update metadata.
+      file.metadata = await this.#idb.q(async ({ metadata, blocks }) => {
+        // @ts-ignore
+        /** @type {Metadata} */ const m = await metadata.get(file.path);
+        if (m.pendingVersion) {
+          console.warn(`removing failed transaction ${m.pendingVersion}`);
+          await new Promise((resolve, reject) => {
+            const range = IDBKeyRange.bound([m.name, -Infinity], [m.name, Infinity]);
+            const request = blocks.openCursor(range);
+            request.onsuccess = () => {
+              const cursor = request.result;
+              if (cursor) {
+                const block = cursor.value;
+                if (block.version < m.version) {
+                  cursor.delete();
+                }
+                cursor.continue();
+              } else {
+                resolve();
+              }
+            };
+            request.onerror = () => reject(request.error);
+          })
 
-      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED:
-        switch (targetState) {
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED:
-            return this._SHAREDtoRESERVED();
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE:
-            return this._SHAREDtoEXCLUSIVE();
-          default:
-            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);
+          delete m.pendingVersion;
+          metadata.put(m);
         }
-      
-      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED:
-        switch (targetState) {
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE:
-            return this._RESERVEDtoEXCLUSIVE();
-          default:
-            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);
-        }
-
-      default:
-        throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);
+        return m;
+      }, 'rw', file.txOptions);
     }
+    return result;
   }
 
-  async #unlock(targetState) {
-    if (targetState === this.#state)  return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
-    switch (this.#state) {
-      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE:
-        switch (targetState) {
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED:
-            return this._EXCLUSIVEtoSHARED();
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE:
-            return this._EXCLUSIVEtoNONE();
-          default:
-            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);
-        }
-      
-      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED:
-        switch (targetState) {
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED:
-            return this._RESERVEDtoSHARED();
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE:
-            return this._RESERVEDtoNONE();
-          default:
-            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);
-        }
-
-      case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED:
-        switch (targetState) {
-          case _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE:
-            return this._SHAREDtoNONE();
-          default:
-            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);
-        }
-
-      default:
-        throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);
+  /**
+   * @param {number} fileId 
+   * @param {number} lockType 
+   * @returns {Promise<number>}
+   */
+  async jUnlock(fileId, lockType) {
+    if (lockType === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE) {
+      const file = this.mapIdToFile.get(fileId);
+      await this.#idb.sync(file.synchronous === 'full');
     }
-  }
-
-  async _NONEtoSHARED() {
-  }
-
-  async _SHAREDtoEXCLUSIVE() {
-    await this._SHAREDtoRESERVED();
-    await this._RESERVEDtoEXCLUSIVE();
-  }
-
-  async _SHAREDtoRESERVED() {
-  }
-
-  async _RESERVEDtoEXCLUSIVE() {
-  }
-
-  async _EXCLUSIVEtoRESERVED() {
-  }
 
-  async _EXCLUSIVEtoSHARED() {
-    await this._EXCLUSIVEtoRESERVED();
-    await this._RESERVEDtoSHARED();
-  }
-
-  async _EXCLUSIVEtoNONE() {
-    await this._EXCLUSIVEtoRESERVED();
-    await this._RESERVEDtoSHARED();
-    await this._SHAREDtoNONE();
-  }
-
-  async _RESERVEDtoSHARED() {
-  }
-
-  async _RESERVEDtoNONE() {
-    await this._RESERVEDtoSHARED();
-    await this._SHAREDtoNONE();
-  }
-
-  async _SHAREDtoNONE() {
+    // Call the actual unlock implementation.
+    return super.jUnlock(fileId, lockType);
   }
 
   /**
-   * @param {string} lockName 
-   * @param {LockOptions} options 
-   * @returns {Promise<?Lock>}
+   * @param {number} fileId
+   * @param {number} op
+   * @param {DataView} pArg
+   * @returns {number|Promise<number>}
    */
-  _acquireWebLock(lockName, options) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        await navigator.locks.request(lockName, options, lock => {
-          resolve(lock);
-          if (lock) {
-            return new Promise(release => this.#releasers.set(lockName, release));
-          }
-        });
-      } catch(e) {
-        reject(e);
+  jFileControl(fileId, op, pArg) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      switch (op) {
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_PRAGMA:
+          const key = extractString(pArg, 4);
+          const value = extractString(pArg, 8);
+          this.log?.('xFileControl', file.path, 'PRAGMA', key, value);
+          const setPragmaResponse = response => {
+            const encoded = new TextEncoder().encode(response);
+            const out = this._module._sqlite3_malloc(encoded.byteLength);
+            const outArray = this._module.HEAPU8.subarray(out, out + encoded.byteLength);
+            outArray.set(encoded);
+            pArg.setUint32(0, out, true);
+            return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_ERROR;
+          };
+          switch (key.toLowerCase()) {
+            case 'page_size':
+              if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+                // Don't allow changing the page size.
+                if (value && file.metadata.fileSize) {
+                  return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_ERROR;
+                }
+              }
+              break;
+            case 'synchronous':
+              if (value) {
+                switch (value.toLowerCase()) {
+                  case '0':
+                  case 'off':
+                    file.synchronous = 'off';
+                    file.txOptions = { durability: 'relaxed' };
+                    break;
+                  case '1':
+                  case 'normal':
+                    file.synchronous = 'normal';
+                    file.txOptions = { durability: 'relaxed' };
+                    break;
+                  case '2':
+                  case '3':
+                  case 'full':
+                  case 'extra':
+                    file.synchronous = 'full';
+                    file.txOptions = { durability: 'strict' };
+                    break;
+                }
+              }
+              break;
+            case 'write_hint':
+              return super.jFileControl(fileId, _WebLocksMixin_js__WEBPACK_IMPORTED_MODULE_2__.WebLocksMixin.WRITE_HINT_OP_CODE, null);
+            }
+          break;
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_SYNC:
+          this.log?.('xFileControl', file.path, 'SYNC');
+          const commitMetadata = Object.assign({}, file.metadata);
+          const prevFileSize = file.rollback.fileSize
+          this.#idb.q(({ metadata, blocks }) => {
+            metadata.put(commitMetadata);
+
+            // Remove old page versions.
+            for (const offset of file.changedPages) {
+              if (offset < prevFileSize) {
+                const range = IDBKeyRange.bound(
+                  [file.path, -offset, commitMetadata.version],
+                  [file.path, -offset, Infinity],
+                  true);
+                blocks.delete(range);
+              }
+            }
+            file.changedPages.clear();
+          }, 'rw', file.txOptions);
+          file.needsMetadataSync = false;
+          file.rollback = null;
+          break;
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_BEGIN_ATOMIC_WRITE:
+          // Every write transaction is atomic, so this is a no-op.
+          this.log?.('xFileControl', file.path, 'BEGIN_ATOMIC_WRITE');
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_COMMIT_ATOMIC_WRITE:
+          // Every write transaction is atomic, so this is a no-op.
+          this.log?.('xFileControl', file.path, 'COMMIT_ATOMIC_WRITE');
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE:
+          this.log?.('xFileControl', file.path, 'ROLLBACK_ATOMIC_WRITE');
+          file.metadata = file.rollback;
+          const rollbackMetadata = Object.assign({}, file.metadata);
+          this.#idb.q(({ metadata, blocks }) => {
+            metadata.put(rollbackMetadata);
+
+            // Remove pages.
+            for (const offset of file.changedPages) {
+              blocks.delete([file.path, -offset, rollbackMetadata.version - 1]);
+            }
+            file.changedPages.clear();
+          }, 'rw', file.txOptions);
+          file.needsMetadataSync = false;
+          file.rollback = null;
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
       }
-    });
-  }
-
-  /**
-   * @param {string} lockName 
-   */
-  _releaseWebLock(lockName) {
-    this.#releasers.get(lockName)?.();
-    this.#releasers.delete(lockName);
+    } catch (e) {
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR;
+    }
+    return super.jFileControl(fileId, op, pArg);
   }
-
+  
   /**
-   * @param {string} lockName 
+   * @param {number} pFile
+   * @returns {number|Promise<number>}
    */
-  async _pollWebLock(lockName) {
-    const query = await navigator.locks.query();
-    return query.held.find(({name}) => name === lockName)?.mode;
+  jDeviceCharacteristics(pFile) {
+    return 0
+    | _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOCAP_BATCH_ATOMIC
+    | _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
   }
 
   /**
-   * @returns {?AbortSignal}
+   * @param {Uint8Array} zBuf 
+   * @returns {number|Promise<number>}
    */
-  _getTimeoutSignal() {
-    if (this.timeoutMillis) {
-      const abortController = new AbortController();
-      setTimeout(() => abortController.abort(), this.timeoutMillis);
-      return abortController.signal;
+  jGetLastError(zBuf) {
+    if (this.lastError) {
+      console.error(this.lastError);
+      const outputArray = zBuf.subarray(0, zBuf.byteLength - 1);
+      const { written } = new TextEncoder().encodeInto(this.lastError.message, outputArray);
+      zBuf[written] = 0;
     }
-    return undefined;
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK
   }
 }
 
-class WebLocksExclusive extends WebLocksBase {
-  /**
-   * @param {string} name 
-   */
-  constructor(name) {
-    super();
-    this._lockName = name + '-outer';
-    this._reservedName = name + '-reserved';
+function extractString(dataView, offset) {
+  const p = dataView.getUint32(offset, true);
+  if (p) {
+    const chars = new Uint8Array(dataView.buffer, p);
+    return new TextDecoder().decode(chars.subarray(0, chars.indexOf(0)));
   }
+  return null;
+}
 
-  async isSomewhereReserved() {
-    const mode = await this._pollWebLock(this._reservedName);
-    return mode === 'exclusive';
-  }
+class IDBContext {
+  /** @type {IDBDatabase} */ #database;
 
-  async _NONEtoSHARED() {
-    await this._acquireWebLock(this._lockName, {
-      mode: 'exclusive',
-      signal: this._getTimeoutSignal()
+  /** @type {Promise} */ #chain = null;
+  /** @type {Promise<any>} */ #txComplete = Promise.resolve();
+  /** @type {IDBRequest?} */ #request = null;
+  /** @type {WeakSet<IDBTransaction>} */ #txPending = new WeakSet();
+  
+  log = null;
+
+  static async create(name) {
+    const database = await new Promise((resolve, reject) => {
+      const request = indexedDB.open(name, 6);
+      request.onupgradeneeded = async event => {
+        const db = request.result;
+        if (event.oldVersion) {
+          console.log(`Upgrading IndexedDB from version ${event.oldVersion}`);
+        }
+        switch (event.oldVersion) {
+          case 0:
+            // Start with the original schema.
+            db.createObjectStore('blocks', { keyPath: ['path', 'offset', 'version']})
+              .createIndex('version', ['path', 'version']);
+            // fall through intentionally
+          case 5:
+            const tx = request.transaction;
+            const blocks = tx.objectStore('blocks');
+            blocks.deleteIndex('version');
+            const metadata = db.createObjectStore('metadata', { keyPath: 'name' });
+
+            await new Promise((resolve, reject) => {
+              // Iterate over all the blocks.
+              let lastBlock = {};
+              const request = tx.objectStore('blocks').openCursor();
+              request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                  const block = cursor.value;
+                  if (typeof block.offset !== 'number' ||
+                      (block.path === lastBlock.path && block.offset === lastBlock.offset)) {
+                    // Remove superceded block (or the "purge" info).
+                    cursor.delete();
+                  } else if (block.offset === 0) {
+                    // Move metadata to its own store.
+                    metadata.put({
+                      name: block.path,
+                      fileSize: block.fileSize,
+                      version: block.version
+                    });
+
+                    delete block.fileSize;
+                    cursor.update(block);
+                  }
+                  lastBlock = block;
+                  cursor.continue();
+                } else {
+                  resolve();
+                }
+              };
+              request.onerror = () => reject(request.error);
+            });
+            break;
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
     });
+    return new IDBContext(database);
   }
 
-  async _SHAREDtoRESERVED() {
-    await this._acquireWebLock(this._reservedName, {
-      mode: 'exclusive',
-      signal: this._getTimeoutSignal()
-    });
+  constructor(database) {
+    this.#database = database;
   }
 
-  async _RESERVEDtoSHARED() {
-    this._releaseWebLock(this._reservedName);
+  close() {
+    this.#database.close();
   }
 
-  async _SHAREDtoNONE() {
-    this._releaseWebLock(this._lockName);
-  }
-}
+  /**
+   * @param {(stores: Object.<string, IDBObjectStore>) => any} f 
+   * @param {'ro'|'rw'} mode 
+   * @returns {Promise<any>}
+   */
+  q(f, mode = 'ro', options = {}) {
+    /** @type {IDBTransactionMode} */
+    const txMode = mode === 'ro' ? 'readonly' : 'readwrite';
+    const txOptions = Object.assign({
+      /** @type {IDBTransactionDurability} */ durability: 'default'
+    }, options);
 
-class WebLocksShared extends WebLocksBase {
-  maxRetryMillis = 1000;
+    // Ensure that queries run sequentially. If any function rejects,
+    // or any request has an error, or the transaction does not commit,
+    // then no subsequent functions will run until sync() or reset().
+    this.#chain = (this.#chain || Promise.resolve())
+      .then(() => this.#q(f, txMode, txOptions));
+    return this.#chain;
+  }
 
   /**
-   * @param {string} name 
+   * @param {(stores: Object.<string, IDBObjectStore>) => any} f 
+   * @param {IDBTransactionMode} mode 
+   * @param {IDBTransactionOptions} options
+   * @returns {Promise<any>}
    */
-  constructor(name) {
-    super();
-    this._outerName = name + '-outer';
-    this._innerName = name + '-inner';
-  }
+  async #q(f, mode, options) {
+    /** @type {IDBTransaction} */ let tx;
+    if (this.#request &&
+        this.#txPending.has(this.#request.transaction) &&
+        this.#request.transaction.mode >= mode &&
+        this.#request.transaction.durability === options.durability) {
+      // The previous request transaction is compatible and has
+      // not yet completed.
+      tx = this.#request.transaction;
+
+      // If the previous request is pending, wait for it to complete.
+      // This ensures that the transaction will be active.
+      if (this.#request.readyState === 'pending') {
+        await new Promise(resolve => {
+          this.#request.addEventListener('success', resolve, { once: true });
+          this.#request.addEventListener('error', resolve, { once: true });
+        });
+      }
+    }
 
-  async isSomewhereReserved() {
-    const mode = await this._pollWebLock(this._outerName);
-    return mode === 'exclusive';
-  }
+    for (let i = 0; i < 2; ++i) {
+      if (!tx) {
+        // The current transaction is missing or doesn't match so
+        // replace it with a new one. wait for the previous
+        // transaction to complete so the lifetimes do not overlap.
+        await this.#txComplete;
 
-  async _NONEtoSHARED() {
-    await this._acquireWebLock(this._outerName, {
-      mode: 'shared',
-      signal: this._getTimeoutSignal()
-    });
-    await this._acquireWebLock(this._innerName, {
-      mode: 'shared',
-      signal: this._getTimeoutSignal()
-    });
-    this._releaseWebLock(this._outerName);
-  }
+        // Create the new transaction.
+        // @ts-ignore
+        tx = this.#database.transaction(this.#database.objectStoreNames, mode, options);
+        this.log?.('IDBTransaction open', mode);
+        this.#txPending.add(tx);
+        this.#txComplete = new Promise((resolve, reject) => {
+          tx.addEventListener('complete', () => {
+            this.log?.('IDBTransaction complete');
+            this.#txPending.delete(tx);
+            resolve();
+          });
+          tx.addEventListener('abort', () => {
+            this.#txPending.delete(tx);
+            reject(new Error('transaction aborted'));
+          });
+        });
+      }
 
-  async _SHAREDtoRESERVED() {
-    let timeoutMillis = 1;
-    while (true) {
-      // Attempt to get the outer lock without blocking.
-      const isLocked = await this._acquireWebLock(this._outerName, {
-        mode: 'exclusive',
-        ifAvailable: true
+      // @ts-ignore
+      // Create object store proxies.
+      const objectStores = [...tx.objectStoreNames].map(name => {
+        return [name, this.proxyStoreOrIndex(tx.objectStore(name))];
       });
-      if (isLocked) break;
 
-      if (await this.isSomewhereReserved()) {
-        // Someone else has a reserved lock so retry cannot succeed.
-        throw new DOMException('', 'AbortError');
+      try {
+        // Execute the function.
+        return await f(Object.fromEntries(objectStores));
+      } catch (e) {
+        // Use a new transaction if this one was inactive. This will
+        // happen if the last request in the transaction completed
+        // in a previous task but the transaction has not yet committed.
+        if (!i && e.name === 'TransactionInactiveError') {
+          this.log?.('TransactionInactiveError, retrying');
+          tx = null;
+          continue;
+        }
+        throw e;
       }
-
-      await new Promise(resolve => setTimeout(resolve, timeoutMillis));
-      timeoutMillis = Math.min(2 * timeoutMillis, this.maxRetryMillis);
     }
-    this._releaseWebLock(this._innerName);
   }
 
-  async _RESERVEDtoEXCLUSIVE() {
-    await this._acquireWebLock(this._innerName, {
-      mode: 'exclusive',
-      signal: this._getTimeoutSignal()
+  /**
+   * Object store methods that return an IDBRequest, except for cursor
+   * creation, are wrapped to return a Promise. In addition, the
+   * request is used internally for chaining.
+   * @param {IDBObjectStore} objectStore 
+   * @returns 
+   */
+  proxyStoreOrIndex(objectStore) {
+    return new Proxy(objectStore, {
+      get: (target, property, receiver) => {
+        const result = Reflect.get(target, property, receiver);
+        if (typeof result === 'function') {
+          return (...args) => {
+            const maybeRequest = Reflect.apply(result, target, args);
+            // @ts-ignore
+            if (maybeRequest instanceof IDBRequest && !property.endsWith('Cursor')) {
+              // // Debug logging.
+              // this.log?.(`${target.name}.${String(property)}`, args);
+              // maybeRequest.addEventListener('success', () => {
+              //   this.log?.(`${target.name}.${String(property)} success`, maybeRequest.result);
+              // });
+              // maybeRequest.addEventListener('error', () => {
+              //   this.log?.(`${target.name}.${String(property)} error`, maybeRequest.error);
+              // });
+              
+              // Save the request.
+              this.#request = maybeRequest;
+
+              // Abort the transaction on error.
+              maybeRequest.addEventListener('error', () => {
+                console.error(maybeRequest.error);
+                maybeRequest.transaction.abort();
+              }, { once: true });              
+
+              // Return a Promise.
+              return wrap(maybeRequest);
+            }
+            return maybeRequest;
+          }
+        }
+        return result;
+      }
     });
   }
 
-  async _EXCLUSIVEtoRESERVED() {
-    this._releaseWebLock(this._innerName);
+  /**
+   * @param {boolean} durable 
+   */
+  async sync(durable) {
+    if (this.#chain) {
+      // This waits for all IndexedDB calls to be made.
+      await this.#chain;
+      if (durable) {
+        // This waits for the final transaction to commit.
+        await this.#txComplete;
+      }
+      this.reset();
+    }
   }
 
-  async _RESERVEDtoSHARED() {
-    await this._acquireWebLock(this._innerName, { mode: 'shared' });
-    this._releaseWebLock(this._outerName);
+  reset() {
+    this.#chain = null;
+    this.#txComplete = Promise.resolve();
+    this.#request = null;
   }
+}
 
-  async _SHAREDtoNONE() {
-    this._releaseWebLock(this._innerName);
-  }
+/**
+ * @param {IDBRequest} request 
+ * @returns {Promise}
+ */
+function wrap(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
 }
 
+
+
 /***/ })
 
 }]);