@powersync/web 1.10.1 → 1.11.0

package/dist/worker/WASQLiteDB.umd.js

@@ -34,8 +34,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   _openDB: () => (/* binding */ _openDB)
 /* harmony export */ });
 /* harmony import */ var _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @journeyapps/wa-sqlite */ "../../node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js");
-/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! comlink */ "../../node_modules/comlink/dist/esm/comlink.mjs");
 /* harmony import */ var async_mutex__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! async-mutex */ "../../node_modules/async-mutex/index.mjs");
+/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! comlink */ "../../node_modules/comlink/dist/esm/comlink.mjs");
 
 
 
@@ -45,8 +45,13 @@ async function _openDB(dbFileName, options = { useWebWorker: true }) {
     const { default: moduleFactory } = await __webpack_require__.e(/*! import() */ "node_modules_journeyapps_wa-sqlite_dist_wa-sqlite-async_mjs").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs */ "../../node_modules/@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs"));
     const module = await moduleFactory();
     const sqlite3 = _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.Factory(module);
+    /**
+     * Register the PowerSync core SQLite extension
+     */
+    module.ccall('powersync_init_static', 'int', []);
     const { IDBBatchAtomicVFS } = await __webpack_require__.e(/*! import() */ "node_modules_journeyapps_wa-sqlite_src_examples_IDBBatchAtomicVFS_js").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js"));
-    const vfs = new IDBBatchAtomicVFS(dbFileName);
+    // @ts-expect-error The types for this static method are missing upstream
+    const vfs = await IDBBatchAtomicVFS.create(dbFileName, module, { lockPolicy: 'exclusive' });
     sqlite3.vfs_register(vfs, true);
     const db = await sqlite3.open_v2(dbFileName);
     const statementMutex = new async_mutex__WEBPACK_IMPORTED_MODULE_1__.Mutex();
@@ -62,7 +67,10 @@ async function _openDB(dbFileName, options = { useWebWorker: true }) {
         updatedTables.clear();
         Array.from(listeners.values()).forEach((l) => l(event));
     }
-    sqlite3.register_table_onchange_hook(db, (opType, tableName, rowId) => {
+    sqlite3.update_hook(db, (updateType, dbName, tableName) => {
+        if (!tableName) {
+            return;
+        }
         updatedTables.add(tableName);
         if (updateTimer == null) {
             updateTimer = setTimeout(fireUpdates, 0);
@@ -144,40 +152,36 @@ async function _openDB(dbFileName, options = { useWebWorker: true }) {
     const executeBatch = async (sql, bindings) => {
         return _acquireExecuteLock(async () => {
             let affectedRows = 0;
-            const str = sqlite3.str_new(db, sql);
-            const query = sqlite3.str_value(str);
             try {
                 await executeSingleStatement('BEGIN TRANSACTION');
-                //Prepare statement once
-                const prepared = await sqlite3.prepare_v2(db, query);
-                if (prepared === null) {
-                    return {
-                        rowsAffected: 0,
-                        rows: { _array: [], length: 0 }
-                    };
-                }
                 const wrappedBindings = bindings ? bindings : [];
-                for (const binding of wrappedBindings) {
-                    // TODO not sure why this is needed currently, but booleans break
-                    for (let i = 0; i < binding.length; i++) {
-                        const b = binding[i];
-                        if (typeof b == 'boolean') {
-                            binding[i] = b ? 1 : 0;
-                        }
-                    }
-                    //Reset bindings
-                    sqlite3.reset(prepared.stmt);
-                    if (bindings) {
-                        sqlite3.bind_collection(prepared.stmt, binding);
+                for await (const stmt of sqlite3.statements(db, sql)) {
+                    if (stmt === null) {
+                        return {
+                            rowsAffected: 0,
+                            rows: { _array: [], length: 0 }
+                        };
                     }
-                    const result = await sqlite3.step(prepared.stmt);
-                    if (result === _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE) {
-                        //The value returned by sqlite3_changes() immediately after an INSERT, UPDATE or DELETE statement run on a view is always zero.
-                        affectedRows += sqlite3.changes(db);
+                    //Prepare statement once
+                    for (const binding of wrappedBindings) {
+                        // TODO not sure why this is needed currently, but booleans break
+                        for (let i = 0; i < binding.length; i++) {
+                            const b = binding[i];
+                            if (typeof b == 'boolean') {
+                                binding[i] = b ? 1 : 0;
+                            }
+                        }
+                        if (bindings) {
+                            sqlite3.bind_collection(stmt, binding);
+                        }
+                        const result = await sqlite3.step(stmt);
+                        if (result === _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE) {
+                            //The value returned by sqlite3_changes() immediately after an INSERT, UPDATE or DELETE statement run on a view is always zero.
+                            affectedRows += sqlite3.changes(db);
+                        }
+                        sqlite3.reset(stmt);
                     }
                 }
-                //Finalize prepared statement
-                await sqlite3.finalize(prepared.stmt);
                 await executeSingleStatement('COMMIT');
             }
             catch (err) {
@@ -187,9 +191,6 @@ async function _openDB(dbFileName, options = { useWebWorker: true }) {
                     rows: { _array: [], length: 0 }
                 };
             }
-            finally {
-                sqlite3.str_finish(str);
-            }
             const result = {
                 rowsAffected: affectedRows,
                 rows: { _array: [], length: 0 }
@@ -1065,6 +1066,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   SQLITE_OPEN_WAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_WAL),
 /* harmony export */   SQLITE_PERM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PERM),
 /* harmony export */   SQLITE_PRAGMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PRAGMA),
+/* harmony export */   SQLITE_PREPARE_NORMALIZED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_NORMALIZED),
+/* harmony export */   SQLITE_PREPARE_NO_VTAB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_NO_VTAB),
+/* harmony export */   SQLITE_PREPARE_PERSISTENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PREPARE_PERSISTENT),
 /* harmony export */   SQLITE_PROTOCOL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PROTOCOL),
 /* harmony export */   SQLITE_RANGE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RANGE),
 /* harmony export */   SQLITE_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_READ),
@@ -1111,6 +1115,8 @@ if (typeof BigInt.prototype['toJSON'] == 'undefined') {
 const MAX_INT64 = 0x7fffffffffffffffn;
 const MIN_INT64 = -0x8000000000000000n;
 
+const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+
 class SQLiteError extends Error {
   constructor(message, code) {
     super(message);
@@ -1120,10 +1126,6 @@ class SQLiteError extends Error {
 
 const async = true;
 
-const onTableChangeCallbacks = {};
-globalThis.__onTablesChanged = function(db, opType, tableName, rowId) {
-  onTableChangeCallbacks[db]?.(opType, tableName, rowId);
-};
 
 /**
  * Builds a Javascript API from the Emscripten module. This API is still
@@ -1135,6 +1137,7 @@ globalThis.__onTablesChanged = function(db, opType, tableName, rowId) {
 function Factory(Module) {
   /** @type {SQLiteAPI} */ const sqlite3 = {};
 
+  Module.retryOps = [];
   const sqliteFreeAddress = Module._getSqliteFree();
 
   // Allocate some space for 32-bit returned values.
@@ -1145,9 +1148,10 @@ function Factory(Module) {
   // memory (use sqlite3_free to deallocate).
   function createUTF8(s) {
     if (typeof s !== 'string') return 0;
-    const n = Module.lengthBytesUTF8(s);
-    const zts = Module._sqlite3_malloc(n + 1);
-    Module.stringToUTF8(s, zts, n + 1);
+    const utf8 = new TextEncoder().encode(s);
+    const zts = Module._sqlite3_malloc(utf8.byteLength + 1);
+    Module.HEAPU8.set(utf8, zts);
+    Module.HEAPU8[zts + utf8.byteLength] = 0;
     return zts;
   }
 
@@ -1257,7 +1261,6 @@ function Factory(Module) {
       const ptr = Module._sqlite3_malloc(byteLength);
       Module.HEAPU8.subarray(ptr).set(value);
       const result = f(stmt, i, ptr, byteLength, sqliteFreeAddress);
-      // trace(fname, result);
       return check(fname, result, mapStmtToDB.get(stmt));
     };
   })();
@@ -1268,7 +1271,6 @@ function Factory(Module) {
     return function(stmt) {
       verifyStatement(stmt);
       const result = f(stmt);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1279,7 +1281,6 @@ function Factory(Module) {
     return function(stmt, i, value) {
       verifyStatement(stmt);
       const result = f(stmt, i, value);
-      // trace(fname, result);
       return check(fname, result, mapStmtToDB.get(stmt));
     };
   })();
@@ -1292,7 +1293,6 @@ function Factory(Module) {
       if (value > 0x7fffffff || value < -0x80000000) return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RANGE;
 
       const result = f(stmt, i, value);
-      // trace(fname, result);
       return check(fname, result, mapStmtToDB.get(stmt));
     };
   })();
@@ -1307,7 +1307,6 @@ function Factory(Module) {
       const lo32 = value & 0xffffffffn;
       const hi32 = value >> 32n;
       const result = f(stmt, i, Number(lo32), Number(hi32));
-      // trace(fname, result);
       return check(fname, result, mapStmtToDB.get(stmt));
     };
   })();
@@ -1318,7 +1317,6 @@ function Factory(Module) {
     return function(stmt, i) {
       verifyStatement(stmt);
       const result = f(stmt, i);
-      // trace(fname, result);
       return check(fname, result, mapStmtToDB.get(stmt));
     };
   })();
@@ -1329,7 +1327,6 @@ function Factory(Module) {
     return function(stmt, i) {
       verifyStatement(stmt);
       const result = f(stmt, i);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1341,7 +1338,6 @@ function Factory(Module) {
       verifyStatement(stmt);
       const ptr = createUTF8(value);
       const result = f(stmt, i, ptr, -1, sqliteFreeAddress);
-      // trace(fname, result);
       return check(fname, result, mapStmtToDB.get(stmt));
     };
   })();
@@ -1352,11 +1348,20 @@ function Factory(Module) {
     return function(db) {
       verifyDatabase(db);
       const result = f(db);
-      // trace(fname, result);
       return result;
     };
   })();
 
+  sqlite3.clear_bindings = (function() {
+    const fname = 'sqlite3_clear_bindings';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(stmt) {
+      verifyStatement(stmt);
+      const result = f(stmt);
+      return check(fname, result, mapStmtToDB.get(stmt));
+    };
+  })();
+
   sqlite3.last_insert_id = (function() {
     const fname = 'sqlite3_last_insert_rowid';
     const f = Module.cwrap(fname, ...decl('n:n'));
@@ -1367,7 +1372,7 @@ function Factory(Module) {
       return result;
     };
   })();
-
+  
   sqlite3.close = (function() {
     const fname = 'sqlite3_close';
     const f = Module.cwrap(fname, ...decl('n:n'), { async });
@@ -1408,7 +1413,6 @@ function Factory(Module) {
       const nBytes = sqlite3.column_bytes(stmt, iCol);
       const address = f(stmt, iCol);
       const result = Module.HEAPU8.subarray(address, address + nBytes);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1419,7 +1423,6 @@ function Factory(Module) {
     return function(stmt, iCol) {
       verifyStatement(stmt);
       const result = f(stmt, iCol);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1430,7 +1433,6 @@ function Factory(Module) {
     return function(stmt) {
       verifyStatement(stmt);
       const result = f(stmt);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1441,7 +1443,6 @@ function Factory(Module) {
     return function(stmt, iCol) {
       verifyStatement(stmt);
       const result = f(stmt, iCol);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1454,7 +1455,6 @@ function Factory(Module) {
     return function(stmt, iCol) {
       verifyStatement(stmt);
       const result = f(stmt, iCol);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1467,7 +1467,6 @@ function Factory(Module) {
       const lo32 = f(stmt, iCol);
       const hi32 = Module.getTempRet0();
       const result = cvt32x2ToBigInt(lo32, hi32);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1478,7 +1477,6 @@ function Factory(Module) {
     return function(stmt, iCol) {
       verifyStatement(stmt);
       const result = f(stmt, iCol);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1498,7 +1496,6 @@ function Factory(Module) {
     return function(stmt, iCol) {
       verifyStatement(stmt);
       const result = f(stmt, iCol);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1509,30 +1506,30 @@ function Factory(Module) {
     return function(stmt, iCol) {
       verifyStatement(stmt);
       const result = f(stmt, iCol);
-      // trace(fname, result);
       return result;
     };
   })();
 
   sqlite3.create_function = function(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal) {
     verifyDatabase(db);
-    if (xFunc && !xStep && !xFinal) {
-      const result = Module.createFunction(db, zFunctionName, nArg, eTextRep, pApp, xFunc);
-      return check('sqlite3_create_function', result, db);
+    
+    // Convert SQLite callback arguments to JavaScript-friendly arguments.
+    function adapt(f) {
+      return f instanceof AsyncFunction ?
+        (async (ctx, n, values) => f(ctx, Module.HEAP32.subarray(values / 4, values / 4 + n))) :
+        ((ctx, n, values) => f(ctx, Module.HEAP32.subarray(values / 4, values / 4 + n)));
     }
 
-    if (!xFunc && xStep && xFinal) {
-      const result = Module.createAggregate(db, zFunctionName, nArg, eTextRep, pApp, xStep, xFinal);
-      return check('sqlite3_create_function', result, db);
-    }
-
-    throw new SQLiteError('invalid function combination', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
-  };
-
-  sqlite3.create_module = function(db, zName, module, appData) {
-    verifyDatabase(db);
-    const result = Module.createModule(db, zName, module, appData);
-    return check('sqlite3_create_module', result, db);
+    const result = Module.create_function(
+      db,
+      zFunctionName,
+      nArg,
+      eTextRep,
+      pApp,
+      xFunc && adapt(xFunc),
+      xStep && adapt(xStep),
+      xFinal);
+    return check('sqlite3_create_function', result, db);
   };
 
   sqlite3.data_count = (function() {
@@ -1541,20 +1538,10 @@ function Factory(Module) {
     return function(stmt) {
       verifyStatement(stmt);
       const result = f(stmt);
-      // trace(fname, result);
       return result;
     };
   })();
 
-  sqlite3.declare_vtab = (function() {
-    const fname = 'sqlite3_declare_vtab';
-    const f = Module.cwrap(fname, ...decl('ns:n'));
-    return function(pVTab, zSQL) {
-      const result = f(pVTab, zSQL);
-      return check('sqlite3_declare_vtab', result);
-    }
-  })();
-
   sqlite3.exec = async function(db, sql, callback) {
     for await (const stmt of sqlite3.statements(db, sql)) {
       let columns;
@@ -1573,13 +1560,8 @@ function Factory(Module) {
     const fname = 'sqlite3_finalize';
     const f = Module.cwrap(fname, ...decl('n:n'), { async });
     return async function(stmt) {
-      if (!mapStmtToDB.has(stmt)) {
-        return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE;
-      }
       const result = await f(stmt);
-
-      const db = mapStmtToDB.get(stmt);
-      mapStmtToDB.delete(stmt);
+      mapStmtToDB.delete(stmt)
 
       // Don't throw on error here. Typically the error has already been
       // thrown and finalize() is part of the cleanup.
@@ -1629,70 +1611,26 @@ function Factory(Module) {
     return async function(zFilename, flags, zVfs) {
       flags = flags || _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_CREATE | _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READWRITE;
       zVfs = createUTF8(zVfs);
-      Module.ccall('setup_powersync', 'int', []);
-
-      const result = await f(zFilename, tmpPtr[0], flags, zVfs);
-
-      const db = Module.getValue(tmpPtr[0], '*');
-
-      databases.add(db);
-      Module._sqlite3_free(zVfs);
-
-      Module.ccall('RegisterExtensionFunctions', 'void', ['number'], [db]);
-      check(fname, result);
-      return db;
-    };
-  })();
-
-  sqlite3.register_table_onchange_hook = function(db, callback) {
-    // Register hooks for this DB as a global hook
-    // It will call the global handler above
-    Module.ccall('register_table_update_hook', 'int', ['number'], [db]);
-
-    onTableChangeCallbacks[db] = function(opType, tableNamePtr, rowId) {
-      // Need to get the string from the pointer
-      // const tableName = Module.UTF8ToString(Module.getValue(tableNamePtr, '*'));
-      const memory = new DataView(Module.HEAPU8.buffer);
-
-      // Find the null terminator to determine the string length
-      let length = 0;
-      while (memory.getUint8(tableNamePtr + length) !== 0) {
-        length++;
-      }
-
-      // Extract the string content
-      const stringBytes = new Uint8Array(Module.HEAPU8.buffer, tableNamePtr, length);
-      const tableName = new TextDecoder().decode(stringBytes);
+      try {
+        // Allow retry operations.
+        const rc = await retry(() => f(zFilename, tmpPtr[0], flags, zVfs));
 
-      /**
-       * Call the callback inside a setTimeout to avoid blocking SQLite.
-       * We use a setTimeout only after fetching data from the heap to avoid
-       * accessing memory which has been freed. 
-       */
-      setTimeout(() => callback(opType, tableName, rowId), 0)
-    };
-  };
+        const db = Module.getValue(tmpPtr[0], '*');
+        databases.add(db);
 
-  sqlite3.prepare_v2 = (function() {
-    const fname = 'sqlite3_prepare_v2';
-    const f = Module.cwrap(fname, ...decl('nnnnn:n'), { async });
-    return async function(db, sql) {
-      const result = await f(db, sql, -1, tmpPtr[0], tmpPtr[1]);
-      check(fname, result, db);
-
-      const stmt = Module.getValue(tmpPtr[0], '*');
-      if (stmt) {
-        mapStmtToDB.set(stmt, db);
-        return { stmt, sql: Module.getValue(tmpPtr[1], '*') };
+        Module.ccall('RegisterExtensionFunctions', 'number', ['number'], [db]);
+        check(fname, rc);
+        return db;
+      } finally {
+        Module._sqlite3_free(zVfs);
       }
-      return null;
     };
   })();
 
   sqlite3.progress_handler = function(db, nProgressOps, handler, userData) {
     verifyDatabase(db);
-    Module.progressHandler(db, nProgressOps, handler, userData);
-  };
+    Module.progress_handler(db, nProgressOps, handler, userData);
+  };;
 
   sqlite3.reset = (function() {
     const fname = 'sqlite3_reset';
@@ -1802,9 +1740,27 @@ function Factory(Module) {
     return row;
   };
 
-  sqlite3.set_authorizer = function(db, authFunction, userData) {
+  sqlite3.set_authorizer = function(db, xAuth, pApp) {
     verifyDatabase(db);
-    const result = Module.setAuthorizer(db, authFunction, userData);
+
+    // Convert SQLite callback arguments to JavaScript-friendly arguments.
+    function cvtArgs(_, iAction, p3, p4, p5, p6) {
+      return [
+        _,
+        iAction,
+        Module.UTF8ToString(p3),
+        Module.UTF8ToString(p4),
+        Module.UTF8ToString(p5),
+        Module.UTF8ToString(p6)
+      ];
+    };
+    function adapt(f) {
+      return f instanceof AsyncFunction ?
+        (async (_, iAction, p3, p4, p5, p6) => f(...cvtArgs(_, iAction, p3, p4, p5, p6))) :
+        ((_, iAction, p3, p4, p5, p6) => f(...cvtArgs(_, iAction, p3, p4, p5, p6)));
+    }
+
+    const result = Module.set_authorizer(db, adapt(xAuth), pApp);
     return check('sqlite3_set_authorizer', result, db);
   };
 
@@ -1814,27 +1770,80 @@ function Factory(Module) {
     return function(stmt) {
       verifyStatement(stmt);
       const result = f(stmt);
-      // trace(fname, result);
       return result;
     };
   })();
 
-  sqlite3.statements = function(db, sql) {
+  sqlite3.statements = function(db, sql, options = {}) {
+    const prepare = Module.cwrap(
+      'sqlite3_prepare_v3',
+      'number',
+      ['number', 'number', 'number', 'number', 'number', 'number'],
+      { async: true });
+
     return (async function*() {
-      const str = sqlite3.str_new(db, sql);
-      let prepared = { stmt: null, sql: sqlite3.str_value(str) };
+      const onFinally = [];
       try {
-        while ((prepared = await sqlite3.prepare_v2(db, prepared.sql))) {
-          // console.log(sqlite3.sql(prepared.stmt));
-          yield prepared.stmt;
-          sqlite3.finalize(prepared.stmt);
-          prepared.stmt = null;
+        // Encode SQL string to UTF-8.
+        const utf8 = new TextEncoder().encode(sql);
+
+        // Copy encoded string to WebAssembly memory. The SQLite docs say
+        // zero-termination is a minor optimization so add room for that.
+        // Also add space for the statement handle and SQL tail pointer.
+        const allocSize = utf8.byteLength - (utf8.byteLength % 4) + 12;
+        const pzHead = Module._sqlite3_malloc(allocSize);
+        const pzEnd = pzHead + utf8.byteLength + 1;
+        onFinally.push(() => Module._sqlite3_free(pzHead));
+        Module.HEAPU8.set(utf8, pzHead);
+        Module.HEAPU8[pzEnd - 1] = 0;
+  
+        // Use extra space for the statement handle and SQL tail pointer.
+        const pStmt = pzHead + allocSize - 8;
+        const pzTail = pzHead + allocSize - 4;
+
+        // Ensure that statement handles are not leaked.
+        let stmt;
+        function maybeFinalize() {
+          if (stmt && !options.unscoped) {
+            sqlite3.finalize(stmt);
+          }
+          stmt = 0;
         }
+        onFinally.push(maybeFinalize);
+        
+        // Loop over statements.
+        Module.setValue(pzTail, pzHead, '*');
+        do {
+          // Reclaim resources for the previous iteration.
+          maybeFinalize();
+
+          // Call sqlite3_prepare_v3() for the next statement.
+          // Allow retry operations.
+          const zTail = Module.getValue(pzTail, '*');
+          const rc = await retry(() => {
+            return prepare(
+              db,
+              zTail,
+              pzEnd - pzTail,
+              options.flags || 0,
+              pStmt,
+              pzTail);
+          });
+
+          if (rc !== _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK) {
+            check('sqlite3_prepare_v3', rc, db);
+          }
+          
+          stmt = Module.getValue(pStmt, '*');
+          if (stmt) {
+            mapStmtToDB.set(stmt, db);
+            yield stmt;
+          }
+        } while (stmt);
       } finally {
-        if (prepared?.stmt) {
-          sqlite3.finalize(prepared.stmt);
+        while (onFinally.length) {
+          onFinally.pop()();
         }
-        sqlite3.str_finish(str);
       }
     })();
   };
@@ -1844,68 +1853,39 @@ function Factory(Module) {
     const f = Module.cwrap(fname, ...decl('n:n'), { async });
     return async function(stmt) {
       verifyStatement(stmt);
-      const result = await f(stmt);
-      return check(fname, result, mapStmtToDB.get(stmt), [_sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW, _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE]);
-    };
-  })();
 
-  // Duplicate some of the SQLite dynamic string API but without
-  // calling SQLite (except for memory allocation). We need some way
-  // to transfer Javascript strings and might as well use an API
-  // that mimics the SQLite API.
-  let stringId = 0;
-  const strings = new Map();
-
-  sqlite3.str_new = function(db, s = '') {
-    const sBytes = Module.lengthBytesUTF8(s);
-    const str = stringId++ & 0xffffffff;
-    const data = {
-      offset: Module._sqlite3_malloc(sBytes + 1),
-      bytes: sBytes
+      // Allow retry operations.
+      const rc = await retry(() => f(stmt));
+
+      return check(fname, rc, mapStmtToDB.get(stmt), [_sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW, _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE]);
     };
-    strings.set(str, data);
-    Module.stringToUTF8(s, data.offset, data.bytes + 1);
-    return str;
-  };
+  })();
 
-  sqlite3.str_appendall = function(str, s) {
-    if (!strings.has(str)) {
-      throw new SQLiteError('not a string', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
-    }
-    const data = strings.get(str);
-
-    const sBytes = Module.lengthBytesUTF8(s);
-    const newBytes = data.bytes + sBytes;
-    const newOffset = Module._sqlite3_malloc(newBytes + 1);
-    const newArray = Module.HEAPU8.subarray(newOffset, newOffset + newBytes + 1);
-    newArray.set(Module.HEAPU8.subarray(data.offset, data.offset + data.bytes));
-    Module.stringToUTF8(s, newOffset + data.bytes, sBytes + 1);
-
-    Module._sqlite3_free(data.offset);
-    data.offset = newOffset;
-    data.bytes = newBytes;
-    strings.set(str, data);
+  sqlite3.commit_hook = function(db, xCommitHook) {
+    verifyDatabase(db);
+    Module.commit_hook(db, xCommitHook);
   };
 
-  sqlite3.str_finish = function(str) {
-    if (!strings.has(str)) {
-      throw new SQLiteError('not a string', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
-    }
-    const data = strings.get(str);
-    strings.delete(str);
-    Module._sqlite3_free(data.offset);
-  };
+  sqlite3.update_hook = function(db, xUpdateHook) {
+    verifyDatabase(db);
 
-  sqlite3.str_value = function(str) {
-    if (!strings.has(str)) {
-      throw new SQLiteError('not a string', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
+    // Convert SQLite callback arguments to JavaScript-friendly arguments.
+    function cvtArgs(iUpdateType, dbName, tblName, lo32, hi32) {
+      return [
+        iUpdateType,
+        Module.UTF8ToString(dbName),
+        Module.UTF8ToString(tblName),
+		cvt32x2ToBigInt(lo32, hi32)
+      ];
+    };
+    function adapt(f) {
+      return f instanceof AsyncFunction ?
+        (async (iUpdateType, dbName, tblName, lo32, hi32) => f(...cvtArgs(iUpdateType, dbName, tblName, lo32, hi32))) :
+        ((iUpdateType, dbName, tblName, lo32, hi32) => f(...cvtArgs(iUpdateType, dbName, tblName, lo32, hi32)));
     }
-    return strings.get(str).offset;
-  };
 
-  sqlite3.user_data = function(context) {
-    return Module.getFunctionUserData(context);
-  };
+    Module.update_hook(db, adapt(xUpdateHook));
+  };;
 
   sqlite3.value = function(pValue) {
     const type = sqlite3.value_type(pValue);
@@ -1934,7 +1914,6 @@ function Factory(Module) {
       const nBytes = sqlite3.value_bytes(pValue);
       const address = f(pValue);
       const result = Module.HEAPU8.subarray(address, address + nBytes);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1944,7 +1923,6 @@ function Factory(Module) {
     const f = Module.cwrap(fname, ...decl('n:n'));
     return function(pValue) {
       const result = f(pValue);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1954,7 +1932,6 @@ function Factory(Module) {
     const f = Module.cwrap(fname, ...decl('n:n'));
     return function(pValue) {
       const result = f(pValue);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1964,7 +1941,6 @@ function Factory(Module) {
     const f = Module.cwrap(fname, ...decl('n:n'));
     return function(pValue) {
       const result = f(pValue);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1976,7 +1952,6 @@ function Factory(Module) {
       const lo32 = f(pValue);
       const hi32 = Module.getTempRet0();
       const result = cvt32x2ToBigInt(lo32, hi32);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1986,7 +1961,6 @@ function Factory(Module) {
     const f = Module.cwrap(fname, ...decl('n:s'));
     return function(pValue) {
       const result = f(pValue);
-      // trace(fname, result);
       return result;
     };
   })();
@@ -1996,33 +1970,42 @@ function Factory(Module) {
     const f = Module.cwrap(fname, ...decl('n:n'));
     return function(pValue) {
       const result = f(pValue);
-      // trace(fname, result);
       return result;
     };
   })();
 
   sqlite3.vfs_register = function(vfs, makeDefault) {
-    const result = Module.registerVFS(vfs, makeDefault);
+    const result = Module.vfs_register(vfs, makeDefault);
     return check('sqlite3_vfs_register', result);
   };
 
   function check(fname, result, db = null, allowed = [_sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK]) {
-    // trace(fname, result);
     if (allowed.includes(result)) return result;
     const message = db ? Module.ccall('sqlite3_errmsg', 'string', ['number'], [db]) : fname;
     throw new SQLiteError(message, result);
   }
 
-  return sqlite3;
-}
+  // This function is used to automatically retry failed calls that
+  // have pending retry operations that should allow the retry to
+  // succeed.
+  async function retry(f) {
+    let rc;
+    do {
+      // Wait for all pending retry operations to complete. This is
+      // normally empty on the first loop iteration.
+      if (Module.retryOps.length) {
+        await Promise.all(Module.retryOps);
+        Module.retryOps = [];
+      }
+      
+      rc = await f();
+
+      // Retry on failure with new pending retry operations.
+    } while (rc && Module.retryOps.length);
+    return rc;
+  }
 
-function trace(...args) {
-  // const date = new Date();
-  // const t = date.getHours().toString().padStart(2, '0') + ':' +
-  //           date.getMinutes().toString().padStart(2, '0') + ':' +
-  //           date.getSeconds().toString().padStart(2, '0') + '.' +
-  //           date.getMilliseconds().toString().padStart(3, '0');
-  // console.debug(t, ...args);
+  return sqlite3;
 }
 
 // Helper function to use a more compact signature specification.
@@ -2271,6 +2254,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   SQLITE_OPEN_WAL: () => (/* binding */ SQLITE_OPEN_WAL),
 /* harmony export */   SQLITE_PERM: () => (/* binding */ SQLITE_PERM),
 /* harmony export */   SQLITE_PRAGMA: () => (/* binding */ SQLITE_PRAGMA),
+/* harmony export */   SQLITE_PREPARE_NORMALIZED: () => (/* binding */ SQLITE_PREPARE_NORMALIZED),
+/* harmony export */   SQLITE_PREPARE_NO_VTAB: () => (/* binding */ SQLITE_PREPARE_NO_VTAB),
+/* harmony export */   SQLITE_PREPARE_PERSISTENT: () => (/* binding */ SQLITE_PREPARE_PERSISTENT),
 /* harmony export */   SQLITE_PROTOCOL: () => (/* binding */ SQLITE_PROTOCOL),
 /* harmony export */   SQLITE_RANGE: () => (/* binding */ SQLITE_RANGE),
 /* harmony export */   SQLITE_READ: () => (/* binding */ SQLITE_READ),
@@ -2569,6 +2555,10 @@ const SQLITE_LIMIT_VARIABLE_NUMBER     = 9;
 const SQLITE_LIMIT_TRIGGER_DEPTH       = 10;
 const SQLITE_LIMIT_WORKER_THREADS      = 11;
 
+const SQLITE_PREPARE_PERSISTENT = 0x01;
+const SQLITE_PREPARE_NORMALIZED = 0x02;
+const SQLITE_PREPARE_NO_VTAB = 0x04;
+
 /***/ })
 
 /******/ 	});