@powersync/web 1.6.0 → 1.8.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"worker/node_modules_journeyapps_wa-sqlite_src_examples_IDBBatchAtomicVFS_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;;;;;;;;;;;;;;;;;AC3KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC52BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AC3PA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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/VFS.js","webpack://sdk_web/../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js","webpack://sdk_web/../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBContext.js","webpack://sdk_web/../../node_modules/@journeyapps/wa-sqlite/src/examples/WebLocks.js"],"sourcesContent":["// Copyright 2022 Roy T. Hashimoto. All Rights Reserved.\nimport * as VFS from './sqlite-constants.js';\nexport * from './sqlite-constants.js';\n\n// Base class for a VFS.\nexport class Base {\n  mxPathName = 64;\n\n  /**\n   * @param {number} fileId \n   * @returns {number}\n   */\n  xClose(fileId) {\n    return VFS.SQLITE_IOERR;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {Uint8Array} pData \n   * @param {number} iOffset\n   * @returns {number}\n   */\n  xRead(fileId, pData, iOffset) {\n    return VFS.SQLITE_IOERR;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {Uint8Array} pData \n   * @param {number} iOffset\n   * @returns {number}\n   */\n  xWrite(fileId, pData, iOffset) {\n    return VFS.SQLITE_IOERR;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} iSize \n   * @returns {number}\n   */\n  xTruncate(fileId, iSize) {\n    return VFS.SQLITE_IOERR;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {*} flags \n   * @returns {number}\n   */\n  xSync(fileId, flags) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {DataView} pSize64 \n   * @returns {number}\n   */\n  xFileSize(fileId, pSize64) {\n    return VFS.SQLITE_IOERR;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} flags \n   * @returns {number}\n   */\n  xLock(fileId, flags) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} flags \n   * @returns {number}\n   */\n  xUnlock(fileId, flags) {\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {DataView} pResOut \n   * @returns {number}\n   */\n  xCheckReservedLock(fileId, pResOut) {\n    pResOut.setInt32(0, 0, true);\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} op \n   * @param {DataView} pArg \n   * @returns {number}\n   */\n  xFileControl(fileId, op, pArg) {\n    return VFS.SQLITE_NOTFOUND;\n  }\n\n  /**\n   * @param {number} fileId \n   * @returns {number}\n   */\n  xSectorSize(fileId) {\n    return 512;\n  }\n\n  /**\n   * @param {number} fileId \n   * @returns {number}\n   */\n  xDeviceCharacteristics(fileId) {\n    return 0;\n  }\n\n  /**\n   * @param {string?} name \n   * @param {number} fileId \n   * @param {number} flags \n   * @param {DataView} pOutFlags \n   * @returns {number}\n   */\n  xOpen(name, fileId, flags, pOutFlags) {\n    return VFS.SQLITE_CANTOPEN;\n  }\n\n  /**\n   * @param {string} name \n   * @param {number} syncDir \n   * @returns {number}\n   */\n  xDelete(name, syncDir) {\n    return VFS.SQLITE_IOERR;\n  }\n\n  /**\n   * @param {string} name \n   * @param {number} flags \n   * @param {DataView} pResOut \n   * @returns {number}\n   */\n  xAccess(name, flags, pResOut) {\n    return VFS.SQLITE_IOERR;\n  }\n\n  /**\n   * Handle asynchronous operation. This implementation will be overriden on\n   * registration by an Asyncify build.\n   * @param {function(): Promise<number>} f \n   * @returns {number}\n   */\n  handleAsync(f) {\n    // This default implementation deliberately does not match the\n    // declared signature. It will be used in testing VFS classes\n    // separately from SQLite. This will work acceptably for methods\n    // that simply return the handleAsync() result without using it.\n    // @ts-ignore\n    return f();\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].reduce((mask, element) => mask | element);","// Copyright 2022 Roy T. Hashimoto. All Rights Reserved.\nimport * as VFS from '../VFS.js';\nimport { WebLocksExclusive as WebLocks } from './WebLocks.js';\nimport { IDBContext } from './IDBContext.js';\n\nconst SECTOR_SIZE = 512;\nconst MAX_TASK_MILLIS = 3000;\n\n/**\n * @typedef VFSOptions\n * @property {\"default\"|\"strict\"|\"relaxed\"} [durability]\n * @property {\"deferred\"|\"manual\"} [purge]\n * @property {number} [purgeAtLeast]\n */\n\n/** @type {VFSOptions} */\nconst DEFAULT_OPTIONS = {\n  durability: \"default\",\n  purge: \"deferred\",\n  purgeAtLeast: 16\n};\n\nfunction log(...args) {\n  // console.debug(...args);\n}\n\n/**\n * @typedef FileBlock IndexedDB object with key [path, offset, version]\n * @property {string} path\n * @property {number} offset negative of position in file\n * @property {number} version\n * @property {Uint8Array} data\n *\n * @property {number} [fileSize] Only present on block 0\n*/\n\n/**\n * @typedef OpenedFileEntry\n * @property {string} path\n * @property {number} flags\n * @property {FileBlock} block0\n * @property {boolean} isMetadataChanged\n * @property {WebLocks} locks\n * \n * @property {Set<number>} [changedPages]\n * @property {boolean} [overwrite]\n */\n\n// This sample VFS stores optionally versioned writes to IndexedDB, which\n// it uses with the SQLite xFileControl() batch atomic write feature.\nexport class IDBBatchAtomicVFS extends VFS.Base {\n  #options;\n  /** @type {Map<number, OpenedFileEntry>} */ #mapIdToFile = new Map();\n\n  /** @type {IDBContext} */ #idb;\n  /** @type {Set<string>} */ #pendingPurges = new Set();\n\n  #taskTimestamp = performance.now();\n  #pendingAsync = new Set();\n\n  // Asyncify can grow WebAssembly memory during an asynchronous call.\n  // If this happens, then any array buffer arguments will be detached.\n  // The workaround is when finding a detached buffer, set this handler\n  // function to process the new buffer outside handlerAsync().\n  #growthHandler = null;\n\n  constructor(idbDatabaseName = 'wa-sqlite', options = DEFAULT_OPTIONS) {\n    super();\n    this.name = idbDatabaseName;\n    this.#options = Object.assign({}, DEFAULT_OPTIONS, options);\n    this.#idb = new IDBContext(openDatabase(idbDatabaseName), {\n      durability: this.#options.durability\n    });\n  }\n\n  async close() {\n    for (const fileId of this.#mapIdToFile.keys()) {\n      await this.xClose(fileId);\n    }\n\n    await this.#idb?.close();\n    this.#idb = null;\n  }\n\n  /**\n   * @param {string?} name \n   * @param {number} fileId \n   * @param {number} flags \n   * @param {DataView} pOutFlags \n   * @returns {number}\n   */\n  xOpen(name, fileId, flags, pOutFlags) {\n    const result = this.handleAsync(async () => {\n      if (name === null) name = `null_${fileId}`;\n      log(`xOpen ${name} 0x${fileId.toString(16)} 0x${flags.toString(16)}`);\n\n      try {\n        // Filenames can be URLs, possibly with query parameters.\n        const url = new URL(name, 'http://localhost/');\n        /** @type {OpenedFileEntry} */ const file = {\n          path: url.pathname,\n          flags,\n          block0: null,\n          isMetadataChanged: true,\n          locks: new WebLocks(url.pathname)\n        };\n        this.#mapIdToFile.set(fileId, file);\n\n        // Read the first block, which also contains the file metadata.\n        await this.#idb.run('readwrite', async ({blocks}) => {\n          file.block0 = await blocks.get(this.#bound(file, 0));\n          if (!file.block0) {\n            if (flags & VFS.SQLITE_OPEN_CREATE) {\n              file.block0 = {\n                path: file.path,\n                offset: 0,\n                version: 0,\n                data: new Uint8Array(0),\n                fileSize: 0\n              };\n              blocks.put(file.block0);\n            } else {\n              throw new Error(`file not found: ${file.path}`);\n            }\n          }\n        });\n\n        // @ts-ignore\n        if (pOutFlags.buffer.detached || !pOutFlags.buffer.byteLength) {\n          pOutFlags = new DataView(new ArrayBuffer(4));\n          this.#growthHandler = (pOutFlagsNew) => {\n            pOutFlagsNew.setInt32(0, pOutFlags.getInt32(0, true), true);\n          };\n        }\n        pOutFlags.setInt32(0, flags & VFS.SQLITE_OPEN_READONLY, true);\n        return VFS.SQLITE_OK;\n      } catch (e) {\n        console.error(e);\n        return VFS.SQLITE_CANTOPEN;\n      }\n    });\n\n    this.#growthHandler?.(pOutFlags);\n    this.#growthHandler = null;\n    return result;\n  }\n\n  /**\n   * @param {number} fileId \n   * @returns {number}\n   */\n  xClose(fileId) {\n    return this.handleAsync(async () => {\n      try {\n        const file = this.#mapIdToFile.get(fileId);\n        if (file) {\n          log(`xClose ${file.path}`);\n\n          this.#mapIdToFile.delete(fileId);\n          if (file.flags & VFS.SQLITE_OPEN_DELETEONCLOSE) {\n            this.#idb.run('readwrite', ({blocks}) => {\n              blocks.delete(IDBKeyRange.bound([file.path], [file.path, []]));\n            });\n          }\n        }\n        return VFS.SQLITE_OK;\n      } catch (e) {\n        console.error(e);\n        return VFS.SQLITE_IOERR;\n      }\n    });\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {Uint8Array} pData \n   * @param {number} iOffset\n   * @returns {number}\n   */\n  xRead(fileId, pData, iOffset) {\n    const byteLength = pData.byteLength;\n    const result = this.handleAsync(async () => {\n      const file = this.#mapIdToFile.get(fileId);\n      log(`xRead ${file.path} ${pData.byteLength} ${iOffset}`);\n\n      try {\n        // Read as many blocks as necessary to satisfy the read request.\n        // Usually a read fits within a single write but there is at least\n        // one case - rollback after journal spill - where reads cross\n        // write boundaries so we have to allow for that.\n        const result = await this.#idb.run('readonly', async ({blocks}) => {\n          // @ts-ignore\n          if (pData.buffer.detached || !pData.buffer.byteLength) {\n            // WebAssembly memory has grown, invalidating our buffer. Use\n            // a temporary buffer and copy after this asynchronous call\n            // completes.\n            pData = new Uint8Array(byteLength);\n            this.#growthHandler = (pDataNew) => pDataNew.set(pData);\n          }\n\n          let pDataOffset = 0;\n          while (pDataOffset < pData.byteLength) {\n            // Fetch the IndexedDB block for this file location.\n            const fileOffset = iOffset + pDataOffset;\n            /** @type {FileBlock} */\n            const block = fileOffset < file.block0.data.byteLength ?\n              file.block0 :\n              await blocks.get(this.#bound(file, -fileOffset));\n\n            if (!block || block.data.byteLength - block.offset <= fileOffset) {\n              pData.fill(0, pDataOffset);\n              return VFS.SQLITE_IOERR_SHORT_READ;\n            }\n\n            const buffer = pData.subarray(pDataOffset);\n            const blockOffset = fileOffset + block.offset;\n            const nBytesToCopy = Math.min(\n              Math.max(block.data.byteLength - blockOffset, 0), // source bytes\n              buffer.byteLength);                               // destination bytes\n            buffer.set(block.data.subarray(blockOffset, blockOffset + nBytesToCopy));\n            pDataOffset += nBytesToCopy;\n          }\n          return VFS.SQLITE_OK;\n        });\n        return result;\n      } catch (e) {\n        console.error(e);\n        return VFS.SQLITE_IOERR;\n      }\n    });\n\n    this.#growthHandler?.(pData);\n    this.#growthHandler = null;\n    return result;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {Uint8Array} pData \n   * @param {number} iOffset\n   * @returns {number}\n   */\n  xWrite(fileId, pData, iOffset) {\n    // Handle asynchronously every MAX_TASK_MILLIS milliseconds. This is\n    // tricky because Asyncify calls asynchronous methods twice: once\n    // to initiate the call and unwinds the stack, then rewinds the\n    // stack and calls again to retrieve the completed result.\n    const rewound = this.#pendingAsync.has(fileId);\n    if (rewound || performance.now() - this.#taskTimestamp > MAX_TASK_MILLIS) {\n      const result = this.handleAsync(async () => {\n        if (this.handleAsync !== super.handleAsync) {\n          this.#pendingAsync.add(fileId);\n        }\n        await new Promise(resolve => setTimeout(resolve));\n\n        const result = this.#xWriteHelper(fileId, pData.slice(), iOffset);\n        this.#taskTimestamp = performance.now();\n        return result;\n      });\n\n      if (rewound) this.#pendingAsync.delete(fileId);\n      return result;\n    }\n    return this.#xWriteHelper(fileId, pData, iOffset);\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {Uint8Array} pData \n   * @param {number} iOffset\n   * @returns {number}\n   */\n  #xWriteHelper(fileId, pData, iOffset) {\n    const file = this.#mapIdToFile.get(fileId);\n    log(`xWrite ${file.path} ${pData.byteLength} ${iOffset}`);\n\n    try {\n      // Update file size if appending.\n      const prevFileSize = file.block0.fileSize;\n      if (file.block0.fileSize < iOffset + pData.byteLength) {\n        file.block0.fileSize = iOffset + pData.byteLength;\n        file.isMetadataChanged = true;\n      }\n\n      // Convert the write directly into an IndexedDB object. Our assumption\n      // is that SQLite will only overwrite data with an xWrite of the same\n      // offset and size unless the database page size changes, except when\n      // changing database page size which is handled by #reblockIfNeeded().\n      const block = iOffset === 0 ? file.block0 : {\n        path: file.path,\n        offset: -iOffset,\n        version: file.block0.version,\n        data: null\n      };\n      block.data = pData.slice();\n\n      if (file.changedPages) {\n        // This write is part of a batch atomic write. All writes in the\n        // batch have a new version, so update the changed list to allow\n        // old versions to be eventually deleted.\n        if (prevFileSize === file.block0.fileSize) {\n          file.changedPages.add(-iOffset);\n        }\n\n        // Defer writing block 0 to IndexedDB until batch commit.\n        if (iOffset !== 0) {\n          this.#idb.run('readwrite', ({blocks}) => blocks.put(block));\n        }\n      } else {\n        // Not a batch atomic write so write through.\n        this.#idb.run('readwrite', ({blocks}) => blocks.put(block));\n      }\n\n      // Clear dirty flag if page 0 was written.\n      file.isMetadataChanged = iOffset === 0 ? false : file.isMetadataChanged;\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      console.error(e);\n      return VFS.SQLITE_IOERR;\n    }\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} iSize \n   * @returns {number}\n   */\n  xTruncate(fileId, iSize) {\n    const file = this.#mapIdToFile.get(fileId);\n    log(`xTruncate ${file.path} ${iSize}`);\n\n    try {\n      Object.assign(file.block0, {\n        fileSize: iSize,\n        data: file.block0.data.slice(0, iSize)\n      });\n\n      // Delete all blocks beyond the file size and update metadata.\n      // This is never called within a transaction.\n      const block0 = Object.assign({}, file.block0);\n      this.#idb.run('readwrite', ({blocks})=> {\n        blocks.delete(this.#bound(file, -Infinity, -iSize));\n        blocks.put(block0);\n      });\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      console.error(e);\n      return VFS.SQLITE_IOERR;\n    }\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} flags \n   * @returns {number}\n   */\n  xSync(fileId, flags) {\n    // Skip IndexedDB sync if durability is relaxed and the last\n    // sync was recent enough.\n    const rewound = this.#pendingAsync.has(fileId);\n    if (rewound || this.#options.durability !== 'relaxed' ||\n        performance.now() - this.#taskTimestamp > MAX_TASK_MILLIS) {\n      const result = this.handleAsync(async () => {\n        if (this.handleAsync !== super.handleAsync) {\n          this.#pendingAsync.add(fileId);\n        }\n\n        const result = await this.#xSyncHelper(fileId, flags);\n        this.#taskTimestamp = performance.now();\n        return result;\n      });\n\n      if (rewound) this.#pendingAsync.delete(fileId);\n      return result;\n    }\n\n    const file = this.#mapIdToFile.get(fileId);\n    log(`xSync ${file.path} ${flags}`);\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} flags \n   * @returns {Promise<number>}\n   */\n  async #xSyncHelper(fileId, flags) {\n    const file = this.#mapIdToFile.get(fileId);\n    log(`xSync ${file.path} ${flags}`);\n    try {\n      if (file.isMetadataChanged) {\n        // Metadata has changed so write block 0 to IndexedDB.\n        this.#idb.run('readwrite', async ({blocks}) => {\n          await blocks.put(file.block0);\n        }); \n        file.isMetadataChanged = false;\n      }\n      await this.#idb.sync();\n    } catch (e) {\n      console.error(e);\n      return VFS.SQLITE_IOERR;\n    }\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {DataView} pSize64 \n   * @returns {number}\n   */\n  xFileSize(fileId, pSize64) {\n    const file = this.#mapIdToFile.get(fileId);\n    log(`xFileSize ${file.path}`);\n\n    pSize64.setBigInt64(0, BigInt(file.block0.fileSize), true)\n    return VFS.SQLITE_OK;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} flags \n   * @returns {number}\n   */\n  xLock(fileId, flags) {\n    return this.handleAsync(async () => {\n      const file = this.#mapIdToFile.get(fileId);\n      log(`xLock ${file.path} ${flags}`);\n\n      try {\n        // Acquire the lock.\n        const result = await file.locks.lock(flags);\n        if (result === VFS.SQLITE_OK && file.locks.state === VFS.SQLITE_LOCK_SHARED) {\n          // Update block 0 in case another connection changed it.\n          file.block0 = await this.#idb.run('readonly', ({blocks}) => {\n            return blocks.get(this.#bound(file, 0));\n          });\n        }\n        return result;\n      } catch (e) {\n        console.error(e);\n        return VFS.SQLITE_IOERR;\n      }\n    });\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} flags \n   * @returns {number}\n   */\n  xUnlock(fileId, flags) {\n    return this.handleAsync(async () => {\n      const file = this.#mapIdToFile.get(fileId);\n      log(`xUnlock ${file.path} ${flags}`);\n      \n      try {\n        return file.locks.unlock(flags);\n      } catch(e) {\n        console.error(e);\n        return VFS.SQLITE_IOERR;\n      }\n    });\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {DataView} pResOut \n   * @returns {number}\n   */\n  xCheckReservedLock(fileId, pResOut) {\n    const result = this.handleAsync(async () => {\n      const file = this.#mapIdToFile.get(fileId);\n      log(`xCheckReservedLock ${file.path}`);\n\n      const isReserved = await file.locks.isSomewhereReserved();\n      function setOutput(pResOut) {\n      };\n\n      // @ts-ignore\n      if (pResOut.buffer.detached || !pResOut.buffer.byteLength) {\n        pResOut = new DataView(new ArrayBuffer(4));\n        this.#growthHandler = (pResOutNew) => {\n          pResOutNew.setInt32(0, pResOut.getInt32(0, true), true);\n        };\n      }\n      pResOut.setInt32(0, isReserved ? 1 : 0, true);\n      return VFS.SQLITE_OK;\n    });\n\n    this.#growthHandler?.(pResOut);\n    this.#growthHandler = null;\n    return result;\n  }\n\n  /**\n   * @param {number} fileId \n   * @returns {number}\n   */\n  xSectorSize(fileId) {\n    log('xSectorSize');\n    return SECTOR_SIZE;\n  }\n\n  /**\n   * @param {number} fileId \n   * @returns {number}\n   */\n  xDeviceCharacteristics(fileId) {\n    log('xDeviceCharacteristics');\n    return VFS.SQLITE_IOCAP_BATCH_ATOMIC |\n           VFS.SQLITE_IOCAP_SAFE_APPEND |\n           VFS.SQLITE_IOCAP_SEQUENTIAL |\n           VFS.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;\n  }\n\n  /**\n   * @param {number} fileId \n   * @param {number} op \n   * @param {DataView} pArg \n   * @returns {number}\n   */\n  xFileControl(fileId, op, pArg) {\n    const file = this.#mapIdToFile.get(fileId);\n    log(`xFileControl ${file.path} ${op}`);\n\n    switch (op) {\n      case 11: //SQLITE_FCNTL_OVERWRITE\n        // This called on VACUUM. Set a flag so we know whether to check\n        // later if the page size changed.\n        file.overwrite = true;\n        return VFS.SQLITE_OK;\n\n      case 21: // SQLITE_FCNTL_SYNC\n        // This is called at the end of each database transaction, whether\n        // it is batch atomic or not. Handle page size changes here.\n        if (file.overwrite) {\n          // As an optimization we only check for and handle a page file\n          // changes if we know a VACUUM has been done because handleAsync()\n          // has to unwind and rewind the stack. We must be sure to follow\n          // the same conditional path in both calls.\n          try {\n            return this.handleAsync(async () => {\n              await this.#reblockIfNeeded(file);\n              return VFS.SQLITE_OK;\n            });\n          } catch (e) {\n            console.error(e);\n            return VFS.SQLITE_IOERR;\n          }\n        }\n\n        if (file.isMetadataChanged) {\n          // Metadata has changed so write block 0 to IndexedDB.\n          try {\n            this.#idb.run('readwrite', async ({blocks}) => {\n              await blocks.put(file.block0);\n            });\n            file.isMetadataChanged = false;\n          } catch (e) {\n            console.error(e);\n            return VFS.SQLITE_IOERR;\n          }\n        }\n        return VFS.SQLITE_OK;\n\n      case 22: // SQLITE_FCNTL_COMMIT_PHASETWO\n        // This is called after a commit is completed.\n        file.overwrite = false;\n        return VFS.SQLITE_OK;\n\n      case 31: // SQLITE_FCNTL_BEGIN_ATOMIC_WRITE\n        return this.handleAsync(async () => {\n          try {\n            // Prepare a new version for IndexedDB blocks.\n            file.block0.version--;\n            file.changedPages = new Set();\n\n            // Clear blocks from abandoned transactions that would conflict\n            // with the new transaction.\n            this.#idb.run('readwrite', async ({blocks}) => {\n              const keys = await blocks.index('version').getAllKeys(IDBKeyRange.bound(\n                [file.path],\n                [file.path, file.block0.version]));\n              for (const key of keys) {\n                blocks.delete(key);\n              }\n            });\n            return VFS.SQLITE_OK;\n          } catch (e) {\n            console.error(e);\n            return VFS.SQLITE_IOERR;\n          }\n        });\n\n      case 32: // SQLITE_FCNTL_COMMIT_ATOMIC_WRITE\n        try {\n          const block0 = Object.assign({}, file.block0);\n          block0.data = block0.data.slice();\n          const changedPages = file.changedPages;\n          file.changedPages = null;\n          file.isMetadataChanged = false;\n          this.#idb.run('readwrite', async ({blocks})=> {\n            // Write block 0 to commit the new version.\n            blocks.put(block0);\n\n            // Blocks to purge are saved in a special IndexedDB object with\n            // an \"index\" of \"purge\". Add pages changed by this transaction.\n            const purgeBlock = await blocks.get([file.path, 'purge', 0]) ?? {\n              path: file.path,\n              offset: 'purge',\n              version: 0,\n              data: new Map(),\n              count: 0\n            };\n\n            purgeBlock.count += changedPages.size;\n            for (const pageIndex of changedPages) {\n              purgeBlock.data.set(pageIndex, block0.version);\n            }\n\n            blocks.put(purgeBlock);\n            this.#maybePurge(file.path, purgeBlock.count);\n          });\n          return VFS.SQLITE_OK;\n        } catch (e) {\n          console.error(e);\n          return VFS.SQLITE_IOERR;\n        }\n\n      case 33: // SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE\n        return this.handleAsync(async () => {\n          try {\n            // Restore original state. Objects for the abandoned version will\n            // be left in IndexedDB to be removed by the next atomic write\n            // transaction.\n            file.changedPages = null;\n            file.isMetadataChanged = false;\n            file.block0 = await this.#idb.run('readonly', ({blocks}) => {\n              return blocks.get([file.path, 0, file.block0.version + 1]);\n            });\n            return VFS.SQLITE_OK;\n          } catch (e) {\n            console.error(e);\n            return VFS.SQLITE_IOERR;\n          }\n        });\n\n      default:\n        return VFS.SQLITE_NOTFOUND;\n    }\n  }\n\n  /**\n   * @param {string} name \n   * @param {number} flags \n   * @param {DataView} pResOut \n   * @returns {number}\n   */\n  xAccess(name, flags, pResOut) {\n    const result = this.handleAsync(async () => {\n      try {\n        const path = new URL(name, 'file://localhost/').pathname;\n        log(`xAccess ${path} ${flags}`);\n\n        // Check if block 0 exists.\n        const key = await this.#idb.run('readonly', ({blocks}) => {\n          return blocks.getKey(this.#bound({path}, 0));\n        });\n\n        // @ts-ignore\n        if (pResOut.buffer.detached || !pResOut.buffer.byteLength) {\n          pResOut = new DataView(new ArrayBuffer(4));\n          this.#growthHandler = (pResOutNew) => {\n            pResOutNew.setInt32(0, pResOut.getInt32(0, true), true);\n          }\n        }\n        pResOut.setInt32(0, key ? 1 : 0, true);\n        return VFS.SQLITE_OK;\n      } catch (e) {\n        console.error(e);\n        return VFS.SQLITE_IOERR;\n      }\n    });\n\n    this.#growthHandler?.(pResOut);\n    this.#growthHandler = null;\n    return result;\n  }\n\n  /**\n   * @param {string} name \n   * @param {number} syncDir \n   * @returns {number}\n   */\n  xDelete(name, syncDir) {\n    return this.handleAsync(async () => {\n      const path = new URL(name, 'file://localhost/').pathname;\n      log(`xDelete ${path} ${syncDir}`);\n\n      try {\n        this.#idb.run('readwrite', ({blocks}) => {\n          return blocks.delete(IDBKeyRange.bound([path], [path, []]));\n        });\n        if (syncDir) {\n          await this.#idb.sync();\n        }\n        return VFS.SQLITE_OK;\n      } catch (e) {\n        console.error(e);\n        return VFS.SQLITE_IOERR;\n      }\n    });\n  }\n\n  /**\n   * Purge obsolete blocks from a database file.\n   * @param {string} path \n   */\n  async purge(path) {\n    const start = Date.now();\n    await this.#idb.run('readwrite', async ({blocks}) => {\n      const purgeBlock = await blocks.get([path, 'purge', 0]);\n      if (purgeBlock) {\n        for (const [pageOffset, version] of purgeBlock.data) {\n          blocks.delete(IDBKeyRange.bound(\n            [path, pageOffset, version],\n            [path, pageOffset, Infinity],\n            true, false));\n        }\n        await blocks.delete([path, 'purge', 0]);\n      }\n      log(`purge ${path} ${purgeBlock?.data.size ?? 0} pages in ${Date.now() - start} ms`);\n    });\n  }\n\n  /**\n   * Conditionally schedule a purge task.\n   * @param {string} path \n   * @param {number} nPages \n   */\n  #maybePurge(path, nPages) {\n    if (this.#options.purge === 'manual' ||\n        this.#pendingPurges.has(path) ||\n        nPages < this.#options.purgeAtLeast) {\n      // No purge needed.\n      return;\n    }\n    \n    if (globalThis.requestIdleCallback) {\n      globalThis.requestIdleCallback(() => {\n        this.purge(path);\n        this.#pendingPurges.delete(path)\n      });\n    } else {\n      setTimeout(() => {\n        this.purge(path);\n        this.#pendingPurges.delete(path)\n      });\n    }\n    this.#pendingPurges.add(path);\n  }\n\n  #bound(file, begin, end = 0) {\n    // Fetch newest block 0. For other blocks, use block 0 version.\n    const version = !begin || -begin < file.block0.data.length ?\n      -Infinity :\n      file.block0.version;\n    return IDBKeyRange.bound(\n      [file.path, begin, version],\n      [file.path, end, Infinity]);\n  }\n\n  // The database page size can be changed with PRAGMA page_size and VACUUM.\n  // The updated file will be overwritten with a regular transaction using\n  // the old page size. After that it will be read and written using the\n  // new page size, so the IndexedDB objects must be combined or split\n  // appropriately.\n  async #reblockIfNeeded(file) {\n    const oldPageSize = file.block0.data.length;\n    if (oldPageSize < 18) return; // no page size defined\n\n    const view = new DataView(file.block0.data.buffer, file.block0.data.byteOffset);\n    let newPageSize = view.getUint16(16);\n    if (newPageSize === 1) newPageSize = 65536;\n    if (newPageSize === oldPageSize) return; // no page size change\n\n    const maxPageSize = Math.max(oldPageSize, newPageSize);\n    const nOldPages = maxPageSize / oldPageSize;\n    const nNewPages = maxPageSize / newPageSize;\n\n    const newPageCount = view.getUint32(28);\n    const fileSize = newPageCount * newPageSize;\n\n    const version = file.block0.version;\n    await this.#idb.run('readwrite', async ({blocks}) => {\n      // When the block size changes, the entire file is rewritten. Delete\n      // all blocks older than block 0 to leave a single version at every\n      // offset.\n      const keys = await blocks.index('version').getAllKeys(IDBKeyRange.bound(\n        [file.path, version + 1],\n        [file.path, Infinity]\n      ));\n      for (const key of keys) {\n        blocks.delete(key);\n      }\n      blocks.delete([file.path, 'purge', 0]);\n\n      // Do the conversion in chunks of the larger of the page sizes.\n      for (let iOffset = 0; iOffset < fileSize; iOffset += maxPageSize) {\n        // Fetch nOldPages. They can be fetched in one request because\n        // there is now a single version in the file.\n        const oldPages = await blocks.getAll(\n          IDBKeyRange.lowerBound([file.path, -(iOffset + maxPageSize), Infinity]),\n          nOldPages);\n        for (const oldPage of oldPages) {\n          blocks.delete([oldPage.path, oldPage.offset, oldPage.version]);\n        }\n\n        // Convert to new pages.\n        if (nNewPages === 1) {\n          // Combine nOldPages old pages into a new page.\n          const buffer = new Uint8Array(newPageSize);\n          for (const oldPage of oldPages) {\n            buffer.set(oldPage.data, -(iOffset + oldPage.offset));\n          }\n          const newPage = {\n            path: file.path,\n            offset: -iOffset,\n            version,\n            data: buffer\n          };\n          if (newPage.offset === 0) {\n            newPage.fileSize = fileSize;\n            file.block0 = newPage;\n          }\n          blocks.put(newPage);\n        } else {\n          // Split an old page into nNewPages new pages.\n          const oldPage = oldPages[0];\n          for (let i = 0; i < nNewPages; ++i) {\n            const offset = -(iOffset + i * newPageSize);\n            if (-offset >= fileSize) break;\n            const newPage = {\n              path: oldPage.path,\n              offset,\n              version,\n              data: oldPage.data.subarray(i * newPageSize, (i + 1) * newPageSize)\n            }\n            if (newPage.offset === 0) {\n              newPage.fileSize = fileSize;\n              file.block0 = newPage;\n            }\n            blocks.put(newPage);\n          }\n        }\n      }\n    });\n  }\n}\n\nfunction openDatabase(idbDatabaseName) {\n  return new Promise((resolve, reject) => {\n    const request = globalThis.indexedDB.open(idbDatabaseName, 5);\n    request.addEventListener('upgradeneeded', function() {\n      const blocks = request.result.createObjectStore('blocks', {\n        keyPath: ['path', 'offset', 'version']\n      });\n      blocks.createIndex('version', ['path', 'version']);\n    });\n    request.addEventListener('success', () => {\n      resolve(request.result);\n    });\n    request.addEventListener('error', () => {\n      reject(request.error);\n    });\n  });\n}","// Copyright 2022 Roy T. Hashimoto. All Rights Reserved.\n\n// IndexedDB transactions older than this will be replaced.\nconst MAX_TRANSACTION_LIFETIME_MILLIS = 5_000;\n\n// For debugging.\nlet nextTxId = 0;\nconst mapTxToId = new WeakMap();\nfunction log(...args) {\n  // console.debug(...args);\n}\n\n// This class manages IDBTransaction and IDBRequest instances. It tries\n// to reuse transactions to minimize transaction overhead.\nexport class IDBContext {\n  /** @type {IDBDatabase} */ #db;\n  /** @type {Promise<IDBDatabase>} */ #dbReady;\n  #txOptions;\n\n  /** @type {IDBTransaction} */ #tx = null;\n  #txTimestamp = 0;\n  #runChain = Promise.resolve();\n  #putChain = Promise.resolve();\n\n  /**\n   * @param {IDBDatabase|Promise<IDBDatabase>} idbDatabase\n   */\n  constructor(idbDatabase, txOptions = { durability: 'default' }) {\n    this.#dbReady = Promise.resolve(idbDatabase).then(db => this.#db = db);\n    this.#txOptions = txOptions;\n  }\n\n  async close() {\n    const db = this.#db ?? await this.#dbReady;\n    await this.#runChain;\n    await this.sync();\n    db.close();\n  }\n  \n  /**\n   * Run a function with the provided object stores. The function\n   * should be idempotent in case it is passed an expired transaction.\n   * @param {IDBTransactionMode} mode\n   * @param {(stores: Object.<string, ObjectStore>) => any} f \n   */\n  async run(mode, f) {\n    // Ensure that functions run sequentially.\n    const result = this.#runChain.then(() => this.#run(mode, f));\n    this.#runChain = result.catch(() => {});\n    return result;\n  }\n\n  /**\n   * @param {IDBTransactionMode} mode\n   * @param {(stores: Object.<string, ObjectStore>) => any} f \n   * @returns \n   */\n  async #run(mode, f) {\n    const db = this.#db ?? await this.#dbReady;\n    if (mode === 'readwrite' && this.#tx?.mode === 'readonly') {\n      // Mode requires a new transaction.\n      this.#tx = null;\n    } else if (performance.now() - this.#txTimestamp > MAX_TRANSACTION_LIFETIME_MILLIS) {\n      // Chrome times out transactions after 60 seconds so refresh preemptively.\n      try {\n        this.#tx?.commit();\n      } catch (e) {\n        // Explicit commit can fail but this can be ignored if it will\n        // auto-commit anyway.\n        if (e.name !== 'InvalidStateError') throw e;\n      }\n\n      // Skip to the next task to allow processing.\n      await new Promise(resolve => setTimeout(resolve));\n      this.#tx = null;\n    }\n\n    // Run the user function with a retry in case the transaction is invalid.\n    for (let i = 0; i < 2; ++i) {\n      if (!this.#tx) {\n        // @ts-ignore\n        this.#tx = db.transaction(db.objectStoreNames, mode, this.#txOptions);\n        const timestamp = this.#txTimestamp = performance.now();\n\n        // Chain the result of every transaction. If any transaction is\n        // aborted then the next sync() call will throw.\n        this.#putChain = this.#putChain.then(() => {\n          return new Promise((resolve, reject) => {\n            this.#tx.addEventListener('complete', event => {\n              resolve();\n              if (this.#tx === event.target) {\n                this.#tx = null;\n              }\n              log(`transaction ${mapTxToId.get(event.target)} complete`);\n            });\n            this.#tx.addEventListener('abort', event => {\n              console.warn('tx abort', (performance.now() - timestamp)/1000);\n              // @ts-ignore\n              const e = event.target.error;\n              reject(e);\n              if (this.#tx === event.target) {\n                this.#tx = null;\n              }\n              log(`transaction ${mapTxToId.get(event.target)} aborted`, e);\n            });\n          });\n        });\n\n        log(`new transaction ${nextTxId} ${mode}`);\n        mapTxToId.set(this.#tx, nextTxId++);\n      }\n\n      try {\n        const stores = Object.fromEntries(Array.from(db.objectStoreNames, name => {\n          return [name, new ObjectStore(this.#tx.objectStore(name))];\n        }));\n        return await f(stores);\n      } catch (e) {\n        this.#tx = null;\n        if (i) throw e;\n        // console.warn('retrying with new transaction');\n      }\n    }\n  }\n\n  async sync() {\n    // Wait until all transactions since the previous sync have committed.\n    // Throw if any transaction failed.\n    await this.#runChain;\n    await this.#putChain;\n    this.#putChain = Promise.resolve();\n  }\n}\n\n/**\n * Helper to convert IDBRequest to Promise.\n * @param {IDBRequest} request \n * @returns {Promise}\n */\nfunction wrapRequest(request) {\n  return new Promise((resolve, reject) => {\n    request.addEventListener('success', () => resolve(request.result));\n    request.addEventListener('error', () => reject(request.error));\n  });\n}\n\n// IDBObjectStore wrapper passed to IDBContext run functions.\nclass ObjectStore {\n  #objectStore;\n\n  /**\n   * @param {IDBObjectStore} objectStore \n   */\n  constructor(objectStore) {\n    this.#objectStore = objectStore;\n  }\n\n  /**\n   * @param {IDBValidKey|IDBKeyRange} query \n   * @returns {Promise}\n   */\n  get(query) {\n    log(`get ${this.#objectStore.name}`, query);\n    const request = this.#objectStore.get(query);\n    return wrapRequest(request);\n  }\n\n  /**\n   * @param {IDBValidKey|IDBKeyRange} query \n   * @param {number} [count]\n   * @returns {Promise}\n   */\n   getAll(query, count) {\n    log(`getAll ${this.#objectStore.name}`, query, count);\n    const request = this.#objectStore.getAll(query, count);\n    return wrapRequest(request);\n  }\n\n  /**\n   * @param {IDBValidKey|IDBKeyRange} query \n   * @returns {Promise<IDBValidKey>}\n   */\n  getKey(query) {\n    log(`getKey ${this.#objectStore.name}`, query);\n    const request = this.#objectStore.getKey(query);\n    return wrapRequest(request);\n  }\n\n  /**\n   * @param {IDBValidKey|IDBKeyRange} query \n   * @param {number} [count]\n   * @returns {Promise}\n   */\n   getAllKeys(query, count) {\n    log(`getAllKeys ${this.#objectStore.name}`, query, count);\n    const request = this.#objectStore.getAllKeys(query, count);\n    return wrapRequest(request);\n  }\n\n  /**\n   * @param {any} value\n   * @param {IDBValidKey} [key] \n   * @returns {Promise}\n   */\n   put(value, key) {\n    log(`put ${this.#objectStore.name}`, value, key);\n    const request = this.#objectStore.put(value, key);\n    return wrapRequest(request);\n  }\n\n  /**\n   * @param {IDBValidKey|IDBKeyRange} query \n   * @returns {Promise}\n   */\n   delete(query) {\n    log(`delete ${this.#objectStore.name}`, query);\n    const request = this.#objectStore.delete(query);\n    return wrapRequest(request);\n  }\n\n  clear() {\n    log(`clear ${this.#objectStore.name}`);\n    const request = this.#objectStore.clear();\n    return wrapRequest(request);\n  }\n\n  index(name) {\n    return new Index(this.#objectStore.index(name));\n  }\n}\n\nclass Index {\n  /** @type {IDBIndex} */ #index;\n\n  /**\n   * @param {IDBIndex} index \n   */\n   constructor(index) {\n    this.#index = index;\n  }\n\n  /**\n   * @param {IDBValidKey|IDBKeyRange} query \n   * @param {number} [count]\n   * @returns {Promise<IDBValidKey[]>}\n   */\n  getAllKeys(query, count) {\n    log(`IDBIndex.getAllKeys ${this.#index.objectStore.name}<${this.#index.name}>`, query, count);\n    const request = this.#index.getAllKeys(query, count);\n    return wrapRequest(request);\n  }\n}","// Copyright 2022 Roy T. Hashimoto. All Rights Reserved.\nimport * as VFS from '../VFS.js';\n\nconst LOCK_TYPE_MASK =\n  VFS.SQLITE_LOCK_NONE |\n  VFS.SQLITE_LOCK_SHARED |\n  VFS.SQLITE_LOCK_RESERVED |\n  VFS.SQLITE_LOCK_PENDING |\n  VFS.SQLITE_LOCK_EXCLUSIVE;\n\nexport class WebLocksBase {\n  get state() { return this.#state; }\n  #state = VFS.SQLITE_LOCK_NONE;\n\n  timeoutMillis = 0;\n\n  /** @type {Map<string, (value: any) => void>} */ #releasers = new Map();\n  /** @type {Promise<0|5|3850>} */ #pending = Promise.resolve(0);\n\n  /**\n   * @param {number} flags \n   * @returns {Promise<0|5|3850>} SQLITE_OK, SQLITE_BUSY, SQLITE_IOERR_LOCK\n   */\n  async lock(flags) {\n    return this.#apply(this.#lock, flags);\n  }\n\n  /**\n   * @param {number} flags \n   * @returns {Promise<0|5|3850>} SQLITE_OK, SQLITE_IOERR_LOCK\n   */\n  async unlock(flags) {\n    return this.#apply(this.#unlock, flags);\n  }\n\n  /**\n   * @returns {Promise<boolean>}\n   */\n  async isSomewhereReserved() {\n    throw new Error('unimplemented');\n  }\n\n  /**\n   * \n   * @param {(targetState: number) => void} method \n   * @param {number} flags \n   */\n  async #apply(method, flags) {\n    const targetState = flags & LOCK_TYPE_MASK;\n    try {\n      // Force locks and unlocks to run sequentially. This allows not\n      // waiting for unlocks to complete.\n      const call = () => method.call(this, targetState);\n      await (this.#pending = this.#pending.then(call, call));\n      this.#state = targetState;\n      return VFS.SQLITE_OK;\n    } catch (e) {\n      if (e.name === 'AbortError') {\n        return VFS.SQLITE_BUSY;\n      }\n      console.error(e);\n      return VFS.SQLITE_IOERR_LOCK;\n    }\n  }\n\n  async #lock(targetState) {\n    if (targetState === this.#state) return VFS.SQLITE_OK;\n    switch (this.#state) {\n      case VFS.SQLITE_LOCK_NONE:\n        switch (targetState) {\n          case VFS.SQLITE_LOCK_SHARED:\n            return this._NONEtoSHARED();\n          default:\n            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);\n        }\n\n      case VFS.SQLITE_LOCK_SHARED:\n        switch (targetState) {\n          case VFS.SQLITE_LOCK_RESERVED:\n            return this._SHAREDtoRESERVED();\n          case VFS.SQLITE_LOCK_EXCLUSIVE:\n            return this._SHAREDtoEXCLUSIVE();\n          default:\n            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);\n        }\n      \n      case VFS.SQLITE_LOCK_RESERVED:\n        switch (targetState) {\n          case VFS.SQLITE_LOCK_EXCLUSIVE:\n            return this._RESERVEDtoEXCLUSIVE();\n          default:\n            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);\n        }\n\n      default:\n        throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);\n    }\n  }\n\n  async #unlock(targetState) {\n    if (targetState === this.#state)  return VFS.SQLITE_OK;\n    switch (this.#state) {\n      case VFS.SQLITE_LOCK_EXCLUSIVE:\n        switch (targetState) {\n          case VFS.SQLITE_LOCK_SHARED:\n            return this._EXCLUSIVEtoSHARED();\n          case VFS.SQLITE_LOCK_NONE:\n            return this._EXCLUSIVEtoNONE();\n          default:\n            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);\n        }\n      \n      case VFS.SQLITE_LOCK_RESERVED:\n        switch (targetState) {\n          case VFS.SQLITE_LOCK_SHARED:\n            return this._RESERVEDtoSHARED();\n          case VFS.SQLITE_LOCK_NONE:\n            return this._RESERVEDtoNONE();\n          default:\n            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);\n        }\n\n      case VFS.SQLITE_LOCK_SHARED:\n        switch (targetState) {\n          case VFS.SQLITE_LOCK_NONE:\n            return this._SHAREDtoNONE();\n          default:\n            throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);\n        }\n\n      default:\n        throw new Error(`unexpected transition ${this.#state} -> ${targetState}`);\n    }\n  }\n\n  async _NONEtoSHARED() {\n  }\n\n  async _SHAREDtoEXCLUSIVE() {\n    await this._SHAREDtoRESERVED();\n    await this._RESERVEDtoEXCLUSIVE();\n  }\n\n  async _SHAREDtoRESERVED() {\n  }\n\n  async _RESERVEDtoEXCLUSIVE() {\n  }\n\n  async _EXCLUSIVEtoRESERVED() {\n  }\n\n  async _EXCLUSIVEtoSHARED() {\n    await this._EXCLUSIVEtoRESERVED();\n    await this._RESERVEDtoSHARED();\n  }\n\n  async _EXCLUSIVEtoNONE() {\n    await this._EXCLUSIVEtoRESERVED();\n    await this._RESERVEDtoSHARED();\n    await this._SHAREDtoNONE();\n  }\n\n  async _RESERVEDtoSHARED() {\n  }\n\n  async _RESERVEDtoNONE() {\n    await this._RESERVEDtoSHARED();\n    await this._SHAREDtoNONE();\n  }\n\n  async _SHAREDtoNONE() {\n  }\n\n  /**\n   * @param {string} lockName \n   * @param {LockOptions} options \n   * @returns {Promise<?Lock>}\n   */\n  _acquireWebLock(lockName, options) {\n    return new Promise(async (resolve, reject) => {\n      try {\n        await navigator.locks.request(lockName, options, lock => {\n          resolve(lock);\n          if (lock) {\n            return new Promise(release => this.#releasers.set(lockName, release));\n          }\n        });\n      } catch(e) {\n        reject(e);\n      }\n    });\n  }\n\n  /**\n   * @param {string} lockName \n   */\n  _releaseWebLock(lockName) {\n    this.#releasers.get(lockName)?.();\n    this.#releasers.delete(lockName);\n  }\n\n  /**\n   * @param {string} lockName \n   */\n  async _pollWebLock(lockName) {\n    const query = await navigator.locks.query();\n    return query.held.find(({name}) => name === lockName)?.mode;\n  }\n\n  /**\n   * @returns {?AbortSignal}\n   */\n  _getTimeoutSignal() {\n    if (this.timeoutMillis) {\n      const abortController = new AbortController();\n      setTimeout(() => abortController.abort(), this.timeoutMillis);\n      return abortController.signal;\n    }\n    return undefined;\n  }\n}\n\nexport class WebLocksExclusive extends WebLocksBase {\n  /**\n   * @param {string} name \n   */\n  constructor(name) {\n    super();\n    this._lockName = name + '-outer';\n    this._reservedName = name + '-reserved';\n  }\n\n  async isSomewhereReserved() {\n    const mode = await this._pollWebLock(this._reservedName);\n    return mode === 'exclusive';\n  }\n\n  async _NONEtoSHARED() {\n    await this._acquireWebLock(this._lockName, {\n      mode: 'exclusive',\n      signal: this._getTimeoutSignal()\n    });\n  }\n\n  async _SHAREDtoRESERVED() {\n    await this._acquireWebLock(this._reservedName, {\n      mode: 'exclusive',\n      signal: this._getTimeoutSignal()\n    });\n  }\n\n  async _RESERVEDtoSHARED() {\n    this._releaseWebLock(this._reservedName);\n  }\n\n  async _SHAREDtoNONE() {\n    this._releaseWebLock(this._lockName);\n  }\n}\n\nexport class WebLocksShared extends WebLocksBase {\n  maxRetryMillis = 1000;\n\n  /**\n   * @param {string} name \n   */\n  constructor(name) {\n    super();\n    this._outerName = name + '-outer';\n    this._innerName = name + '-inner';\n  }\n\n  async isSomewhereReserved() {\n    const mode = await this._pollWebLock(this._outerName);\n    return mode === 'exclusive';\n  }\n\n  async _NONEtoSHARED() {\n    await this._acquireWebLock(this._outerName, {\n      mode: 'shared',\n      signal: this._getTimeoutSignal()\n    });\n    await this._acquireWebLock(this._innerName, {\n      mode: 'shared',\n      signal: this._getTimeoutSignal()\n    });\n    this._releaseWebLock(this._outerName);\n  }\n\n  async _SHAREDtoRESERVED() {\n    let timeoutMillis = 1;\n    while (true) {\n      // Attempt to get the outer lock without blocking.\n      const isLocked = await this._acquireWebLock(this._outerName, {\n        mode: 'exclusive',\n        ifAvailable: true\n      });\n      if (isLocked) break;\n\n      if (await this.isSomewhereReserved()) {\n        // Someone else has a reserved lock so retry cannot succeed.\n        throw new DOMException('', 'AbortError');\n      }\n\n      await new Promise(resolve => setTimeout(resolve, timeoutMillis));\n      timeoutMillis = Math.min(2 * timeoutMillis, this.maxRetryMillis);\n    }\n    this._releaseWebLock(this._innerName);\n  }\n\n  async _RESERVEDtoEXCLUSIVE() {\n    await this._acquireWebLock(this._innerName, {\n      mode: 'exclusive',\n      signal: this._getTimeoutSignal()\n    });\n  }\n\n  async _EXCLUSIVEtoRESERVED() {\n    this._releaseWebLock(this._innerName);\n  }\n\n  async _RESERVEDtoSHARED() {\n    await this._acquireWebLock(this._innerName, { mode: 'shared' });\n    this._releaseWebLock(this._outerName);\n  }\n\n  async _SHAREDtoNONE() {\n    this._releaseWebLock(this._innerName);\n  }\n}"],"names":[],"sourceRoot":""}

package/lib/package.json

@@ -0,0 +1,89 @@
+{
+    "name": "@powersync/web",
+    "version": "1.8.0",
+    "description": "A Web SDK for JourneyApps PowerSync",
+    "main": "lib/src/index.js",
+    "types": "lib/src/index.d.ts",
+    "files": [
+        "lib",
+        "!lib/tests",
+        "dist"
+    ],
+    "exports": {
+        ".": "./lib/src/index.js",
+        "./umd": {
+            "import": "./dist/index.umd.js",
+            "require": "./dist/index.umd.js",
+            "types": "./lib/src/index.d.ts"
+        },
+        "./umd/worker/db": {
+            "import": "./dist/worker/WASQLiteDB.umd.js",
+            "require": "./dist/worker/WASQLiteDB.umd.js",
+            "types": "./lib/src/index.d.ts"
+        },
+        "./umd/worker/sync": {
+            "import": "./dist/worker/SharedSyncImplementation.umd.js",
+            "require": "./dist/worker/SharedSyncImplementation.umd.js",
+            "types": "./lib/src/index.d.ts"
+        }
+    },
+    "repository": "https://github.com/powersync-ja/powersync-js",
+    "bugs": {
+        "url": "https://github.com/powersync-ja/powersync-js/issues"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/",
+        "access": "public"
+    },
+    "homepage": "https://docs.powersync.com",
+    "scripts": {
+        "build:tsc": "tsc --build",
+        "build:webpack-main": "webpack",
+        "build:webpack-workers": "webpack --config webpack.workers.config.js",
+        "build": "npm run build:tsc -- \"$@\" && npm run build:webpack-main && npm run build:webpack-workers",
+        "clean": "rm -rf lib tsconfig.tsbuildinfo",
+        "watch": "tsc --build -w",
+        "test": "pnpm build && vitest"
+    },
+    "keywords": [
+        "data sync",
+        "offline-first",
+        "sqlite",
+        "real-time data stream",
+        "live data"
+    ],
+    "author": "JOURNEYAPPS",
+    "license": "Apache-2.0",
+    "peerDependencies": {
+        "@journeyapps/wa-sqlite": "^0.3.0",
+        "@powersync/common": "workspace:^1.18.0"
+    },
+    "dependencies": {
+        "@powersync/common": "workspace:*",
+        "async-mutex": "^0.4.0",
+        "bson": "^6.6.0",
+        "comlink": "^4.4.1",
+        "js-logger": "^1.6.1"
+    },
+    "devDependencies": {
+        "@journeyapps/wa-sqlite": "^0.3.0",
+        "@types/uuid": "^9.0.6",
+        "@vitest/browser": "^1.3.1",
+        "crypto-browserify": "^3.12.0",
+        "p-defer": "^4.0.1",
+        "source-map-loader": "^5.0.0",
+        "stream-browserify": "^3.0.0",
+        "terser-webpack-plugin": "^5.3.9",
+        "typescript": "^5.5.3",
+        "uuid": "^9.0.1",
+        "vite": "^5.1.1",
+        "vite-plugin-top-level-await": "^1.4.1",
+        "vite-plugin-wasm": "^3.3.0",
+        "vitest": "^1.3.1",
+        "vm-browserify": "^1.1.2",
+        "webdriverio": "^8.32.3",
+        "webpack": "^5.90.1",
+        "webpack-cli": "^5.1.4",
+        "webpack-node-externals": "^3.0.0"
+    }
+}

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

@@ -1,6 +1,6 @@
-import { type AbstractStreamingSyncImplementation, type BucketStorageAdapter, type PowerSyncBackendConnector, type PowerSyncCloseOptions, type PowerSyncConnectionOptions, AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings } from '@powersync/common';
+import { type BucketStorageAdapter, type PowerSyncBackendConnector, type PowerSyncCloseOptions, type PowerSyncConnectionOptions, AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, StreamingSyncImplementation } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { WebSQLFlags } from './adapters/web-sql-flags';
+import { ResolvedWebSQLOpenOptions, WebSQLFlags } from './adapters/web-sql-flags';
 export interface WebPowerSyncFlags extends WebSQLFlags {
     /**
      * Externally unload open PowerSync database instances when the window closes.
@@ -12,10 +12,22 @@ export interface WebPowerSyncFlags extends WebSQLFlags {
 type WithWebFlags<Base> = Base & {
     flags?: WebPowerSyncFlags;
 };
-export type WebPowerSyncDatabaseOptionsWithAdapter = WithWebFlags<PowerSyncDatabaseOptionsWithDBAdapter>;
-export type WebPowerSyncDatabaseOptionsWithOpenFactory = WithWebFlags<PowerSyncDatabaseOptionsWithOpenFactory>;
-export type WebPowerSyncDatabaseOptionsWithSettings = WithWebFlags<PowerSyncDatabaseOptionsWithSettings>;
-export type WebPowerSyncDatabaseOptions = WithWebFlags<PowerSyncDatabaseOptions>;
+export interface WebSyncOptions {
+    /**
+     * Allows you to override the default sync worker.
+     *
+     * You can either provide a path to the worker script
+     * or a factory method that returns a worker.
+     */
+    worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => SharedWorker);
+}
+type WithWebSyncOptions<Base> = Base & {
+    sync?: WebSyncOptions;
+};
+export type WebPowerSyncDatabaseOptionsWithAdapter = WithWebSyncOptions<WithWebFlags<PowerSyncDatabaseOptionsWithDBAdapter>>;
+export type WebPowerSyncDatabaseOptionsWithOpenFactory = WithWebSyncOptions<WithWebFlags<PowerSyncDatabaseOptionsWithOpenFactory>>;
+export type WebPowerSyncDatabaseOptionsWithSettings = WithWebSyncOptions<WithWebFlags<PowerSyncDatabaseOptionsWithSettings>>;
+export type WebPowerSyncDatabaseOptions = WithWebSyncOptions<WithWebFlags<PowerSyncDatabaseOptions>>;
 export declare const DEFAULT_POWERSYNC_FLAGS: Required<WebPowerSyncFlags>;
 export declare const resolveWebPowerSyncFlags: (flags?: WebPowerSyncFlags) => WebPowerSyncFlags;
 /**
@@ -52,6 +64,6 @@ export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     connect(connector: PowerSyncBackendConnector, options?: PowerSyncConnectionOptions): Promise<void>;
     protected generateBucketStorageAdapter(): BucketStorageAdapter;
     protected runExclusive<T>(cb: () => Promise<T>): Promise<any>;
-    protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector): AbstractStreamingSyncImplementation;
+    protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector): StreamingSyncImplementation;
 }
 export {};

package/lib/src/db/PowerSyncDatabase.js

@@ -118,3 +118,4 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
         }
     }
 }
+//# sourceMappingURL=PowerSyncDatabase.js.map

package/lib/src/db/PowerSyncDatabase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PowerSyncDatabase.js","sourceRoot":"","sources":["../../../src/db/PowerSyncDatabase.ts"],"names":[],"mappings":"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"}

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

@@ -24,3 +24,4 @@ export class AbstractWebPowerSyncDatabaseOpenFactory extends AbstractPowerSyncDa
         return new PowerSyncDatabase(options);
     }
 }
+//# sourceMappingURL=AbstractWebPowerSyncDatabaseOpenFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractWebPowerSyncDatabaseOpenFactory.js","sourceRoot":"","sources":["../../../../src/db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,oCAAoC,EAGrC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,iBAAiB,EAGjB,wBAAwB,EACzB,MAAM,4BAA4B,CAAC;AAYpC;;;;;GAKG;AACH,MAAM,OAAgB,uCAAwC,SAAQ,oCAAoC;IAClF;IAAtB,YAAsB,OAAuC;QAC3D,KAAK,CAAC,OAAO,CAAC,CAAC;QADK,YAAO,GAAP,OAAO,CAAgC;IAE7D,CAAC;IAED,eAAe;QACb,OAAO;YACL,GAAG,IAAI,CAAC,OAAO;YACf,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE;YACvB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;SACpD,CAAC;IACJ,CAAC;IAED,gBAAgB,CAAC,OAAiC;QAChD,OAAO,IAAI,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;CACF"}

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

@@ -1,8 +1,8 @@
 import { DBAdapter, SQLOpenFactory } from '@powersync/common';
-import { WebSQLFlags, WebSQLOpenFactoryOptions } from './web-sql-flags';
+import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions } from './web-sql-flags';
 export declare abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
     protected options: WebSQLOpenFactoryOptions;
-    protected resolvedFlags: WebSQLFlags;
+    protected resolvedFlags: ResolvedWebSQLFlags;
     constructor(options: WebSQLOpenFactoryOptions);
     /**
      * Opens a DBAdapter if not in SSR mode

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

@@ -12,19 +12,20 @@ export class AbstractWebSQLOpenFactory {
      * A SSR implementation is loaded if SSR mode is detected.
      */
     openDB() {
-        const isSSR = isServerSide();
-        if (isSSR && !this.resolvedFlags.disableSSRWarning) {
+        const { resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() } } = this;
+        if (ssrMode && !disableSSRWarning) {
             console.warn(`
   Running PowerSync in SSR mode.
   Only empty query results will be returned.
   Disable this warning by setting 'disableSSRWarning: true' in options.`);
         }
-        if (!this.resolvedFlags.enableMultiTabs) {
+        if (!enableMultiTabs) {
             console.warn('Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.');
         }
-        if (isSSR) {
+        if (ssrMode) {
             return new SSRDBAdapter();
         }
         return this.openAdapter();
     }
 }
+//# sourceMappingURL=AbstractWebSQLOpenFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractWebSQLOpenFactory.js","sourceRoot":"","sources":["../../../../src/db/adapters/AbstractWebSQLOpenFactory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAiD,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAElH,MAAM,OAAgB,yBAAyB;IAGvB;IAFZ,aAAa,CAAsB;IAE7C,YAAsB,OAAiC;QAAjC,YAAO,GAAP,OAAO,CAA0B;QACrD,IAAI,CAAC,aAAa,GAAG,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACzD,CAAC;IAOD;;;OAGG;IACH,MAAM;QACJ,MAAM,EACJ,aAAa,EAAE,EAAE,iBAAiB,EAAE,eAAe,EAAE,OAAO,GAAG,YAAY,EAAE,EAAE,EAChF,GAAG,IAAI,CAAC;QACT,IAAI,OAAO,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAClC,OAAO,CAAC,IAAI,CACV;;;wEAGgE,CACjE,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,CACV,uGAAuG,CACxG,CAAC;QACJ,CAAC;QAED,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,IAAI,YAAY,EAAE,CAAC;QAC5B,CAAC;QAED,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;CACF"}

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

@@ -63,3 +63,4 @@ export class SSRDBAdapter extends BaseObserver {
         };
     }
 }
+//# sourceMappingURL=SSRDBAdapter.js.map

package/lib/src/db/adapters/SSRDBAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SSRDBAdapter.js","sourceRoot":"","sources":["../../../../src/db/adapters/SSRDBAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,MAAM,mBAAmB,GAAgB;IACvC,YAAY,EAAE,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,MAAM,OAAO,YAAa,SAAQ,YAA+B;IAC/D,IAAI,CAAS;IACb,SAAS,CAAQ;IACjB,UAAU,CAAQ;IAElB;QACE,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,IAAI,KAAK,EAAE,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,IAAI,KAAK,EAAE,CAAC;IAChC,CAAC;IAED,KAAK,KAAI,CAAC;IAEV,KAAK,CAAC,QAAQ,CAAI,EAAmC,EAAE,OAAuB;QAC5E,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACrD,CAAC;IAED,KAAK,CAAC,eAAe,CAAI,EAAmC,EAAE,OAAuB;QACnF,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC;IACxE,CAAC;IAED,KAAK,CAAC,SAAS,CAAI,EAAmC,EAAE,OAAuB;QAC7E,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAI,EAAmC,EAAE,OAAuB;QACpF,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC;IACzE,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,KAAa,EAAE,MAAc;QACzC,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,KAAK,IAAI,EAAE,CAAC,mBAAmB,CAAC,CAAC;IACvE,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,KAAa,EAAE,MAAgB;QAChD,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,KAAK,IAAI,EAAE,CAAC,mBAAmB,CAAC,CAAC;IACvE,CAAC;IAED,KAAK,CAAC,MAAM,CAAI,GAAW,EAAE,UAAkB;QAC7C,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,KAAK,CAAC,WAAW,CAAI,GAAW,EAAE,UAA8B;QAC9D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,GAAG,CAAI,GAAW,EAAE,UAA8B;QACtD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACK,8BAA8B;QACpC,OAAO;YACL,GAAG,IAAI;YACP,MAAM,EAAE,KAAK,IAAI,EAAE;gBACjB,OAAO,mBAAmB,CAAC;YAC7B,CAAC;YACD,QAAQ,EAAE,KAAK,IAAI,EAAE;gBACnB,OAAO,mBAAmB,CAAC;YAC7B,CAAC;SACF,CAAC;IACJ,CAAC;CACF"}

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

@@ -1,5 +1,5 @@
 import { type DBAdapter, type DBAdapterListener, type DBLockOptions, type LockContext, type PowerSyncOpenFactoryOptions, type QueryResult, type Transaction, BaseObserver } from '@powersync/common';
-import { WebSQLFlags } from '../web-sql-flags';
+import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../web-sql-flags';
 /**
  * These flags are the same as {@link WebSQLFlags}.
  * This export is maintained only for API consistency
@@ -12,6 +12,7 @@ export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptio
      * A worker will be initialized if none is provided
      */
     workerPort?: MessagePort;
+    worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
 }
 /**
  * Adapter for WA-SQLite SQLite connections.
@@ -25,7 +26,7 @@ export declare class WASQLiteDBAdapter extends BaseObserver<DBAdapterListener> i
     private debugMode;
     constructor(options: WASQLiteDBAdapterOptions);
     get name(): string;
-    protected get flags(): WASQLiteFlags;
+    protected get flags(): Required<WASQLiteFlags>;
     getWorker(): void;
     protected init(): Promise<void>;
     execute(query: string, params?: any[] | undefined): Promise<QueryResult>;

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

@@ -2,7 +2,8 @@ import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
 import Logger from 'js-logger';
 import { _openDB } from '../../../shared/open-db';
-import { getWorkerDatabaseOpener } from '../../../worker/db/open-worker-database';
+import { getWorkerDatabaseOpener, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
+import { resolveWebSQLFlags } from '../web-sql-flags';
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
@@ -44,7 +45,7 @@ export class WASQLiteDBAdapter extends BaseObserver {
         return this.options.dbFilename;
     }
     get flags() {
-        return this.options.flags ?? {};
+        return resolveWebSQLFlags(this.options.flags ?? {});
     }
     getWorker() { }
     async init() {
@@ -53,9 +54,15 @@ export class WASQLiteDBAdapter extends BaseObserver {
             this.logger.warn('Multiple tabs are not enabled in this browser');
         }
         if (useWebWorker) {
+            const optionsDbWorker = this.options.worker;
             const dbOpener = this.options.workerPort
                 ? Comlink.wrap(this.options.workerPort)
-                : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs);
+                : typeof optionsDbWorker === 'function'
+                    ? Comlink.wrap(resolveWorkerDatabasePortFactory(() => optionsDbWorker({
+                        ...this.options,
+                        flags: this.flags
+                    })))
+                    : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs, optionsDbWorker);
             this.methods = await dbOpener(this.options.dbFilename);
             this.methods.registerOnTableChange(Comlink.proxy((event) => {
                 this.iterateListeners((cb) => cb.tablesUpdated?.(event));
@@ -208,3 +215,4 @@ export class WASQLiteDBAdapter extends BaseObserver {
         };
     }
 }
+//# sourceMappingURL=WASQLiteDBAdapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WASQLiteDBAdapter.js","sourceRoot":"","sources":["../../../../../src/db/adapters/wa-sqlite/WASQLiteDBAdapter.ts"],"names":[],"mappings":"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"}

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

@@ -11,3 +11,4 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
         });
     }
 }
+//# sourceMappingURL=WASQLiteOpenFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WASQLiteOpenFactory.js","sourceRoot":"","sources":["../../../../../src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAEzE;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,yBAAyB;IACtD,WAAW;QACnB,OAAO,IAAI,iBAAiB,CAAC;YAC3B,GAAG,IAAI,CAAC,OAAO;YACf,KAAK,EAAE,IAAI,CAAC,aAAa;SAC1B,CAAC,CAAC;IACL,CAAC;CACF"}

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

@@ -19,3 +19,4 @@ export class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDa
         return new PowerSyncDatabase(options);
     }
 }
+//# sourceMappingURL=WASQLitePowerSyncDatabaseOpenFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WASQLitePowerSyncDatabaseOpenFactory.js","sourceRoot":"","sources":["../../../../../src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,uCAAuC,EAAE,MAAM,4CAA4C,CAAC;AACrG,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,OAAO,oCAAqC,SAAQ,uCAAuC;IACrF,MAAM;QACd,MAAM,OAAO,GAAG,IAAI,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtD,OAAO,OAAO,CAAC,MAAM,EAAE,CAAC;IAC1B,CAAC;IAED,gBAAgB,CAAC,OAAiC;QAChD,OAAO,IAAI,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;CACF"}

package/lib/src/db/adapters/web-sql-flags.d.ts

@@ -30,12 +30,23 @@ export interface WebSQLFlags {
      */
     ssrMode?: boolean;
 }
+export type ResolvedWebSQLFlags = Required<WebSQLFlags>;
+export interface ResolvedWebSQLOpenOptions extends SQLOpenOptions {
+    flags: ResolvedWebSQLFlags;
+}
 /**
  * Options for opening a Web SQL connection
  */
 export interface WebSQLOpenFactoryOptions extends SQLOpenOptions {
     flags?: WebSQLFlags;
+    /**
+     * Allows you to override the default wasqlite db worker.
+     *
+     * You can either provide a path to the worker script
+     * or a factory method that returns a worker.
+     */
+    worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
 }
 export declare function isServerSide(): boolean;
-export declare const DEFAULT_WEB_SQL_FLAGS: Required<WebSQLFlags>;
-export declare function resolveWebSQLFlags(flags?: WebSQLFlags): WebSQLFlags;
+export declare const DEFAULT_WEB_SQL_FLAGS: ResolvedWebSQLFlags;
+export declare function resolveWebSQLFlags(flags?: WebSQLFlags): ResolvedWebSQLFlags;

package/lib/src/db/adapters/web-sql-flags.js

@@ -28,3 +28,4 @@ export function resolveWebSQLFlags(flags) {
     }
     return resolvedFlags;
 }
+//# sourceMappingURL=web-sql-flags.js.map

package/lib/src/db/adapters/web-sql-flags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-sql-flags.js","sourceRoot":"","sources":["../../../../src/db/adapters/web-sql-flags.ts"],"names":[],"mappings":"AA2DA,MAAM,UAAU,YAAY;IAC1B,OAAO,OAAO,MAAM,IAAI,WAAW,CAAC;AACtC,CAAC;AAED,MAAM,CAAC,MAAM,qBAAqB,GAAwB;IACxD,aAAa,EAAE,IAAI;IACnB,iBAAiB,EAAE,KAAK;IACxB,OAAO,EAAE,YAAY,EAAE;IACvB;;;OAGG;IACH,eAAe,EACb,OAAO,UAAU,CAAC,SAAS,KAAK,WAAW,IAAI,mBAAmB;QAClE,OAAO,YAAY,KAAK,WAAW;QACnC,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,6BAA6B,CAAC;QACzD,CAAE,MAAc,CAAC,MAAM;IACzB,YAAY,EAAE,IAAI;CACnB,CAAC;AAEF,MAAM,UAAU,kBAAkB,CAAC,KAAmB;IACpD,MAAM,aAAa,GAAG;QACpB,GAAG,qBAAqB;QACxB,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;KACjB,CAAC;IACF,IAAI,OAAO,KAAK,EAAE,eAAe,IAAI,WAAW,EAAE,CAAC;QACjD,aAAa,CAAC,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC;IACxD,CAAC;IACD,IAAI,KAAK,EAAE,YAAY,KAAK,KAAK,EAAE,CAAC;QAClC,aAAa,CAAC,eAAe,GAAG,KAAK,CAAC;IACxC,CAAC;IACD,OAAO,aAAa,CAAC;AACvB,CAAC"}

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

@@ -1,8 +1,40 @@
-import { AbstractStreamingSyncImplementation, AbstractStreamingSyncImplementationOptions, LockOptions } from '@powersync/common';
+import { AbstractStreamingSyncImplementationOptions, BaseObserver, LockOptions, PowerSyncConnectionOptions, StreamingSyncImplementation, SyncStatus, SyncStatusOptions } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-export declare class SSRStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+export declare class SSRStreamingSyncImplementation extends BaseObserver implements StreamingSyncImplementation {
     syncMutex: Mutex;
     crudMutex: Mutex;
+    isConnected: boolean;
+    lastSyncedAt?: Date | undefined;
+    syncStatus: SyncStatus;
     constructor(options: AbstractStreamingSyncImplementationOptions);
     obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
+    /**
+     * This is a no-op in SSR mode
+     */
+    connect(options?: PowerSyncConnectionOptions): Promise<void>;
+    dispose(): Promise<void>;
+    /**
+     * This is a no-op in SSR mode
+     */
+    disconnect(): Promise<void>;
+    /**
+     * This SSR Mode implementation is immediately ready.
+     */
+    waitForReady(): Promise<void>;
+    /**
+     * This will never resolve in SSR Mode.
+     */
+    waitForStatus(status: SyncStatusOptions): Promise<void>;
+    /**
+     * Returns a placeholder checkpoint. This should not be used.
+     */
+    getWriteCheckpoint(): Promise<string>;
+    /**
+     * The SSR mode adapter will never complete syncing.
+     */
+    hasCompletedSync(): Promise<boolean>;
+    /**
+     * This is a no-op in SSR mode.
+     */
+    triggerCrudUpload(): void;
 }

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

@@ -1,15 +1,56 @@
-import { AbstractStreamingSyncImplementation, LockType } from '@powersync/common';
+import { BaseObserver, LockType, SyncStatus } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-export class SSRStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+export class SSRStreamingSyncImplementation extends BaseObserver {
     syncMutex;
     crudMutex;
+    isConnected;
+    lastSyncedAt;
+    syncStatus;
     constructor(options) {
-        super(options);
+        super();
         this.syncMutex = new Mutex();
         this.crudMutex = new Mutex();
+        this.syncStatus = new SyncStatus({});
+        this.isConnected = false;
     }
     obtainLock(lockOptions) {
         const mutex = lockOptions.type == LockType.CRUD ? this.crudMutex : this.syncMutex;
         return mutex.runExclusive(lockOptions.callback);
     }
+    /**
+     * This is a no-op in SSR mode
+     */
+    async connect(options) { }
+    async dispose() { }
+    /**
+     * This is a no-op in SSR mode
+     */
+    async disconnect() { }
+    /**
+     * This SSR Mode implementation is immediately ready.
+     */
+    async waitForReady() { }
+    /**
+     * This will never resolve in SSR Mode.
+     */
+    async waitForStatus(status) {
+        return new Promise((r) => { });
+    }
+    /**
+     * Returns a placeholder checkpoint. This should not be used.
+     */
+    async getWriteCheckpoint() {
+        return '1';
+    }
+    /**
+     * The SSR mode adapter will never complete syncing.
+     */
+    async hasCompletedSync() {
+        return false;
+    }
+    /**
+     * This is a no-op in SSR mode.
+     */
+    triggerCrudUpload() { }
 }
+//# sourceMappingURL=SSRWebStreamingSyncImplementation.js.map

package/lib/src/db/sync/SSRWebStreamingSyncImplementation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SSRWebStreamingSyncImplementation.js","sourceRoot":"","sources":["../../../../src/db/sync/SSRWebStreamingSyncImplementation.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAEZ,QAAQ,EAGR,UAAU,EAEX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,MAAM,OAAO,8BAA+B,SAAQ,YAAY;IAC9D,SAAS,CAAQ;IACjB,SAAS,CAAQ;IAEjB,WAAW,CAAU;IACrB,YAAY,CAAoB;IAChC,UAAU,CAAa;IAEvB,YAAY,OAAmD;QAC7D,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,SAAS,GAAG,IAAI,KAAK,EAAE,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,IAAI,KAAK,EAAE,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;QACrC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED,UAAU,CAAI,WAA2B;QACvC,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;QAClF,OAAO,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,OAAoC,IAAkB,CAAC;IAErE,KAAK,CAAC,OAAO,KAAI,CAAC;IAElB;;OAEG;IACH,KAAK,CAAC,UAAU,KAAmB,CAAC;IAEpC;;OAEG;IACH,KAAK,CAAC,YAAY,KAAI,CAAC;IAEvB;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,MAAyB;QAC3C,OAAO,IAAI,OAAO,CAAO,CAAC,CAAC,EAAE,EAAE,GAAE,CAAC,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,kBAAkB;QACtB,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,gBAAgB;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,iBAAiB,KAAI,CAAC;CACvB"}