@powersync/web 0.0.0-dev-20260216124709 → 0.0.0-dev-20260225163712

package/dist/worker/node_modules_pnpm_journeyapps_wa-sqlite_0_0_0-dev-20260225162137_node_modules_journeyapps_wa--3f11fc.umd.js

@@ -0,0 +1,3375 @@
+"use strict";
+(self["webpackChunksdk_web"] = self["webpackChunksdk_web"] || []).push([["node_modules_pnpm_journeyapps_wa-sqlite_0_0_0-dev-20260225162137_node_modules_journeyapps_wa--3f11fc"],{
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js"
+/*!*************************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/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/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+
+
+const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+
+// Milliseconds since Julian epoch as a BigInt.
+// https://github.com/sqlite/sqlite/blob/e57527c14f7b7cfa6e32eeab5c549d50c4fa3674/src/os_unix.c#L6872-L6882
+const UNIX_EPOCH = 24405875n * 8640000n;
+
+// 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} nByte 
+   * @param {number} pCharOut
+   * @returns {number|Promise<number>}
+   */
+  xRandomness(pVfs, nByte, pCharOut) {
+    const randomArray = new Uint8Array(nByte);
+    crypto.getRandomValues(randomArray);
+    // Copy randomArray to the WebAssembly memory
+    const buffer = pCharOut; // Pointer to memory in WebAssembly
+    this._module.HEAPU8.set(randomArray, buffer); // Copy randomArray into memory starting at buffer
+    return nByte;
+  }
+
+  /**
+   * Gets the current time as milliseconds since Unix epoch
+   * @param {number} pVfs pointer to the VFS
+   * @param {number} pTime pointer to write the time value
+   * @returns {number} SQLite error code
+   */
+  xCurrentTimeInt64(pVfs, pTime) {
+    // Create a DataView to write the current time
+    const timeView = this.#makeTypedDataView('BigInt64', pTime);
+  
+    const currentTime = BigInt(Date.now());
+    // Convert the current time to milliseconds since Unix epoch
+    const value = UNIX_EPOCH + currentTime;
+    
+    // Write the time value to the pointer location
+    timeView.setBigInt64(0, value, true);
+    
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @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 a DataView-like class.
+   * This wrapper class prevents use of incorrect type or endianness, and
+   * reacquires the underlying buffer when the WebAssembly memory is resized.
+   * @param {'Int32'|'BigInt64'} type 
+   * @param {number} byteOffset 
+   * @returns {DataView}
+   */
+  #makeTypedDataView(type, byteOffset) {
+    // @ts-ignore
+    return new DataViewProxy(this._module, byteOffset, type);
+  }
+
+  /**
+   * Wrapped Uint8Array for buffer arguments.
+   * Memory blocks are passed as a Uint8Array-like class. This wrapper
+   * class reacquires the underlying buffer when the WebAssembly memory
+   * is resized.
+   * @param {number} byteOffset 
+   * @param {number} byteLength 
+   * @returns {Uint8Array}
+   */
+  #makeDataArray(byteOffset, byteLength) {
+    // @ts-ignore
+    return new Uint8ArrayProxy(this._module, byteOffset, byteLength);
+  }
+
+  #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);
+}
+
+// This class provides a Uint8Array-like interface for a WebAssembly memory
+// buffer. It is used to access memory blocks passed as arguments to
+// xRead, xWrite, etc. The class reacquires the underlying buffer when the
+// WebAssembly memory is resized, which can happen when the memory is
+// detached and resized by the WebAssembly module.
+//
+// Note that although this class implements the same methods as Uint8Array,
+// it is not a real Uint8Array and passing it to functions that expect
+// a Uint8Array may not work. Use subarray() to get a real Uint8Array
+// if needed.
+class Uint8ArrayProxy {
+  #module;
+
+  #_array = new Uint8Array()
+  get #array() {
+    if (this.#_array.buffer.byteLength === 0) {
+      // WebAssembly memory resize detached the buffer so re-create the
+      // array with the new buffer.
+      this.#_array = this.#module.HEAPU8.subarray(
+        this.byteOffset,
+        this.byteOffset + this.byteLength);
+    }
+    return this.#_array;
+  }
+
+  /**
+   * @param {*} module
+   * @param {number} byteOffset 
+   * @param {number} byteLength 
+   */
+  constructor(module, byteOffset, byteLength) {
+    this.#module = module;
+    this.byteOffset = byteOffset;
+    this.length = this.byteLength = byteLength;
+  }
+
+  get buffer() {
+    return this.#array.buffer;
+  }
+
+  at(index) {
+    return this.#array.at(index);
+  }
+  copyWithin(target, start, end) {
+    this.#array.copyWithin(target, start, end);
+  }
+  entries() {
+    return this.#array.entries();
+  }
+  every(predicate) {
+    return this.#array.every(predicate);
+  }
+  fill(value, start, end) {
+    this.#array.fill(value, start, end);
+  }
+  filter(predicate) {
+    return this.#array.filter(predicate);
+  }
+  find(predicate) {
+    return this.#array.find(predicate);
+  }
+  findIndex(predicate) {
+    return this.#array.findIndex(predicate);
+  }
+  findLast(predicate) {
+    return this.#array.findLast(predicate);
+  }
+  findLastIndex(predicate) {
+    return this.#array.findLastIndex(predicate);
+  }
+  forEach(callback) {
+    this.#array.forEach(callback);
+  }
+  includes(value, start) {
+    return this.#array.includes(value, start);
+  }
+  indexOf(value, start) {
+    return this.#array.indexOf(value, start);
+  }
+  join(separator) {
+    return this.#array.join(separator);
+  }
+  keys() {
+    return this.#array.keys();
+  }
+  lastIndexOf(value, start) {
+    return this.#array.lastIndexOf(value, start);
+  }
+  map(callback) {
+    return this.#array.map(callback);
+  }
+  reduce(callback, initialValue) {
+    return this.#array.reduce(callback, initialValue);
+  }
+  reduceRight(callback, initialValue) {
+    return this.#array.reduceRight(callback, initialValue);
+  }
+  reverse() {
+    this.#array.reverse();
+  }
+  set(array, offset) {
+    this.#array.set(array, offset);
+  }
+  slice(start, end) {
+    return this.#array.slice(start, end);
+  }
+  some(predicate) {
+    return this.#array.some(predicate);
+  }
+  sort(compareFn) {
+    this.#array.sort(compareFn);
+  }
+  subarray(begin, end) {
+    return this.#array.subarray(begin, end);
+  }
+  toLocaleString(locales, options) {
+    // @ts-ignore
+    return this.#array.toLocaleString(locales, options);
+  }
+  toReversed() {
+    return this.#array.toReversed();
+  }
+  toSorted(compareFn) {
+    return this.#array.toSorted(compareFn);
+  }
+  toString() {
+    return this.#array.toString();
+  }
+  values() {
+    return this.#array.values();
+  }
+  with(index, value) {
+    return this.#array.with(index, value);
+  }
+  [Symbol.iterator]() {
+    return this.#array[Symbol.iterator]();
+  }
+}
+
+// This class provides a DataView-like interface for a WebAssembly memory
+// buffer, restricted to either Int32 or BigInt64 types. It also reacquires
+// the underlying buffer when the WebAssembly memory is resized, which can
+// happen when the memory is detached and resized by the WebAssembly module.
+class DataViewProxy {
+  #module;
+  #type;
+
+  #_view = new DataView(new ArrayBuffer(0));
+  get #view() {
+    if (this.#_view.buffer.byteLength === 0) {
+      // WebAssembly memory resize detached the buffer so re-create the
+      // view with the new buffer.
+      this.#_view = new DataView(
+        this.#module.HEAPU8.buffer,
+        this.#module.HEAPU8.byteOffset + this.byteOffset);
+    }
+    return this.#_view;
+  }
+
+  /**
+   * @param {*} module
+   * @param {number} byteOffset 
+   * @param {'Int32'|'BigInt64'} type
+   */
+  constructor(module, byteOffset, type) {
+    this.#module = module;
+    this.byteOffset = byteOffset;
+    this.#type = type;
+  }
+
+  get buffer() {
+    return this.#view.buffer;
+  }
+  get byteLength() {
+    return this.#type === 'Int32' ? 4 : 8;
+  }
+
+  getInt32(byteOffset, littleEndian) {
+    if (this.#type !== 'Int32') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    return this.#view.getInt32(byteOffset, littleEndian);
+  }
+  setInt32(byteOffset, value, littleEndian) {
+    if (this.#type !== 'Int32') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    this.#view.setInt32(byteOffset, value, littleEndian);
+  }
+  getBigInt64(byteOffset, littleEndian) {
+    if (this.#type !== 'BigInt64') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    return this.#view.getBigInt64(byteOffset, littleEndian);
+  }
+  setBigInt64(byteOffset, value, littleEndian) {
+    if (this.#type !== 'BigInt64') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    this.#view.setBigInt64(byteOffset, value, littleEndian);
+  }
+}
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/VFS.js"
+/*!*******************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/VFS.js ***!
+  \*******************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Base: () => (/* binding */ Base),
+/* harmony export */   FILE_TYPE_MASK: () => (/* binding */ FILE_TYPE_MASK),
+/* harmony export */   SQLITE_ABORT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ABORT),
+/* harmony export */   SQLITE_ACCESS_EXISTS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_EXISTS),
+/* harmony export */   SQLITE_ACCESS_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_READ),
+/* harmony export */   SQLITE_ACCESS_READWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_READWRITE),
+/* harmony export */   SQLITE_ALTER_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ALTER_TABLE),
+/* harmony export */   SQLITE_ANALYZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ANALYZE),
+/* harmony export */   SQLITE_ATTACH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ATTACH),
+/* harmony export */   SQLITE_AUTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_AUTH),
+/* harmony export */   SQLITE_BLOB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BLOB),
+/* harmony export */   SQLITE_BUSY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY),
+/* harmony export */   SQLITE_CANTOPEN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN),
+/* harmony export */   SQLITE_CONSTRAINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT),
+/* harmony export */   SQLITE_CONSTRAINT_CHECK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_CHECK),
+/* harmony export */   SQLITE_CONSTRAINT_COMMITHOOK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_COMMITHOOK),
+/* harmony export */   SQLITE_CONSTRAINT_FOREIGNKEY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_FOREIGNKEY),
+/* harmony export */   SQLITE_CONSTRAINT_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_FUNCTION),
+/* harmony export */   SQLITE_CONSTRAINT_NOTNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_NOTNULL),
+/* harmony export */   SQLITE_CONSTRAINT_PINNED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_PINNED),
+/* harmony export */   SQLITE_CONSTRAINT_PRIMARYKEY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_PRIMARYKEY),
+/* harmony export */   SQLITE_CONSTRAINT_ROWID: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_ROWID),
+/* harmony export */   SQLITE_CONSTRAINT_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_TRIGGER),
+/* harmony export */   SQLITE_CONSTRAINT_UNIQUE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_UNIQUE),
+/* harmony export */   SQLITE_CONSTRAINT_VTAB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_VTAB),
+/* harmony export */   SQLITE_COPY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_COPY),
+/* harmony export */   SQLITE_CORRUPT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CORRUPT),
+/* harmony export */   SQLITE_CREATE_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_INDEX),
+/* harmony export */   SQLITE_CREATE_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TABLE),
+/* harmony export */   SQLITE_CREATE_TEMP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_INDEX),
+/* harmony export */   SQLITE_CREATE_TEMP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_TABLE),
+/* harmony export */   SQLITE_CREATE_TEMP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_TRIGGER),
+/* harmony export */   SQLITE_CREATE_TEMP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_VIEW),
+/* harmony export */   SQLITE_CREATE_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TRIGGER),
+/* harmony export */   SQLITE_CREATE_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_VIEW),
+/* harmony export */   SQLITE_CREATE_VTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_VTABLE),
+/* harmony export */   SQLITE_DELETE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DELETE),
+/* harmony export */   SQLITE_DENY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DENY),
+/* harmony export */   SQLITE_DETACH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DETACH),
+/* harmony export */   SQLITE_DETERMINISTIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DETERMINISTIC),
+/* harmony export */   SQLITE_DIRECTONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DIRECTONLY),
+/* harmony export */   SQLITE_DONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE),
+/* harmony export */   SQLITE_DROP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_INDEX),
+/* harmony export */   SQLITE_DROP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TABLE),
+/* harmony export */   SQLITE_DROP_TEMP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_INDEX),
+/* harmony export */   SQLITE_DROP_TEMP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_TABLE),
+/* harmony export */   SQLITE_DROP_TEMP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_TRIGGER),
+/* harmony export */   SQLITE_DROP_TEMP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_VIEW),
+/* harmony export */   SQLITE_DROP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TRIGGER),
+/* harmony export */   SQLITE_DROP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_VIEW),
+/* harmony export */   SQLITE_DROP_VTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_VTABLE),
+/* harmony export */   SQLITE_EMPTY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_EMPTY),
+/* harmony export */   SQLITE_ERROR: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ERROR),
+/* harmony export */   SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_BEGIN_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_BUSYHANDLER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_BUSYHANDLER),
+/* harmony export */   SQLITE_FCNTL_CHUNK_SIZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CHUNK_SIZE),
+/* harmony export */   SQLITE_FCNTL_CKPT_DONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CKPT_DONE),
+/* harmony export */   SQLITE_FCNTL_CKPT_START: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CKPT_START),
+/* harmony export */   SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_COMMIT_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_COMMIT_PHASETWO: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_COMMIT_PHASETWO),
+/* harmony export */   SQLITE_FCNTL_DATA_VERSION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_DATA_VERSION),
+/* harmony export */   SQLITE_FCNTL_FILE_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_FILE_POINTER),
+/* harmony export */   SQLITE_FCNTL_GET_LOCKPROXYFILE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_GET_LOCKPROXYFILE),
+/* harmony export */   SQLITE_FCNTL_HAS_MOVED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_HAS_MOVED),
+/* harmony export */   SQLITE_FCNTL_JOURNAL_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_JOURNAL_POINTER),
+/* harmony export */   SQLITE_FCNTL_LAST_ERRNO: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LAST_ERRNO),
+/* harmony export */   SQLITE_FCNTL_LOCKSTATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LOCKSTATE),
+/* harmony export */   SQLITE_FCNTL_LOCK_TIMEOUT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LOCK_TIMEOUT),
+/* harmony export */   SQLITE_FCNTL_MMAP_SIZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_MMAP_SIZE),
+/* harmony export */   SQLITE_FCNTL_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_OVERWRITE),
+/* harmony export */   SQLITE_FCNTL_PDB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PDB),
+/* harmony export */   SQLITE_FCNTL_PERSIST_WAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PERSIST_WAL),
+/* harmony export */   SQLITE_FCNTL_POWERSAFE_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_POWERSAFE_OVERWRITE),
+/* harmony export */   SQLITE_FCNTL_PRAGMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PRAGMA),
+/* harmony export */   SQLITE_FCNTL_RBU: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_RBU),
+/* harmony export */   SQLITE_FCNTL_RESERVE_BYTES: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_RESERVE_BYTES),
+/* harmony export */   SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_SET_LOCKPROXYFILE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SET_LOCKPROXYFILE),
+/* harmony export */   SQLITE_FCNTL_SIZE_HINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SIZE_HINT),
+/* harmony export */   SQLITE_FCNTL_SIZE_LIMIT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SIZE_LIMIT),
+/* harmony export */   SQLITE_FCNTL_SYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SYNC),
+/* harmony export */   SQLITE_FCNTL_SYNC_OMITTED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SYNC_OMITTED),
+/* harmony export */   SQLITE_FCNTL_TEMPFILENAME: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_TEMPFILENAME),
+/* harmony export */   SQLITE_FCNTL_TRACE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_TRACE),
+/* harmony export */   SQLITE_FCNTL_VFSNAME: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_VFSNAME),
+/* harmony export */   SQLITE_FCNTL_VFS_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_VFS_POINTER),
+/* harmony export */   SQLITE_FCNTL_WAL_BLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WAL_BLOCK),
+/* harmony export */   SQLITE_FCNTL_WIN32_AV_RETRY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_AV_RETRY),
+/* harmony export */   SQLITE_FCNTL_WIN32_GET_HANDLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_GET_HANDLE),
+/* harmony export */   SQLITE_FCNTL_WIN32_SET_HANDLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_SET_HANDLE),
+/* harmony export */   SQLITE_FCNTL_ZIPVFS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_ZIPVFS),
+/* harmony export */   SQLITE_FLOAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FLOAT),
+/* harmony export */   SQLITE_FORMAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FORMAT),
+/* harmony export */   SQLITE_FULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FULL),
+/* harmony export */   SQLITE_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FUNCTION),
+/* harmony export */   SQLITE_IGNORE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IGNORE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_EQ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_EQ),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_FUNCTION),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GLOB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GLOB),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_IS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_IS),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNOT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNOT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNOTNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNOTNULL),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNULL),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LIKE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LIKE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_MATCH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_MATCH),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_NE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_NE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_REGEXP: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_REGEXP),
+/* harmony export */   SQLITE_INDEX_SCAN_UNIQUE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_SCAN_UNIQUE),
+/* harmony export */   SQLITE_INNOCUOUS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INNOCUOUS),
+/* harmony export */   SQLITE_INSERT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INSERT),
+/* harmony export */   SQLITE_INTEGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTEGER),
+/* harmony export */   SQLITE_INTERNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTERNAL),
+/* harmony export */   SQLITE_INTERRUPT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTERRUPT),
+/* harmony export */   SQLITE_IOCAP_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC),
+/* harmony export */   SQLITE_IOCAP_ATOMIC16K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC16K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC1K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC1K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC2K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC2K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC32K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC32K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC4K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC4K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC512: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC512),
+/* harmony export */   SQLITE_IOCAP_ATOMIC64K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC64K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC8K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC8K),
+/* harmony export */   SQLITE_IOCAP_BATCH_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_BATCH_ATOMIC),
+/* harmony export */   SQLITE_IOCAP_IMMUTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_IMMUTABLE),
+/* harmony export */   SQLITE_IOCAP_POWERSAFE_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_POWERSAFE_OVERWRITE),
+/* harmony export */   SQLITE_IOCAP_SAFE_APPEND: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_SAFE_APPEND),
+/* harmony export */   SQLITE_IOCAP_SEQUENTIAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_SEQUENTIAL),
+/* harmony export */   SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN),
+/* harmony export */   SQLITE_IOERR: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR),
+/* harmony export */   SQLITE_IOERR_ACCESS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_ACCESS),
+/* harmony export */   SQLITE_IOERR_BEGIN_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_BEGIN_ATOMIC),
+/* harmony export */   SQLITE_IOERR_CHECKRESERVEDLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_CHECKRESERVEDLOCK),
+/* harmony export */   SQLITE_IOERR_CLOSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_CLOSE),
+/* harmony export */   SQLITE_IOERR_COMMIT_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_COMMIT_ATOMIC),
+/* harmony export */   SQLITE_IOERR_DATA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DATA),
+/* harmony export */   SQLITE_IOERR_DELETE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DELETE),
+/* harmony export */   SQLITE_IOERR_DELETE_NOENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DELETE_NOENT),
+/* harmony export */   SQLITE_IOERR_DIR_FSYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DIR_FSYNC),
+/* harmony export */   SQLITE_IOERR_FSTAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_FSTAT),
+/* harmony export */   SQLITE_IOERR_FSYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_FSYNC),
+/* harmony export */   SQLITE_IOERR_GETTEMPPATH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_GETTEMPPATH),
+/* harmony export */   SQLITE_IOERR_LOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_LOCK),
+/* harmony export */   SQLITE_IOERR_NOMEM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_NOMEM),
+/* harmony export */   SQLITE_IOERR_RDLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_RDLOCK),
+/* harmony export */   SQLITE_IOERR_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_READ),
+/* harmony export */   SQLITE_IOERR_ROLLBACK_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_ROLLBACK_ATOMIC),
+/* harmony export */   SQLITE_IOERR_SEEK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SEEK),
+/* harmony export */   SQLITE_IOERR_SHORT_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SHORT_READ),
+/* harmony export */   SQLITE_IOERR_TRUNCATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_TRUNCATE),
+/* harmony export */   SQLITE_IOERR_UNLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_UNLOCK),
+/* harmony export */   SQLITE_IOERR_VNODE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_VNODE),
+/* harmony export */   SQLITE_IOERR_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_WRITE),
+/* harmony export */   SQLITE_LIMIT_ATTACHED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_ATTACHED),
+/* harmony export */   SQLITE_LIMIT_COLUMN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_COLUMN),
+/* harmony export */   SQLITE_LIMIT_COMPOUND_SELECT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_COMPOUND_SELECT),
+/* harmony export */   SQLITE_LIMIT_EXPR_DEPTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_EXPR_DEPTH),
+/* harmony export */   SQLITE_LIMIT_FUNCTION_ARG: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_FUNCTION_ARG),
+/* harmony export */   SQLITE_LIMIT_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_LENGTH),
+/* harmony export */   SQLITE_LIMIT_LIKE_PATTERN_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_LIKE_PATTERN_LENGTH),
+/* harmony export */   SQLITE_LIMIT_SQL_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_SQL_LENGTH),
+/* harmony export */   SQLITE_LIMIT_TRIGGER_DEPTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_TRIGGER_DEPTH),
+/* harmony export */   SQLITE_LIMIT_VARIABLE_NUMBER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_VARIABLE_NUMBER),
+/* harmony export */   SQLITE_LIMIT_VDBE_OP: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_VDBE_OP),
+/* harmony export */   SQLITE_LIMIT_WORKER_THREADS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_WORKER_THREADS),
+/* harmony export */   SQLITE_LOCKED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCKED),
+/* harmony export */   SQLITE_LOCK_EXCLUSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE),
+/* harmony export */   SQLITE_LOCK_NONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE),
+/* harmony export */   SQLITE_LOCK_PENDING: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_PENDING),
+/* harmony export */   SQLITE_LOCK_RESERVED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED),
+/* harmony export */   SQLITE_LOCK_SHARED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED),
+/* harmony export */   SQLITE_MISMATCH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISMATCH),
+/* harmony export */   SQLITE_MISUSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE),
+/* harmony export */   SQLITE_NOLFS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOLFS),
+/* harmony export */   SQLITE_NOMEM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOMEM),
+/* harmony export */   SQLITE_NOTADB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTADB),
+/* harmony export */   SQLITE_NOTFOUND: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND),
+/* harmony export */   SQLITE_NOTICE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTICE),
+/* harmony export */   SQLITE_NULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NULL),
+/* harmony export */   SQLITE_OK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK),
+/* harmony export */   SQLITE_OPEN_AUTOPROXY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_AUTOPROXY),
+/* harmony export */   SQLITE_OPEN_CREATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_CREATE),
+/* harmony export */   SQLITE_OPEN_DELETEONCLOSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_DELETEONCLOSE),
+/* harmony export */   SQLITE_OPEN_EXCLUSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_EXCLUSIVE),
+/* harmony export */   SQLITE_OPEN_FULLMUTEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_FULLMUTEX),
+/* harmony export */   SQLITE_OPEN_MAIN_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_DB),
+/* harmony export */   SQLITE_OPEN_MAIN_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_JOURNAL),
+/* harmony export */   SQLITE_OPEN_MEMORY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MEMORY),
+/* harmony export */   SQLITE_OPEN_NOFOLLOW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_NOFOLLOW),
+/* harmony export */   SQLITE_OPEN_NOMUTEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_NOMUTEX),
+/* harmony export */   SQLITE_OPEN_PRIVATECACHE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_PRIVATECACHE),
+/* harmony export */   SQLITE_OPEN_READONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READONLY),
+/* harmony export */   SQLITE_OPEN_READWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READWRITE),
+/* harmony export */   SQLITE_OPEN_SHAREDCACHE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SHAREDCACHE),
+/* harmony export */   SQLITE_OPEN_SUBJOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUBJOURNAL),
+/* harmony export */   SQLITE_OPEN_SUPER_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUPER_JOURNAL),
+/* harmony export */   SQLITE_OPEN_TEMP_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_DB),
+/* harmony export */   SQLITE_OPEN_TEMP_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_JOURNAL),
+/* harmony export */   SQLITE_OPEN_TRANSIENT_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TRANSIENT_DB),
+/* harmony export */   SQLITE_OPEN_URI: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_URI),
+/* 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),
+/* harmony export */   SQLITE_READONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_READONLY),
+/* harmony export */   SQLITE_RECURSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RECURSIVE),
+/* harmony export */   SQLITE_REINDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_REINDEX),
+/* harmony export */   SQLITE_ROW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW),
+/* harmony export */   SQLITE_SAVEPOINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SAVEPOINT),
+/* harmony export */   SQLITE_SCHEMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SCHEMA),
+/* harmony export */   SQLITE_SELECT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SELECT),
+/* harmony export */   SQLITE_STATIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_STATIC),
+/* harmony export */   SQLITE_SUBTYPE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SUBTYPE),
+/* harmony export */   SQLITE_SYNC_DATAONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_DATAONLY),
+/* harmony export */   SQLITE_SYNC_FULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_FULL),
+/* harmony export */   SQLITE_SYNC_NORMAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_NORMAL),
+/* harmony export */   SQLITE_TEXT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TEXT),
+/* harmony export */   SQLITE_TOOBIG: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TOOBIG),
+/* harmony export */   SQLITE_TRANSACTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TRANSACTION),
+/* harmony export */   SQLITE_TRANSIENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TRANSIENT),
+/* harmony export */   SQLITE_UPDATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UPDATE),
+/* harmony export */   SQLITE_UTF16: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16),
+/* harmony export */   SQLITE_UTF16BE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16BE),
+/* harmony export */   SQLITE_UTF16LE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16LE),
+/* harmony export */   SQLITE_UTF8: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF8),
+/* 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/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/sqlite-constants.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+
+
+
+const DEFAULT_SECTOR_SIZE = 512;
+
+// Base class for a VFS.
+class Base {
+  name;
+  mxPathname = 64;
+  _module;
+
+  /**
+   * @param {string} name 
+   * @param {object} module 
+   */
+  constructor(name, module) {
+    this.name = name;
+    this._module = module;
+  }
+
+  /**
+   * @returns {void|Promise<void>} 
+   */
+  close() {
+  }
+
+  /**
+   * @returns {boolean|Promise<boolean>}
+   */
+  isReady() {
+    return true;
+  }
+
+  /**
+   * Overload in subclasses to indicate which methods are asynchronous.
+   * @param {string} methodName 
+   * @returns {boolean}
+   */
+  hasAsyncMethod(methodName) {
+    return false;
+  }
+
+  /**
+   * @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) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
+   */
+  xDelete(pVfs, zName, syncDir) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} flags 
+   * @param {number} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  xAccess(pVfs, zName, flags, pResOut) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} zName 
+   * @param {number} nOut 
+   * @param {number} zOut 
+   * @returns {number|Promise<number>}
+   */
+  xFullPathname(pVfs, zName, nOut, zOut) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pVfs 
+   * @param {number} nBuf 
+   * @param {number} zBuf 
+   * @returns {number|Promise<number>}
+   */
+  xGetLastError(pVfs, nBuf, zBuf) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @returns {number|Promise<number>}
+   */
+  xClose(pFile) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @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) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @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) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @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 
+   * @returns {number|Promise<number>}
+   */
+  xSync(pFile, flags) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * 
+   * @param {number} pFile 
+   * @param {number} pSize 
+   * @returns {number|Promise<number>}
+   */
+  xFileSize(pFile, pSize) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  xLock(pFile, lockType) {
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  }
+
+  /**
+   * @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>}
+   */
+  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;
+  }
+}
+
+const FILE_TYPE_MASK = [
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_DB,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_JOURNAL,
+  _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_DB,
+  _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_WAL
+].reduce((mask, element) => mask | element);
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/LazyLock.js"
+/*!*********************************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/LazyLock.js ***!
+  \*********************************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   LazyLock: () => (/* binding */ LazyLock)
+/* harmony export */ });
+/* harmony import */ var _Lock_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Lock.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js");
+
+
+class LazyLock extends _Lock_js__WEBPACK_IMPORTED_MODULE_0__.Lock {
+  #channel;
+  #isBusy = false;
+  #hasReleaseRequest = false;
+
+  /**
+   * @param {string} name 
+   */
+  constructor(name) {
+    super(name);
+    this.#channel = new BroadcastChannel(name);
+    this.#channel.onmessage = (event) => {
+      if (this.#isBusy) {
+        // We're using the lock so postpone the release.
+        this.#hasReleaseRequest = true;
+      } else {
+        this.release();
+      }
+    }
+  }
+
+  close() {
+    super.close
+    this.#channel.onmessage = null;
+    this.#channel.close();
+  }
+
+  /**
+   * @param {LockMode} mode 
+   * @param {number} timeout 
+   * @returns {Promise<boolean>}
+   */
+  async acquire(mode, timeout = -1) {
+    this.#isBusy = true;
+    try {
+      if (mode === this.mode) {
+        // We never had to release the lock.
+        return true;
+      }
+
+      if (this.mode) {
+        // Release the lock to acquire it in a different mode.
+        super.release();
+      } else {
+        // Poll for the lock. This isn't necessary but if it works it avoids
+        // the BroadcastChannel traffic.
+        if (await super.acquire(mode, 0)) {
+          return true;
+        }
+      }
+
+      // Request the lock.
+      const pResult = super.acquire(mode, timeout)
+      this.#channel.postMessage({});
+
+      return await pResult;
+    } catch (e) {
+      this.release();
+      throw e;
+    }
+  }
+
+  /**
+   * @param {LockMode} mode 
+   * @returns {boolean}
+   */
+  acquireIfHeld(mode) {
+    if (mode === this.mode) {
+      this.#isBusy = true;
+      return true;
+    }
+    return false;
+  }
+
+  release() {
+    super.release();
+    this.#isBusy = false;
+    this.#hasReleaseRequest = false;
+  }
+
+  releaseLazy() {
+    // Release the lock only if someone else wants it.
+    this.#isBusy = false;
+    if (this.#hasReleaseRequest) {
+      this.release();
+    }
+  }
+}
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js"
+/*!*****************************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js ***!
+  \*****************************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Lock: () => (/* binding */ Lock)
+/* harmony export */ });
+// This is a convenience wrapper for the Web Locks API.
+class Lock {
+  #name;
+  /** @type {LockMode?} */ #mode = null;
+  #releaser = null;
+
+  /**
+   * @param {string} name 
+   */
+  constructor(name) {
+    this.#name = name;
+  }
+
+  get name() { return this.#name; }
+  get mode() { return this.#mode; }
+
+  close() {
+    this.release();
+  }
+  
+  /**
+   * @param {'shared'|'exclusive'} mode 
+   * @param {number} timeout -1 for infinite, 0 for poll, >0 for milliseconds
+   * @return {Promise<boolean>} true if lock acquired, false on failed poll
+   */
+  async acquire(mode, timeout = -1) {
+    if (this.#releaser) {
+      throw new Error(`Lock ${this.#name} is already acquired`);
+    }
+    return new Promise((resolve, reject) => {
+      /** @type {LockOptions} */
+      const options = { mode, ifAvailable: timeout === 0 };
+      let timeoutId;
+      if (timeout > 0) {
+        const abortController = new AbortController();
+        timeoutId = self.setTimeout(() => {
+          abortController.abort();
+        }, timeout);
+        options.signal = abortController.signal;
+      }
+
+      navigator.locks.request(this.#name, options, lock => {
+        if (timeoutId) clearTimeout(timeoutId);
+        if (lock === null) {
+          // Polling (with timeout = 0) did not acquire the lock.
+          return resolve(false);
+        }
+
+        // Lock acquired. The lock is released when this returned
+        // Promise is resolved.
+        this.#mode = mode;
+        return new Promise(releaser => {
+          this.#releaser = releaser;
+          resolve(true);
+        })
+      }).catch(e => {
+        return reject(e);
+      });
+    });
+  }
+
+  release() {
+    this.#releaser?.();
+    this.#releaser = null;
+    this.#mode = null;
+  }
+}
+
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js"
+/*!******************************************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js ***!
+  \******************************************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   OPFSWriteAheadVFS: () => (/* binding */ OPFSWriteAheadVFS)
+/* harmony export */ });
+/* harmony import */ var _FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../FacadeVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js");
+/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../VFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+/* harmony import */ var _Lock_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Lock.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js");
+/* harmony import */ var _LazyLock_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./LazyLock.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/LazyLock.js");
+/* harmony import */ var _WriteAhead_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./WriteAhead.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/WriteAhead.js");
+
+
+
+
+
+
+const LIBRARY_FILES_ROOT = '.wa-sqlite';
+const DEFAULT_TEMP_FILES = 6;
+
+const finalizationRegistry = new FinalizationRegistry((/** @type {() => void} */ f) => f());
+
+/**
+ * @typedef FileEntry
+ * @property {string} zName
+ * @property {number} flags
+ * @property {FileSystemSyncAccessHandle} [accessHandle]
+
+ * Main database file properties:
+ * @property {*} [retryResult]
+ * @property {FileSystemSyncAccessHandle} [waHandle]
+ * @property {FileSystemSyncAccessHandle} [journalHandle]
+ * 
+ * @property {boolean} [useWriteAhead]
+ * @property {'reserved'|'exclusive'} [writeHint]
+ * @property {'normal'|'exclusive'|null} [lockingMode]
+ * @property {number} [lockState] SQLITE_LOCK_*
+ * @property {LazyLock} [readLock]
+ * @property {Lock} [writeLock]
+ * @property {number} [timeout]
+ * 
+ * @property {WriteAhead} [writeAhead]
+ */
+
+/**
+ * @typedef OPFSWriteAheadOptions
+ * @property {number} [nTmpFiles]
+ * @property {number} [autoCheckpointPages]
+ * @property {number} [heartbeatInterval]
+ * @property {number} [heartbeatActionDelay]
+ */
+
+class OPFSWriteAheadVFS extends _FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__.FacadeVFS {
+  lastError = null;
+  log = null;
+  
+  /** @type {Map<number, FileEntry>} */ mapIdToFile = new Map();
+  /** @type {Map<string, FileEntry>} */ mapPathToFile = new Map();
+
+  /** @type {Map<string, FileSystemSyncAccessHandle>} */ boundTempFiles = new Map();
+  /** @type {Set<FileSystemSyncAccessHandle>} */ unboundTempFiles = new Set();
+  /** @type {OPFSWriteAheadOptions} */ options = {
+    nTmpFiles: DEFAULT_TEMP_FILES
+  };
+
+  _ready;
+
+  static async create(name, module, options) {
+    const vfs = new OPFSWriteAheadVFS(name, module);
+    Object.assign(vfs.options, options);
+    await vfs.isReady();
+    return vfs;
+  }
+
+  constructor(name, module) {
+    super(name, module);
+    this._ready = (async () => {
+      // Ensure the library files root directory exists.
+      let dirHandle = await navigator.storage.getDirectory();
+      dirHandle = await dirHandle.getDirectoryHandle(LIBRARY_FILES_ROOT, { create: true });
+
+      // Clean up any stale session directories.
+      // @ts-ignore
+      for await (const name of dirHandle.keys()) {
+        if (name.startsWith('.session-')) {
+          // Acquire a lock on the session directory to ensure it is not in use.
+          await navigator.locks.request(name, { ifAvailable: true }, async lock => {
+            if (lock) {
+              // This directory is not in use.
+              try {
+                await dirHandle.removeEntry(name, { recursive: true });
+              } catch (e) {
+                // Ignore errors, will try again next time.
+              }
+            }
+          });
+        }
+      }
+
+      // Create our session directory.
+      const dirName = `.session-${Math.random().toString(16).slice(2)}`;
+      await new Promise(resolve => {
+        navigator.locks.request(dirName, () => {
+          // @ts-ignore
+          resolve();
+          return new Promise(release => {
+            // @ts-ignore
+            finalizationRegistry.register(this, release);
+          });
+        });
+      });
+      dirHandle = await dirHandle.getDirectoryHandle(dirName, { create: true });
+
+      // Create temporary files.
+      for (let i = 0; i < this.options.nTmpFiles; i++) {
+        const fileHandle= await dirHandle.getFileHandle(i.toString(), { create: true });
+        const accessHandle = await fileHandle.createSyncAccessHandle();
+        finalizationRegistry.register(this, () => accessHandle.close());
+        this.unboundTempFiles.add(accessHandle);
+      }
+    })();
+  }
+
+  isReady() {
+    return Promise.all([super.isReady(), this._ready]).then(() => true);
+  }
+
+ /**
+   * @param {string?} zName 
+   * @param {number} fileId 
+   * @param {number} flags 
+   * @param {DataView} pOutFlags 
+   * @returns {number}
+   */
+  jOpen(zName, fileId, flags, pOutFlags) {
+    try {
+      if (zName === null) {
+        // Generate a temporary filename. This will only be used as a
+        // key to map to a pre-opened temporary file access handle.
+        zName = Math.random().toString(16).slice(2);
+      }
+
+      const file = this.mapPathToFile.get(zName) ?? {
+        zName,
+        flags,
+        retryResult: null,
+      };
+      this.mapPathToFile.set(zName, file);
+
+      if (flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        // Open database and journal files with a retry operation.
+        if (file.retryResult === null) {
+          // This is the initial open attempt. Start the asynchronous task
+          // and return SQLITE_BUSY to force a retry.
+          this._module.retryOps.push(this.#retryOpen(zName, flags, fileId, pOutFlags));
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+        } else if (file.retryResult instanceof Error) {
+          throw file.retryResult;
+        }
+
+        // Initialize database file state.
+        file.accessHandle = file.retryResult.accessHandle;
+        file.journalHandle = file.retryResult.journalHandle;
+        file.writeAhead = file.retryResult.writeAhead;
+        file.retryResult = null;
+
+        file.lockState = _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE;
+        file.lockingMode = null;
+        file.readLock = new _LazyLock_js__WEBPACK_IMPORTED_MODULE_3__.LazyLock(`${zName}#read`);
+        file.writeLock = new _Lock_js__WEBPACK_IMPORTED_MODULE_2__.Lock(`${zName}#write`);
+        file.timeout = -1;
+        file.useWriteAhead = true;
+        file.writeHint = null;
+      } else if (flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_JOURNAL) {
+        // A journal file is managed with its main database so look that up.
+        const dbFile = this.#getDbFileFromJournalName(zName);
+        if (!dbFile) {
+          throw new Error(`database file not found for journal ${zName}`);
+        }
+
+        // Determine whether to use the public journal (which is hot or
+        // could become hot) or a private journal from the session directory.
+        // This is necessary because read connections can test a journal
+        // for hotness while a write-ahead transaction is in progress.
+        if (!dbFile.useWriteAhead || dbFile.journalHandle.getSize() > 0) { 
+          // Either write-ahead is not being used, or a hot journal is being
+          // opened for recovery. Use the public journal.
+          file.accessHandle = dbFile.journalHandle;
+        } else if (dbFile.useWriteAhead && dbFile.lockState > _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_SHARED) {
+          // The journal is being opened for a write-ahead transaction.
+          // This journal can never be hot so don't expose it to other
+          // connections.
+          file.accessHandle = this.#openTemporaryFile(zName);
+        } else {
+          throw new Error('unexpected journal file conditions');
+        }
+      } else if (flags & (_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_WAL | _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_SUPER_JOURNAL)) {
+        throw new Error('WAL and super-journal files are not supported');
+      } else {
+        // This is a temporary file. Use an unbound pre-opened accessHandle.
+        file.accessHandle = this.#openTemporaryFile(zName);
+      }
+
+      this.mapIdToFile.set(fileId, file);
+      pOutFlags.setInt32(0, flags, true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_CANTOPEN;
+    }
+  }
+
+  /**
+   * @param {string} zName 
+   * @param {number} syncDir 
+   * @returns {number}
+   */
+  jDelete(zName, syncDir) {
+    try {
+      if (this.boundTempFiles.has(zName)) {
+        const file = this.mapPathToFile.get(zName);
+        this.#deleteTemporaryFile(file);
+      } else if (zName.endsWith('-journal')) {
+        const dbFile = this.#getDbFileFromJournalName(zName);
+        dbFile?.journalHandle.truncate(0);
+        dbFile?.journalHandle.flush();
+        this.mapPathToFile.delete(zName);
+      } else {
+        throw new Error(`unexpected file deletion: ${zName}`);
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_DELETE;
+    }
+  }
+
+  /**
+   * @param {string} zName 
+   * @param {number} flags 
+   * @param {DataView} pResOut 
+   * @returns {number}
+   */
+  jAccess(zName, flags, pResOut) {
+    try {
+      // Special case main journal files.
+      if (zName.endsWith('-journal')) {
+        const dbFile = this.#getDbFileFromJournalName(zName);
+        if (dbFile) {
+          if (dbFile.lockState <= _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_SHARED) {
+            // SQLite is testing for a hot journal. Journals created in the
+            // session directory for write-ahead transactions are never hot,
+            // i.e. they are used only for rollback. So here we look for
+            // the status of the public journal.
+            if (dbFile.journalHandle.getSize() === 0) {
+              // Treat an empty journal file as non-existent.
+              pResOut.setInt32(0, 0, true);
+            } else {
+              pResOut.setInt32(0, 1, true);
+            }
+          }
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+      }
+
+      const file = this.mapPathToFile.get(zName);
+      pResOut.setInt32(0, file ? 1 : 0, true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_ACCESS;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @returns {number}
+   */
+  jClose(fileId) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file?.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        file.writeAhead.close();
+        file.accessHandle.close();
+        file.waHandle.close();
+        this.mapPathToFile.delete(file?.zName);
+
+        file.journalHandle.close();
+        const journalPath = this.#getJournalNameFromDbName(file.zName);
+        this.mapPathToFile.delete(journalPath);
+
+        file.readLock.close();
+        file.writeLock.close();
+      } else if (file?.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_JOURNAL) {
+        // The actual OPFS journal file is managed with the main database
+        // file, so don't close the access handle here.
+      } else if (file?.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_DELETEONCLOSE) {
+        this.#deleteTemporaryFile(file);
+      }
+
+      // Disassociate fileId from file entry.
+      this.mapIdToFile.delete(fileId);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_CLOSE;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number}
+   */
+  jRead(fileId, pData, iOffset) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+
+      let bytesRead = null;
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        // Try reading from the write-ahead overlays first. A read on the
+        // database file is always a complete page, except when reading
+        // from the 100-byte header.
+        const pageOffset = iOffset < 100 ? iOffset : 0;
+        const page = file.writeAhead.read(iOffset - pageOffset);
+        if (page) {
+          const readData = page.subarray(pageOffset, pageOffset + pData.byteLength);
+          pData.set(readData);
+          bytesRead = readData.byteLength;
+        }
+      }
+
+      if (bytesRead === null) {
+        // Read directly from the OPFS file.
+
+        // On Chrome (at least), passing pData to accessHandle.read() is
+        // an error because pData is a Proxy of a Uint8Array. Calling
+        // subarray() produces a real Uint8Array and that works.
+        bytesRead = file.accessHandle.read(pData.subarray(), { at: iOffset });
+      }
+
+      if (bytesRead < pData.byteLength) {
+        pData.fill(0, bytesRead);
+        return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_SHORT_READ;
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_READ;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number}
+   */
+  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.useWriteAhead) {
+          // Write to the write-ahead overlay.
+          file.writeAhead.write(iOffset, pData);
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+      }
+
+      // On Chrome (at least), passing pData to accessHandle.write() is
+      // an error because pData is a Proxy of a Uint8Array. Calling
+      // subarray() produces a real Uint8Array and that works.
+      file.accessHandle.write(pData.subarray(), { at: iOffset });
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_WRITE;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {number} iSize 
+   * @returns {number}
+   */
+  jTruncate(fileId, iSize) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        if (file.useWriteAhead) {
+          file.writeAhead.truncate(iSize);
+          return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+      }
+      file.accessHandle.truncate(iSize);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_TRUNCATE;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {number} flags 
+   * @returns {number}
+   */
+  jSync(fileId, flags) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        if (file.useWriteAhead) {
+          // TODO: Track PRAGMA synchronous setting.
+          file.writeAhead.sync('normal');
+        } else {
+          file.accessHandle.flush();
+        }
+      } else if (!this.boundTempFiles.has(file.zName)) {
+        // Persistent journal file requires sync.
+        file.accessHandle.flush();
+      } else {
+        // This is a temporary file so sync is not needed.
+        // Temporary journals are only used for rollback by the
+        // connection that created them, not for recovery.
+      }
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_FSYNC;
+    }
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {DataView} pSize64 
+   * @returns {number}
+   */
+  jFileSize(fileId, pSize64) {
+    try {
+      const file = this.mapIdToFile.get(fileId);
+
+      let size;
+      if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+        size = file.writeAhead.getFileSize() || file.accessHandle.getSize();
+      } else {
+        size = file.accessHandle.getSize();
+      }
+      pSize64.setBigInt64(0, BigInt(size), true);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_FSTAT;
+    }
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number|Promise<number>}
+   */
+  jLock(pFile, lockType) {
+    try {
+      const file = this.mapIdToFile.get(pFile);
+      if (file.lockState === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE && lockType === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_SHARED) {
+        // We do all our locking work in this transition.
+        if (file.retryResult === null) {
+          if (file.lockingMode === 'exclusive') {
+            // SQLite exclusive locking mode really means that no unlocking
+            // is done, not that the locking state is immediately EXCLUSIVE.
+            // This is a problem if the first transaction after setting
+            // exclusive locking mode does not come with a write hint, so
+            // we force the write hint here.
+            file.writeHint = 'exclusive';
+            file.useWriteAhead = false;
+          }
+
+          if (file.writeHint || file.readLock.mode !== 'shared') {
+            // Asynchronous lock acquisition is needed. Set retryResult to
+            // non-null so when SQLite calls jUnlock() it knows not to reset
+            // any locks we have in progress.
+            file.retryResult = {};
+            this._module.retryOps.push(this.#retryLock(pFile, lockType));
+            return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+          }
+
+          // This is a read transaction and we can get the shared
+          // lock synchronously.
+          file.readLock.acquireIfHeld('shared');
+        } else if (file.retryResult instanceof Error) {
+          throw file.retryResult;
+        }
+
+        // We have acquired the needed locks, either synchronously or
+        // via retry.
+        file.retryResult = null;
+        if (file.writeHint === null) {
+          // Ensure that our read-only view of the database does not change
+          // while in the SHARED lock state. The corresponding method
+          // isolateForWrite() is not called in this method, but instead
+          // in retryLock() because it is asynchronous.
+          file.writeAhead.isolateForRead();
+        }
+      } else if (lockType >= _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_RESERVED && !file.writeLock.mode) {
+        // This is a write transaction but we don't already have the write
+        // lock. This happens when the write hint was not used, which this
+        // VFS treats as an error.
+        throw new Error('Multi-statement write transaction cannot use BEGIN DEFERRED');
+      }
+      file.lockState = lockType;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    } catch (e) {
+      if (e.name === 'AbortError') {
+        // Timeout expired while waiting for the lock.
+        return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+      }
+
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_LOCK;
+    }
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {number} lockType 
+   * @returns {number}
+   */
+  jUnlock(pFile, lockType) {
+    try {
+      const file = this.mapIdToFile.get(pFile);
+
+      // If retryResult is non-null, an asynchronous lock operation is in
+      // progress. In that case, don't change any locks.
+      if (!file.retryResult && lockType === _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE) {
+        // In this VFS, this is the only unlock transition that matters.
+        if (file.useWriteAhead) {
+          // Exit write-ahead isolation.
+          file.writeAhead.rejoin();
+        }
+
+        file.writeLock.release();
+        if (file.readLock.mode === 'exclusive') {
+          // TODO: Consider lazy release here as well.
+          file.readLock.release();
+        } else {
+          file.readLock.releaseLazy();
+        }
+        file.writeHint = null;
+
+        if (file.lockingMode === 'normal') {
+          file.useWriteAhead = true;
+        }
+      }
+      file.lockState = lockType;
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_UNLOCK;
+    }
+  }
+
+  /**
+   * @param {number} pFile 
+   * @param {DataView} pResOut 
+   * @returns {number}
+   */
+  jCheckReservedLock(pFile, pResOut) {
+    // This function is only called in the SHARED lock state, and when
+    // a potentially hot journal file exists. Such a journal can only
+    // be created without using write-ahead, and such a connection
+    // cannot co-exist with this connection in SHARED.
+    pResOut.setInt32(0, 0, true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} pFile
+   * @param {number} op
+   * @param {DataView} pArg
+   * @returns {number}
+   */
+  jFileControl(pFile, op, pArg) {
+    try {
+      const file = this.mapIdToFile.get(pFile);
+      switch (op) {
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_PRAGMA:
+          const key = this._module.UTF8ToString(pArg.getUint32(4, true));
+          const valueAddress = pArg.getUint32(8, true);
+          const value = valueAddress ? this._module.UTF8ToString(valueAddress) : null;
+          this.log?.(`PRAGMA ${key} ${value}`);
+          switch (key.toLowerCase()) {
+            case 'experimental_pragma_20251114':
+              // After entering the SHARED locking state on the next
+              // transaction, SQLite intends to immediately (barring a hot
+              // journal) transition to RESERVED if value is '1', or
+              // EXCLUSIVE if value is '2'.
+              switch (value) {
+                case '1':
+                  file.writeHint = 'reserved';
+                  break;
+                case '2':
+                  file.writeHint = 'exclusive';
+                  break;
+                default:
+                  throw new Error(`unexpected write hint value: ${value}`);
+              }
+              break;
+            case 'busy_timeout':
+              // Override SQLite's handling of busy timeouts with our
+              // blocking lock timeouts.
+              if (value !== null) {
+                file.timeout = parseInt(value);
+              } else {
+                // Return current timeout.
+                const s = file.timeout.toString();
+                const ptr = this._module._sqlite3_malloc64(s.length + 1);
+                this._module.stringToUTF8(s, ptr, s.length + 1);
+                pArg.setUint32(0, ptr, true);
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+            case 'locking_mode':
+              // Track SQLite locking mode. We will use write-ahead only in
+              // normal locking mode.
+              switch (value?.toLowerCase()) {
+                case 'normal':
+                  file.lockingMode = 'normal';
+                  break;
+                case 'exclusive':
+                  file.lockingMode = 'exclusive';
+                  break;
+              }
+              break;
+            case 'vfs_trace':
+              // This is a trace feature for debugging only.
+              if (value !== null) {
+                this.log = parseInt(value) !== 0 ? console.debug : null;
+                file.writeAhead.log = this.log;
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+            case 'wal_autocheckpoint':
+              if (value !== null) {
+                const pageCount = parseInt(value);
+                if (pageCount > 0) {
+                  file.writeAhead.options.autoCheckpointPages = pageCount;
+                }
+              }
+              break;
+            case 'wal_checkpoint':
+              const checkpointMode = (value ?? 'passive').toLowerCase();
+              switch ((value ?? 'passive').toLowerCase()) {
+                case 'passive':
+                case 'full':
+                case 'restart':
+                case 'truncate':
+                  if (file.lockState !== _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE) {
+                    throw new Error('invalid while database is locked');
+                  }
+                  
+                  this._module.pendingOps.push(this.#pendingCheckpoint(file, checkpointMode));
+                  break;
+                case 'noop':
+                  // Return the current size of the write-ahead file. SQLite
+                  // returns different information, but that is not feasible
+                  // from a VFS.
+                  {
+                    const s = file.writeAhead.getWriteAheadSize().toString();
+                    const ptr = this._module._sqlite3_malloc64(s.length + 1);
+                    this._module.stringToUTF8(s, ptr, s.length + 1);
+                    pArg.setUint32(0, ptr, true);
+                  }
+                  break;
+                default:
+                  throw new Error(`unexpected wal_checkpoint mode: ${value}`);
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+            case 'write_ahead':
+              // For testing purposes only: enable or disable write-ahead mode.
+              if (value !== null) {
+                if (file.lockState !== _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE) {
+                  throw new Error('cannot change write_ahead mode while database is locked');
+                }
+                file.useWriteAhead = parseInt(value) !== 0;
+              } else {
+                const s = (file.useWriteAhead ? '1' : '0');
+                const ptr = this._module._sqlite3_malloc64(s.length + 1);
+                this._module.stringToUTF8(s, ptr, s.length + 1);
+                pArg.setUint32(0, ptr, true);
+              }
+              return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+          }
+          break;
+
+        // Support SQLite batch atomic write transactions.
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_BEGIN_ATOMIC_WRITE:
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_COMMIT_ATOMIC_WRITE:
+          if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+            return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+          }
+          break;
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE:
+          if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+            file.writeAhead.rollback();
+            return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+          }
+          break;
+
+        case _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_SYNC:
+          if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+            if (file.useWriteAhead) {
+              file.writeAhead.commit();
+            }
+          }
+          break;
+      }
+    } catch (e) {
+      console.error(e.stack);
+      this.lastError = e;
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR;
+    }
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_NOTFOUND;
+  }
+
+  /**
+   * @param {number} pFile
+   * @returns {number}
+   */
+  jDeviceCharacteristics(pFile) {
+    let result = _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
+
+    const file = this.mapIdToFile.get(pFile);
+    if (file.useWriteAhead) {
+      // When write-ahead is in use, we can do batch atomic writes.
+      result |= _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOCAP_BATCH_ATOMIC;
+    }
+    return result;
+  }
+
+  /**
+   * @param {Uint8Array} zBuf 
+   * @returns {number}
+   */
+  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 _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK
+  }
+
+  /**
+   * @param {string} zName 
+   * @returns {FileSystemSyncAccessHandle}
+   */
+  #openTemporaryFile(zName) {
+    if (this.unboundTempFiles.size === 0) {
+      throw new Error('no temporary files available');
+    }
+
+    // Bind an access handle from the temporary pool.
+    const accessHandle = this.unboundTempFiles.values().next().value;
+    this.unboundTempFiles.delete(accessHandle);
+    this.boundTempFiles.set(zName, accessHandle);
+    return accessHandle;
+  }
+
+  /**
+   * @param {FileEntry} file 
+   */
+  #deleteTemporaryFile(file) {
+    file.accessHandle.truncate(0);
+
+    // Temporary files are not actually deleted, just returned to the pool.
+    this.mapPathToFile.delete(file.zName);
+    this.unboundTempFiles.add(file.accessHandle);
+    this.boundTempFiles.delete(file.zName);
+  }
+
+  /**
+   * @param {string} dbName 
+   * @returns {string}
+   */
+  #getJournalNameFromDbName(dbName) {
+    return `${dbName}-journal`;
+  }
+
+  #getWriteAheadNameFromDbName(dbName) {
+    // Our WAL file is not compatible with SQLite WAL, so use a distinct name.
+    return `${dbName}-waf`;
+  }
+
+  /**
+   * @param {string} journalName 
+   * @returns {FileEntry}
+   */
+  #getDbFileFromJournalName(journalName) {
+    const dbFilename = journalName.slice(0, -'-journal'.length);
+    return this.mapPathToFile.get(dbFilename);
+  }
+
+  /**
+   * 
+   * @param {FileEntry} file 
+   * @param {'passive'|'full'|'restart'|'truncate'} mode 
+   */
+  async #pendingCheckpoint(file, mode) {
+    try {
+      const ckptLockOptions = { ifAvailable: mode === 'passive' };
+      if (mode !== 'passive') {
+        await file.readLock.acquire('exclusive', file.timeout);
+        await file.writeLock.acquire('exclusive');
+      }
+      
+      await file.writeAhead.checkpoint(mode);
+    } catch (e) {
+      console.error(e);
+    } finally {
+      file.readLock.release();
+      file.writeLock.release();
+    }
+  }
+
+  /**
+   * Handle asynchronous jLock() tasks.
+   * @param {number} pFile 
+   * @param {number} lockType 
+   */
+  async #retryLock(pFile, lockType) {
+    const file = this.mapIdToFile.get(pFile);
+    try {
+      switch (file.writeHint) {
+        case 'reserved':
+        case 'exclusive':
+          if (file.useWriteAhead) {
+            // Write-ahead transactions only need writeLock, not readLock.
+            await file.writeLock.acquire('exclusive', file.timeout);
+            file.writeAhead.isolateForWrite();
+          } else {
+            // This transaction will write directly to the database,
+            // i.e. not using write-ahead. Get exclusive access.
+            await file.readLock.acquire('exclusive', file.timeout);
+            await file.writeLock.acquire('exclusive');
+
+            // Transfer everything in write-ahead to the OPFS file.
+            await file.writeAhead.checkpoint('restart');
+          }
+          break;
+        default:
+          // This transaction will only read.
+          await file.readLock.acquire('shared', file.timeout);
+          break;
+      }
+      file.retryResult = {};
+    } catch (e) {
+      file.retryResult = e;
+      return;
+    }
+  }
+
+  /**
+   * Handle asynchronous jOpen() tasks.
+   * @param {string} zName 
+   * @param {number} flags 
+   * @param {number} fileId 
+   * @param {DataView} pOutFlags 
+   * @returns {Promise<void>}
+   */
+  async #retryOpen(zName, flags, fileId, pOutFlags) {
+    /** @type {(() => void)[]} */ const onError = [];
+    const file = this.mapPathToFile.get(zName);
+    try {
+      await navigator.locks.request(`${zName}#open`, async lock => {
+        // Parse the path components.
+        const directoryNames = zName.split('/').filter(d => d);
+        const dbName = directoryNames.pop();
+
+        // Get the OPFS directory handle.
+        let dirHandle = await navigator.storage.getDirectory();
+        const create = !!(flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_CREATE);
+        for (const directoryName of directoryNames) {
+          dirHandle = await dirHandle.getDirectoryHandle(directoryName, { create });
+        }
+
+        // Open the main database OPFS file. We need to know whether the file
+        // was created or not so we know whether to remove any existing
+        // IndexedDB database with the same name. This will not be necessary
+        // if the write-ahead data is moved to OPFS entirely.
+        let created = false;
+        /** @type {FileSystemSyncAccessHandle} */ let accessHandle;
+        try {
+          const fileHandle = await dirHandle.getFileHandle(dbName);
+          // @ts-ignore
+          accessHandle = await fileHandle.createSyncAccessHandle({
+            mode: 'readwrite-unsafe'
+          });
+        } catch (e) {
+          if (e.name === 'NotFoundError' && create) {
+            const fileHandle = await dirHandle.getFileHandle(dbName, { create });
+            // @ts-ignore
+            accessHandle = await fileHandle.createSyncAccessHandle({
+              mode: 'readwrite-unsafe'
+            });
+            created = true;
+          } else {
+            throw e;
+          }
+        }
+        onError.push(() => {
+          accessHandle.close();
+          if (created) {
+            dirHandle.removeEntry(dbName);
+          }
+        });
+
+        // Pre-open the journal OPFS file here.
+        const journalName = this.#getJournalNameFromDbName(dbName);
+        const fileHandle = await dirHandle.getFileHandle(journalName, { create: true });
+        // @ts-ignore
+        const journalHandle = await fileHandle.createSyncAccessHandle({
+          mode: 'readwrite-unsafe'
+        });
+        onError.push(() => {
+          journalHandle.close();
+          if (created) {
+            dirHandle.removeEntry(journalName);
+          }
+        });
+
+        // Open the WAL file.
+        const waName = this.#getWriteAheadNameFromDbName(dbName);
+        const waFileHandle = await dirHandle.getFileHandle(waName, { create: true });
+        // @ts-ignore
+        const waHandle = await waFileHandle.createSyncAccessHandle({
+          mode: 'readwrite-unsafe'
+        });
+        onError.push(() => {
+          waHandle.close();
+          if (created) {
+            dirHandle.removeEntry(waName);
+          }
+        });
+        
+        // Create the write-ahead manager.
+        const writeAhead = new _WriteAhead_js__WEBPACK_IMPORTED_MODULE_4__.WriteAhead(
+          zName,
+          accessHandle,
+          waHandle,
+          Object.assign({ create: created }, this.options));
+        await writeAhead.ready();
+
+        file.retryResult = { accessHandle, waHandle, journalHandle, writeAhead };
+      });
+    } catch (e) {
+      while (onError.length) {
+        onError.pop()();
+      }
+      file.retryResult = e;
+    }
+  }
+}
+
+
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/WriteAhead.js"
+/*!***********************************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/WriteAhead.js ***!
+  \***********************************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   WriteAhead: () => (/* binding */ WriteAhead)
+/* harmony export */ });
+/* harmony import */ var _Lock_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Lock.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@0.0.0-dev-20260225162137/node_modules/@journeyapps/wa-sqlite/src/examples/Lock.js");
+
+
+const DEFAULT_AUTOCHECKPOINT_PAGES = 1_000;
+const DEFAULT_BACKSTOP_INTERVAL = 30_000;
+
+const SECTOR_SIZE = 4096;
+const WAL_FILE_HEADER_SIZE = 32;
+const WAL_FRAME_BASE = SECTOR_SIZE + WAL_FILE_HEADER_SIZE; // first frame starts at this offset
+
+/**
+ * @typedef PageEntry
+ * @property {number} waOffset location in WAL file
+ * @property {number} pageSize
+ * @property {Uint8Array} [pageData]
+ */
+
+/**
+ * @typedef Transaction
+ * @property {number} id
+ * @property {Map<number, PageEntry>} pages address to page data mapping
+ * @property {number} dbFileSize
+ * @property {number} dbPageSize
+ * @property {number} waOffsetEnd
+ */
+
+/**
+ * @typedef WriteAheadOptions
+ * @property {boolean} [create=false] true if database is being created
+ * @property {number} [autoCheckpointPages]
+ * @property {number} [backstopInterval]
+ */
+
+class WriteAhead {
+  log = null;
+  /** @type {WriteAheadOptions} */ options = {
+    create: false,
+    autoCheckpointPages: DEFAULT_AUTOCHECKPOINT_PAGES,
+    backstopInterval: DEFAULT_BACKSTOP_INTERVAL,
+  };
+
+  #zName;
+  #dbHandle;
+  #waFile;
+
+  #dbFileSize = 0;
+
+  /** @type {Promise<any>} */ #ready;
+  /** @type {'read'|'write'} */ #isolationState = null
+
+  /** @type {Lock} */ #txIdLock = null;
+  /** @type {Transaction} */ #txActive = null;
+  
+  /** @type {Map<number, PageEntry>} */ #waOverlay = new Map();
+  /** @type {Map<number, Transaction>} */ #mapIdToTx = new Map();
+  /** @type {Map<number, Transaction>} */ #pendingTx = new Map();
+
+  #broadcastChannel;
+  /** @type {number} */ #backstopTimer;
+
+  /**
+   * @param {string} zName 
+   * @param {FileSystemSyncAccessHandle} dbHandle
+   * @param {FileSystemSyncAccessHandle} waHandle
+   * @param {WriteAheadOptions} options 
+   */
+  constructor(zName, dbHandle, waHandle, options) {
+    this.#zName = zName;
+    this.#dbHandle = dbHandle;
+    this.#waFile = new WriteAheadFile(waHandle);
+    this.options = Object.assign(this.options, options);
+
+    // All the asynchronous initialization is done here.
+    this.#ready = (async () => {
+      // Disable checkpointing by other connections until we're ready.
+      await this.#updateTxIdLock();
+      await navigator.locks.request(`${this.#zName}-ckpt`, async () => {
+        // This is just a barrier; nothing needs to be done here.
+      });
+
+      // Load all the transactions from the WAL file.
+      if (this.options.create) {
+        this.#waFile.create();
+      }
+
+      this.#waFile.open();
+      for (const tx of this.#waFile.readAllTx()) {
+        this.#activateTx(tx);
+      }
+
+      // Listen for transactions and checkpoints from other connections.
+      this.#broadcastChannel = new BroadcastChannel(`${zName}#wa`);
+      this.#broadcastChannel.onmessage = (event) => {
+        this.#handleMessage(event);
+      };
+
+      // Update our tx lock to reflect the current txId.
+      await this.#updateTxIdLock();
+
+      // Schedule first backstop. The backstop is a guard against a crash
+      // in another context between persisting a transaction and broadcasting
+      // it.
+      this.#backstop();
+    })();
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  ready() {
+    return this.#ready;
+  }
+
+  close() {
+    // Stop asynchronous maintenance.
+    this.#broadcastChannel.onmessage = null;
+    clearTimeout(this.#backstopTimer);
+
+    // Wait for any pending commit to complete.
+    this.#txIdLock?.release();
+    this.#broadcastChannel.close();
+  }
+
+  /**
+   * Freeze our view of the database.
+   * The view includes the transactions received so far but is not
+   * guaranteed to be completely up to date (this allows this method
+   * to be synchronous). Unfreeze the view with rejoin().
+   */
+  isolateForRead() {
+    if (this.#isolationState !== null) {
+      throw new Error('Already in isolated state');
+    }
+    this.#isolationState = 'read';
+
+    if (this.#waFile.checkReset()) {
+      // The WAL file has been reset with a full checkpoint. Our view
+      // must be at the final transaction before the checkpoint for
+      // that to have happened. The previous overlay is now stale. In
+      // case we haven't received the checkpoint broadcast, make sure
+      // the overlay is cleared.
+      this.#handleCheckpoint(this.#waFile.txId);
+    }
+  }
+
+  /**
+   * Freeze our view of the database for writing.
+   * The view includes all transactions. Unfreeze the view with rejoin().
+   */
+  isolateForWrite() {
+    if (this.#isolationState !== null) {
+      throw new Error('Already in isolated state');
+    }
+    this.#isolationState = 'write';
+
+    // Backstop is not needed while writing because we will be current.
+    clearTimeout(this.#backstopTimer);
+    this.#backstopTimer = null;
+
+    if (this.#waFile.checkReset()) {
+      // The WAL file has been reset with a full checkpoint. Our view
+      // must be at the final transaction before the checkpoint for
+      // that to have happened. The previous overlay is now stale. In
+      // case we haven't received the checkpoint broadcast, make sure
+      // the overlay is cleared.
+      this.#handleCheckpoint(this.#waFile.txId);
+    }
+
+    // A writer needs all previous transactions assimilated.
+    this.#advanceTxId({ readToCurrent: true });
+  }
+
+  rejoin() {
+    if (this.#isolationState === 'write') {
+      // Resume backstop after write isolation.
+      this.#backstop();
+    } else {
+      // Catch up on new transactions that arrived while isolated.
+      this.#advanceTxId();
+    }
+    this.#isolationState = null;
+  }
+
+  /**
+   * @param {number} offset 
+   * @return {Uint8Array?}
+   */
+  read(offset) {
+    // First look for the page in any write transaction in progress.
+    // If the page is not found in the transaction overlay, look in the
+    // write-ahead overlay.
+    const pageEntry = this.#txActive?.pages.get(offset) ?? this.#waOverlay.get(offset);
+    if (pageEntry) {
+      this.log?.(`%cread page at offset ${offset} from WAL ${pageEntry.waOffset}`, 'background-color: gold;');
+      if (pageEntry.pageData) {
+        // Page data is cached.
+        return pageEntry.pageData;
+      }
+
+      // Read the page from the WAL file.
+      const buffer = new Uint8Array(pageEntry.pageSize);
+      this.#waFile.accessHandle.read(buffer, { at: pageEntry.waOffset });
+      return buffer;
+    }
+    return null;
+  }
+
+  /**
+   * @param {number} offset 
+   * @param {Uint8Array} data 
+   */
+  write(offset, data) {
+    if (this.#isolationState !== 'write') {
+      throw new Error('Not in write isolated state');
+    }
+
+    if (!this.#txActive) {
+      // There is no active transaction so create one.
+      this.#txActive = this.#waFile.beginTx();
+    }
+    const waOffset = this.#waFile.writePage(offset, data.slice());
+    this.log?.(`%c#write page at ${offset} to WAL ${waOffset}`, 'background-color: lightskyblue;');
+  }
+
+  /**
+   * @param {number} newSize 
+   */
+  truncate(newSize) {
+    // Remove any pages past the truncation point. We don't need to save
+    // the file size because that will be extracted from page 1.
+    for (const offset of this.#txActive.pages.keys()) {
+      if (offset >= newSize) {
+        this.#txActive.pages.delete(offset);
+      }
+    }
+  }
+
+  getFileSize() {
+    // If the overlay is empty, the last file size may no longer be valid
+    // if direct changes were made to the main database file.
+    return this.#waOverlay.size ? this.#dbFileSize : null;
+  }
+
+  commit() {
+    // Persist the final pending transaction page with the database size.
+    this.#waFile.commitTx();
+
+    // Incorporate the transaction locally.
+    this.#activateTx(this.#txActive);
+    this.#updateTxIdLock();
+
+    const payload = { type: 'tx', tx: this.#txActive };
+    // this.#handleMessage(new MessageEvent('message', { data: payload }));
+    // this.#advanceTxId();
+    this.#txActive = null;
+
+    // Send the transaction to other connections.
+    this.#broadcastChannel.postMessage(payload);
+  }
+
+  rollback() {
+    // Discard transaction pages.
+    this.#waFile.abortTx();
+    this.#txActive = null;
+  }
+  
+  /**
+   * @param {'normal'|'full'} mode 
+   */
+  sync(mode) {
+    if (mode === 'full') {
+      this.#waFile.accessHandle.flush();
+    }
+  }
+
+  /**
+   * Flush all write-ahead transactions to the main database file.
+   * There must be no other connections reading or writing.
+   * @param {'passive'|'full'|'restart'|'truncate'} mode
+   */
+  async checkpoint(mode) {
+    if (mode !== 'passive') {
+      this.isolateForWrite();
+    }
+    try {
+      const options = {
+        isRestart: mode !== 'passive',
+        isRequired: mode !== 'passive'
+      };
+      await this.#checkpoint(options);
+
+      if (mode === 'truncate') {
+        this.#waFile.accessHandle.truncate(this.#waFile.currentOffset);
+        this.log?.(`%ccheckpoint restart WAL file`, 'background-color: lightgreen;');
+      }
+    } finally {
+      if (mode !== 'passive') {
+        this.rejoin();
+      }
+    }
+  }
+
+  /**
+   * Return the known usage size of the write-ahead file. Note that the
+   * actual file size may be larger if this connection is not current
+   * or if the file has obsolete content past the current point.
+   * @returns {number}
+   */
+  getWriteAheadSize() {
+    return this.#waFile.currentOffset;
+  }
+
+  /**
+   * Incorporate a transaction into our view of the database.
+   * @param {Transaction} tx 
+   */
+  #activateTx(tx) {
+    // Transfer to the active collection of transactions.
+    this.#mapIdToTx.set(tx.id, tx);
+  
+    // Add transaction pages to the write-ahead overlay.
+    for (const [offset, pageEntry] of tx.pages) {
+      this.#waOverlay.set(offset, pageEntry);
+    }
+    this.#dbFileSize = tx.dbFileSize;
+  }
+
+  /**
+   * Advance the local view of the database. By default, advance to the
+   * last broadcast transaction. Optionally, also advance through any
+   * additional transactions in the WAL file to be fully current.
+   * 
+   * @param {{readToCurrent?: boolean}} options
+   */
+  #advanceTxId(options = {}) {
+    let didAdvance = false;
+    while (this.#pendingTx.size) {
+      // Fetch the next transaction in sequence. Usually this will come
+      // from pendingTx, but if it is missing then read it from the file.
+      const nextTxId = this.#waFile.txId + 1;
+      let tx;
+      if (this.#pendingTx.has(nextTxId)) {
+        tx = this.#pendingTx.get(nextTxId);
+        this.#pendingTx.delete(tx.id);
+        this.#waFile.skipTx(tx.id, tx.waOffsetEnd);
+      } else {
+        tx = this.#waFile.readTx();
+      }
+
+      this.#activateTx(tx);
+      didAdvance = true;
+    }
+
+    if (options.readToCurrent) {
+      // Read all additional transactions from the WAL file.
+      for (const tx of this.#waFile.readAllTx()) {
+        this.#activateTx(tx);
+        didAdvance = true;
+      }
+    }
+
+    if (didAdvance) {
+      // Publish our new view txId.
+      this.#updateTxIdLock();
+    }
+  }
+
+  /**
+   * Move pages from write-ahead to main database file.
+   * 
+   * @param {{isRestart?: boolean, isRequired?: boolean}} options
+   */
+  async #checkpoint(options = {}) {
+    // By default, checkpointing is abandoned if another connection is
+    // already checkpointing. With the isRequired option, a checkpoint
+    // is always performed. This is necessary for leaving write-ahead
+    // mode or a user-requested checkpoint.
+    const lockOptions = {
+      ifAvailable: !options.isRequired,
+    };
+
+    await navigator.locks.request(`${this.#zName}-ckpt`, lockOptions, async lock => {
+      if (!lock) return null;
+
+      /** @type {number} */ let ckptId;
+      if (options.isRestart) {
+        // Full checkpoint, use the current WAL file txId.
+        ckptId = this.#waFile.txId;
+
+        // Wait for all connections to reach this txId. Each connection
+        // acquires a shared lock whose name contains the database name,
+        // the minimum and maximum txId it has in mapIdToTx. We want all
+        // maximum txId values to be ckptId.
+        let pendingLockNames = [];
+        do {
+          // Wait for connections with lower maximum txIds. When a
+          // connection advances its txId, it will release its previous
+          // lock and acquire a new one.
+          await Promise.all(
+            pendingLockNames.map(name => navigator.locks.request(name, async () => {}))
+          );
+
+          // Refresh the list of locks with lower txIds.
+          pendingLockNames = (await this.#getTxIdLocks())
+            .filter(value => value.maxTxId < ckptId)
+            .map(value => value.name);
+        } while (pendingLockNames.length > 0);
+        this.log?.(`%c#checkpoint full txId ${ckptId}`, 'background-color: lightgreen;');
+      } else {
+        // Not a full checkpoint, so find the lowest txId in use by any
+        // connection.
+        ckptId = (await this.#getTxIdLocks())
+          .reduce((min, value) => Math.min(min, value.maxTxId), this.#waFile.txId);
+        this.log?.(`%c#checkpoint partial txId ${ckptId}`, 'background-color: lightgreen;');
+      }
+
+      // Sync the WAL file. This ensures that if there is a crash after
+      // part of the WAL has been copied, the uncopied part will still be
+      // available afterwards.
+      this.#waFile.accessHandle.flush();
+
+      // Starting at ckptId and going backwards (earlier), write transaction
+      // pages to the main database file. Do not overwrite a page written
+      // by a later transaction.
+      const writtenOffsets = new Set();
+      let dbFileSize = 0;
+      let tx = /** @type {Transaction} */ ({ id: ckptId + 1 });
+      while (tx = this.#mapIdToTx.get(tx.id - 1)) {
+        if (tx.id === ckptId) {
+          // Set the file size from the latest transaction. This may be
+          // unnecessary as SQLite is not known to reduce the database size
+          // except with VACUUM.
+          dbFileSize = tx.dbFileSize;
+          this.#dbHandle.truncate(dbFileSize);
+        }
+
+        for (const [offset, pageEntry] of tx.pages) {
+          if (offset < dbFileSize && !writtenOffsets.has(offset)) {
+            let pageData = pageEntry.pageData;
+            if (!pageData) {
+              // Page data was not cached, so read it from the WAL file.
+              pageData = new Uint8Array(pageEntry.pageSize);
+              const nRead = this.#waFile.accessHandle.read(
+                pageData,
+                { at: pageEntry.waOffset });
+              if (nRead !== pageData.byteLength) {
+                throw new Error('Checkpoint read failed');
+              }
+            }
+
+            // Write the page to the database file.
+            const nWritten = this.#dbHandle.write(pageData, { at: offset });
+            if (nWritten !== pageData.byteLength) {
+              throw new Error('Checkpoint write failed');
+            }
+            writtenOffsets.add(offset);
+            this.log?.(`%c#checkpoint wrote txId ${tx.id} page at ${offset} to database`, 'background-color: lightgreen;');
+          }
+        }
+      }
+
+      if (writtenOffsets.size > 0) {
+        // Ensure data is safely in the file.
+        this.#dbHandle.flush();
+
+        // Notify other connections and ourselves of the checkpoint.
+        this.#broadcastChannel.postMessage({
+          type: 'ckpt',
+          ckptId,
+        });
+        this.#handleCheckpoint(ckptId);
+      }
+
+      if (options.isRestart) {
+        this.#waFile.reset();
+      }
+    });
+  }
+
+  /**
+   * After a checkpoint, remove checkpointed pages from write-ahead.
+   * The checkpoint may be been done locally or by another connection.
+   * @param {number} ckptId 
+   */
+  #handleCheckpoint(ckptId) {
+    this.log?.(`%c#handleCheckpoint to txId ${ckptId}`, 'background-color: lightgreen;');
+
+    // Loop backwards from ckptId.
+    let tx = /** @type {Transaction} */ ({ id: ckptId + 1 });
+    while (tx = this.#mapIdToTx.get(tx.id - 1)) {
+      // Remove pages from write-ahead overlay.
+      for (const [offset, page] of tx.pages.entries()) {
+        // Be sure not to remove a newer version of the page.
+        const overlayPage = this.#waOverlay.get(offset);
+        if (overlayPage === page) {
+          this.log?.(`%cremove txId ${tx.id} page at offset ${offset}`, 'background-color: lightgreen;');
+          this.#waOverlay.delete(offset);
+        }
+      }
+
+      // Remove transaction.
+      this.#mapIdToTx.delete(tx.id);
+    }
+    this.#updateTxIdLock();
+  }
+
+  /**
+   * @param {MessageEvent} event 
+   */
+  #handleMessage(event) {
+    if (event.data.type === 'tx') {
+      // New transaction from another connection. Don't use it if we
+      // already have it.
+      /** @type {Transaction} */ const tx = event.data.tx;
+      if (tx.id > this.#waFile.txId) {
+        this.#pendingTx.set(tx.id, tx);
+        if (this.#isolationState === null) {
+          // Not in an isolated state, so advance our view of the database.
+          this.#advanceTxId();
+        }
+      }
+    } else if (event.data.type === 'ckpt') {
+      // Checkpoint notification from another connection.
+      /** @type {number} */ const ckptId = event.data.ckptId;
+      this.#handleCheckpoint(ckptId);
+    }
+  }
+
+  /**
+   * Periodic check for recovering from lost transaction broadcasts.
+   */
+  async #backstop() {
+    try {
+      if (this.#backstopTimer) { 
+        if (this.#isolationState === null) {
+          // Not in an isolated state, so advance our view of the database.
+          const oldTxId = this.#waFile.txId;
+          this.#advanceTxId({ readToCurrent: true });
+          if (this.#waFile.txId > oldTxId) {
+            this.log?.(`%cbackstop txId ${oldTxId} -> ${this.#waFile.txId}`, 'background-color: lightyellow;');
+          }
+        }
+      }
+    } catch (e) {
+      console.error('Backstop failed', e);
+    }
+
+    // Schedule next backstop. Add a bit of jitter to decorrelate
+    // backstops across multiple connections.
+    const delay = this.options.backstopInterval * (0.9 + 0.2 * Math.random());
+    this.#backstopTimer = self.setTimeout(() => {
+      this.#backstop();
+    }, delay);
+  }
+  
+  /**
+   * Update the lock that publishes our current txId.
+   */
+  async #updateTxIdLock() {
+    // Our view of the database, i.e. the txId, is encoded into the name
+    // of a lock so other connections can see it. When our txId changes,
+    // we acquire a new lock and release the old one. We must not release
+    // the old lock until the new one is in place.
+    const oldLock = this.#txIdLock;
+    const newLockName = this.#encodeTxIdLockName();
+    if (oldLock?.name !== newLockName) {
+      this.#txIdLock = new _Lock_js__WEBPACK_IMPORTED_MODULE_0__.Lock(newLockName);
+      await this.#txIdLock.acquire('shared').then(() => {
+        // The new lock is acquired.
+        oldLock?.release();
+      });
+
+      if (this.log) {
+        const { minTxId, maxTxId } = this.#decodeTxIdLockName(newLockName);
+        this.log?.(`%ctxId to ${minTxId}:${maxTxId}`, 'background-color: pink;');
+      }
+    }
+  }
+
+  /**
+   * Get all txId locks for this database.
+   * @returns {Promise<{name: string, minTxId: number, maxTxId: number}[]>}
+   */
+  async #getTxIdLocks() {
+    const { held } = await navigator.locks.query();
+    return held
+      .map(lock => this.#decodeTxIdLockName(lock.name))
+      .filter(value => value !== null)
+  }
+
+  /**
+   * @returns {string}
+   */
+  #encodeTxIdLockName() {
+    // The maxTxId is our current view of the database. The minTxId is
+    // the lowest txId we get pages from the WAL for, which is the lowest
+    // key in mapIdToTx. If mapIdToTx is empty then we aren't reading
+    // from the WAL at all - in this case we arbitrarily set minTxId to
+    // invalid value maxTxId + 1.
+    const maxTxId = this.#waFile.txId;
+    const minTxId = this.#mapIdToTx.keys().next().value ?? (maxTxId + 1);
+    return `${this.#zName}-txId<${minTxId}:${maxTxId}>`;
+  }
+
+  /**
+   * @param {string} lockName 
+   * @returns {{name: string, minTxId: number, maxTxId: number}}
+   */
+  #decodeTxIdLockName(lockName) {
+    const match = lockName.match(/^(.*)-txId<(\d+):(\d+)>$/);
+    if (match?.[1] === this.#zName) {
+      // This txId lock is for this database.
+      return {
+        name: match[1],
+        minTxId: parseInt(match[2]),
+        maxTxId: parseInt(match[3])
+      };
+    }
+    return null;
+  }
+}
+
+class WriteAheadFile {
+  static MAGIC = 0x377f0684;
+  static FILE_HEADER_SIZE = 32;
+  static FRAME_HEADER_SIZE = 32;
+  static FRAME_TYPE_PAGE = 0;
+  static FRAME_TYPE_COMMIT = 1;
+
+  /** @type {FileSystemSyncAccessHandle} */ accessHandle;
+  /** @type {number} */ currentOffset;
+  
+  txId = 0;
+  salt1 = 0;
+  salt2 = 0;
+
+  /** @type {Transaction} */ txInProgress = null;
+
+  constructor(accessHandle) {
+    this.accessHandle = accessHandle;
+  }
+
+  create() {
+    this.accessHandle.truncate(0);
+    this.#writeFileHeader();
+  }
+
+  open() {
+    // Read file headers from both header slots and use the one with the
+    // higher nextTxId.
+    const fileHeader = [0, SECTOR_SIZE]
+      .map(offset => this.#readFileHeader(offset))
+      .filter(h => h)
+      .sort((a, b) => b.nextTxId - a.nextTxId)[0];
+    
+    this.currentOffset = WAL_FRAME_BASE;
+    this.txId = fileHeader.nextTxId - 1;
+    this.salt1 = fileHeader.salt1;
+    this.salt2 = fileHeader.salt2;
+  }
+
+  reset(options = { truncate: true }) {
+    const fileHeader = this.#writeFileHeader();
+    if (options.truncate) {
+      this.accessHandle.truncate(WAL_FRAME_BASE);
+    }
+
+    this.currentOffset = WAL_FRAME_BASE;
+    this.salt1 = fileHeader.salt1;
+    this.salt2 = fileHeader.salt2;
+  }
+
+  checkReset() {
+    // Check for a new header. There are two header slots in the file.
+    // Look in the slot that is not current, which will be at offset 0
+    // or SECTOR_SIZE depending on the current salt1 value (salt1 is
+    // incremented on each new header).
+    const headerOffset = (this.salt1 & 0x1) ? 0 : SECTOR_SIZE;
+    const fileHeader = this.#readFileHeader(headerOffset);
+    if (fileHeader?.nextTxId > this.txId &&
+        fileHeader.salt1 === ((this.salt1 + 1) | 0)) {
+      // The WAL file has been reset.
+      this.currentOffset = WAL_FRAME_BASE;
+      this.salt1 = fileHeader.salt1;
+      this.salt2 = fileHeader.salt2;
+      return true;
+    }
+    return false;
+  }
+
+  *readAllTx() {
+    while (true) {
+      const tx = this.readTx();
+      if (!tx) break;
+      yield tx;
+    }
+  }
+
+  /**
+   * @returns {Transaction?}
+   */
+  readTx() {
+    // Read the next complete transaction or return null.
+    let offset = this.currentOffset;
+    /** @type {Transaction?} */ let tx = null;
+    while (true) {
+      const frame = this.#readFrame(offset);
+      if (!frame) return null;
+
+      if (frame.frameType === WriteAheadFile.FRAME_TYPE_COMMIT) {
+        // Update the instance state.
+        this.txId += 1;
+        this.currentOffset = offset + frame.byteLength;
+  
+        tx.id = this.txId;
+        tx.dbFileSize = frame.dbFileSize;
+        tx.waOffsetEnd = this.currentOffset;
+        return tx;
+      }
+
+      // frameType === WriteAheadFile.FRAME_TYPE_PAGE
+      if (!tx) {
+        tx = {
+          id: 0, // placeholder
+          pages: new Map(),
+          dbFileSize: 0, // placeholder
+          dbPageSize: frame.pageData.byteLength,
+          waOffsetEnd: 0 // placeholder
+        };
+      }
+
+      tx.pages.set(
+        frame.pageOffset,
+        {
+          pageSize: frame.pageData.byteLength,
+          waOffset: offset + WriteAheadFile.FRAME_HEADER_SIZE
+       });
+
+      offset += frame.byteLength;
+    }
+  }
+
+  /**
+   * This method is called when transaction(s) have been received by other
+   * means than readTx(), e.g. via BroadcastChannel.
+   * 
+   * @param {number} txId 
+   * @param {number} offset 
+   */
+  skipTx(txId, offset) {
+    this.txId = txId;
+    this.currentOffset = offset;
+  }
+
+  /**
+   * 
+   * @param {{overwrite?: boolean}} options 
+   * @returns {Transaction}
+   */
+  beginTx(options = {}) {
+    this.txInProgress = {
+      id: this.txId + 1,
+      pages: new Map(),
+      dbFileSize: 0,
+      dbPageSize: 0,
+      waOffsetEnd: this.currentOffset
+    };
+    return this.txInProgress;
+  }
+
+  /**
+   * Write a page frame to the WAL file.
+   * 
+   * @param {number} pageOffset 
+   * @param {Uint8Array} pageData 
+   */
+  writePage(pageOffset, pageData) {
+    const headerView = new DataView(new ArrayBuffer(WriteAheadFile.FRAME_HEADER_SIZE));
+    headerView.setUint8(0, WriteAheadFile.FRAME_TYPE_PAGE);
+    headerView.setUint16(2, pageData.byteLength === 65536 ? 1 : pageData.byteLength);
+    headerView.setBigUint64(8, BigInt(pageOffset));
+    headerView.setUint32(16, this.salt1);
+    headerView.setUint32(20, this.salt2);
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, WriteAheadFile.FRAME_HEADER_SIZE - 8));
+    checksum.update(pageData);
+    headerView.setUint32(24, checksum.s0);
+    headerView.setUint32(28, checksum.s1);
+
+    const bytesWritten =
+      this.accessHandle.write(headerView, { at: this.txInProgress.waOffsetEnd }) +
+      this.accessHandle.write(pageData, {
+        at: this.txInProgress.waOffsetEnd + WriteAheadFile.FRAME_HEADER_SIZE
+      });
+    if (bytesWritten !== headerView.byteLength + pageData.byteLength) {
+      throw new Error('write failed');
+    }
+
+    const pageEntry = {
+      pageSize: pageData.byteLength,
+      waOffset: this.txInProgress.waOffsetEnd + WriteAheadFile.FRAME_HEADER_SIZE
+    };
+    if (pageOffset === 0) {
+      // This is page 1, which contains the database header.
+      const dataView = new DataView(pageData.buffer, pageData.byteOffset, pageData.byteLength);
+      const pageCount = dataView.getUint32(28);
+      this.txInProgress.dbFileSize = pageCount * pageData.byteLength;
+      this.txInProgress.dbPageSize = pageData.byteLength;
+
+      // Cache page 1 as a performance optimization and to exercise the
+      // cache code path.
+      pageEntry.pageData = pageData;
+    }
+
+    this.txInProgress.pages.set(pageOffset, pageEntry);
+    this.txInProgress.waOffsetEnd += bytesWritten;
+
+    return pageEntry.waOffset;
+  }
+
+  /**
+   * @returns {Transaction}
+   */
+  commitTx() {
+    const headerView = new DataView(new ArrayBuffer(WriteAheadFile.FRAME_HEADER_SIZE));
+    headerView.setUint8(0, WriteAheadFile.FRAME_TYPE_COMMIT);
+    headerView.setBigUint64(8, BigInt(this.txInProgress.dbFileSize));
+    headerView.setUint32(16, this.salt1);
+    headerView.setUint32(20, this.salt2);
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, WriteAheadFile.FRAME_HEADER_SIZE - 8));
+    headerView.setUint32(24, checksum.s0);
+    headerView.setUint32(28, checksum.s1);
+
+    const bytesWritten = this.accessHandle.write(headerView, {
+      at: this.txInProgress.waOffsetEnd
+    });
+    if (bytesWritten !== headerView.byteLength) {
+      throw new Error('write failed');
+    }
+    this.txInProgress.waOffsetEnd += bytesWritten;
+
+    const tx = this.txInProgress;
+    this.txInProgress = null;
+    this.currentOffset = tx.waOffsetEnd;
+    this.txId = tx.id;
+    return tx;
+  }
+
+  abortTx() {
+    this.txInProgress = null;
+  }
+
+  #readFileHeader(offset) {
+    const headerView = new DataView(new ArrayBuffer(WriteAheadFile.FILE_HEADER_SIZE));
+    if (this.accessHandle.read(headerView, { at: offset }) !== headerView.byteLength) {
+      return null;
+    }
+
+    if (headerView.getUint32(0) !== WriteAheadFile.MAGIC) return null;
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, WriteAheadFile.FILE_HEADER_SIZE - 8));
+    if (!checksum.matches(headerView.getUint32(24), headerView.getUint32(28))) {
+      return null;
+    }
+
+    return {
+      nextTxId: Number(headerView.getBigUint64(8)),
+      salt1: headerView.getUint32(16),
+      salt2: headerView.getUint32(20)
+    }
+  }
+
+  #readFrame(offset) {
+    const headerView = new DataView(new ArrayBuffer(WriteAheadFile.FRAME_HEADER_SIZE));
+    if (this.accessHandle.read(headerView, { at: offset }) !== headerView.byteLength) {
+      return null;
+    }
+
+    // Verify the frame header salt values match the file header.
+    const frameSalt1 = headerView.getUint32(16);
+    const frameSalt2 = headerView.getUint32(20);
+    if (frameSalt1 !== this.salt1 || frameSalt2 !== this.salt2) {
+      return null;
+    }
+
+    const payloadSize = (size => size === 1 ? 65536 : size)(headerView.getUint16(2));
+    /** @type {Uint8Array} */ let payloadData;
+    if (payloadSize) {
+      payloadData = new Uint8Array(payloadSize);
+      const payloadBytesRead = this.accessHandle.read(
+        payloadData,
+        { at: offset + WriteAheadFile.FRAME_HEADER_SIZE });
+      if (payloadBytesRead !== payloadSize ) return null;
+    }
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, WriteAheadFile.FRAME_HEADER_SIZE - 8));
+    if (payloadData) {
+      checksum.update(payloadData);
+    }
+    if (!checksum.matches(headerView.getUint32(24), headerView.getUint32(28))) {
+      return null;
+    }
+
+    const frameType = headerView.getUint8(0);
+    if (frameType === WriteAheadFile.FRAME_TYPE_PAGE) {
+      return {
+        frameType,
+        byteLength: WriteAheadFile.FRAME_HEADER_SIZE + payloadSize,
+        pageOffset: Number(headerView.getBigUint64(8)),
+        pageData: payloadData
+      }
+    } else if (frameType === WriteAheadFile.FRAME_TYPE_COMMIT) {
+      const flags = headerView.getUint8(1);
+      return {
+        frameType,
+        byteLength: WriteAheadFile.FRAME_HEADER_SIZE,
+        dbFileSize: Number(headerView.getBigUint64(8)),
+        isOverwrite: !!(flags & 0x1)
+      }
+    }
+    throw new Error(`Invalid frame type: ${frameType}`);
+  }
+
+  #writeFileHeader() {
+    // Derive new values from the previous values. Note that salt1 always
+    // flips between even and odd so successive headers are written to
+    // alternating slots. If the write fails, the file remains in a valid
+    // state.
+    const nextTxId = this.txId + 1;
+    const salt1 = (this.salt1 + 1) | 0;
+    const salt2 = Math.floor(Math.random() * 0xffffffff);
+    const headerView = new DataView(new ArrayBuffer(WriteAheadFile.FILE_HEADER_SIZE));
+    headerView.setUint32(0, WriteAheadFile.MAGIC);
+    headerView.setBigUint64(8, BigInt(nextTxId));
+    headerView.setUint32(16, salt1);
+    headerView.setUint32(20, salt2);
+
+    const checksum = new Checksum();
+    checksum.update(new Uint8Array(headerView.buffer, 0, WriteAheadFile.FILE_HEADER_SIZE - 8));
+    headerView.setUint32(24, checksum.s0);
+    headerView.setUint32(28, checksum.s1);
+
+    // A header with an even salt1 is written at offset 0, and with an
+    // odd salt1 at SECTOR_SIZE.
+    const headerOffset = (salt1 & 0x1) ? SECTOR_SIZE : 0;
+    const bytesWritten = this.accessHandle.write(headerView, { at: headerOffset });
+    if (bytesWritten !== headerView.byteLength) {
+      throw new Error('write failed');
+    }
+
+    this.accessHandle.flush();
+    return { nextTxId, salt1, salt2 };
+  }
+}
+
+// https://www.sqlite.org/fileformat.html#checksum_algorithm
+class Checksum {
+  /** @type {number} */ s0 = 0;
+  /** @type {number} */ s1 = 0;
+
+  /**
+   * @param {ArrayBuffer|ArrayBufferView} data 
+   */
+  update(data) {
+    if ((data.byteLength % 8) !== 0) throw new Error('Data must be a multiple of 8 bytes');
+    const words = ArrayBuffer.isView(data) ?
+      new Uint32Array(data.buffer, data.byteOffset, data.byteLength / 4) :
+      new Uint32Array(data);
+    for (let i = 0; i < words.length; i += 2) {
+      this.s0 = (this.s0 + words[i]     + this.s1) >>> 0;
+      this.s1 = (this.s1 + words[i + 1] + this.s0) >>> 0;
+    }
+  }
+
+  matches(s0, s1) {
+    return this.s0 === s0 && this.s1 === s1;
+  }
+}
+
+class InvalidFrameError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'InvalidFrameError';
+  }
+}
+
+/***/ }
+
+}]);
+//# sourceMappingURL=node_modules_pnpm_journeyapps_wa-sqlite_0_0_0-dev-20260225162137_node_modules_journeyapps_wa--3f11fc.umd.js.map