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

package/dist/worker/node_modules_journeyapps_wa-sqlite_src_examples_OPFSCoopSyncVFS_js.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker/node_modules_journeyapps_wa-sqlite_src_examples_OPFSCoopSyncVFS_js.umd.js","mappings":";;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/sBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AC7NA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sources":["webpack://sdk_web/../../node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js","webpack://sdk_web/../../node_modules/@journeyapps/wa-sqlite/src/VFS.js","webpack://sdk_web/../../node_modules/@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js"],"sourcesContent":["// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.\nimport * as VFS from './VFS.js';\n\nconst AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;\n\n// Milliseconds since Julian epoch as a BigInt.\n// https://github.com/sqlite/sqlite/blob/e57527c14f7b7cfa6e32eeab5c549d50c4fa3674/src/os_unix.c#L6872-L6882\nconst UNIX_EPOCH = 24405875n * 8640000n;\n\n// Convenience base class for a JavaScript VFS.\n// The raw xOpen, xRead, etc. function signatures receive only C primitives\n// which aren't easy to work with. This class provides corresponding calls\n// like jOpen, jRead, etc., which receive JavaScript-friendlier arguments\n// such as string, Uint8Array, and DataView.\nexport class FacadeVFS extends VFS.Base {\n  /**\n   * @param {string} name \n   * @param {object} module \n   */\n  constructor(name, module) {\n    super(name, module);\n  }\n\n  /**\n   * Override to indicate which methods are asynchronous.\n   * @param {string} methodName \n   * @returns {boolean}\n   */\n  hasAsyncMethod(methodName) {\n    // The input argument is a string like \"xOpen\", so convert to \"jOpen\".\n    // Then check if the method exists and is async.\n    const jMethodName = `j${methodName.slice(1)}`;\n    return this[jMethodName] instanceof AsyncFunction;\n  }\n  \n  /**\n   * Return the filename for a file id for use by mixins.\n   * @param {number} pFile \n   * @returns {string}\n   */\n  getFilename(pFile) {\n    throw new Error('unimplemented');\n  }\n\n  /**\n   * @param {string?} filename \n   * @param {number} pFile \n   * @param {number} flags \n   * @param {DataView} pOutFlags \n   * @returns {number|Promise<number>}\n   */\n  jOpen(filename, pFile, flags, pOutFlags) {\n    return VFS.SQLITE_CANTOPEN;\n  }\n\n  /**\n   * @param {string} filename \n   * @param {number} syncDir \n   * @returns {number|Promise<number>}\n   */\n  jDelete(filename, syncDir) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {string} filename \n   * @param {number} flags \n   * @param {DataView} pResOut \n   * @returns {number|Promise<number>}\n   */\n  jAccess(filename, flags, pResOut) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {string} filename \n   * @param {Uint8Array} zOut \n   * @returns {number|Promise<number>}\n   */\n  jFullPathname(filename, zOut) {\n    // Copy the filename to the output buffer.\n    const { read, written } = new TextEncoder().encodeInto(filename, zOut);\n    if (read < filename.length) return VFS.SQLITE_IOERR;\n    if (written >= zOut.length) return VFS.SQLITE_IOERR;\n    zOut[written] = 0;\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {Uint8Array} zBuf \n   * @returns {number|Promise<number>}\n   */\n  jGetLastError(zBuf) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @returns {number|Promise<number>}\n   */\n  jClose(pFile) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {Uint8Array} pData \n   * @param {number} iOffset \n   * @returns {number|Promise<number>}\n   */\n  jRead(pFile, pData, iOffset) {\n    pData.fill(0);\n    return VFS.SQLITE_IOERR_SHORT_READ;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {Uint8Array} pData \n   * @param {number} iOffset \n   * @returns {number|Promise<number>}\n   */\n  jWrite(pFile, pData, iOffset) {\n    return VFS.SQLITE_IOERR_WRITE;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} size \n   * @returns {number|Promise<number>}\n   */\n  jTruncate(pFile, size) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} flags \n   * @returns {number|Promise<number>}\n   */\n  jSync(pFile, flags) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {DataView} pSize\n   * @returns {number|Promise<number>}\n   */\n  jFileSize(pFile, pSize) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} lockType \n   * @returns {number|Promise<number>}\n   */\n  jLock(pFile, lockType) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} lockType \n   * @returns {number|Promise<number>}\n   */\n  jUnlock(pFile, lockType) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {DataView} pResOut \n   * @returns {number|Promise<number>}\n   */\n  jCheckReservedLock(pFile, pResOut) {\n    pResOut.setInt32(0, 0, true);\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile\n   * @param {number} op\n   * @param {DataView} pArg\n   * @returns {number|Promise<number>}\n   */\n  jFileControl(pFile, op, pArg) {\n    return VFS.SQLITE_NOTFOUND;\n  }\n\n  /**\n   * @param {number} pFile\n   * @returns {number|Promise<number>}\n   */\n  jSectorSize(pFile) {\n    return super.xSectorSize(pFile);\n  }\n\n  /**\n   * @param {number} pFile\n   * @returns {number|Promise<number>}\n   */\n  jDeviceCharacteristics(pFile) {\n    return 0;\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} zName \n   * @param {number} pFile \n   * @param {number} flags \n   * @param {number} pOutFlags \n   * @returns {number|Promise<number>}\n   */\n  xOpen(pVfs, zName, pFile, flags, pOutFlags) {\n    const filename = this.#decodeFilename(zName, flags);\n    const pOutFlagsView = this.#makeTypedDataView('Int32', pOutFlags);\n    this['log']?.('jOpen', filename, pFile, '0x' + flags.toString(16));\n    return this.jOpen(filename, pFile, flags, pOutFlagsView);\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} nByte \n   * @param {number} pCharOut\n   * @returns {number|Promise<number>}\n   */\n  xRandomness(pVfs, nByte, pCharOut) {\n    const randomArray = new Uint8Array(nByte);\n    crypto.getRandomValues(randomArray);\n    // Copy randomArray to the WebAssembly memory\n    const buffer = pCharOut; // Pointer to memory in WebAssembly\n    this._module.HEAPU8.set(randomArray, buffer); // Copy randomArray into memory starting at buffer\n    return nByte;\n  }\n\n  /**\n   * Gets the current time as milliseconds since Unix epoch\n   * @param {number} pVfs pointer to the VFS\n   * @param {number} pTime pointer to write the time value\n   * @returns {number} SQLite error code\n   */\n  xCurrentTimeInt64(pVfs, pTime) {\n    // Create a DataView to write the current time\n    const timeView = this.#makeTypedDataView('BigInt64', pTime);\n  \n    const currentTime = BigInt(Date.now());\n    // Convert the current time to milliseconds since Unix epoch\n    const value = UNIX_EPOCH + currentTime;\n    \n    // Write the time value to the pointer location\n    timeView.setBigInt64(0, value, true);\n    \n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} zName \n   * @param {number} syncDir \n   * @returns {number|Promise<number>}\n   */\n  xDelete(pVfs, zName, syncDir) {\n    const filename = this._module.UTF8ToString(zName);\n    this['log']?.('jDelete', filename, syncDir);\n    return this.jDelete(filename, syncDir);\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} zName \n   * @param {number} flags \n   * @param {number} pResOut \n   * @returns {number|Promise<number>}\n   */\n  xAccess(pVfs, zName, flags, pResOut) {\n    const filename = this._module.UTF8ToString(zName);\n    const pResOutView = this.#makeTypedDataView('Int32', pResOut);\n    this['log']?.('jAccess', filename, flags);\n    return this.jAccess(filename, flags, pResOutView);\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} zName \n   * @param {number} nOut \n   * @param {number} zOut \n   * @returns {number|Promise<number>}\n   */\n  xFullPathname(pVfs, zName, nOut, zOut) {\n    const filename = this._module.UTF8ToString(zName);\n    const zOutArray = this._module.HEAPU8.subarray(zOut, zOut + nOut);\n    this['log']?.('jFullPathname', filename, nOut);\n    return this.jFullPathname(filename, zOutArray);\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} nBuf \n   * @param {number} zBuf \n   * @returns {number|Promise<number>}\n   */\n  xGetLastError(pVfs, nBuf, zBuf) {\n    const zBufArray = this._module.HEAPU8.subarray(zBuf, zBuf + nBuf);\n    this['log']?.('jGetLastError', nBuf);\n    return this.jGetLastError(zBufArray);\n  }\n\n  /**\n   * @param {number} pFile \n   * @returns {number|Promise<number>}\n   */\n  xClose(pFile) {\n    this['log']?.('jClose', pFile);\n    return this.jClose(pFile);\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} pData \n   * @param {number} iAmt \n   * @param {number} iOffsetLo \n   * @param {number} iOffsetHi \n   * @returns {number|Promise<number>}\n   */\n  xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {\n    const pDataArray = this.#makeDataArray(pData, iAmt);\n    const iOffset = delegalize(iOffsetLo, iOffsetHi);\n    this['log']?.('jRead', pFile, iAmt, iOffset);\n    return this.jRead(pFile, pDataArray, iOffset);\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} pData \n   * @param {number} iAmt \n   * @param {number} iOffsetLo \n   * @param {number} iOffsetHi \n   * @returns {number|Promise<number>}\n   */\n  xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {\n    const pDataArray = this.#makeDataArray(pData, iAmt);\n    const iOffset = delegalize(iOffsetLo, iOffsetHi);\n    this['log']?.('jWrite', pFile, pDataArray, iOffset);\n    return this.jWrite(pFile, pDataArray, iOffset);\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} sizeLo \n   * @param {number} sizeHi \n   * @returns {number|Promise<number>}\n   */\n  xTruncate(pFile, sizeLo, sizeHi) {\n    const size = delegalize(sizeLo, sizeHi);\n    this['log']?.('jTruncate', pFile, size);\n    return this.jTruncate(pFile, size);\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} flags \n   * @returns {number|Promise<number>}\n   */\n  xSync(pFile, flags) {\n    this['log']?.('jSync', pFile, flags);\n    return this.jSync(pFile, flags);\n  }\n\n  /**\n   * \n   * @param {number} pFile \n   * @param {number} pSize \n   * @returns {number|Promise<number>}\n   */\n  xFileSize(pFile, pSize) {\n    const pSizeView = this.#makeTypedDataView('BigInt64', pSize);\n    this['log']?.('jFileSize', pFile);\n    return this.jFileSize(pFile, pSizeView);\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} lockType \n   * @returns {number|Promise<number>}\n   */\n  xLock(pFile, lockType) {\n    this['log']?.('jLock', pFile, lockType);\n    return this.jLock(pFile, lockType);\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} lockType \n   * @returns {number|Promise<number>}\n   */\n  xUnlock(pFile, lockType) {\n    this['log']?.('jUnlock', pFile, lockType);\n    return this.jUnlock(pFile, lockType);\n  } \n\n  /**\n   * @param {number} pFile \n   * @param {number} pResOut \n   * @returns {number|Promise<number>}\n   */\n  xCheckReservedLock(pFile, pResOut) {\n    const pResOutView = this.#makeTypedDataView('Int32', pResOut);\n    this['log']?.('jCheckReservedLock', pFile);\n    return this.jCheckReservedLock(pFile, pResOutView);\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} op \n   * @param {number} pArg \n   * @returns {number|Promise<number>}\n   */\n  xFileControl(pFile, op, pArg) {\n    const pArgView = new DataView(\n      this._module.HEAPU8.buffer,\n      this._module.HEAPU8.byteOffset + pArg);\n    this['log']?.('jFileControl', pFile, op, pArgView);\n    return this.jFileControl(pFile, op, pArgView);\n  }\n\n  /**\n   * @param {number} pFile \n   * @returns {number|Promise<number>}\n   */\n  xSectorSize(pFile) {\n    this['log']?.('jSectorSize', pFile);\n    return this.jSectorSize(pFile);\n  }\n\n  /**\n   * @param {number} pFile \n   * @returns {number|Promise<number>}\n   */\n  xDeviceCharacteristics(pFile) {\n    this['log']?.('jDeviceCharacteristics', pFile);\n    return this.jDeviceCharacteristics(pFile);\n  }\n\n  /**\n   * Wrapped DataView for pointer arguments.\n   * Pointers to a single value are passed using a DataView-like class.\n   * This wrapper class prevents use of incorrect type or endianness, and\n   * reacquires the underlying buffer when the WebAssembly memory is resized.\n   * @param {'Int32'|'BigInt64'} type \n   * @param {number} byteOffset \n   * @returns {DataView}\n   */\n  #makeTypedDataView(type, byteOffset) {\n    // @ts-ignore\n    return new DataViewProxy(this._module, byteOffset, type);\n  }\n\n  /**\n   * Wrapped Uint8Array for buffer arguments.\n   * Memory blocks are passed as a Uint8Array-like class. This wrapper\n   * class reacquires the underlying buffer when the WebAssembly memory\n   * is resized.\n   * @param {number} byteOffset \n   * @param {number} byteLength \n   * @returns {Uint8Array}\n   */\n  #makeDataArray(byteOffset, byteLength) {\n    // @ts-ignore\n    return new Uint8ArrayProxy(this._module, byteOffset, byteLength);\n  }\n\n  #decodeFilename(zName, flags) {\n    if (flags & VFS.SQLITE_OPEN_URI) {\n      // The first null-terminated string is the URI path. Subsequent\n      // strings are query parameter keys and values.\n      // https://www.sqlite.org/c3ref/open.html#urifilenamesinsqlite3open\n      let pName = zName;\n      let state = 1;\n      const charCodes = [];\n      while (state) {\n        const charCode = this._module.HEAPU8[pName++];\n        if (charCode) {\n          charCodes.push(charCode);\n        } else {\n          if (!this._module.HEAPU8[pName]) state = null;\n          switch (state) {\n            case 1: // path\n              charCodes.push('?'.charCodeAt(0));\n              state = 2;\n              break;\n            case 2: // key\n              charCodes.push('='.charCodeAt(0));\n              state = 3;\n              break;\n            case 3: // value\n              charCodes.push('&'.charCodeAt(0));\n              state = 2;\n              break;\n          }\n        }\n      }\n      return  new TextDecoder().decode(new Uint8Array(charCodes));\n    }\n    return zName ? this._module.UTF8ToString(zName) : null;\n  }\n}\n\n// Emscripten \"legalizes\" 64-bit integer arguments by passing them as\n// two 32-bit signed integers.\nfunction delegalize(lo32, hi32) {\n  return (hi32 * 0x100000000) + lo32 + (lo32 < 0 ? 2**32 : 0);\n}\n\n// This class provides a Uint8Array-like interface for a WebAssembly memory\n// buffer. It is used to access memory blocks passed as arguments to\n// xRead, xWrite, etc. The class reacquires the underlying buffer when the\n// WebAssembly memory is resized, which can happen when the memory is\n// detached and resized by the WebAssembly module.\n//\n// Note that although this class implements the same methods as Uint8Array,\n// it is not a real Uint8Array and passing it to functions that expect\n// a Uint8Array may not work. Use subarray() to get a real Uint8Array\n// if needed.\nclass Uint8ArrayProxy {\n  #module;\n\n  #_array = new Uint8Array()\n  get #array() {\n    if (this.#_array.buffer.byteLength === 0) {\n      // WebAssembly memory resize detached the buffer so re-create the\n      // array with the new buffer.\n      this.#_array = this.#module.HEAPU8.subarray(\n        this.byteOffset,\n        this.byteOffset + this.byteLength);\n    }\n    return this.#_array;\n  }\n\n  /**\n   * @param {*} module\n   * @param {number} byteOffset \n   * @param {number} byteLength \n   */\n  constructor(module, byteOffset, byteLength) {\n    this.#module = module;\n    this.byteOffset = byteOffset;\n    this.length = this.byteLength = byteLength;\n  }\n\n  get buffer() {\n    return this.#array.buffer;\n  }\n\n  at(index) {\n    return this.#array.at(index);\n  }\n  copyWithin(target, start, end) {\n    this.#array.copyWithin(target, start, end);\n  }\n  entries() {\n    return this.#array.entries();\n  }\n  every(predicate) {\n    return this.#array.every(predicate);\n  }\n  fill(value, start, end) {\n    this.#array.fill(value, start, end);\n  }\n  filter(predicate) {\n    return this.#array.filter(predicate);\n  }\n  find(predicate) {\n    return this.#array.find(predicate);\n  }\n  findIndex(predicate) {\n    return this.#array.findIndex(predicate);\n  }\n  findLast(predicate) {\n    return this.#array.findLast(predicate);\n  }\n  findLastIndex(predicate) {\n    return this.#array.findLastIndex(predicate);\n  }\n  forEach(callback) {\n    this.#array.forEach(callback);\n  }\n  includes(value, start) {\n    return this.#array.includes(value, start);\n  }\n  indexOf(value, start) {\n    return this.#array.indexOf(value, start);\n  }\n  join(separator) {\n    return this.#array.join(separator);\n  }\n  keys() {\n    return this.#array.keys();\n  }\n  lastIndexOf(value, start) {\n    return this.#array.lastIndexOf(value, start);\n  }\n  map(callback) {\n    return this.#array.map(callback);\n  }\n  reduce(callback, initialValue) {\n    return this.#array.reduce(callback, initialValue);\n  }\n  reduceRight(callback, initialValue) {\n    return this.#array.reduceRight(callback, initialValue);\n  }\n  reverse() {\n    this.#array.reverse();\n  }\n  set(array, offset) {\n    this.#array.set(array, offset);\n  }\n  slice(start, end) {\n    return this.#array.slice(start, end);\n  }\n  some(predicate) {\n    return this.#array.some(predicate);\n  }\n  sort(compareFn) {\n    this.#array.sort(compareFn);\n  }\n  subarray(begin, end) {\n    return this.#array.subarray(begin, end);\n  }\n  toLocaleString(locales, options) {\n    // @ts-ignore\n    return this.#array.toLocaleString(locales, options);\n  }\n  toReversed() {\n    return this.#array.toReversed();\n  }\n  toSorted(compareFn) {\n    return this.#array.toSorted(compareFn);\n  }\n  toString() {\n    return this.#array.toString();\n  }\n  values() {\n    return this.#array.values();\n  }\n  with(index, value) {\n    return this.#array.with(index, value);\n  }\n  [Symbol.iterator]() {\n    return this.#array[Symbol.iterator]();\n  }\n}\n\n// This class provides a DataView-like interface for a WebAssembly memory\n// buffer, restricted to either Int32 or BigInt64 types. It also reacquires\n// the underlying buffer when the WebAssembly memory is resized, which can\n// happen when the memory is detached and resized by the WebAssembly module.\nclass DataViewProxy {\n  #module;\n  #type;\n\n  #_view = new DataView(new ArrayBuffer(0));\n  get #view() {\n    if (this.#_view.buffer.byteLength === 0) {\n      // WebAssembly memory resize detached the buffer so re-create the\n      // view with the new buffer.\n      this.#_view = new DataView(\n        this.#module.HEAPU8.buffer,\n        this.#module.HEAPU8.byteOffset + this.byteOffset);\n    }\n    return this.#_view;\n  }\n\n  /**\n   * @param {*} module\n   * @param {number} byteOffset \n   * @param {'Int32'|'BigInt64'} type\n   */\n  constructor(module, byteOffset, type) {\n    this.#module = module;\n    this.byteOffset = byteOffset;\n    this.#type = type;\n  }\n\n  get buffer() {\n    return this.#view.buffer;\n  }\n  get byteLength() {\n    return this.#type === 'Int32' ? 4 : 8;\n  }\n\n  getInt32(byteOffset, littleEndian) {\n    if (this.#type !== 'Int32') {\n      throw new Error('invalid type');\n    }\n    if (!littleEndian) throw new Error('must be little endian');\n    return this.#view.getInt32(byteOffset, littleEndian);\n  }\n  setInt32(byteOffset, value, littleEndian) {\n    if (this.#type !== 'Int32') {\n      throw new Error('invalid type');\n    }\n    if (!littleEndian) throw new Error('must be little endian');\n    this.#view.setInt32(byteOffset, value, littleEndian);\n  }\n  getBigInt64(byteOffset, littleEndian) {\n    if (this.#type !== 'BigInt64') {\n      throw new Error('invalid type');\n    }\n    if (!littleEndian) throw new Error('must be little endian');\n    return this.#view.getBigInt64(byteOffset, littleEndian);\n  }\n  setBigInt64(byteOffset, value, littleEndian) {\n    if (this.#type !== 'BigInt64') {\n      throw new Error('invalid type');\n    }\n    if (!littleEndian) throw new Error('must be little endian');\n    this.#view.setBigInt64(byteOffset, value, littleEndian);\n  }\n}","// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.\nimport * as VFS from './sqlite-constants.js';\nexport * from './sqlite-constants.js';\n\nconst DEFAULT_SECTOR_SIZE = 512;\n\n// Base class for a VFS.\nexport class Base {\n  name;\n  mxPathname = 64;\n  _module;\n\n  /**\n   * @param {string} name \n   * @param {object} module \n   */\n  constructor(name, module) {\n    this.name = name;\n    this._module = module;\n  }\n\n  /**\n   * @returns {void|Promise<void>} \n   */\n  close() {\n  }\n\n  /**\n   * @returns {boolean|Promise<boolean>}\n   */\n  isReady() {\n    return true;\n  }\n\n  /**\n   * Overload in subclasses to indicate which methods are asynchronous.\n   * @param {string} methodName \n   * @returns {boolean}\n   */\n  hasAsyncMethod(methodName) {\n    return false;\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} zName \n   * @param {number} pFile \n   * @param {number} flags \n   * @param {number} pOutFlags \n   * @returns {number|Promise<number>}\n   */\n  xOpen(pVfs, zName, pFile, flags, pOutFlags) {\n    return VFS.SQLITE_CANTOPEN;\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} zName \n   * @param {number} syncDir \n   * @returns {number|Promise<number>}\n   */\n  xDelete(pVfs, zName, syncDir) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} zName \n   * @param {number} flags \n   * @param {number} pResOut \n   * @returns {number|Promise<number>}\n   */\n  xAccess(pVfs, zName, flags, pResOut) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} zName \n   * @param {number} nOut \n   * @param {number} zOut \n   * @returns {number|Promise<number>}\n   */\n  xFullPathname(pVfs, zName, nOut, zOut) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pVfs \n   * @param {number} nBuf \n   * @param {number} zBuf \n   * @returns {number|Promise<number>}\n   */\n  xGetLastError(pVfs, nBuf, zBuf) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @returns {number|Promise<number>}\n   */\n  xClose(pFile) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} pData \n   * @param {number} iAmt \n   * @param {number} iOffsetLo \n   * @param {number} iOffsetHi \n   * @returns {number|Promise<number>}\n   */\n  xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} pData \n   * @param {number} iAmt \n   * @param {number} iOffsetLo \n   * @param {number} iOffsetHi \n   * @returns {number|Promise<number>}\n   */\n  xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} sizeLo \n   * @param {number} sizeHi \n   * @returns {number|Promise<number>}\n   */\n  xTruncate(pFile, sizeLo, sizeHi) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} flags \n   * @returns {number|Promise<number>}\n   */\n  xSync(pFile, flags) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * \n   * @param {number} pFile \n   * @param {number} pSize \n   * @returns {number|Promise<number>}\n   */\n  xFileSize(pFile, pSize) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} lockType \n   * @returns {number|Promise<number>}\n   */\n  xLock(pFile, lockType) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} lockType \n   * @returns {number|Promise<number>}\n   */\n  xUnlock(pFile, lockType) {\n    return VFS.SQLITE_OK;\n  } \n\n  /**\n   * @param {number} pFile \n   * @param {number} pResOut \n   * @returns {number|Promise<number>}\n   */\n  xCheckReservedLock(pFile, pResOut) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} pFile \n   * @param {number} op \n   * @param {number} pArg \n   * @returns {number|Promise<number>}\n   */\n  xFileControl(pFile, op, pArg) {\n    return VFS.SQLITE_NOTFOUND;\n  }\n\n  /**\n   * @param {number} pFile \n   * @returns {number|Promise<number>}\n   */\n  xSectorSize(pFile) {\n    return DEFAULT_SECTOR_SIZE;\n  }\n\n  /**\n   * @param {number} pFile \n   * @returns {number|Promise<number>}\n   */\n  xDeviceCharacteristics(pFile) {\n    return 0;\n  }\n}\n\nexport const FILE_TYPE_MASK = [\n  VFS.SQLITE_OPEN_MAIN_DB,\n  VFS.SQLITE_OPEN_MAIN_JOURNAL,\n  VFS.SQLITE_OPEN_TEMP_DB,\n  VFS.SQLITE_OPEN_TEMP_JOURNAL,\n  VFS.SQLITE_OPEN_TRANSIENT_DB,\n  VFS.SQLITE_OPEN_SUBJOURNAL,\n  VFS.SQLITE_OPEN_SUPER_JOURNAL,\n  VFS.SQLITE_OPEN_WAL\n].reduce((mask, element) => mask | element);","// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.\nimport { FacadeVFS } from '../FacadeVFS.js';\nimport * as VFS from '../VFS.js';\n\nconst DEFAULT_TEMPORARY_FILES = 10;\nconst LOCK_NOTIFY_INTERVAL = 1000;\n\nconst DB_RELATED_FILE_SUFFIXES = ['', '-journal', '-wal'];\n\nconst finalizationRegistry = new FinalizationRegistry(releaser => releaser());\n\nclass File {\n  /** @type {string} */ path\n  /** @type {number} */ flags;\n  /** @type {FileSystemSyncAccessHandle} */ accessHandle;\n\n  /** @type {PersistentFile?} */ persistentFile;\n\n  constructor(path, flags) {\n    this.path = path;\n    this.flags = flags;\n  }\n}\n\nclass PersistentFile {\n  /** @type {FileSystemFileHandle} */ fileHandle\n  /** @type {FileSystemSyncAccessHandle} */ accessHandle = null\n\n  // The following properties are for main database files.\n\n  /** @type {boolean} */ isLockBusy = false;\n  /** @type {boolean} */ isFileLocked = false;\n  /** @type {boolean} */ isRequestInProgress = false;\n  /** @type {function} */ handleLockReleaser = null;\n\n  /** @type {BroadcastChannel} */ handleRequestChannel;\n  /** @type {boolean} */ isHandleRequested = false;\n\n  constructor(fileHandle) {\n    this.fileHandle = fileHandle;\n  }\n}\n\nexport class OPFSCoopSyncVFS extends FacadeVFS {\n  /** @type {Map<number, File>} */ mapIdToFile = new Map();\n\n  lastError = null;\n  log = null; //function(...args) { console.log(`[${contextName}]`, ...args) };\n  \n  /** @type {Map<string, PersistentFile>} */ persistentFiles = new Map();\n  /** @type {Map<string, FileSystemSyncAccessHandle>} */ boundAccessHandles = new Map();\n  /** @type {Set<FileSystemSyncAccessHandle>} */ unboundAccessHandles = new Set();\n  /** @type {Set<string>} */ accessiblePaths = new Set();\n  releaser = null;\n\n  static async create(name, module) {\n    const vfs = new OPFSCoopSyncVFS(name, module);\n    await Promise.all([\n      vfs.isReady(),\n      vfs.#initialize(DEFAULT_TEMPORARY_FILES),\n    ]);\n    return vfs;\n  }\n\n  constructor(name, module) {\n    super(name, module);\n  }\n\n  async #initialize(nTemporaryFiles) {\n    // Delete temporary directories no longer in use.\n    const root = await navigator.storage.getDirectory();\n    // @ts-ignore\n    for await (const entry of root.values()) {\n      if (entry.kind === 'directory' && entry.name.startsWith('.ahp-')) {\n        // A lock with the same name as the directory protects it from\n        // being deleted.\n        await navigator.locks.request(entry.name, { ifAvailable: true }, async lock => {\n          if (lock) {\n            this.log?.(`Deleting temporary directory ${entry.name}`);\n            await root.removeEntry(entry.name, { recursive: true });\n          } else {\n            this.log?.(`Temporary directory ${entry.name} is in use`);\n          }\n        });\n      }\n    }\n\n    // Create our temporary directory.\n    const tmpDirName = `.ahp-${Math.random().toString(36).slice(2)}`;\n    this.releaser = await new Promise(resolve => {\n      navigator.locks.request(tmpDirName, () => {\n        return new Promise(release => {\n          resolve(release);\n        });\n      });\n    });\n    finalizationRegistry.register(this, this.releaser);\n    const tmpDir = await root.getDirectoryHandle(tmpDirName, { create: true });\n\n    // Populate temporary directory.\n    for (let i = 0; i < nTemporaryFiles; i++) {\n      const tmpFile = await tmpDir.getFileHandle(`${i}.tmp`, { create: true });\n      const tmpAccessHandle = await tmpFile.createSyncAccessHandle();\n      this.unboundAccessHandles.add(tmpAccessHandle);\n    }\n  }\n\n  /**\n   * @param {string?} zName \n   * @param {number} fileId \n   * @param {number} flags \n   * @param {DataView} pOutFlags \n   * @returns {number}\n   */\n  jOpen(zName, fileId, flags, pOutFlags) {\n    try {\n      const url = new URL(zName || Math.random().toString(36).slice(2), 'file://');\n      const path = url.pathname;\n\n      if (flags & VFS.SQLITE_OPEN_MAIN_DB) {\n        const persistentFile = this.persistentFiles.get(path);\n        if (persistentFile?.isRequestInProgress) {\n          // Should not reach here unless SQLite itself retries an open.\n          // Otherwise, asynchronous operations started on a previous\n          // open try should have completed.\n          return VFS.SQLITE_BUSY;\n        } else if (!persistentFile) {\n          // This is the usual starting point for opening a database.\n          // Register a Promise that resolves when the database and related\n          // files are ready to be used.\n          this.log?.(`creating persistent file for ${path}`);\n          const create = !!(flags & VFS.SQLITE_OPEN_CREATE);\n          this._module.retryOps.push((async () => {\n            try {\n              // Get the path directory handle.\n              let dirHandle = await navigator.storage.getDirectory();\n              const directories = path.split('/').filter(d => d);\n              const filename = directories.pop();\n              for (const directory of directories) {\n                dirHandle = await dirHandle.getDirectoryHandle(directory, { create });\n              }\n\n              // Get file handles for the database and related files,\n              // and create persistent file instances.\n              for (const suffix of DB_RELATED_FILE_SUFFIXES) {\n                const fileHandle = await dirHandle.getFileHandle(filename + suffix, { create });\n                await this.#createPersistentFile(fileHandle);\n              }\n\n              // Get access handles for the files.\n              const file = new File(path, flags);\n              file.persistentFile = this.persistentFiles.get(path);\n              await this.#requestAccessHandle(file);\n            } catch (e) {\n              // Use an invalid persistent file to signal this error\n              // for the retried open.\n              const persistentFile = new PersistentFile(null);\n              this.persistentFiles.set(path, persistentFile);\n              console.error(e);\n            }\n          })());\n          return VFS.SQLITE_BUSY;\n        } else if (!persistentFile.fileHandle) {\n          // The asynchronous open operation failed.\n          this.persistentFiles.delete(path);\n          return VFS.SQLITE_CANTOPEN;\n        } else if (!persistentFile.accessHandle) {\n          // This branch is reached if the database was previously opened\n          // and closed.\n          this._module.retryOps.push((async () => {\n            const file = new File(path, flags);\n            file.persistentFile = this.persistentFiles.get(path);\n            await this.#requestAccessHandle(file);\n          })());\n          return VFS.SQLITE_BUSY;\n        }\n      }\n\n      if (!this.accessiblePaths.has(path) &&\n          !(flags & VFS.SQLITE_OPEN_CREATE)) {\n        throw new Error(`File ${path} not found`);\n      }\n\n      const file = new File(path, flags);\n      this.mapIdToFile.set(fileId, file);\n\n      if (this.persistentFiles.has(path)) {\n        file.persistentFile = this.persistentFiles.get(path);\n      } else if (this.boundAccessHandles.has(path)) {\n        // This temporary file was previously created and closed. Reopen\n        // the same access handle.\n        file.accessHandle = this.boundAccessHandles.get(path);\n      } else if (this.unboundAccessHandles.size) {\n        // Associate an unbound access handle to this file.\n        file.accessHandle = this.unboundAccessHandles.values().next().value;\n        file.accessHandle.truncate(0);\n        this.unboundAccessHandles.delete(file.accessHandle);\n        this.boundAccessHandles.set(path, file.accessHandle);\n      }\n      this.accessiblePaths.add(path);\n  \n      pOutFlags.setInt32(0, flags, true);\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_CANTOPEN;\n    }\n  }\n\n  /**\n   * @param {string} zName \n   * @param {number} syncDir \n   * @returns {number}\n   */\n  jDelete(zName, syncDir) {\n    try {\n      const url = new URL(zName, 'file://');\n      const path = url.pathname;\n      if (this.persistentFiles.has(path)) {\n        const persistentFile = this.persistentFiles.get(path);\n        persistentFile.accessHandle.truncate(0);\n      } else {\n        this.boundAccessHandles.get(path)?.truncate(0);\n      }\n      this.accessiblePaths.delete(path);\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR_DELETE;\n    }\n  }\n\n  /**\n   * @param {string} zName \n   * @param {number} flags \n   * @param {DataView} pResOut \n   * @returns {number}\n   */\n  jAccess(zName, flags, pResOut) {\n    try {\n      const url = new URL(zName, 'file://');\n      const path = url.pathname;\n      pResOut.setInt32(0, this.accessiblePaths.has(path) ? 1 : 0, true);\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR_ACCESS;\n    } \n  }\n\n  /**\n   * @param {number} fileId \n   * @returns {number}\n   */\n  jClose(fileId) {\n    try {\n      const file = this.mapIdToFile.get(fileId);\n      this.mapIdToFile.delete(fileId);\n\n      if (file?.flags & VFS.SQLITE_OPEN_MAIN_DB) {\n        if (file.persistentFile?.handleLockReleaser) {\n          this.#releaseAccessHandle(file);\n        }\n      } else if (file?.flags & VFS.SQLITE_OPEN_DELETEONCLOSE) {\n        file.accessHandle.truncate(0);\n        this.accessiblePaths.delete(file.path);\n        if (!this.persistentFiles.has(file.path)) {\n          this.boundAccessHandles.delete(file.path);\n          this.unboundAccessHandles.add(file.accessHandle);\n        }\n      }\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR_CLOSE;\n    }\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {Uint8Array} pData \n   * @param {number} iOffset\n   * @returns {number}\n   */\n  jRead(fileId, pData, iOffset) {\n    try {\n      const file = this.mapIdToFile.get(fileId);\n\n      // On Chrome (at least), passing pData to accessHandle.read() is\n      // an error because pData is a Proxy of a Uint8Array. Calling\n      // subarray() produces a real Uint8Array and that works.\n      const accessHandle = file.accessHandle || file.persistentFile.accessHandle;\n      const bytesRead = accessHandle.read(pData.subarray(), { at: iOffset });\n\n      // Opening a database file performs one read without a xLock call.\n      if ((file.flags & VFS.SQLITE_OPEN_MAIN_DB) && !file.persistentFile.isFileLocked) {\n        this.#releaseAccessHandle(file);\n      }\n\n      if (bytesRead < pData.byteLength) {\n        pData.fill(0, bytesRead);\n        return VFS.SQLITE_IOERR_SHORT_READ;\n      }\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR_READ;\n    }\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {Uint8Array} pData \n   * @param {number} iOffset\n   * @returns {number}\n   */\n  jWrite(fileId, pData, iOffset) {\n    try {\n      const file = this.mapIdToFile.get(fileId);\n\n      // On Chrome (at least), passing pData to accessHandle.write() is\n      // an error because pData is a Proxy of a Uint8Array. Calling\n      // subarray() produces a real Uint8Array and that works.\n      const accessHandle = file.accessHandle || file.persistentFile.accessHandle;\n      const nBytes = accessHandle.write(pData.subarray(), { at: iOffset });\n      if (nBytes !== pData.byteLength) throw new Error('short write');\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR_WRITE;\n    }\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} iSize \n   * @returns {number}\n   */\n  jTruncate(fileId, iSize) {\n    try {\n      const file = this.mapIdToFile.get(fileId);\n      const accessHandle = file.accessHandle || file.persistentFile.accessHandle;\n      accessHandle.truncate(iSize);\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR_TRUNCATE;\n    }\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} flags \n   * @returns {number}\n   */\n  jSync(fileId, flags) {\n    try {\n      const file = this.mapIdToFile.get(fileId);\n      const accessHandle = file.accessHandle || file.persistentFile.accessHandle;\n      accessHandle.flush();\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR_FSYNC;\n    }\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {DataView} pSize64 \n   * @returns {number}\n   */\n  jFileSize(fileId, pSize64) {\n    try {\n      const file = this.mapIdToFile.get(fileId);\n      const accessHandle = file.accessHandle || file.persistentFile.accessHandle;\n      const size = accessHandle.getSize();\n      pSize64.setBigInt64(0, BigInt(size), true);\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR_FSTAT;\n    }\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} lockType \n   * @returns {number}\n   */\n  jLock(fileId, lockType) {\n    const file = this.mapIdToFile.get(fileId);\n    if (file.persistentFile.isRequestInProgress) {\n      file.persistentFile.isLockBusy = true;\n      return VFS.SQLITE_BUSY;\n    }\n\n    file.persistentFile.isFileLocked = true;\n    if (!file.persistentFile.handleLockReleaser) {\n      // Start listening for notifications from other connections.\n      // This is before we actually get access handles, but waiting to\n      // listen until then allows a race condition where notifications\n      // are missed. \n      file.persistentFile.handleRequestChannel.onmessage = () => {\n        this.log?.(`received notification for ${file.path}`);\n        if (file.persistentFile.isFileLocked) {\n          // We're still using the access handle, so mark it to be\n          // released when we're done.\n          file.persistentFile.isHandleRequested = true;\n        } else {\n          // Release the access handles immediately.\n          this.#releaseAccessHandle(file);\n        }\n        file.persistentFile.handleRequestChannel.onmessage = null;\n      };\n\n      this.#requestAccessHandle(file);\n      this.log?.('returning SQLITE_BUSY');\n      file.persistentFile.isLockBusy = true;\n      return VFS.SQLITE_BUSY;\n    }\n    file.persistentFile.isLockBusy = false;\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} lockType \n   * @returns {number}\n   */\n  jUnlock(fileId, lockType) {\n    const file = this.mapIdToFile.get(fileId);\n    if (lockType === VFS.SQLITE_LOCK_NONE) {\n      // Don't change any state if this unlock is because xLock returned\n      // SQLITE_BUSY.\n      if (!file.persistentFile.isLockBusy) {\n        if (file.persistentFile.isHandleRequested) {\n            // Another connection wants the access handle.\n          this.#releaseAccessHandle(file);\n          file.persistentFile.isHandleRequested = false;\n        }\n        file.persistentFile.isFileLocked = false;\n      }\n    }\n    return VFS.SQLITE_OK;\n  }\n  \n  /**\n   * @param {number} fileId\n   * @param {number} op\n   * @param {DataView} pArg\n   * @returns {number|Promise<number>}\n   */\n  jFileControl(fileId, op, pArg) {\n    try {\n      const file = this.mapIdToFile.get(fileId);\n      switch (op) {\n        case VFS.SQLITE_FCNTL_PRAGMA:\n          const key = extractString(pArg, 4);\n          const value = extractString(pArg, 8);\n          this.log?.('xFileControl', file.path, 'PRAGMA', key, value);\n          switch (key.toLowerCase()) {\n            case 'journal_mode':\n              if (value &&\n                  !['off', 'memory', 'delete', 'wal'].includes(value.toLowerCase())) {\n                throw new Error('journal_mode must be \"off\", \"memory\", \"delete\", or \"wal\"');\n              }\n              break;\n          }\n          break;\n      }\n    } catch (e) {\n      this.lastError = e;\n      return VFS.SQLITE_IOERR;\n    }\n    return VFS.SQLITE_NOTFOUND;\n  }\n\n  /**\n   * @param {Uint8Array} zBuf \n   * @returns \n   */\n  jGetLastError(zBuf) {\n    if (this.lastError) {\n      console.error(this.lastError);\n      const outputArray = zBuf.subarray(0, zBuf.byteLength - 1);\n      const { written } = new TextEncoder().encodeInto(this.lastError.message, outputArray);\n      zBuf[written] = 0;\n    }\n    return VFS.SQLITE_OK\n  }\n\n  /**\n   * @param {FileSystemFileHandle} fileHandle \n   * @returns {Promise<PersistentFile>}\n   */\n  async #createPersistentFile(fileHandle) {\n    const persistentFile = new PersistentFile(fileHandle);\n    const root = await navigator.storage.getDirectory();\n    const relativePath = await root.resolve(fileHandle);\n    const path = `/${relativePath.join('/')}`;\n    persistentFile.handleRequestChannel = new BroadcastChannel(`ahp:${path}`);\n    this.persistentFiles.set(path, persistentFile);\n\n    const f = await fileHandle.getFile();\n    if (f.size) {\n      this.accessiblePaths.add(path);\n    }\n    return persistentFile;\n  }\n\n  /**\n   * @param {File} file \n   */\n  #requestAccessHandle(file) {\n    console.assert(!file.persistentFile.handleLockReleaser);\n    if (!file.persistentFile.isRequestInProgress) {\n      file.persistentFile.isRequestInProgress = true;\n      this._module.retryOps.push((async () => {\n        // Acquire the Web Lock.\n        file.persistentFile.handleLockReleaser = await this.#acquireLock(file.persistentFile);\n        try {\n          // Get access handles for the database and releated files in parallel.\n          this.log?.(`creating access handles for ${file.path}`)\n          await Promise.all(DB_RELATED_FILE_SUFFIXES.map(async suffix => {\n            const persistentFile = this.persistentFiles.get(file.path + suffix);\n            if (persistentFile) {\n              persistentFile.accessHandle =\n                await persistentFile.fileHandle.createSyncAccessHandle();\n            }\n          }));\n        } catch (e) {\n          this.log?.(`failed to create access handles for ${file.path}`, e);\n          // Close any of the potentially opened access handles\n          this.#releaseAccessHandle(file);\n          throw e;\n        } finally {\n          file.persistentFile.isRequestInProgress = false;\n        }\n      })());\n      return this._module.retryOps.at(-1);\n    }\n    return Promise.resolve();\n  }\n\n  /**\n   * @param {File} file \n   */\n  async #releaseAccessHandle(file) {\n    DB_RELATED_FILE_SUFFIXES.forEach(async suffix => {\n      const persistentFile = this.persistentFiles.get(file.path + suffix);\n      if (persistentFile) {\n        persistentFile.accessHandle?.close();\n        persistentFile.accessHandle = null;\n      }\n    });\n    this.log?.(`access handles closed for ${file.path}`)\n\n    file.persistentFile.handleLockReleaser?.();\n    file.persistentFile.handleLockReleaser = null;\n    this.log?.(`lock released for ${file.path}`)\n  }\n\n  /**\n   * @param {PersistentFile} persistentFile \n   * @returns  {Promise<function>} lock releaser\n   */\n  #acquireLock(persistentFile) {\n    return new Promise(resolve => {\n      // Tell other connections we want the access handle.\n      const lockName = persistentFile.handleRequestChannel.name;\n      const notify = () => {\n        this.log?.(`notifying for ${lockName}`);\n        persistentFile.handleRequestChannel.postMessage(null);\n      }\n      const notifyId = setInterval(notify, LOCK_NOTIFY_INTERVAL);\n      setTimeout(notify);\n\n      this.log?.(`lock requested: ${lockName}`)\n      navigator.locks.request(lockName, lock => {\n        // We have the lock. Stop asking other connections for it.\n        this.log?.(`lock acquired: ${lockName}`, lock);\n        clearInterval(notifyId);\n        return new Promise(resolve);\n      });\n    });\n  }\n}\n\nfunction extractString(dataView, offset) {\n  const p = dataView.getUint32(offset, true);\n  if (p) {\n    const chars = new Uint8Array(dataView.buffer, p);\n    return new TextDecoder().decode(chars.subarray(0, chars.indexOf(0)));\n  }\n  return null;\n}"],"names":[],"ignoreList":[],"sourceRoot":""}

package/lib/package.json

@@ -1,11 +1,13 @@
 {
     "name": "@powersync/web",
-    "version": "1.29.1",
-    "description": "PowerSync web SDK. Sync Postgres, MongoDB or MySQL with SQLite in your web app",
+    "version": "1.31.0",
+    "description": "PowerSync Web SDK",
     "main": "lib/src/index.js",
+    "module": "lib/src/index.js",
+    "type": "module",
     "types": "lib/src/index.d.ts",
     "bin": {
-        "powersync-web": "bin/powersync.js"
+        "powersync-web": "bin/powersync.cjs"
     },
     "files": [
         "bin",
@@ -15,21 +17,23 @@
         "src"
     ],
     "exports": {
-        ".": "./lib/src/index.js",
+        ".": {
+            "types": "./lib/src/index.d.ts",
+            "default": "./lib/src/index.js"
+        },
         "./umd": {
-            "import": "./dist/index.umd.js",
-            "require": "./dist/index.umd.js",
-            "types": "./lib/src/index.d.ts"
+            "types": "./lib/src/index.d.ts",
+            "default": "./dist/index.umd.js"
         },
         "./umd/worker/db": {
+            "types": "./lib/src/index.d.ts",
             "import": "./dist/worker/WASQLiteDB.umd.js",
-            "require": "./dist/worker/WASQLiteDB.umd.js",
-            "types": "./lib/src/index.d.ts"
+            "require": "./dist/worker/WASQLiteDB.umd.js"
         },
         "./umd/worker/sync": {
+            "types": "./lib/src/index.d.ts",
             "import": "./dist/worker/SharedSyncImplementation.umd.js",
-            "require": "./dist/worker/SharedSyncImplementation.umd.js",
-            "types": "./lib/src/index.d.ts"
+            "require": "./dist/worker/SharedSyncImplementation.umd.js"
         }
     },
     "repository": "https://github.com/powersync-ja/powersync-js",
@@ -49,7 +53,8 @@
         "build:prod": "pnpm run build:tsc --sourceMap false && pnpm run build:webpack-main && pnpm run build:webpack-workers",
         "clean": "rm -rf lib dist tsconfig.tsbuildinfo",
         "watch": "tsc --build -w",
-        "test": "pnpm build && vitest"
+        "test": "pnpm build && vitest",
+        "test:exports": "attw --pack . --entrypoints . --profile=esm-only "
     },
     "keywords": [
         "data sync",
@@ -61,8 +66,8 @@
     "author": "JOURNEYAPPS",
     "license": "Apache-2.0",
     "peerDependencies": {
-        "@journeyapps/wa-sqlite": "^1.3.4",
-        "@powersync/common": "workspace:^1.43.1"
+        "@journeyapps/wa-sqlite": "^1.4.1",
+        "@powersync/common": "workspace:^1.45.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",
@@ -72,7 +77,7 @@
         "commander": "^12.1.0"
     },
     "devDependencies": {
-        "@journeyapps/wa-sqlite": "^1.3.4",
+        "@journeyapps/wa-sqlite": "^1.4.1",
         "@types/uuid": "^9.0.6",
         "crypto-browserify": "^3.12.0",
         "p-defer": "^4.0.1",

package/lib/src/db/PowerSyncDatabase.d.ts

@@ -1,6 +1,6 @@
 import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, StreamingSyncImplementation, type BucketStorageAdapter, type PowerSyncBackendConnector, type PowerSyncCloseOptions, type RequiredAdditionalConnectionOptions } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { ResolvedWebSQLOpenOptions, WebSQLFlags } from './adapters/web-sql-flags';
+import { ResolvedWebSQLOpenOptions, WebSQLFlags } from './adapters/web-sql-flags.js';
 export interface WebPowerSyncFlags extends WebSQLFlags {
     /**
      * Externally unload open PowerSync database instances when the window closes.
@@ -69,6 +69,8 @@ export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
      * multiple tabs are not enabled.
      */
     close(options?: PowerSyncCloseOptions): Promise<void>;
+    protected loadVersion(): Promise<void>;
+    protected resolveOfflineSyncStatus(): Promise<void>;
     protected generateBucketStorageAdapter(): BucketStorageAdapter;
     protected runExclusive<T>(cb: () => Promise<T>): Promise<T>;
     protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: RequiredAdditionalConnectionOptions): StreamingSyncImplementation;

package/lib/src/db/PowerSyncDatabase.js

@@ -1,12 +1,12 @@
 import { AbstractPowerSyncDatabase, SqliteBucketStorage, isDBAdapter, isSQLOpenFactory } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { getNavigatorLocks } from '../shared/navigator';
-import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory';
-import { DEFAULT_WEB_SQL_FLAGS, resolveWebSQLFlags } from './adapters/web-sql-flags';
-import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation';
-import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation';
-import { WebRemote } from './sync/WebRemote';
-import { WebStreamingSyncImplementation } from './sync/WebStreamingSyncImplementation';
+import { getNavigatorLocks } from '../shared/navigator.js';
+import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory.js';
+import { DEFAULT_WEB_SQL_FLAGS, isServerSide, resolveWebSQLFlags } from './adapters/web-sql-flags.js';
+import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation.js';
+import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation.js';
+import { WebRemote } from './sync/WebRemote.js';
+import { WebStreamingSyncImplementation } from './sync/WebStreamingSyncImplementation.js';
 export const DEFAULT_POWERSYNC_FLAGS = {
     ...DEFAULT_WEB_SQL_FLAGS,
     externallyUnload: false
@@ -81,6 +81,18 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
             disconnect: options?.disconnect ?? !this.resolvedFlags.enableMultiTabs
         });
     }
+    async loadVersion() {
+        if (isServerSide()) {
+            return;
+        }
+        return super.loadVersion();
+    }
+    async resolveOfflineSyncStatus() {
+        if (isServerSide()) {
+            return;
+        }
+        return super.resolveOfflineSyncStatus();
+    }
     generateBucketStorageAdapter() {
         return new SqliteBucketStorage(this.database);
     }

package/lib/src/db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.d.ts

@@ -1,5 +1,5 @@
 import { AbstractPowerSyncDatabase, AbstractPowerSyncDatabaseOpenFactory, PowerSyncDatabaseOptions, PowerSyncOpenFactoryOptions } from '@powersync/common';
-import { WebPowerSyncDatabaseOptions, WebPowerSyncFlags } from '../../db/PowerSyncDatabase';
+import { WebPowerSyncDatabaseOptions, WebPowerSyncFlags } from '../../db/PowerSyncDatabase.js';
 /**
  * {@link WebPowerSyncFlags}
  * Maintaining export for consistency with API from previous versions

package/lib/src/db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js

@@ -1,5 +1,5 @@
 import { AbstractPowerSyncDatabaseOpenFactory } from '@powersync/common';
-import { PowerSyncDatabase, resolveWebPowerSyncFlags } from '../../db/PowerSyncDatabase';
+import { PowerSyncDatabase, resolveWebPowerSyncFlags } from '../../db/PowerSyncDatabase.js';
 /**
  * Intermediate PowerSync Database Open factory for Web which uses a mock
  * SSR DB Adapter if running on server side.

package/lib/src/db/adapters/AbstractWebSQLOpenFactory.d.ts

@@ -1,5 +1,5 @@
-import { type ILogger, DBAdapter, SQLOpenFactory } from '@powersync/common';
-import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions } from './web-sql-flags';
+import { DBAdapter, type ILogger, SQLOpenFactory } from '@powersync/common';
+import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions } from './web-sql-flags.js';
 export declare abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
     protected options: WebSQLOpenFactoryOptions;
     protected resolvedFlags: ResolvedWebSQLFlags;

package/lib/src/db/adapters/AbstractWebSQLOpenFactory.js

@@ -1,6 +1,6 @@
 import { createLogger } from '@powersync/common';
-import { SSRDBAdapter } from './SSRDBAdapter';
-import { isServerSide, resolveWebSQLFlags } from './web-sql-flags';
+import { SSRDBAdapter } from './SSRDBAdapter.js';
+import { isServerSide, resolveWebSQLFlags } from './web-sql-flags.js';
 export class AbstractWebSQLOpenFactory {
     options;
     resolvedFlags;

package/lib/src/db/adapters/AsyncDatabaseConnection.d.ts

@@ -1,5 +1,5 @@
 import { BatchedUpdateNotification, QueryResult } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 /**
  * @internal
  * Proxied query result does not contain a function for accessing row values
@@ -14,14 +14,6 @@ export type ProxiedQueryResult = Omit<QueryResult, 'rows'> & {
  * @internal
  */
 export type OnTableChangeCallback = (event: BatchedUpdateNotification) => void;
-/**
- * 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.
- */
-export declare class ConnectionClosedError extends Error {
-    constructor(message: string);
-}
 /**
  * @internal
  * An async Database connection which provides basic async SQL methods.

package/lib/src/db/adapters/AsyncDatabaseConnection.js

@@ -1,11 +1 @@
-/**
- * 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.
- */
-export class ConnectionClosedError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ConnectionClosedError';
-    }
-}
+export {};

package/lib/src/db/adapters/LockedAsyncDatabaseAdapter.d.ts

@@ -1,7 +1,7 @@
 import { BaseObserver, DBAdapterListener, DBLockOptions, LockContext, QueryResult, Transaction, type ILogger } from '@powersync/common';
-import { AsyncDatabaseConnection } from './AsyncDatabaseConnection';
-import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { AsyncDatabaseConnection } from './AsyncDatabaseConnection.js';
+import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter.js';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 /**
  * @internal
  */

package/lib/src/db/adapters/LockedAsyncDatabaseAdapter.js

@@ -1,8 +1,7 @@
-import { BaseObserver, createLogger } from '@powersync/common';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { ConnectionClosedError } from './AsyncDatabaseConnection';
-import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
-import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
+import { BaseObserver, ConnectionClosedError, createLogger } from '@powersync/common';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection.js';
+import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection.js';
 /**
  * @internal
  * Wraps a {@link AsyncDatabaseConnection} and provides exclusive locking functions in
@@ -179,7 +178,14 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
      */
     async close() {
         this.closing = true;
-        this._disposeTableChangeListener?.();
+        /**
+         * Note that we obtain a reference to the callback to avoid calling the callback with `this` as the context.
+         * This is to avoid Comlink attempting to clone `this` when calling the method.
+         */
+        const dispose = this._disposeTableChangeListener;
+        if (dispose) {
+            dispose();
+        }
         this.pendingAbortControllers.forEach((controller) => controller.abort('Closed'));
         await this.baseDB?.close?.();
         this.closed = true;
@@ -231,23 +237,30 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     }
     async acquireLock(callback, options) {
         await this.waitForInitialized();
+        // The database is being opened in the background. Wait for it here.
+        if (this.databaseOpenPromise) {
+            await this.databaseOpenPromise;
+        }
         return this._acquireLock(async () => {
             let holdId = null;
             try {
-                // The database is being opened in the background. Wait for it here.
-                if (this.databaseOpenPromise) {
-                    /**
-                     * We can't await this since it uses the same lock as we're in now.
-                     */
+                /**
+                 * We can't await this since it uses the same lock as we're in now.
+                 * If there is a pending open, this call will throw.
+                 * If there is no pending open, but there is also no database - the open
+                 * might have failed. We need to re-open the database.
+                 */
+                if (this.databaseOpenPromise || !this._db) {
                     throw new ConnectionClosedError('Connection is busy re-opening');
                 }
                 holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
                 return await callback();
             }
             catch (ex) {
-                if (ex instanceof ConnectionClosedError || (ex instanceof Error && ex.name === 'NoModificationAllowedError')) {
+                if (ConnectionClosedError.MATCHES(ex)) {
                     if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
                         // Immediately re-open the database. We need to miss as little table updates as possible.
+                        // Note, don't await this since it uses the same lock as we're in now.
                         this.reOpenInternalDB();
                     }
                 }

package/lib/src/db/adapters/WebDBAdapter.d.ts

@@ -1,5 +1,5 @@
 import { DBAdapter } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 export type SharedConnectionWorker = {
     identifier: string;
     port: MessagePort;

package/lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.d.ts

@@ -1,7 +1,7 @@
 import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { AsyncDatabaseConnection, OnTableChangeCallback, OpenAsyncDatabaseConnection, ProxiedQueryResult } from './AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { AsyncDatabaseConnection, OnTableChangeCallback, OpenAsyncDatabaseConnection, ProxiedQueryResult } from './AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 export type SharedConnectionWorker = {
     identifier: string;
     port: MessagePort;

package/lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js

@@ -1,6 +1,5 @@
-import { BaseObserver } from '@powersync/common';
+import { BaseObserver, ConnectionClosedError } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { ConnectionClosedError } from './AsyncDatabaseConnection';
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.

package/lib/src/db/adapters/wa-sqlite/WASQLiteConnection.d.ts

@@ -1,8 +1,8 @@
 import * as SQLite from '@journeyapps/wa-sqlite';
 import { BaseObserver, BatchedUpdateNotification } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection';
-import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory';
+import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
 /**
  * List of currently tested virtual filesystems
  */

package/lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js

@@ -1,7 +1,6 @@
 import * as SQLite from '@journeyapps/wa-sqlite';
 import { BaseObserver } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { OPFSCoopSyncVFS } from '../../../worker/db/opfs';
 /**
  * List of currently tested virtual filesystems
  */
@@ -81,10 +80,12 @@ export const DEFAULT_MODULE_FACTORIES = {
         else {
             module = await SyncWASQLiteModuleFactory();
         }
+        // @ts-expect-error The types for this static method are missing upstream
+        const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
         const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
         return {
             module,
-            vfs: vfs
+            vfs
         };
     }
 };
@@ -310,7 +311,15 @@ export class WASqliteConnection extends BaseObserver {
     }
     async close() {
         this.broadcastChannel?.close();
-        await this.sqliteAPI.close(this.dbP);
+        await this.acquireExecuteLock(async () => {
+            /**
+             * Running the close operation inside the same execute mutex prevents errors like:
+             * ```
+             * unable to close due to unfinalized statements or unfinished backups
+             * ```
+             */
+            await this.sqliteAPI.close(this.dbP);
+        });
     }
     async registerOnTableChange(callback) {
         return this.registerListener({

package/lib/src/db/adapters/wa-sqlite/WASQLiteDBAdapter.d.ts

@@ -1,7 +1,7 @@
 import { type PowerSyncOpenFactoryOptions } from '@powersync/common';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { ResolvedWebSQLOpenOptions, TemporaryStorageOption, WebSQLFlags } from '../web-sql-flags';
-import { WASQLiteVFS } from './WASQLiteConnection';
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { ResolvedWebSQLOpenOptions, TemporaryStorageOption, WebSQLFlags } from '../web-sql-flags.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
 /**
  * These flags are the same as {@link WebSQLFlags}.
  * This export is maintained only for API consistency

package/lib/src/db/adapters/wa-sqlite/WASQLiteDBAdapter.js

@@ -1,9 +1,9 @@
 import * as Comlink from 'comlink';
-import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase.js';
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 /**
  * Adapter for WA-SQLite SQLite connections.
  */

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.d.ts

@@ -1,8 +1,8 @@
 import { DBAdapter, type ILogLevel } from '@powersync/common';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
-import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags';
-import { WASQLiteVFS } from './WASQLiteConnection';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
     vfs?: WASQLiteVFS;
 }

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.js

@@ -1,10 +1,10 @@
 import * as Comlink from 'comlink';
-import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags';
-import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
+import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
 /**
  * Opens a SQLite connection using WA-SQLite.
  */

package/lib/src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.d.ts

@@ -1,5 +1,5 @@
 import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions } from '@powersync/common';
-import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
 /**
  * @deprecated {@link PowerSyncDatabase} can now be constructed directly
  * @example

package/lib/src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js

@@ -1,6 +1,6 @@
-import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase';
-import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase.js';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 /**
  * @deprecated {@link PowerSyncDatabase} can now be constructed directly
  * @example

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.d.ts

@@ -1,9 +1,9 @@
 import { PowerSyncConnectionOptions, PowerSyncCredentials, SubscribedStream, SyncStatusOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { WorkerClient } from '../../worker/sync/WorkerClient';
-import { WebDBAdapter } from '../adapters/WebDBAdapter';
-import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
+import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider.js';
+import { WorkerClient } from '../../worker/sync/WorkerClient.js';
+import { WebDBAdapter } from '../adapters/WebDBAdapter.js';
+import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation.js';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.js

@@ -1,9 +1,9 @@
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags';
-import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider.js';
+import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation.js';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags.js';
+import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation.js';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.