@powersync/web 0.0.0-dev-20251129133952 → 0.0.0-dev-20251203144301

package/dist/worker/SharedSyncImplementation.umd.js

@@ -3,6 +3,1209 @@ var sdk_web;
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
+/***/ "../../node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js":
+/*!******************************************************************!*\
+  !*** ../../node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js ***!
+  \******************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   FacadeVFS: () => (/* binding */ FacadeVFS)
+/* harmony export */ });
+/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./VFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+
+
+const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+
+// 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/@journeyapps/wa-sqlite/src/VFS.js":
+/*!************************************************************!*\
+  !*** ../../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/@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/@journeyapps/wa-sqlite/src/sqlite-api.js":
 /*!*******************************************************************!*\
   !*** ../../node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js ***!
@@ -3228,12 +4431,26 @@ class SyncStatus {
         return {
             connected: this.connected,
             connecting: this.connecting,
-            dataFlow: this.dataFlowStatus,
+            dataFlow: {
+                ...this.dataFlowStatus,
+                uploadError: this.serializeError(this.dataFlowStatus.uploadError),
+                downloadError: this.serializeError(this.dataFlowStatus.downloadError)
+            },
             lastSyncedAt: this.lastSyncedAt,
             hasSynced: this.hasSynced,
             priorityStatusEntries: this.priorityStatusEntries
         };
     }
+    serializeError(error) {
+        if (typeof error == 'undefined') {
+            return undefined;
+        }
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+        };
+    }
     static comparePriorities(a, b) {
         return b.priority - a.priority; // Reverse because higher priorities have lower numbers
     }
@@ -14659,7 +15876,7 @@ The next upload iteration will be delayed.`);
                                 uploadError: ex
                             }
                         });
-                        await this.delayRetry(controller.signal, this.options.crudUploadThrottleMs);
+                        await this.delayRetry(controller.signal);
                         if (!this.isConnected) {
                             // Exit the upload loop if the sync stream is no longer connected
                             break;
@@ -15370,14 +16587,14 @@ The next upload iteration will be delayed.`);
         // trigger this for all updates
         this.iterateListeners((cb) => cb.statusUpdated?.(options));
     }
-    async delayRetry(signal, delayMs) {
+    async delayRetry(signal) {
         return new Promise((resolve) => {
             if (signal?.aborted) {
                 // If the signal is already aborted, resolve immediately
                 resolve();
                 return;
             }
-            const delay = delayMs ?? this.options.retryDelayMs;
+            const { retryDelayMs } = this.options;
             let timeoutId;
             const endDelay = () => {
                 resolve();
@@ -15388,7 +16605,7 @@ The next upload iteration will be delayed.`);
                 signal?.removeEventListener('abort', endDelay);
             };
             signal?.addEventListener('abort', endDelay, { once: true });
-            timeoutId = setTimeout(endDelay, delay);
+            timeoutId = setTimeout(endDelay, retryDelayMs);
         });
     }
     updateSubscriptions(subscriptions) {
@@ -17612,6 +18829,11 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   ConnectionClosedError: () => (/* binding */ ConnectionClosedError)
 /* harmony export */ });
+/**
+ * Thrown when an underlying database connection is closed.
+ * This is particularly relevant when worker connections are marked as closed while
+ * operations are still in progress.
+ */
 class ConnectionClosedError extends Error {
     constructor(message) {
         super(message);
@@ -17633,7 +18855,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   LockedAsyncDatabaseAdapter: () => (/* binding */ LockedAsyncDatabaseAdapter)
 /* harmony export */ });
 /* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
-/* harmony import */ var _shared_navigator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../..//shared/navigator */ "./lib/src/shared/navigator.js");
+/* harmony import */ var _shared_navigator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../shared/navigator */ "./lib/src/shared/navigator.js");
 /* harmony import */ var _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./AsyncDatabaseConnection */ "./lib/src/db/adapters/AsyncDatabaseConnection.js");
 /* harmony import */ var _WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./WorkerWrappedAsyncDatabaseConnection */ "./lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js");
 /* harmony import */ var _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./wa-sqlite/WASQLiteConnection */ "./lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js");
@@ -17659,7 +18881,6 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
     _config = null;
     pendingAbortControllers;
     requiresHolds;
-    requiresReOpen;
     databaseOpenPromise = null;
     closing;
     closed;
@@ -17672,7 +18893,6 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
         this.closed = false;
         this.closing = false;
         this.requiresHolds = null;
-        this.requiresReOpen = false;
         // Set the name if provided. We can query for the name if not available yet
         this.debugMode = options.debugMode ?? false;
         if (this.debugMode) {
@@ -17712,24 +18932,67 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
         return this.initPromise;
     }
     async openInternalDB() {
-        // Dispose any previous table change listener.
-        this._disposeTableChangeListener?.();
-        this._disposeTableChangeListener = null;
-        const isReOpen = !!this._db;
-        this._db = await this.options.openConnection();
-        await this._db.init();
-        this._config = await this._db.getConfig();
-        await this.registerOnChangeListener(this._db);
-        if (isReOpen) {
-            this.iterateListeners((cb) => cb.databaseReOpened?.());
-        }
         /**
-         * This is only required for the long-lived shared IndexedDB connections.
+         * Execute opening of the db in a lock in order not to interfere with other operations.
          */
-        this.requiresHolds = this._config.vfs == _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__.WASQLiteVFS.IDBBatchAtomicVFS;
+        return this._acquireLock(async () => {
+            // Dispose any previous table change listener.
+            this._disposeTableChangeListener?.();
+            this._disposeTableChangeListener = null;
+            this._db?.close().catch((ex) => this.logger.warn(`Error closing database before opening new instance`, ex));
+            const isReOpen = !!this._db;
+            this._db = null;
+            this._db = await this.options.openConnection();
+            await this._db.init();
+            this._config = await this._db.getConfig();
+            await this.registerOnChangeListener(this._db);
+            if (isReOpen) {
+                this.iterateListeners((cb) => cb.databaseReOpened?.());
+            }
+            /**
+             * This is only required for the long-lived shared IndexedDB connections.
+             */
+            this.requiresHolds = this._config.vfs == _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__.WASQLiteVFS.IDBBatchAtomicVFS;
+        });
+    }
+    _reOpen() {
+        this.databaseOpenPromise = this.openInternalDB().finally(() => {
+            this.databaseOpenPromise = null;
+        });
+        return this.databaseOpenPromise;
+    }
+    /**
+     * Re-opens the underlying database.
+     * Returns a pending operation if one is already in progress.
+     */
+    async reOpenInternalDB() {
+        if (!this.options.reOpenOnConnectionClosed) {
+            throw new Error(`Cannot re-open underlying database, reOpenOnConnectionClosed is not enabled`);
+        }
+        if (this.databaseOpenPromise) {
+            return this.databaseOpenPromise;
+        }
+        return this._reOpen();
     }
     async _init() {
-        await this.openInternalDB();
+        /**
+         * For OPFS, we can see this open call sometimes fail due to NoModificationAllowedError.
+         * We should be able to recover from this by re-opening the database.
+         */
+        const maxAttempts = 3;
+        for (let count = 0; count < maxAttempts; count++) {
+            try {
+                await this.openInternalDB();
+                break;
+            }
+            catch (ex) {
+                if (count == maxAttempts - 1) {
+                    throw ex;
+                }
+                this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
         this.iterateListeners((cb) => cb.initialized?.());
     }
     getConfiguration() {
@@ -17806,8 +19069,7 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
             timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
         });
     }
-    async acquireLock(callback, options) {
-        await this.waitForInitialized();
+    async _acquireLock(callback, options) {
         if (this.closing) {
             throw new Error(`Cannot acquire lock, the database is closing`);
         }
@@ -17825,30 +19087,29 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
             if (timeoutId) {
                 clearTimeout(timeoutId);
             }
+            return await callback();
+        });
+    }
+    async acquireLock(callback, options) {
+        await this.waitForInitialized();
+        return this._acquireLock(async () => {
             let holdId = null;
             try {
                 // The database is being opened in the background. Wait for it here.
                 if (this.databaseOpenPromise) {
-                    try {
-                        await this.databaseOpenPromise;
-                    }
-                    catch (ex) {
-                        // This will cause a retry of opening the database.
-                        const wrappedError = new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError('Could not open database');
-                        wrappedError.cause = ex;
-                        throw wrappedError;
-                    }
+                    /**
+                     * We can't await this since it uses the same lock as we're in now.
+                     */
+                    throw new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError('Connection is busy re-opening');
                 }
                 holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
                 return await callback();
             }
             catch (ex) {
-                if (ex instanceof _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError) {
+                if (ex instanceof _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError || (ex instanceof Error && ex.name === 'NoModificationAllowedError')) {
                     if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
                         // Immediately re-open the database. We need to miss as little table updates as possible.
-                        this.databaseOpenPromise = this.openInternalDB().finally(() => {
-                            this.databaseOpenPromise = null;
-                        });
+                        this.reOpenInternalDB();
                     }
                 }
                 throw ex;
@@ -17858,7 +19119,7 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
                     await this.baseDB.releaseHold(holdId);
                 }
             }
-        });
+        }, options);
     }
     async readTransaction(fn, options) {
         return this.readLock(this.wrapTransaction(fn));
@@ -17985,19 +19246,22 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   WorkerWrappedAsyncDatabaseConnection: () => (/* binding */ WorkerWrappedAsyncDatabaseConnection)
 /* harmony export */ });
-/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! comlink */ "../../node_modules/comlink/dist/esm/comlink.mjs");
-/* harmony import */ var _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AsyncDatabaseConnection */ "./lib/src/db/adapters/AsyncDatabaseConnection.js");
+/* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
+/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! comlink */ "../../node_modules/comlink/dist/esm/comlink.mjs");
+/* harmony import */ var _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./AsyncDatabaseConnection */ "./lib/src/db/adapters/AsyncDatabaseConnection.js");
+
 
 
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
-class WorkerWrappedAsyncDatabaseConnection {
+class WorkerWrappedAsyncDatabaseConnection extends _powersync_common__WEBPACK_IMPORTED_MODULE_0__.BaseObserver {
     options;
     lockAbortController = new AbortController();
     notifyRemoteClosed;
     constructor(options) {
+        super();
         this.options = options;
         if (options.remoteCanCloseUnexpectedly) {
             this.notifyRemoteClosed = new AbortController();
@@ -18030,17 +19294,20 @@ class WorkerWrappedAsyncDatabaseConnection {
     isAutoCommit() {
         return this.withRemote(() => this.baseConnection.isAutoCommit());
     }
-    withRemote(workerPromise) {
+    withRemote(workerPromise, fireActionOnAbort = false) {
         const controller = this.notifyRemoteClosed;
         if (controller) {
             return new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
-                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_0__.ConnectionClosedError('Called operation on closed remote'));
-                    // Don't run the operation if we're going to reject
-                    return;
+                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__.ConnectionClosedError('Called operation on closed remote'));
+                    if (!fireActionOnAbort) {
+                        // Don't run the operation if we're going to reject
+                        // We might want to fire-and-forget the operation in some cases (like a close operation)
+                        return;
+                    }
                 }
                 function handleAbort() {
-                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_0__.ConnectionClosedError('Remote peer closed with request in flight'));
+                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__.ConnectionClosedError('Remote peer closed with request in flight'));
                 }
                 function completePromise(action) {
                     controller.signal.removeEventListener('abort', handleAbort);
@@ -18094,7 +19361,7 @@ class WorkerWrappedAsyncDatabaseConnection {
                 reject(ex);
             }
         }));
-        const newPort = await remote[comlink__WEBPACK_IMPORTED_MODULE_1__.createEndpoint]();
+        const newPort = await remote[comlink__WEBPACK_IMPORTED_MODULE_2__.createEndpoint]();
         return { port: newPort, identifier };
     }
     /**
@@ -18102,17 +19369,19 @@ class WorkerWrappedAsyncDatabaseConnection {
      * This can be extended by custom implementations in order to handle proxy events.
      */
     async registerOnTableChange(callback) {
-        return this.baseConnection.registerOnTableChange(comlink__WEBPACK_IMPORTED_MODULE_1__.proxy(callback));
+        return this.baseConnection.registerOnTableChange(comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(callback));
     }
     async close() {
         // Abort any pending lock requests.
         this.lockAbortController.abort();
         try {
-            await this.withRemote(() => this.baseConnection.close());
+            // fire and forget the close operation
+            await this.withRemote(() => this.baseConnection.close(), true);
         }
         finally {
-            this.options.remote[comlink__WEBPACK_IMPORTED_MODULE_1__.releaseProxy]();
+            this.options.remote[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
             this.options.onClose?.();
+            this.iterateListeners((l) => l.closing?.());
         }
     }
     execute(sql, params) {
@@ -18151,6 +19420,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @journeyapps/wa-sqlite */ "../../node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js");
 /* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
 /* harmony import */ var async_mutex__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! async-mutex */ "../../node_modules/async-mutex/index.mjs");
+/* harmony import */ var _worker_db_opfs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../../worker/db/opfs */ "./lib/src/worker/db/opfs.js");
+
 
 
 
@@ -18233,11 +19504,10 @@ const DEFAULT_MODULE_FACTORIES = {
         else {
             module = await SyncWASQLiteModuleFactory();
         }
-        // @ts-expect-error The types for this static method are missing upstream
-        const { OPFSCoopSyncVFS } = await __webpack_require__.e(/*! import() */ "node_modules_journeyapps_wa-sqlite_src_examples_OPFSCoopSyncVFS_js").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js"));
+        const vfs = await _worker_db_opfs__WEBPACK_IMPORTED_MODULE_3__.OPFSCoopSyncVFS.create(options.dbFileName, module);
         return {
             module,
-            vfs: await OPFSCoopSyncVFS.create(options.dbFileName, module)
+            vfs: vfs
         };
     }
 };
@@ -18737,6 +20007,604 @@ const getNavigatorLocks = () => {
 };
 
 
+/***/ }),
+
+/***/ "./lib/src/worker/db/opfs.js":
+/*!***********************************!*\
+  !*** ./lib/src/worker/db/opfs.js ***!
+  \***********************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   OPFSCoopSyncVFS: () => (/* binding */ OPFSCoopSyncVFS)
+/* harmony export */ });
+/* harmony import */ var _journeyapps_wa_sqlite_src_FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @journeyapps/wa-sqlite/src/FacadeVFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js");
+/* harmony import */ var _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @journeyapps/wa-sqlite/src/VFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+// @ts-nocheck
+
+
+const DEFAULT_TEMPORARY_FILES = 10;
+const LOCK_NOTIFY_INTERVAL = 1000;
+const DB_RELATED_FILE_SUFFIXES = ['', '-journal', '-wal'];
+const finalizationRegistry = new FinalizationRegistry((releaser) => releaser());
+class File {
+    /** @type {string} */ path;
+    /** @type {number} */ flags;
+    /** @type {FileSystemSyncAccessHandle} */ accessHandle;
+    /** @type {PersistentFile?} */ persistentFile;
+    constructor(path, flags) {
+        this.path = path;
+        this.flags = flags;
+    }
+}
+class PersistentFile {
+    /** @type {FileSystemFileHandle} */ fileHandle;
+    /** @type {FileSystemSyncAccessHandle} */ accessHandle = null;
+    // The following properties are for main database files.
+    /** @type {boolean} */ isLockBusy = false;
+    /** @type {boolean} */ isFileLocked = false;
+    /** @type {boolean} */ isRequestInProgress = false;
+    /** @type {function} */ handleLockReleaser = null;
+    /** @type {BroadcastChannel} */ handleRequestChannel;
+    /** @type {boolean} */ isHandleRequested = false;
+    constructor(fileHandle) {
+        this.fileHandle = fileHandle;
+    }
+}
+class OPFSCoopSyncVFS extends _journeyapps_wa_sqlite_src_FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__.FacadeVFS {
+    /** @type {Map<number, File>} */ mapIdToFile = new Map();
+    lastError = null;
+    log = null; //function(...args) { console.log(`[${contextName}]`, ...args) };
+    /** @type {Map<string, PersistentFile>} */ persistentFiles = new Map();
+    /** @type {Map<string, FileSystemSyncAccessHandle>} */ boundAccessHandles = new Map();
+    /** @type {Set<FileSystemSyncAccessHandle>} */ unboundAccessHandles = new Set();
+    /** @type {Set<string>} */ accessiblePaths = new Set();
+    releaser = null;
+    static async create(name, module) {
+        const vfs = new OPFSCoopSyncVFS(name, module);
+        await Promise.all([vfs.isReady(), vfs.#initialize(DEFAULT_TEMPORARY_FILES)]);
+        return vfs;
+    }
+    constructor(name, module) {
+        super(name, module);
+    }
+    async #initialize(nTemporaryFiles) {
+        // Delete temporary directories no longer in use.
+        const root = await navigator.storage.getDirectory();
+        // @ts-ignore
+        for await (const entry of root.values()) {
+            if (entry.kind === 'directory' && entry.name.startsWith('.ahp-')) {
+                // A lock with the same name as the directory protects it from
+                // being deleted.
+                await navigator.locks.request(entry.name, { ifAvailable: true }, async (lock) => {
+                    if (lock) {
+                        this.log?.(`Deleting temporary directory ${entry.name}`);
+                        await root.removeEntry(entry.name, { recursive: true });
+                    }
+                    else {
+                        this.log?.(`Temporary directory ${entry.name} is in use`);
+                    }
+                });
+            }
+        }
+        // Create our temporary directory.
+        const tmpDirName = `.ahp-${Math.random().toString(36).slice(2)}`;
+        this.releaser = await new Promise((resolve) => {
+            navigator.locks.request(tmpDirName, () => {
+                return new Promise((release) => {
+                    resolve(release);
+                });
+            });
+        });
+        const releaseHandle = async () => {
+            await Promise.all(this.persistentFiles.values().map(async (file) => {
+                try {
+                    await this.#releaseAccessHandle(file);
+                }
+                catch (e) {
+                    this.log?.('error releasing access handle', e);
+                }
+                finally {
+                    release();
+                }
+            }));
+        };
+        finalizationRegistry.register(this, releaseHandle);
+        finalizationRegistry.register(this, this.releaser);
+        const tmpDir = await root.getDirectoryHandle(tmpDirName, { create: true });
+        // Populate temporary directory.
+        for (let i = 0; i < nTemporaryFiles; i++) {
+            const tmpFile = await tmpDir.getFileHandle(`${i}.tmp`, { create: true });
+            const tmpAccessHandle = await tmpFile.createSyncAccessHandle();
+            this.unboundAccessHandles.add(tmpAccessHandle);
+        }
+    }
+    /**
+     * @param {string?} zName
+     * @param {number} fileId
+     * @param {number} flags
+     * @param {DataView} pOutFlags
+     * @returns {number}
+     */
+    jOpen(zName, fileId, flags, pOutFlags) {
+        try {
+            const url = new URL(zName || Math.random().toString(36).slice(2), 'file://');
+            const path = url.pathname;
+            if (flags & _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+                const persistentFile = this.persistentFiles.get(path);
+                if (persistentFile?.isRequestInProgress) {
+                    // Should not reach here unless SQLite itself retries an open.
+                    // Otherwise, asynchronous operations started on a previous
+                    // open try should have completed.
+                    return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+                }
+                else if (!persistentFile) {
+                    // This is the usual starting point for opening a database.
+                    // Register a Promise that resolves when the database and related
+                    // files are ready to be used.
+                    this.log?.(`creating persistent file for ${path}`);
+                    const create = !!(flags & _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_CREATE);
+                    this._module.retryOps.push((async () => {
+                        try {
+                            // Get the path directory handle.
+                            let dirHandle = await navigator.storage.getDirectory();
+                            const directories = path.split('/').filter((d) => d);
+                            const filename = directories.pop();
+                            for (const directory of directories) {
+                                dirHandle = await dirHandle.getDirectoryHandle(directory, { create });
+                            }
+                            // Get file handles for the database and related files,
+                            // and create persistent file instances.
+                            for (const suffix of DB_RELATED_FILE_SUFFIXES) {
+                                const fileHandle = await dirHandle.getFileHandle(filename + suffix, { create });
+                                await this.#createPersistentFile(fileHandle);
+                            }
+                            // Get access handles for the files.
+                            const file = new File(path, flags);
+                            file.persistentFile = this.persistentFiles.get(path);
+                            await this.#requestAccessHandle(file);
+                        }
+                        catch (e) {
+                            // Use an invalid persistent file to signal this error
+                            // for the retried open.
+                            const persistentFile = new PersistentFile(null);
+                            this.persistentFiles.set(path, persistentFile);
+                            console.error(e);
+                        }
+                    })());
+                    return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+                }
+                else if (!persistentFile.fileHandle) {
+                    // The asynchronous open operation failed.
+                    this.persistentFiles.delete(path);
+                    return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_CANTOPEN;
+                }
+                else if (!persistentFile.accessHandle) {
+                    // This branch is reached if the database was previously opened
+                    // and closed.
+                    this._module.retryOps.push((async () => {
+                        const file = new File(path, flags);
+                        file.persistentFile = this.persistentFiles.get(path);
+                        await this.#requestAccessHandle(file);
+                    })());
+                    return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+                }
+            }
+            if (!this.accessiblePaths.has(path) && !(flags & _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_CREATE)) {
+                throw new Error(`File ${path} not found`);
+            }
+            const file = new File(path, flags);
+            this.mapIdToFile.set(fileId, file);
+            if (this.persistentFiles.has(path)) {
+                file.persistentFile = this.persistentFiles.get(path);
+            }
+            else if (this.boundAccessHandles.has(path)) {
+                // This temporary file was previously created and closed. Reopen
+                // the same access handle.
+                file.accessHandle = this.boundAccessHandles.get(path);
+            }
+            else if (this.unboundAccessHandles.size) {
+                // Associate an unbound access handle to this file.
+                file.accessHandle = this.unboundAccessHandles.values().next().value;
+                file.accessHandle.truncate(0);
+                this.unboundAccessHandles.delete(file.accessHandle);
+                this.boundAccessHandles.set(path, file.accessHandle);
+            }
+            this.accessiblePaths.add(path);
+            pOutFlags.setInt32(0, flags, true);
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_CANTOPEN;
+        }
+    }
+    /**
+     * @param {string} zName
+     * @param {number} syncDir
+     * @returns {number}
+     */
+    jDelete(zName, syncDir) {
+        try {
+            const url = new URL(zName, 'file://');
+            const path = url.pathname;
+            if (this.persistentFiles.has(path)) {
+                const persistentFile = this.persistentFiles.get(path);
+                persistentFile.accessHandle.truncate(0);
+            }
+            else {
+                this.boundAccessHandles.get(path)?.truncate(0);
+            }
+            this.accessiblePaths.delete(path);
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_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 {
+            const url = new URL(zName, 'file://');
+            const path = url.pathname;
+            pResOut.setInt32(0, this.accessiblePaths.has(path) ? 1 : 0, true);
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_ACCESS;
+        }
+    }
+    /**
+     * @param {number} fileId
+     * @returns {number}
+     */
+    jClose(fileId) {
+        try {
+            const file = this.mapIdToFile.get(fileId);
+            this.mapIdToFile.delete(fileId);
+            if (file?.flags & _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB) {
+                if (file.persistentFile?.accessHandle) {
+                    this.#releaseAccessHandle(file);
+                }
+            }
+            else if (file?.flags & _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_DELETEONCLOSE) {
+                file.accessHandle.truncate(0);
+                this.accessiblePaths.delete(file.path);
+                if (!this.persistentFiles.has(file.path)) {
+                    this.boundAccessHandles.delete(file.path);
+                    this.unboundAccessHandles.add(file.accessHandle);
+                }
+            }
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_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);
+            // 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.
+            const accessHandle = file.accessHandle || file.persistentFile.accessHandle;
+            const bytesRead = accessHandle.read(pData.subarray(), { at: iOffset });
+            // Opening a database file performs one read without a xLock call.
+            if (file.flags & _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_MAIN_DB && !file.persistentFile.isFileLocked) {
+                this.#releaseAccessHandle(file);
+            }
+            if (bytesRead < pData.byteLength) {
+                pData.fill(0, bytesRead);
+                return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_SHORT_READ;
+            }
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_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);
+            // 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.
+            const accessHandle = file.accessHandle || file.persistentFile.accessHandle;
+            const nBytes = accessHandle.write(pData.subarray(), { at: iOffset });
+            if (nBytes !== pData.byteLength)
+                throw new Error('short write');
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_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);
+            const accessHandle = file.accessHandle || file.persistentFile.accessHandle;
+            accessHandle.truncate(iSize);
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_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);
+            const accessHandle = file.accessHandle || file.persistentFile.accessHandle;
+            accessHandle.flush();
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_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);
+            const accessHandle = file.accessHandle || file.persistentFile.accessHandle;
+            const size = accessHandle.getSize();
+            pSize64.setBigInt64(0, BigInt(size), true);
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_FSTAT;
+        }
+    }
+    /**
+     * @param {number} fileId
+     * @param {number} lockType
+     * @returns {number}
+     */
+    jLock(fileId, lockType) {
+        const file = this.mapIdToFile.get(fileId);
+        if (file.persistentFile.isRequestInProgress) {
+            file.persistentFile.isLockBusy = true;
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+        }
+        file.persistentFile.isFileLocked = true;
+        if (!file.persistentFile.handleLockReleaser) {
+            // Start listening for notifications from other connections.
+            // This is before we actually get access handles, but waiting to
+            // listen until then allows a race condition where notifications
+            // are missed.
+            file.persistentFile.handleRequestChannel.onmessage = () => {
+                this.log?.(`received notification for ${file.path}`);
+                if (file.persistentFile.isFileLocked) {
+                    // We're still using the access handle, so mark it to be
+                    // released when we're done.
+                    file.persistentFile.isHandleRequested = true;
+                }
+                else {
+                    // Release the access handles immediately.
+                    this.#releaseAccessHandle(file);
+                }
+                file.persistentFile.handleRequestChannel.onmessage = null;
+            };
+            this.#requestAccessHandle(file);
+            this.log?.('returning SQLITE_BUSY');
+            file.persistentFile.isLockBusy = true;
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_BUSY;
+        }
+        file.persistentFile.isLockBusy = false;
+        return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    }
+    /**
+     * @param {number} fileId
+     * @param {number} lockType
+     * @returns {number}
+     */
+    jUnlock(fileId, lockType) {
+        const file = this.mapIdToFile.get(fileId);
+        if (lockType === _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_LOCK_NONE) {
+            // Don't change any state if this unlock is because xLock returned
+            // SQLITE_BUSY.
+            if (!file.persistentFile.isLockBusy) {
+                if (file.persistentFile.isHandleRequested) {
+                    // Another connection wants the access handle.
+                    this.#releaseAccessHandle(file);
+                    file.persistentFile.isHandleRequested = false;
+                }
+                file.persistentFile.isFileLocked = false;
+            }
+        }
+        return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    }
+    /**
+     * @param {number} fileId
+     * @param {number} op
+     * @param {DataView} pArg
+     * @returns {number|Promise<number>}
+     */
+    jFileControl(fileId, op, pArg) {
+        try {
+            const file = this.mapIdToFile.get(fileId);
+            switch (op) {
+                case _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_FCNTL_PRAGMA:
+                    const key = extractString(pArg, 4);
+                    const value = extractString(pArg, 8);
+                    this.log?.('xFileControl', file.path, 'PRAGMA', key, value);
+                    switch (key.toLowerCase()) {
+                        case 'journal_mode':
+                            if (value && !['off', 'memory', 'delete', 'wal'].includes(value.toLowerCase())) {
+                                throw new Error('journal_mode must be "off", "memory", "delete", or "wal"');
+                            }
+                            break;
+                    }
+                    break;
+            }
+        }
+        catch (e) {
+            this.lastError = e;
+            return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR;
+        }
+        return _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_NOTFOUND;
+    }
+    /**
+     * @param {Uint8Array} zBuf
+     * @returns
+     */
+    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 _journeyapps_wa_sqlite_src_VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+    }
+    /**
+     * @param {FileSystemFileHandle} fileHandle
+     * @returns {Promise<PersistentFile>}
+     */
+    async #createPersistentFile(fileHandle) {
+        const persistentFile = new PersistentFile(fileHandle);
+        const root = await navigator.storage.getDirectory();
+        const relativePath = await root.resolve(fileHandle);
+        const path = `/${relativePath.join('/')}`;
+        persistentFile.handleRequestChannel = new BroadcastChannel(`ahp:${path}`);
+        this.persistentFiles.set(path, persistentFile);
+        const f = await fileHandle.getFile();
+        if (f.size) {
+            this.accessiblePaths.add(path);
+        }
+        return persistentFile;
+    }
+    /**
+     * @param {File} file
+     */
+    #requestAccessHandle(file) {
+        console.assert(!file.persistentFile.handleLockReleaser);
+        if (!file.persistentFile.isRequestInProgress) {
+            file.persistentFile.isRequestInProgress = true;
+            this._module.retryOps.push((async () => {
+                // Acquire the Web Lock.
+                file.persistentFile.handleLockReleaser = await this.#acquireLock(file.persistentFile);
+                try {
+                    // Get access handles for the database and releated files in parallel.
+                    this.log?.(`creating access handles for ${file.path}`);
+                    await Promise.all(DB_RELATED_FILE_SUFFIXES.map(async (suffix) => {
+                        const persistentFile = this.persistentFiles.get(file.path + suffix);
+                        if (persistentFile) {
+                            persistentFile.accessHandle = await persistentFile.fileHandle.createSyncAccessHandle();
+                        }
+                    }));
+                }
+                catch (e) {
+                    this.log?.(`failed to create access handles for ${file.path}`, e);
+                    // Close any of the potentially opened access handles
+                    DB_RELATED_FILE_SUFFIXES.forEach(async (suffix) => {
+                        const persistentFile = this.persistentFiles.get(file.path + suffix);
+                        if (persistentFile) {
+                            persistentFile.accessHandle?.close();
+                        }
+                    });
+                    // Release the lock, if we failed here, we'd need to obtain the lock later in order to retry
+                    file.persistentFile.handleLockReleaser();
+                    throw e;
+                }
+                finally {
+                    file.persistentFile.isRequestInProgress = false;
+                }
+            })());
+            return this._module.retryOps.at(-1);
+        }
+        return Promise.resolve();
+    }
+    /**
+     * @param {File} file
+     */
+    async #releaseAccessHandle(file) {
+        DB_RELATED_FILE_SUFFIXES.forEach(async (suffix) => {
+            const persistentFile = this.persistentFiles.get(file.path + suffix);
+            if (persistentFile) {
+                persistentFile.accessHandle?.close();
+                persistentFile.accessHandle = null;
+            }
+        });
+        this.log?.(`access handles closed for ${file.path}`);
+        file.persistentFile.handleLockReleaser?.();
+        file.persistentFile.handleLockReleaser = null;
+        this.log?.(`lock released for ${file.path}`);
+    }
+    /**
+     * @param {PersistentFile} persistentFile
+     * @returns  {Promise<function>} lock releaser
+     */
+    #acquireLock(persistentFile) {
+        return new Promise((resolve) => {
+            // Tell other connections we want the access handle.
+            const lockName = persistentFile.handleRequestChannel.name;
+            const notify = () => {
+                this.log?.(`notifying for ${lockName}`);
+                persistentFile.handleRequestChannel.postMessage(null);
+            };
+            const notifyId = setInterval(notify, LOCK_NOTIFY_INTERVAL);
+            setTimeout(notify);
+            this.log?.(`lock requested: ${lockName}`);
+            navigator.locks.request(lockName, (lock) => {
+                // We have the lock. Stop asking other connections for it.
+                this.log?.(`lock acquired: ${lockName}`, lock);
+                clearInterval(notifyId);
+                return new Promise(resolve);
+            });
+        });
+    }
+}
+function extractString(dataView, offset) {
+    const p = dataView.getUint32(offset, true);
+    if (p) {
+        const chars = new Uint8Array(dataView.buffer, p);
+        return new TextDecoder().decode(chars.subarray(0, chars.indexOf(0)));
+    }
+    return null;
+}
+
+
 /***/ }),
 
 /***/ "./lib/src/worker/sync/BroadcastLogger.js":
@@ -18992,14 +20860,25 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     /**
      * Gets the last client port which we know is safe from unexpected closes.
      */
-    get lastWrappedPort() {
-        // Find the last port which is protected from close
-        for (let i = this.ports.length - 1; i >= 0; i--) {
-            if (this.ports[i].isProtectedFromClose && !this.ports[i].isClosing) {
-                return this.ports[i];
+    async getLastWrappedPort() {
+        // Find the last port which is not closing
+        return await this.portMutex.runExclusive(() => {
+            for (let i = this.ports.length - 1; i >= 0; i--) {
+                if (!this.ports[i].isClosing) {
+                    return this.ports[i];
+                }
             }
-        }
-        return;
+            return;
+        });
+    }
+    /**
+     * In some very rare cases a specific tab might not respond to requests.
+     * This returns a random port which is not closing.
+     */
+    async getRandomWrappedPort() {
+        return await this.portMutex.runExclusive(() => {
+            return this.ports[Math.floor(Math.random() * this.ports.length)];
+        });
     }
     async waitForStatus(status) {
         return this.withSyncImplementation(async (sync) => {
@@ -19041,39 +20920,45 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     async setParams(params) {
         await this.portMutex.runExclusive(async () => {
             this.collectActiveSubscriptions();
-            if (this.syncParams) {
-                // Cannot modify already existing sync implementation params
-                return;
-            }
-            // First time setting params
-            this.syncParams = params;
-            if (params.streamOptions?.flags?.broadcastLogs) {
-                this.logger = this.broadCastLogger;
+        });
+        if (this.syncParams) {
+            // Cannot modify already existing sync implementation params
+            return;
+        }
+        // First time setting params
+        this.syncParams = params;
+        if (params.streamOptions?.flags?.broadcastLogs) {
+            this.logger = this.broadCastLogger;
+        }
+        const lockedAdapter = new _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_4__.LockedAsyncDatabaseAdapter({
+            name: params.dbParams.dbFilename,
+            openConnection: async () => {
+                // Gets a connection from the clients when a new connection is requested.
+                const db = await this.openInternalDB();
+                db.registerListener({
+                    closing: () => {
+                        lockedAdapter.reOpenInternalDB();
+                    }
+                });
+                return db;
+            },
+            logger: this.logger,
+            reOpenOnConnectionClosed: true
+        });
+        this.distributedDB = lockedAdapter;
+        await lockedAdapter.init();
+        lockedAdapter.registerListener({
+            databaseReOpened: () => {
+                // We may have missed some table updates while the database was closed.
+                // We can poke the crud in case we missed any updates.
+                this.connectionManager.syncStreamImplementation?.triggerCrudUpload();
             }
-            const lockedAdapter = new _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_4__.LockedAsyncDatabaseAdapter({
-                name: params.dbParams.dbFilename,
-                openConnection: async () => {
-                    // Gets a connection from the clients when a new connection is requested.
-                    return await this.openInternalDB();
-                },
-                logger: this.logger,
-                reOpenOnConnectionClosed: true
-            });
-            this.distributedDB = lockedAdapter;
-            await lockedAdapter.init();
-            lockedAdapter.registerListener({
-                databaseReOpened: () => {
-                    // We may have missed some table updates while the database was closed.
-                    // We can poke the crud in case we missed any updates.
-                    this.connectionManager.syncStreamImplementation?.triggerCrudUpload();
-                }
-            });
-            self.onerror = (event) => {
-                // Share any uncaught events on the broadcast logger
-                this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
-            };
-            this.iterateListeners((l) => l.initialized?.());
         });
+        self.onerror = (event) => {
+            // Share any uncaught events on the broadcast logger
+            this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
+        };
+        this.iterateListeners((l) => l.initialized?.());
     }
     async dispose() {
         await this.waitForReady();
@@ -19103,7 +20988,6 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 clientProvider: comlink__WEBPACK_IMPORTED_MODULE_7__.wrap(port),
                 currentSubscriptions: [],
                 closeListeners: [],
-                isProtectedFromClose: false,
                 isClosing: false
             };
             this.ports.push(portProvider);
@@ -19189,7 +21073,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
             adapter: new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SqliteBucketStorage(this.distributedDB, this.logger),
             remote: new _db_sync_WebRemote__WEBPACK_IMPORTED_MODULE_2__.WebRemote({
                 invalidateCredentials: async () => {
-                    const lastPort = this.lastWrappedPort;
+                    const lastPort = await this.getLastWrappedPort();
                     if (!lastPort) {
                         throw new Error('No client port found to invalidate credentials');
                     }
@@ -19202,7 +21086,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     }
                 },
                 fetchCredentials: async () => {
-                    const lastPort = this.lastWrappedPort;
+                    const lastPort = await this.getLastWrappedPort();
                     if (!lastPort) {
                         throw new Error('No client port found to fetch credentials');
                     }
@@ -19227,7 +21111,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 }
             }, this.logger),
             uploadCrud: async () => {
-                const lastPort = this.lastWrappedPort;
+                const lastPort = await this.getLastWrappedPort();
                 if (!lastPort) {
                     throw new Error('No client port found to upload crud');
                 }
@@ -19262,11 +21146,15 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     async openInternalDB() {
         while (true) {
             try {
-                const lastClient = this.lastWrappedPort;
-                if (!lastClient) {
+                const client = await this.getRandomWrappedPort();
+                if (!client) {
                     // Should not really happen in practice
                     throw new Error(`Could not open DB connection since no client is connected.`);
                 }
+                // Fail-safe timeout for opening a database connection.
+                const timeout = setTimeout(() => {
+                    abortController.abort();
+                }, 10_000);
                 /**
                  * Handle cases where the client might close while opening a connection.
                  */
@@ -19275,13 +21163,19 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     abortController.abort();
                 };
                 const removeCloseListener = () => {
-                    const index = lastClient.closeListeners.indexOf(closeListener);
+                    const index = client.closeListeners.indexOf(closeListener);
                     if (index >= 0) {
-                        lastClient.closeListeners.splice(index, 1);
+                        client.closeListeners.splice(index, 1);
                     }
                 };
-                lastClient.closeListeners.push(closeListener);
-                const workerPort = await withAbort(() => lastClient.clientProvider.getDBWorkerPort(), abortController.signal).catch((ex) => {
+                client.closeListeners.push(closeListener);
+                const workerPort = await withAbort({
+                    action: () => client.clientProvider.getDBWorkerPort(),
+                    signal: abortController.signal,
+                    cleanupOnAbort: (port) => {
+                        port.close();
+                    }
+                }).catch((ex) => {
                     removeCloseListener();
                     throw ex;
                 });
@@ -19293,10 +21187,17 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                  * We typically execute the closeListeners using the portMutex in a different context.
                  * We can't rely on the closeListeners to abort the operation if the tab is closed.
                  */
-                const db = await withAbort(() => remote(this.syncParams.dbParams), abortController.signal).finally(() => {
+                const db = await withAbort({
+                    action: () => remote(this.syncParams.dbParams),
+                    signal: abortController.signal,
+                    cleanupOnAbort: (db) => {
+                        db.close();
+                    }
+                }).finally(() => {
                     // We can remove the close listener here since we no longer need it past this point.
                     removeCloseListener();
                 });
+                clearTimeout(timeout);
                 const wrapped = new _db_adapters_WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_5__.WorkerWrappedAsyncDatabaseConnection({
                     remote,
                     baseConnection: db,
@@ -19305,15 +21206,15 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     // that and ensure pending requests are aborted when the tab is closed.
                     remoteCanCloseUnexpectedly: true
                 });
-                lastClient.closeListeners.push(async () => {
+                client.closeListeners.push(async () => {
                     this.logger.info('Aborting open connection because associated tab closed.');
                     /**
                      * Don't await this close operation. It might never resolve if the tab is closed.
-                     * We run the close operation first, before marking the remote as closed. This gives the database some chance
-                     * to close the connection.
+                     * We mark the remote as closed first, this will reject any pending requests.
+                     * We then call close. The close operation is configured to fire-and-forget, the main promise will reject immediately.
                      */
-                    wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
                     wrapped.markRemoteClosed();
+                    wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
                 });
                 return wrapped;
             }
@@ -19331,23 +21232,12 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
         this.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus(status);
         this.ports.forEach((p) => p.clientProvider.statusChanged(status));
     }
-    /**
-     * A function only used for unit tests which updates the internal
-     * sync stream client and all tab client's sync status
-     */
-    async _testUpdateAllStatuses(status) {
-        if (!this.connectionManager.syncStreamImplementation) {
-            throw new Error('Cannot update status without a sync stream implementation');
-        }
-        // Only assigning, don't call listeners for this test
-        this.connectionManager.syncStreamImplementation.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus(status);
-        this.updateAllStatuses(status);
-    }
 }
 /**
  * Runs the action with an abort controller.
  */
-function withAbort(action, signal) {
+function withAbort(options) {
+    const { action, signal, cleanupOnAbort } = options;
     return new Promise((resolve, reject) => {
         if (signal.aborted) {
             reject(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Operation aborted by abort controller'));
@@ -19363,7 +21253,13 @@ function withAbort(action, signal) {
             action();
         }
         action()
-            .then((data) => completePromise(() => resolve(data)))
+            .then((data) => {
+            // We already rejected due to the abort, allow for cleanup
+            if (signal.aborted) {
+                return completePromise(() => cleanupOnAbort?.(data));
+            }
+            completePromise(() => resolve(data));
+        })
             .catch((e) => completePromise(() => reject(e)));
     });
 }
@@ -19402,8 +21298,6 @@ class WorkerClient {
         this.sync = sync;
         this.port = port;
         comlink__WEBPACK_IMPORTED_MODULE_2__.expose(this, this.port);
-    }
-    async initialize() {
         /**
          * Adds an extra listener which can remove this port
          * from the list of monitored ports.
@@ -19414,15 +21308,6 @@ class WorkerClient {
                 await this.removePort();
             }
         });
-        /**
-         * Keep a reference to the resolved port promise.
-         * The init timing is difficult to predict due to the async message passing.
-         * We only want to use a port if we are know it's been protected from being closed.
-         * The lock based close signal will be added asynchronously. We need to use the
-         * added port once the lock is configured.
-         */
-        this.resolvedPortPromise = this.sync.addPort(this.port);
-        this.resolvedPort = await this.resolvedPortPromise;
     }
     async removePort() {
         if (this.resolvedPort) {
@@ -19444,19 +21329,9 @@ class WorkerClient {
      * it can consider the connection to be closed.
      */
     async addLockBasedCloseSignal(name) {
-        if (!this.resolvedPortPromise) {
-            // The init logic above is actually synchronous, so this should not happen.
-            this.sync.broadCastLogger.warn('addLockBasedCloseSignal called before port promise registered');
-        }
-        else {
-            const wrappedPort = await this.resolvedPortPromise;
-            /**
-             * The client registered a navigator lock. We now can guarantee detecting if the client has closed.
-             * E.g. before this point: It's possible some ports might have been created and closed before the
-             * lock based close signal is added. We should not trust those ports.
-             */
-            wrappedPort.isProtectedFromClose = true;
-        }
+        // Only add the port once the lock has been obtained on the client.
+        this.resolvedPort = await this.sync.addPort(this.port);
+        // Don't await this lock request
         (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_0__.getNavigatorLocks)().request(name, async () => {
             await this.removePort();
         });
@@ -19488,9 +21363,6 @@ class WorkerClient {
     disconnect() {
         return this.sync.disconnect();
     }
-    async _testUpdateAllStatuses(status) {
-        return this.sync._testUpdateAllStatuses(status);
-    }
 }
 
 
@@ -19672,7 +21544,7 @@ logger.useDefaults();
 const sharedSyncImplementation = new _SharedSyncImplementation__WEBPACK_IMPORTED_MODULE_1__.SharedSyncImplementation();
 _self.onconnect = async function (event) {
     const port = event.ports[0];
-    await new _WorkerClient__WEBPACK_IMPORTED_MODULE_2__.WorkerClient(sharedSyncImplementation, port).initialize();
+    new _WorkerClient__WEBPACK_IMPORTED_MODULE_2__.WorkerClient(sharedSyncImplementation, port);
 };
 
 })();