Merging upstream version 3.46.0.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

13 files changed, 854 insertions, 591 deletions

diff --git a/ext/wasm/api/README.md b/ext/wasm/api/README.md
index eb0f073..ebd4aaa 100644
--- a/ext/wasm/api/README.md
+++ b/ext/wasm/api/README.md
@@ -78,10 +78,12 @@ browser client:
       a Promise-based interface into the Worker #1 API. This is
       a far user-friendlier way to interface with databases running
       in a Worker thread.
-- **`sqlite3-v-helper.js`**\  
-  Installs `sqlite3.vfs` and `sqlite3.vtab`, namespaces which contain
-  helpers for use by downstream code which creates `sqlite3_vfs`
-  and `sqlite3_module` implementations.
+- **`sqlite3-vfs-helper.js`**\  
+  Installs the `sqlite3.vfs` namespace, which contain helpers for use
+  by downstream code which creates `sqlite3_vfs` implementations.
+- **`sqlite3-vtab-helper.js`**\  
+  Installs the `sqlite3.vtab` namespace, which contain helpers for use
+  by downstream code which creates `sqlite3_module` implementations.
 - **`sqlite3-vfs-opfs.c-pp.js`**\  
   is an sqlite3 VFS implementation which supports the Origin-Private
   FileSystem (OPFS) as a storage layer to provide persistent storage
diff --git a/ext/wasm/api/post-js-header.js b/ext/wasm/api/post-js-header.js
index 0e27e1f..7fd82a7 100644
--- a/ext/wasm/api/post-js-header.js
+++ b/ext/wasm/api/post-js-header.js
@@ -19,8 +19,10 @@ Module.postRun.push(function(Module/*the Emscripten-style module object*/){
      - sqlite3-api-glue.js      => glues previous parts together
      - sqlite3-api-oo.js        => SQLite3 OO API #1
      - sqlite3-api-worker1.js   => Worker-based API
-     - sqlite3-vfs-helper.js    => Internal-use utilities for...
-     - sqlite3-vfs-opfs.js      => OPFS VFS
+     - sqlite3-vfs-helper.c-pp.js  => Utilities for VFS impls
+     - sqlite3-vtab-helper.c-pp.js => Utilities for virtual table impls
+     - sqlite3-vfs-opfs.c-pp.js  => OPFS VFS
+     - sqlite3-vfs-opfs-sahpool.c-pp.js => OPFS SAHPool VFS
      - sqlite3-api-cleanup.js   => final API cleanup
      - post-js-footer.js        => closes this postRun() function
   */
diff --git a/ext/wasm/api/sqlite3-api-glue.js b/ext/wasm/api/sqlite3-api-glue.js
index 29efb3e..83b2ee1 100644
--- a/ext/wasm/api/sqlite3-api-glue.js
+++ b/ext/wasm/api/sqlite3-api-glue.js
@@ -14,7 +14,8 @@
   previous steps of the sqlite3-api.js bootstrapping process:
   sqlite3-api-prologue.js, whwasmutil.js, and jaccwabyt.js. It
   initializes the main API pieces so that the downstream components
-  (e.g. sqlite3-api-oo1.js) have all that they need.
+  (e.g. sqlite3-api-oo1.js) have all of the infrastructure that they
+  need.
 */
 globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
   'use strict';
@@ -328,7 +329,16 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
     wasm.bindingSignatures.push(["sqlite3_normalized_sql", "string", "sqlite3_stmt*"]);
   }
 
-  if(wasm.exports.sqlite3_activate_see instanceof Function){
+//#if enable-see
+  if(wasm.exports.sqlite3_key_v2 instanceof Function){
+    /**
+       This code is capable of using an SEE build but note that an SEE
+       WASM build is generally incompatible with SEE's license
+       conditions. It is permitted for use internally in organizations
+       which have licensed SEE, but not for public sites because
+       exposing an SEE build of sqlite3.wasm effectively provides all
+       clients with a working copy of the commercial SEE code.
+    */
     wasm.bindingSignatures.push(
       ["sqlite3_key", "int", "sqlite3*", "string", "int"],
       ["sqlite3_key_v2","int","sqlite3*","string","*","int"],
@@ -337,10 +347,14 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
       ["sqlite3_activate_see", undefined, "string"]
     );
   }
+//#endif enable-see
+
   /**
      Functions which require BigInt (int64) support are separated from
      the others because we need to conditionally bind them or apply
      dummy impls, depending on the capabilities of the environment.
+     (That said: we never actually build without BigInt support,
+     and such builds are untested.)
 
      Note that not all of these functions directly require int64
      but are only for use with APIs which require int64. For example,
@@ -359,7 +373,10 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
     /* Careful! Short version: de/serialize() are problematic because they
        might use a different allocator than the user for managing the
        deserialized block. de/serialize() are ONLY safe to use with
-       sqlite3_malloc(), sqlite3_free(), and its 64-bit variants. */,
+       sqlite3_malloc(), sqlite3_free(), and its 64-bit variants. Because
+       of this, the canonical builds of sqlite3.wasm/js guarantee that
+       sqlite3.wasm.alloc() and friends use those allocators. Custom builds
+       may not guarantee that, however. */,
     ["sqlite3_drop_modules", "int", ["sqlite3*", "**"]],
     ["sqlite3_last_insert_rowid", "i64", ["sqlite3*"]],
     ["sqlite3_malloc64", "*","i64"],
@@ -422,8 +439,6 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
 
   // Add session/changeset APIs...
   if(wasm.bigIntEnabled && !!wasm.exports.sqlite3changegroup_add){
-    /* ACHTUNG: 2022-12-23: the session/changeset API bindings are
-       COMPLETELY UNTESTED. */
     /**
        FuncPtrAdapter options for session-related callbacks with the
        native signature "i(ps)". This proxy converts the 2nd argument
@@ -601,16 +616,25 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
   /**
      Functions which are intended solely for API-internal use by the
      WASM components, not client code. These get installed into
-     sqlite3.wasm. Some of them get exposed to clients via variants
-     named sqlite3_js_...().
+     sqlite3.util. Some of them get exposed to clients via variants
+     in sqlite3_js_...().
+
+     2024-01-11: these were renamed, with two underscores in the
+     prefix, to ensure that clients do not accidentally depend on
+     them.  They have always been documented as internal-use-only, so
+     no clients "should" be depending on the old names.
   */
-  wasm.bindingSignatures.wasm = [
-    ["sqlite3_wasm_db_reset", "int", "sqlite3*"],
-    ["sqlite3_wasm_db_vfs", "sqlite3_vfs*", "sqlite3*","string"],
-    ["sqlite3_wasm_vfs_create_file", "int",
-     "sqlite3_vfs*","string","*", "int"],
-    ["sqlite3_wasm_posix_create_file", "int", "string","*", "int"],
-    ["sqlite3_wasm_vfs_unlink", "int", "sqlite3_vfs*","string"]
+  wasm.bindingSignatures.wasmInternal = [
+    ["sqlite3__wasm_db_reset", "int", "sqlite3*"],
+    ["sqlite3__wasm_db_vfs", "sqlite3_vfs*", "sqlite3*","string"],
+    [/* DO NOT USE. This is deprecated since 2023-08-11 because it can
+        trigger assert() in debug builds when used with file sizes
+        which are not sizes to a multiple of a valid db page size. */
+      "sqlite3__wasm_vfs_create_file", "int", "sqlite3_vfs*","string","*", "int"
+    ],
+    ["sqlite3__wasm_posix_create_file", "int", "string","*", "int"],
+    ["sqlite3__wasm_vfs_unlink", "int", "sqlite3_vfs*","string"],
+    ["sqlite3__wasm_qfmt_token","string:dealloc", "string","int"]
   ];
 
   /**
@@ -652,7 +676,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
 
        Use case: sqlite3_bind_pointer() and sqlite3_result_pointer()
        call for "a static string and preferably a string
-       literal". This converter is used to ensure that the string
+       literal." This converter is used to ensure that the string
        value seen by those functions is long-lived and behaves as they
        need it to.
     */
@@ -674,14 +698,15 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
        `sqlite3_vfs*` via capi.sqlite3_vfs.pointer.
     */
     const __xArgPtr = wasm.xWrap.argAdapter('*');
-    const nilType = function(){}/*a class no value can ever be an instance of*/;
+    const nilType = function(){
+      /*a class which no value can ever be an instance of*/
+    };
     wasm.xWrap.argAdapter('sqlite3_filename', __xArgPtr)
     ('sqlite3_context*', __xArgPtr)
     ('sqlite3_value*', __xArgPtr)
     ('void*', __xArgPtr)
     ('sqlite3_changegroup*', __xArgPtr)
     ('sqlite3_changeset_iter*', __xArgPtr)
-    //('sqlite3_rebaser*', __xArgPtr)
     ('sqlite3_session*', __xArgPtr)
     ('sqlite3_stmt*', (v)=>
       __xArgPtr((v instanceof (sqlite3?.oo1?.Stmt || nilType))
@@ -742,8 +767,8 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
     for(const e of wasm.bindingSignatures){
       capi[e[0]] = wasm.xWrap.apply(null, e);
     }
-    for(const e of wasm.bindingSignatures.wasm){
-      wasm[e[0]] = wasm.xWrap.apply(null, e);
+    for(const e of wasm.bindingSignatures.wasmInternal){
+      util[e[0]] = wasm.xWrap.apply(null, e);
     }
 
     /* For C API functions which cannot work properly unless
@@ -765,9 +790,9 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
        implicitly making it part of the public interface. */
     delete wasm.bindingSignatures;
 
-    if(wasm.exports.sqlite3_wasm_db_error){
+    if(wasm.exports.sqlite3__wasm_db_error){
       const __db_err = wasm.xWrap(
-        'sqlite3_wasm_db_error', 'int', 'sqlite3*', 'int', 'string'
+        'sqlite3__wasm_db_error', 'int', 'sqlite3*', 'int', 'string'
       );
       /**
          Sets the given db's error state. Accepts:
@@ -785,7 +810,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
          Returns the resulting code. Pass (pDb,0,0) to clear the error
          state.
        */
-      util.sqlite3_wasm_db_error = function(pDb, resultCode, message){
+      util.sqlite3__wasm_db_error = function(pDb, resultCode, message){
         if(resultCode instanceof sqlite3.WasmAllocError){
           resultCode = capi.SQLITE_NOMEM;
           message = 0 /*avoid allocating message string*/;
@@ -796,17 +821,17 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         return pDb ? __db_err(pDb, resultCode, message) : resultCode;
       };
     }else{
-      util.sqlite3_wasm_db_error = function(pDb,errCode,msg){
-        console.warn("sqlite3_wasm_db_error() is not exported.",arguments);
+      util.sqlite3__wasm_db_error = function(pDb,errCode,msg){
+        console.warn("sqlite3__wasm_db_error() is not exported.",arguments);
         return errCode;
       };
     }
   }/*xWrap() bindings*/
 
   {/* Import C-level constants and structs... */
-    const cJson = wasm.xCall('sqlite3_wasm_enum_json');
+    const cJson = wasm.xCall('sqlite3__wasm_enum_json');
     if(!cJson){
-      toss("Maintenance required: increase sqlite3_wasm_enum_json()'s",
+      toss("Maintenance required: increase sqlite3__wasm_enum_json()'s",
            "static buffer size!");
     }
     //console.debug('wasm.ctype length =',wasm.cstrlen(cJson));
@@ -877,7 +902,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         delete capi[k];
       }
       capi.sqlite3_vtab_config = wasm.xWrap(
-        'sqlite3_wasm_vtab_config','int',[
+        'sqlite3__wasm_vtab_config','int',[
           'sqlite3*', 'int', 'int']
       );
     }/* end vtab-related setup */
@@ -889,7 +914,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
      consistency with non-special-case wrappings.
   */
   const __dbArgcMismatch = (pDb,f,n)=>{
-    return util.sqlite3_wasm_db_error(pDb, capi.SQLITE_MISUSE,
+    return util.sqlite3__wasm_db_error(pDb, capi.SQLITE_MISUSE,
                                       f+"() requires "+n+" argument"+
                                       (1===n?"":'s')+".");
   };
@@ -898,7 +923,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
       argument and require SQLITE_UTF8.  Sets the db error code to
       SQLITE_FORMAT and returns that code. */
   const __errEncoding = (pDb)=>{
-    return util.sqlite3_wasm_db_error(
+    return util.sqlite3__wasm_db_error(
       pDb, capi.SQLITE_FORMAT, "SQLITE_UTF8 is the only supported encoding."
     );
   };
@@ -1128,7 +1153,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         }
         return rc;
       }catch(e){
-        return util.sqlite3_wasm_db_error(pDb, e);
+        return util.sqlite3__wasm_db_error(pDb, e);
       }
     };
 
@@ -1254,7 +1279,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         return rc;
       }catch(e){
         console.error("sqlite3_create_function_v2() setup threw:",e);
-        return util.sqlite3_wasm_db_error(pDb, e, "Creation of UDF threw: "+e);
+        return util.sqlite3__wasm_db_error(pDb, e, "Creation of UDF threw: "+e);
       }
     };
 
@@ -1299,7 +1324,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         return rc;
       }catch(e){
         console.error("sqlite3_create_window_function() setup threw:",e);
-        return util.sqlite3_wasm_db_error(pDb, e, "Creation of UDF threw: "+e);
+        return util.sqlite3__wasm_db_error(pDb, e, "Creation of UDF threw: "+e);
       }
     };
     /**
@@ -1394,7 +1419,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
           case 'string': return __prepare.basic(pDb, xSql, xSqlLen, prepFlags, ppStmt, null);
           case 'number': return __prepare.full(pDb, xSql, xSqlLen, prepFlags, ppStmt, pzTail);
           default:
-            return util.sqlite3_wasm_db_error(
+            return util.sqlite3__wasm_db_error(
               pDb, capi.SQLITE_MISUSE,
               "Invalid SQL argument type for sqlite3_prepare_v2/v3()."
             );
@@ -1438,7 +1463,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         }else if('string'===typeof text){
           [p, n] = wasm.allocCString(text);
         }else{
-          return util.sqlite3_wasm_db_error(
+          return util.sqlite3__wasm_db_error(
             capi.sqlite3_db_handle(pStmt), capi.SQLITE_MISUSE,
             "Invalid 3rd argument type for sqlite3_bind_text()."
           );
@@ -1446,7 +1471,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         return __bindText(pStmt, iCol, p, n, capi.SQLITE_WASM_DEALLOC);
       }catch(e){
         wasm.dealloc(p);
-        return util.sqlite3_wasm_db_error(
+        return util.sqlite3__wasm_db_error(
           capi.sqlite3_db_handle(pStmt), e
         );
       }
@@ -1472,7 +1497,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         }else if('string'===typeof pMem){
           [p, n] = wasm.allocCString(pMem);
         }else{
-          return util.sqlite3_wasm_db_error(
+          return util.sqlite3__wasm_db_error(
             capi.sqlite3_db_handle(pStmt), capi.SQLITE_MISUSE,
             "Invalid 3rd argument type for sqlite3_bind_blob()."
           );
@@ -1480,7 +1505,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
         return __bindBlob(pStmt, iCol, p, n, capi.SQLITE_WASM_DEALLOC);
       }catch(e){
         wasm.dealloc(p);
-        return util.sqlite3_wasm_db_error(
+        return util.sqlite3__wasm_db_error(
           capi.sqlite3_db_handle(pStmt), e
         );
       }
@@ -1504,11 +1529,11 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
           case capi.SQLITE_CONFIG_SORTERREF_SIZE: // 28  /* int nByte */
           case capi.SQLITE_CONFIG_STMTJRNL_SPILL: // 26  /* int nByte */
           case capi.SQLITE_CONFIG_URI:// 17  /* int */
-            return wasm.exports.sqlite3_wasm_config_i(op, args[0]);
+            return wasm.exports.sqlite3__wasm_config_i(op, args[0]);
           case capi.SQLITE_CONFIG_LOOKASIDE: // 13  /* int int */
-            return wasm.exports.sqlite3_wasm_config_ii(op, args[0], args[1]);
+            return wasm.exports.sqlite3__wasm_config_ii(op, args[0], args[1]);
           case capi.SQLITE_CONFIG_MEMDB_MAXSIZE: // 29  /* sqlite3_int64 */
-            return wasm.exports.sqlite3_wasm_config_j(op, args[0]);
+            return wasm.exports.sqlite3__wasm_config_j(op, args[0]);
           case capi.SQLITE_CONFIG_GETMALLOC: // 5 /* sqlite3_mem_methods* */
           case capi.SQLITE_CONFIG_GETMUTEX: // 11  /* sqlite3_mutex_methods* */
           case capi.SQLITE_CONFIG_GETPCACHE2: // 19  /* sqlite3_pcache_methods2* */
@@ -1529,6 +1554,10 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
           case capi.SQLITE_CONFIG_SQLLOG: // 21  /* xSqllog, void* */
           case capi.SQLITE_CONFIG_WIN32_HEAPSIZE: // 23  /* int nByte */
           default:
+          /* maintenance note: we specifically do not include
+             SQLITE_CONFIG_ROWID_IN_VIEW here, on the grounds that
+             it's only for legacy support and no apps written with
+             this API require that. */
             return capi.SQLITE_NOTFOUND;
       }
     };
@@ -1574,11 +1603,11 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
   if( pKvvfs ){/* kvvfs-specific glue */
     if(util.isUIThread()){
       const kvvfsMethods = new capi.sqlite3_kvvfs_methods(
-        wasm.exports.sqlite3_wasm_kvvfs_methods()
+        wasm.exports.sqlite3__wasm_kvvfs_methods()
       );
       delete capi.sqlite3_kvvfs_methods;
 
-      const kvvfsMakeKey = wasm.exports.sqlite3_wasm_kvvfsMakeKeyOnPstack,
+      const kvvfsMakeKey = wasm.exports.sqlite3__wasm_kvvfsMakeKeyOnPstack,
             pstack = wasm.pstack;
 
       const kvvfsStorage = (zClass)=>
@@ -1587,7 +1616,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
 
       /**
          Implementations for members of the object referred to by
-         sqlite3_wasm_kvvfs_methods(). We swap out the native
+         sqlite3__wasm_kvvfs_methods(). We swap out the native
          implementations with these, which use localStorage or
          sessionStorage for their backing store.
       */
@@ -1667,5 +1696,181 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
     }
   }/*pKvvfs*/
 
+  /* Warn if client-level code makes use of FuncPtrAdapter. */
   wasm.xWrap.FuncPtrAdapter.warnOnUse = true;
+
+  const StructBinder = sqlite3.StructBinder
+  /* we require a local alias b/c StructBinder is removed from the sqlite3
+     object during the final steps of the API cleanup. */;
+  /**
+     Installs a StructBinder-bound function pointer member of the
+     given name and function in the given StructBinder.StructType
+     target object.
+
+     It creates a WASM proxy for the given function and arranges for
+     that proxy to be cleaned up when tgt.dispose() is called. Throws
+     on the slightest hint of error, e.g. tgt is-not-a StructType,
+     name does not map to a struct-bound member, etc.
+
+     As a special case, if the given function is a pointer, then
+     `wasm.functionEntry()` is used to validate that it is a known
+     function. If so, it is used as-is with no extra level of proxying
+     or cleanup, else an exception is thrown. It is legal to pass a
+     value of 0, indicating a NULL pointer, with the caveat that 0
+     _is_ a legal function pointer in WASM but it will not be accepted
+     as such _here_. (Justification: the function at address zero must
+     be one which initially came from the WASM module, not a method we
+     want to bind to a virtual table or VFS.)
+
+     This function returns a proxy for itself which is bound to tgt
+     and takes 2 args (name,func). That function returns the same
+     thing as this one, permitting calls to be chained.
+
+     If called with only 1 arg, it has no side effects but returns a
+     func with the same signature as described above.
+
+     ACHTUNG: because we cannot generically know how to transform JS
+     exceptions into result codes, the installed functions do no
+     automatic catching of exceptions. It is critical, to avoid
+     undefined behavior in the C layer, that methods mapped via
+     this function do not throw. The exception, as it were, to that
+     rule is...
+
+     If applyArgcCheck is true then each JS function (as opposed to
+     function pointers) gets wrapped in a proxy which asserts that it
+     is passed the expected number of arguments, throwing if the
+     argument count does not match expectations. That is only intended
+     for dev-time usage for sanity checking, and may leave the C
+     environment in an undefined state.
+  */
+  const installMethod = function callee(
+    tgt, name, func, applyArgcCheck = callee.installMethodArgcCheck
+  ){
+    if(!(tgt instanceof StructBinder.StructType)){
+      toss("Usage error: target object is-not-a StructType.");
+    }else if(!(func instanceof Function) && !wasm.isPtr(func)){
+      toss("Usage errror: expecting a Function or WASM pointer to one.");
+    }
+    if(1===arguments.length){
+      return (n,f)=>callee(tgt, n, f, applyArgcCheck);
+    }
+    if(!callee.argcProxy){
+      callee.argcProxy = function(tgt, funcName, func,sig){
+        return function(...args){
+          if(func.length!==arguments.length){
+            toss("Argument mismatch for",
+                 tgt.structInfo.name+"::"+funcName
+                 +": Native signature is:",sig);
+          }
+          return func.apply(this, args);
+        }
+      };
+      /* An ondispose() callback for use with
+         StructBinder-created types. */
+      callee.removeFuncList = function(){
+        if(this.ondispose.__removeFuncList){
+          this.ondispose.__removeFuncList.forEach(
+            (v,ndx)=>{
+              if('number'===typeof v){
+                try{wasm.uninstallFunction(v)}
+                catch(e){/*ignore*/}
+              }
+              /* else it's a descriptive label for the next number in
+                 the list. */
+            }
+          );
+          delete this.ondispose.__removeFuncList;
+        }
+      };
+    }/*static init*/
+    const sigN = tgt.memberSignature(name);
+    if(sigN.length<2){
+      toss("Member",name,"does not have a function pointer signature:",sigN);
+    }
+    const memKey = tgt.memberKey(name);
+    const fProxy = (applyArgcCheck && !wasm.isPtr(func))
+    /** This middle-man proxy is only for use during development, to
+        confirm that we always pass the proper number of
+        arguments. We know that the C-level code will always use the
+        correct argument count. */
+          ? callee.argcProxy(tgt, memKey, func, sigN)
+          : func;
+    if(wasm.isPtr(fProxy)){
+      if(fProxy && !wasm.functionEntry(fProxy)){
+        toss("Pointer",fProxy,"is not a WASM function table entry.");
+      }
+      tgt[memKey] = fProxy;
+    }else{
+      const pFunc = wasm.installFunction(fProxy, tgt.memberSignature(name, true));
+      tgt[memKey] = pFunc;
+      if(!tgt.ondispose || !tgt.ondispose.__removeFuncList){
+        tgt.addOnDispose('ondispose.__removeFuncList handler',
+                         callee.removeFuncList);
+        tgt.ondispose.__removeFuncList = [];
+      }
+      tgt.ondispose.__removeFuncList.push(memKey, pFunc);
+    }
+    return (n,f)=>callee(tgt, n, f, applyArgcCheck);
+  }/*installMethod*/;
+  installMethod.installMethodArgcCheck = false;
+
+  /**
+     Installs methods into the given StructBinder.StructType-type
+     instance. Each entry in the given methods object must map to a
+     known member of the given StructType, else an exception will be
+     triggered.  See installMethod() for more details, including the
+     semantics of the 3rd argument.
+
+     As an exception to the above, if any two or more methods in the
+     2nd argument are the exact same function, installMethod() is
+     _not_ called for the 2nd and subsequent instances, and instead
+     those instances get assigned the same method pointer which is
+     created for the first instance. This optimization is primarily to
+     accommodate special handling of sqlite3_module::xConnect and
+     xCreate methods.
+
+     On success, returns its first argument. Throws on error.
+  */
+  const installMethods = function(
+    structInstance, methods, applyArgcCheck = installMethod.installMethodArgcCheck
+  ){
+    const seen = new Map /* map of <Function, memberName> */;
+    for(const k of Object.keys(methods)){
+      const m = methods[k];
+      const prior = seen.get(m);
+      if(prior){
+        const mkey = structInstance.memberKey(k);
+        structInstance[mkey] = structInstance[structInstance.memberKey(prior)];
+      }else{
+        installMethod(structInstance, k, m, applyArgcCheck);
+        seen.set(m, k);
+      }
+    }
+    return structInstance;
+  };
+
+  /**
+     Equivalent to calling installMethod(this,...arguments) with a
+     first argument of this object. If called with 1 or 2 arguments
+     and the first is an object, it's instead equivalent to calling
+     installMethods(this,...arguments).
+  */
+  StructBinder.StructType.prototype.installMethod = function callee(
+    name, func, applyArgcCheck = installMethod.installMethodArgcCheck
+  ){
+    return (arguments.length < 3 && name && 'object'===typeof name)
+      ? installMethods(this, ...arguments)
+      : installMethod(this, ...arguments);
+  };
+
+  /**
+     Equivalent to calling installMethods() with a first argument
+     of this object.
+  */
+  StructBinder.StructType.prototype.installMethods = function(
+    methods, applyArgcCheck = installMethod.installMethodArgcCheck
+  ){
+    return installMethods(this, methods, applyArgcCheck);
+  };
+
 });
diff --git a/ext/wasm/api/sqlite3-api-oo1.js b/ext/wasm/api/sqlite3-api-oo1.js
index 160d59d..e557cbd 100644
--- a/ext/wasm/api/sqlite3-api-oo1.js
+++ b/ext/wasm/api/sqlite3-api-oo1.js
@@ -87,6 +87,104 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
   */
   const __vfsPostOpenSql = Object.create(null);
 
+//#if enable-see
+  /**
+     Converts ArrayBuffer or Uint8Array ba into a string of hex
+     digits.
+  */
+  const byteArrayToHex = function(ba){
+    if( ba instanceof ArrayBuffer ){
+      ba = new Uint8Array(ba);
+    }
+    const li = [];
+    const digits = "0123456789abcdef";
+    for( const d of ba ){
+      li.push( digits[(d & 0xf0) >> 4], digits[d & 0x0f] );
+    }
+    return li.join('');
+  };
+
+  /**
+     Internal helper to apply an SEE key to a just-opened
+     database. Requires that db be-a DB object which has just been
+     opened, opt be the options object processed by its ctor, and opt
+     must have either the key, hexkey, or textkey properties, either
+     as a string, an ArrayBuffer, or a Uint8Array.
+
+     This is a no-op in non-SEE builds. It throws on error and returns
+     without side effects if none of the key/textkey/hexkey options
+     are set. It throws if more than one is set or if any are set to
+     values of an invalid type.
+
+     Returns true if it applies the key, else an unspecified falsy value.
+  */
+  const dbCtorApplySEEKey = function(db,opt){
+    if( !capi.sqlite3_key_v2 ) return;
+    let keytype;
+    let key;
+    const check = (opt.key ? 1 : 0) + (opt.hexkey ? 1 : 0) + (opt.textkey ? 1 : 0);
+    if( !check ) return;
+    else if( check>1 ){
+      toss3(capi.SQLITE_MISUSE,
+            "Only ONE of (key, hexkey, textkey) may be provided.");
+    }
+    if( opt.key ){
+      /* It is not legal to bind an argument to PRAGMA key=?, so we
+         convert it to a hexkey... */
+      keytype = 'key';
+      key = opt.key;
+      if('string'===typeof key){
+        key = new TextEncoder('utf-8').encode(key);
+      }
+      if((key instanceof ArrayBuffer) || (key instanceof Uint8Array)){
+        key = byteArrayToHex(key);
+        keytype = 'hexkey';
+      }else{
+        toss3(capi.SQLITE_MISUSE,
+              "Invalid value for the 'key' option. Expecting a string,",
+              "ArrayBuffer, or Uint8Array.");
+        return;
+      }
+    }else if( opt.textkey ){
+      /* For textkey we need it to be in string form, so convert it to
+         a string if it's a byte array... */
+      keytype = 'textkey';
+      key = opt.textkey;
+      if(key instanceof ArrayBuffer){
+        key = new Uint8Array(key);
+      }
+      if(key instanceof Uint8Array){
+        key = new TextDecoder('utf-8').decode(key);
+      }else if('string'!==typeof key){
+        toss3(capi.SQLITE_MISUSE,
+              "Invalid value for the 'textkey' option. Expecting a string,",
+              "ArrayBuffer, or Uint8Array.");
+      }
+    }else if( opt.hexkey ){
+      keytype = 'hexkey';
+      key = opt.hexkey;
+      if((key instanceof ArrayBuffer) || (key instanceof Uint8Array)){
+        key = byteArrayToHex(key);
+      }else if('string'!==typeof key){
+        toss3(capi.SQLITE_MISUSE,
+              "Invalid value for the 'hexkey' option. Expecting a string,",
+              "ArrayBuffer, or Uint8Array.");
+      }
+      /* else assume it's valid hex codes */
+    }else{
+      return;
+    }
+    let stmt;
+    try{
+      stmt = db.prepare("PRAGMA "+keytype+"="+util.sqlite3__wasm_qfmt_token(key, 1));
+      stmt.step();
+    }finally{
+      if(stmt) stmt.finalize();
+    }
+    return true;
+  };
+//#endif enable-see
+
   /**
      A proxy for DB class constructors. It must be called with the
      being-construct DB object as its "this". See the DB constructor
@@ -175,16 +273,28 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
     __ptrMap.set(this, pDb);
     __stmtMap.set(this, Object.create(null));
     try{
+//#if enable-see
+      dbCtorApplySEEKey(this,opt);
+//#endif
       // Check for per-VFS post-open SQL/callback...
-      const pVfs = capi.sqlite3_js_db_vfs(pDb);
-      if(!pVfs) toss3("Internal error: cannot get VFS for new db handle.");
+      const pVfs = capi.sqlite3_js_db_vfs(pDb)
+            || toss3("Internal error: cannot get VFS for new db handle.");
       const postInitSql = __vfsPostOpenSql[pVfs];
-      if(postInitSql instanceof Function){
-        postInitSql(this, sqlite3);
-      }else if(postInitSql){
-        checkSqlite3Rc(
-          pDb, capi.sqlite3_exec(pDb, postInitSql, 0, 0, 0)
-        );
+      if(postInitSql){
+        /**
+           Reminder: if this db is encrypted and the client did _not_ pass
+           in the key, any init code will fail, causing the ctor to throw.
+           We don't actually know whether the db is encrypted, so we cannot
+           sensibly apply any heuristics which skip the init code only for
+           encrypted databases for which no key has yet been supplied.
+        */
+        if(postInitSql instanceof Function){
+          postInitSql(this, sqlite3);
+        }else{
+          checkSqlite3Rc(
+            pDb, capi.sqlite3_exec(pDb, postInitSql, 0, 0, 0)
+          );
+        }
       }
     }catch(e){
       this.close();
@@ -280,6 +390,36 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
      - `flags`: open-mode flags
      - `vfs`: the VFS fname
 
+//#if enable-see
+
+     SEE-capable builds optionally support ONE of the following
+     additional options:
+
+     - `key`, `hexkey`, or `textkey`: encryption key as a string,
+       ArrayBuffer, or Uint8Array. These flags function as documented
+       for the SEE pragmas of the same names. Using a byte array for
+       `hexkey` is equivalent to the same series of hex codes in
+       string form, so `'666f6f'` is equivalent to
+       `Uint8Array([0x66,0x6f,0x6f])`. A `textkey` byte array is
+       assumed to be UTF-8. A `key` string is transformed into a UTF-8
+       byte array, and a `key` byte array is transformed into a
+       `hexkey` with the same bytes.
+
+     In non-SEE builds, these options are ignored. In SEE builds,
+     `PRAGMA key/textkey/hexkey=X` is executed immediately after
+     opening the db. If more than one of the options is provided,
+     or any option has an invalid argument type, an exception is
+     thrown.
+
+     Note that some DB subclasses may run post-initialization SQL
+     code, e.g. to set a busy-handler timeout or tweak the page cache
+     size. Such code is run _after_ the SEE key is applied. If no key
+     is supplied and the database is encrypted, execution of the
+     post-initialization SQL will fail, causing the constructor to
+     throw.
+
+//#endif enable-see
+
      The `filename` and `vfs` arguments may be either JS strings or
      C-strings allocated via WASM. `flags` is required to be a JS
      string (because it's specific to this API, which is specific
@@ -288,7 +428,8 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
      For purposes of passing a DB instance to C-style sqlite3
      functions, the DB object's read-only `pointer` property holds its
      `sqlite3*` pointer value. That property can also be used to check
-     whether this DB instance is still open.
+     whether this DB instance is still open: it will evaluate to
+     `undefined` after the DB object's close() method is called.
 
      In the main window thread, the filenames `":localStorage:"` and
      `":sessionStorage:"` are special: they cause the db to use either
@@ -433,40 +574,56 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
       out.returnVal = ()=>opt.resultRows;
     }
     if(opt.callback || opt.resultRows){
-      switch((undefined===opt.rowMode)
-             ? 'array' : opt.rowMode) {
-          case 'object': out.cbArg = (stmt)=>stmt.get(Object.create(null)); break;
-          case 'array': out.cbArg = (stmt)=>stmt.get([]); break;
-          case 'stmt':
-            if(Array.isArray(opt.resultRows)){
-              toss3("exec(): invalid rowMode for a resultRows array: must",
-                    "be one of 'array', 'object',",
-                    "a result column number, or column name reference.");
-            }
-            out.cbArg = (stmt)=>stmt;
+      switch((undefined===opt.rowMode) ? 'array' : opt.rowMode) {
+        case 'object':
+          out.cbArg = (stmt,cache)=>{
+            if( !cache.columnNames ) cache.columnNames = stmt.getColumnNames([]);
+            /* https://sqlite.org/forum/forumpost/3632183d2470617d:
+               conversion of rows to objects (key/val pairs) is
+               somewhat expensive for large data sets because of the
+               native-to-JS conversion of the column names. If we
+               instead cache the names and build objects from that
+               list of strings, it can run twice as fast. The
+               difference is not noticeable for small data sets but
+               becomes human-perceivable when enough rows are
+               involved. */
+            const row = stmt.get([]);
+            const rv = Object.create(null);
+            for( const i in cache.columnNames ) rv[cache.columnNames[i]] = row[i];
+            return rv;
+          };
+          break;
+        case 'array': out.cbArg = (stmt)=>stmt.get([]); break;
+        case 'stmt':
+          if(Array.isArray(opt.resultRows)){
+            toss3("exec(): invalid rowMode for a resultRows array: must",
+                  "be one of 'array', 'object',",
+                  "a result column number, or column name reference.");
+          }
+          out.cbArg = (stmt)=>stmt;
+          break;
+        default:
+          if(util.isInt32(opt.rowMode)){
+            out.cbArg = (stmt)=>stmt.get(opt.rowMode);
             break;
-          default:
-            if(util.isInt32(opt.rowMode)){
-              out.cbArg = (stmt)=>stmt.get(opt.rowMode);
-              break;
-            }else if('string'===typeof opt.rowMode
-                     && opt.rowMode.length>1
-                     && '$'===opt.rowMode[0]){
-              /* "$X": fetch column named "X" (case-sensitive!). Prior
-                 to 2022-12-14 ":X" and "@X" were also permitted, but
-                 having so many options is unnecessary and likely to
-                 cause confusion. */
-              const $colName = opt.rowMode.substr(1);
-              out.cbArg = (stmt)=>{
-                const rc = stmt.get(Object.create(null))[$colName];
-                return (undefined===rc)
-                  ? toss3(capi.SQLITE_NOTFOUND,
-                          "exec(): unknown result column:",$colName)
-                  : rc;
-              };
-              break;
-            }
-            toss3("Invalid rowMode:",opt.rowMode);
+          }else if('string'===typeof opt.rowMode
+                   && opt.rowMode.length>1
+                   && '$'===opt.rowMode[0]){
+            /* "$X": fetch column named "X" (case-sensitive!). Prior
+               to 2022-12-14 ":X" and "@X" were also permitted, but
+               having so many options is unnecessary and likely to
+               cause confusion. */
+            const $colName = opt.rowMode.substr(1);
+            out.cbArg = (stmt)=>{
+              const rc = stmt.get(Object.create(null))[$colName];
+              return (undefined===rc)
+                ? toss3(capi.SQLITE_NOTFOUND,
+                        "exec(): unknown result column:",$colName)
+                : rc;
+            };
+            break;
+          }
+          toss3("Invalid rowMode:",opt.rowMode);
       }
     }
     return out;
@@ -884,10 +1041,15 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
                  and names. */) ? 0 : 1;
             evalFirstResult = false;
             if(arg.cbArg || resultRows){
+              const cbArgCache = Object.create(null)
+              /* 2nd arg for arg.cbArg, used by (at least) row-to-object
+                 converter */;
               for(; stmt.step(); stmt._lockedByExec = false){
-                if(0===gotColNames++) stmt.getColumnNames(opt.columnNames);
+                if(0===gotColNames++){
+                  stmt.getColumnNames(cbArgCache.columnNames = (opt.columnNames || []));
+                }
                 stmt._lockedByExec = true;
-                const row = arg.cbArg(stmt);
+                const row = arg.cbArg(stmt,cbArgCache);
                 if(resultRows) resultRows.push(row);
                 if(callback && false === callback.call(opt, row, stmt)){
                   break;
@@ -1522,7 +1684,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
          they are larger than 32 bits, else double or int32, depending
          on whether they have a fractional part. Booleans are bound as
          integer 0 or 1. It is not expected the distinction of binding
-         doubles which have no fractional parts is integers is
+         doubles which have no fractional parts and integers is
          significant for the majority of clients due to sqlite3's data
          typing model. If [BigInt] support is enabled then this
          routine will bind BigInt values as 64-bit integers if they'll
@@ -1706,7 +1868,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
        an exception is thrown.
 
        By default it will determine the data type of the result
-       automatically. If passed a second arugment, it must be one
+       automatically. If passed a second argument, it must be one
        of the enumeration values for sqlite3 types, which are
        defined as members of the sqlite3 module: SQLITE_INTEGER,
        SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB. Any other value,
@@ -1906,16 +2068,26 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
        Functionally equivalent to DB(storageName,'c','kvvfs') except
        that it throws if the given storage name is not one of 'local'
        or 'session'.
+
+       As of version 3.46, the argument may optionally be an options
+       object in the form:
+
+       {
+         filename: 'session'|'local',
+         ... etc. (all options supported by the DB ctor)
+       }
+
+       noting that the 'vfs' option supported by main DB
+       constructor is ignored here: the vfs is always 'kvvfs'.
     */
     sqlite3.oo1.JsStorageDb = function(storageName='session'){
+      const opt = dbCtorHelper.normalizeArgs(...arguments);
+      storageName = opt.filename;
       if('session'!==storageName && 'local'!==storageName){
         toss3("JsStorageDb db name must be one of 'session' or 'local'.");
       }
-      dbCtorHelper.call(this, {
-        filename: storageName,
-        flags: 'c',
-        vfs: "kvvfs"
-      });
+      opt.vfs = 'kvvfs';
+      dbCtorHelper.call(this, opt);
     };
     const jdb = sqlite3.oo1.JsStorageDb;
     jdb.prototype = Object.create(DB.prototype);
diff --git a/ext/wasm/api/sqlite3-api-prologue.js b/ext/wasm/api/sqlite3-api-prologue.js
index ef1154f..689c79a 100644
--- a/ext/wasm/api/sqlite3-api-prologue.js
+++ b/ext/wasm/api/sqlite3-api-prologue.js
@@ -37,7 +37,7 @@
 
    This function expects a configuration object, intended to abstract
    away details specific to any given WASM environment, primarily so
-   that it can be used without any _direct_ dependency on
+   that it can be used without any direct dependency on
    Emscripten. (Note the default values for the config object!) The
    config object is only honored the first time this is
    called. Subsequent calls ignore the argument and return the same
@@ -98,14 +98,37 @@
 
    The returned object is the top-level sqlite3 namespace object.
 
+
+   Client code may optionally assign sqlite3ApiBootstrap.defaultConfig
+   an object-type value before calling sqlite3ApiBootstrap() (without
+   arguments) in order to tell that call to use this object as its
+   default config value. The intention of this is to provide
+   downstream clients with a reasonably flexible approach for plugging
+   in an environment-suitable configuration without having to define a
+   new global-scope symbol.
+
+   However, because clients who access this library via an
+   Emscripten-hosted module will not have an opportunity to call
+   sqlite3ApiBootstrap() themselves, nor to access it before it is
+   called, an alternative option for setting the configuration is to
+   define globalThis.sqlite3ApiConfig to an object. If it is set, it
+   is used instead of sqlite3ApiBootstrap.defaultConfig if
+   sqlite3ApiBootstrap() is called without arguments.
+
+   Both sqlite3ApiBootstrap.defaultConfig and
+   globalThis.sqlite3ApiConfig get deleted by sqlite3ApiBootstrap()
+   because any changes to them made after that point would have no
+   useful effect.
 */
 'use strict';
 globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
   apiConfig = (globalThis.sqlite3ApiConfig || sqlite3ApiBootstrap.defaultConfig)
 ){
   if(sqlite3ApiBootstrap.sqlite3){ /* already initalized */
-    console.warn("sqlite3ApiBootstrap() called multiple times.",
-                 "Config and external initializers are ignored on calls after the first.");
+    (sqlite3ApiBootstrap.sqlite3.config || console).warn(
+      "sqlite3ApiBootstrap() called multiple times.",
+      "Config and external initializers are ignored on calls after the first."
+    );
     return sqlite3ApiBootstrap.sqlite3;
   }
   const config = Object.assign(Object.create(null),{
@@ -114,8 +137,16 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
     bigIntEnabled: (()=>{
       if('undefined'!==typeof Module){
         /* Emscripten module will contain HEAPU64 when built with
-           -sWASM_BIGINT=1, else it will not. */
-        return !!Module.HEAPU64;
+           -sWASM_BIGINT=1, else it will not.
+
+           As of emsdk 3.1.55, when building in strict mode, HEAPxyz
+           are only available if _explicitly_ included in the exports,
+           else they are not. We do not (as of 2024-03-04) use -sSTRICT
+           for the canonical builds.
+        */
+        if( !!Module.HEAPU64 ) return true;
+        /* Else fall through and hope for the best. Nobody _really_
+           builds this without BigInt support, do they? */
       }
       return !!globalThis.BigInt64Array;
     })(),
@@ -149,6 +180,15 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
       config[k] = config[k]();
     }
   });
+
+  /**
+     Eliminate any confusion about whether these config objects may
+     be used after library initialization by eliminating the outward-facing
+     objects...
+  */
+  delete globalThis.sqlite3ApiConfig;
+  delete sqlite3ApiBootstrap.defaultConfig;
+
   /**
       The main sqlite3 binding API gets installed into this object,
       mimicking the C API as closely as we can. The numerous members
@@ -205,7 +245,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
 
        The exception's message is created by concatenating its
        arguments with a space between each, except for the
-       two-args-with-an-objec form and that the first argument will
+       two-args-with-an-object form and that the first argument will
        get coerced to a string, as described above, if it's an
        integer.
 
@@ -1061,7 +1101,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
        are undefined if the passed-in value did not come from
        this.pointer.
     */
-    restore: wasm.exports.sqlite3_wasm_pstack_restore,
+    restore: wasm.exports.sqlite3__wasm_pstack_restore,
     /**
        Attempts to allocate the given number of bytes from the
        pstack. On success, it zeroes out a block of memory of the
@@ -1083,7 +1123,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
       if('string'===typeof n && !(n = wasm.sizeofIR(n))){
         WasmAllocError.toss("Invalid value for pstack.alloc(",arguments[0],")");
       }
-      return wasm.exports.sqlite3_wasm_pstack_alloc(n)
+      return wasm.exports.sqlite3__wasm_pstack_alloc(n)
         || WasmAllocError.toss("Could not allocate",n,
                                "bytes from the pstack.");
     },
@@ -1163,10 +1203,10 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
     */
     pointer: {
       configurable: false, iterable: true, writeable: false,
-      get: wasm.exports.sqlite3_wasm_pstack_ptr
+      get: wasm.exports.sqlite3__wasm_pstack_ptr
       //Whether or not a setter as an alternative to restore() is
       //clearer or would just lead to confusion is unclear.
-      //set: wasm.exports.sqlite3_wasm_pstack_restore
+      //set: wasm.exports.sqlite3__wasm_pstack_restore
     },
     /**
        sqlite3.wasm.pstack.quota to the total number of bytes
@@ -1175,7 +1215,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
     */
     quota: {
       configurable: false, iterable: true, writeable: false,
-      get: wasm.exports.sqlite3_wasm_pstack_quota
+      get: wasm.exports.sqlite3__wasm_pstack_quota
     },
     /**
        sqlite3.wasm.pstack.remaining resolves to the amount of space
@@ -1183,7 +1223,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
     */
     remaining: {
       configurable: false, iterable: true, writeable: false,
-      get: wasm.exports.sqlite3_wasm_pstack_remaining
+      get: wasm.exports.sqlite3__wasm_pstack_remaining
     }
   })/*wasm.pstack properties*/;
 
@@ -1256,14 +1296,14 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
     }
     try{
       if(pdir && 0===wasm.xCallWrapped(
-        'sqlite3_wasm_init_wasmfs', 'i32', ['string'], pdir
+        'sqlite3__wasm_init_wasmfs', 'i32', ['string'], pdir
       )){
         return __wasmfsOpfsDir = pdir;
       }else{
         return __wasmfsOpfsDir = "";
       }
     }catch(e){
-      // sqlite3_wasm_init_wasmfs() is not available
+      // sqlite3__wasm_init_wasmfs() is not available
       return __wasmfsOpfsDir = "";
     }
   };
@@ -1365,7 +1405,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
       const zSchema = schema
             ? (wasm.isPtr(schema) ? schema : wasm.scopedAllocCString(''+schema))
             : 0;
-      let rc = wasm.exports.sqlite3_wasm_db_serialize(
+      let rc = wasm.exports.sqlite3__wasm_db_serialize(
         pDb, zSchema, ppOut, pSize, 0
       );
       if(rc){
@@ -1391,7 +1431,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
      or not provided, then "main" is assumed.
   */
   capi.sqlite3_js_db_vfs =
-    (dbPointer, dbName=0)=>wasm.sqlite3_wasm_db_vfs(dbPointer, dbName);
+    (dbPointer, dbName=0)=>util.sqlite3__wasm_db_vfs(dbPointer, dbName);
 
   /**
      A thin wrapper around capi.sqlite3_aggregate_context() which
@@ -1449,7 +1489,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
       if(!util.isInt32(dataLen) || dataLen<0){
         SQLite3Error.toss("Invalid 3rd argument for sqlite3_js_posix_create_file().");
       }
-      const rc = wasm.sqlite3_wasm_posix_create_file(filename, pData, dataLen);
+      const rc = util.sqlite3__wasm_posix_create_file(filename, pData, dataLen);
       if(rc) SQLite3Error.toss("Creation of file failed with sqlite3 result code",
                                capi.sqlite3_js_rc_str(rc));
     }finally{
@@ -1551,7 +1591,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
       SQLite3Error.toss("Invalid 4th argument for sqlite3_js_vfs_create_file().");
     }
     try{
-      const rc = wasm.sqlite3_wasm_vfs_create_file(vfs, filename, pData, dataLen);
+      const rc = util.sqlite3__wasm_vfs_create_file(vfs, filename, pData, dataLen);
       if(rc) SQLite3Error.toss("Creation of file failed with sqlite3 result code",
                                capi.sqlite3_js_rc_str(rc));
     }finally{
@@ -1672,12 +1712,12 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
   */
   capi.sqlite3_db_config = function(pDb, op, ...args){
     if(!this.s){
-      this.s = wasm.xWrap('sqlite3_wasm_db_config_s','int',
+      this.s = wasm.xWrap('sqlite3__wasm_db_config_s','int',
                           ['sqlite3*', 'int', 'string:static']
                           /* MAINDBNAME requires a static string */);
-      this.pii = wasm.xWrap('sqlite3_wasm_db_config_pii', 'int',
+      this.pii = wasm.xWrap('sqlite3__wasm_db_config_pii', 'int',
                             ['sqlite3*', 'int', '*','int', 'int']);
-      this.ip = wasm.xWrap('sqlite3_wasm_db_config_ip','int',
+      this.ip = wasm.xWrap('sqlite3__wasm_db_config_ip','int',
                            ['sqlite3*', 'int', 'int','*']);
     }
     switch(op){
@@ -1798,7 +1838,7 @@ globalThis.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
   /**
      Calls either sqlite3_result_error_nomem(), if e is-a
      WasmAllocError, or sqlite3_result_error(). In the latter case,
-     the second arugment is coerced to a string to create the error
+     the second argument is coerced to a string to create the error
      message.
 
      The first argument is a (sqlite3_context*). Returns void.
diff --git a/ext/wasm/api/sqlite3-api-worker1.js b/ext/wasm/api/sqlite3-api-worker1.js
index 3099c19..2e59761 100644
--- a/ext/wasm/api/sqlite3-api-worker1.js
+++ b/ext/wasm/api/sqlite3-api-worker1.js
@@ -359,6 +359,7 @@
 
 */
 globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
+const util = sqlite3.util;
 sqlite3.initWorker1API = function(){
   'use strict';
   const toss = (...args)=>{throw new Error(args.join(' '))};
@@ -409,12 +410,12 @@ sqlite3.initWorker1API = function(){
       if(db){
         delete this.dbs[getDbId(db)];
         const filename = db.filename;
-        const pVfs = sqlite3.wasm.sqlite3_wasm_db_vfs(db.pointer, 0);
+        const pVfs = util.sqlite3__wasm_db_vfs(db.pointer, 0);
         db.close();
         const ddNdx = this.dbList.indexOf(db);
         if(ddNdx>=0) this.dbList.splice(ddNdx, 1);
         if(alsoUnlink && filename && pVfs){
-          sqlite3.wasm.sqlite3_wasm_vfs_unlink(pVfs, filename);
+          util.sqlite3__wasm_vfs_unlink(pVfs, filename);
         }
       }
     },
@@ -458,11 +459,6 @@ sqlite3.initWorker1API = function(){
     return wState.dbList[0] && getDbId(wState.dbList[0]);
   };
 
-  const guessVfs = function(filename){
-    const m = /^file:.+(vfs=(\w+))/.exec(filename);
-    return sqlite3.capi.sqlite3_vfs_find(m ? m[2] : 0);
-  };
-
   const isSpecialDbFilename = (n)=>{
     return ""===n || ':'===n[0];
   };
@@ -484,36 +480,8 @@ sqlite3.initWorker1API = function(){
         toss("Throwing because of simulateError flag.");
       }
       const rc = Object.create(null);
-      let byteArray, pVfs;
       oargs.vfs = args.vfs;
-      if(isSpecialDbFilename(args.filename)){
-        oargs.filename = args.filename || "";
-      }else{
-        oargs.filename = args.filename;
-        byteArray = args.byteArray;
-        if(byteArray) pVfs = guessVfs(args.filename);
-      }
-      if(pVfs){
-        /* 2022-11-02: this feature is as-yet untested except that
-           sqlite3_wasm_vfs_create_file() has been tested from the
-           browser dev console. */
-        let pMem;
-        try{
-          pMem = sqlite3.wasm.allocFromTypedArray(byteArray);
-          const rc = sqlite3.wasm.sqlite3_wasm_vfs_create_file(
-            pVfs, oargs.filename, pMem, byteArray.byteLength
-          );
-          if(rc) sqlite3.SQLite3Error.toss(rc);
-        }catch(e){
-          throw new sqlite3.SQLite3Error(
-            e.name+' creating '+args.filename+": "+e.message, {
-              cause: e
-            }
-          );
-        }finally{
-          if(pMem) sqlite3.wasm.dealloc(pMem);
-        }
-      }
+      oargs.filename = args.filename || "";
       const db = wState.open(oargs);
       rc.filename = db.filename;
       rc.persistent = !!sqlite3.capi.sqlite3_js_db_uses_vfs(db.pointer, "opfs");
diff --git a/ext/wasm/api/sqlite3-opfs-async-proxy.js b/ext/wasm/api/sqlite3-opfs-async-proxy.js
index cafd296..e671094 100644
--- a/ext/wasm/api/sqlite3-opfs-async-proxy.js
+++ b/ext/wasm/api/sqlite3-opfs-async-proxy.js
@@ -51,7 +51,7 @@
 */
 "use strict";
 const wPost = (type,...args)=>postMessage({type, payload:args});
-const installAsyncProxy = function(self){
+const installAsyncProxy = function(){
   const toss = function(...args){throw new Error(args.join(' '))};
   if(globalThis.window === globalThis){
     toss("This code cannot run from the main thread.",
@@ -562,6 +562,14 @@ const installAsyncProxy = function(self){
           wTimeEnd();
           return;
         }
+        if( state.opfsFlags.OPFS_UNLINK_BEFORE_OPEN & opfsFlags ){
+          try{
+            await hDir.removeEntry(filenamePart);
+          }catch(e){
+            /* ignoring */
+            //warn("Ignoring failed Unlink of",filename,":",e);
+          }
+        }
         const hFile = await hDir.getFileHandle(filenamePart, {create});
         wTimeEnd();
         const fh = Object.assign(Object.create(null),{
@@ -911,5 +919,5 @@ if(!globalThis.SharedArrayBuffer){
          !navigator?.storage?.getDirectory){
   wPost('opfs-unavailable',"Missing required OPFS APIs.");
 }else{
-  installAsyncProxy(self);
+  installAsyncProxy();
 }
diff --git a/ext/wasm/api/sqlite3-vfs-helper.c-pp.js b/ext/wasm/api/sqlite3-vfs-helper.c-pp.js
new file mode 100644
index 0000000..4d29c7b
--- /dev/null
+++ b/ext/wasm/api/sqlite3-vfs-helper.c-pp.js
@@ -0,0 +1,103 @@
+/*
+** 2022-11-30
+**
+** The author disclaims copyright to this source code.  In place of a
+** legal notice, here is a blessing:
+**
+** *   May you do good and not evil.
+** *   May you find forgiveness for yourself and forgive others.
+** *   May you share freely, never taking more than you give.
+*/
+
+/**
+   This file installs sqlite3.vfs, a namespace of helpers for use in
+   the creation of JavaScript implementations of sqlite3_vfs.
+*/
+'use strict';
+globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
+  const wasm = sqlite3.wasm, capi = sqlite3.capi, toss = sqlite3.util.toss3;
+  const vfs = Object.create(null);
+  sqlite3.vfs = vfs;
+
+  /**
+     Uses sqlite3_vfs_register() to register this
+     sqlite3.capi.sqlite3_vfs instance. This object must have already
+     been filled out properly. If the first argument is truthy, the
+     VFS is registered as the default VFS, else it is not.
+
+     On success, returns this object. Throws on error.
+  */
+  capi.sqlite3_vfs.prototype.registerVfs = function(asDefault=false){
+    if(!(this instanceof sqlite3.capi.sqlite3_vfs)){
+      toss("Expecting a sqlite3_vfs-type argument.");
+    }
+    const rc = capi.sqlite3_vfs_register(this, asDefault ? 1 : 0);
+    if(rc){
+      toss("sqlite3_vfs_register(",this,") failed with rc",rc);
+    }
+    if(this.pointer !== capi.sqlite3_vfs_find(this.$zName)){
+      toss("BUG: sqlite3_vfs_find(vfs.$zName) failed for just-installed VFS",
+           this);
+    }
+    return this;
+  };
+
+  /**
+     A wrapper for
+     sqlite3.StructBinder.StructType.prototype.installMethods() or
+     registerVfs() to reduce installation of a VFS and/or its I/O
+     methods to a single call.
+
+     Accepts an object which contains the properties "io" and/or
+     "vfs", each of which is itself an object with following properties:
+
+     - `struct`: an sqlite3.StructBinder.StructType-type struct. This
+       must be a populated (except for the methods) object of type
+       sqlite3_io_methods (for the "io" entry) or sqlite3_vfs (for the
+       "vfs" entry).
+
+     - `methods`: an object mapping sqlite3_io_methods method names
+       (e.g. 'xClose') to JS implementations of those methods. The JS
+       implementations must be call-compatible with their native
+       counterparts.
+
+     For each of those object, this function passes its (`struct`,
+     `methods`, (optional) `applyArgcCheck`) properties to
+     installMethods().
+
+     If the `vfs` entry is set then:
+
+     - Its `struct` property's registerVfs() is called. The
+       `vfs` entry may optionally have an `asDefault` property, which
+       gets passed as the argument to registerVfs().
+
+     - If `struct.$zName` is falsy and the entry has a string-type
+       `name` property, `struct.$zName` is set to the C-string form of
+       that `name` value before registerVfs() is called. That string
+       gets added to the on-dispose state of the struct.
+
+     On success returns this object. Throws on error.
+  */
+  vfs.installVfs = function(opt){
+    let count = 0;
+    const propList = ['io','vfs'];
+    for(const key of propList){
+      const o = opt[key];
+      if(o){
+        ++count;
+        o.struct.installMethods(o.methods, !!o.applyArgcCheck);
+        if('vfs'===key){
+          if(!o.struct.$zName && 'string'===typeof o.name){
+            o.struct.addOnDispose(
+              o.struct.$zName = wasm.allocCString(o.name)
+            );
+          }
+          o.struct.registerVfs(!!o.asDefault);
+        }
+      }
+    }
+    if(!count) toss("Misuse: installVfs() options object requires at least",
+                    "one of:", propList);
+    return this;
+  };
+}/*sqlite3ApiBootstrap.initializers.push()*/);
diff --git a/ext/wasm/api/sqlite3-vfs-opfs-sahpool.c-pp.js b/ext/wasm/api/sqlite3-vfs-opfs-sahpool.c-pp.js
index 2089ece..3f4182d 100644
--- a/ext/wasm/api/sqlite3-vfs-opfs-sahpool.c-pp.js
+++ b/ext/wasm/api/sqlite3-vfs-opfs-sahpool.c-pp.js
@@ -1137,8 +1137,9 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
      existing content. Throws if the pool has no available file slots,
      on I/O error, or if the input does not appear to be a
      database. In the latter case, only a cursory examination is made.
-     Note that this routine is _only_ for importing database files,
-     not arbitrary files, the reason being that this VFS will
+     Results are undefined if the given db name refers to an opened
+     db.  Note that this routine is _only_ for importing database
+     files, not arbitrary files, the reason being that this VFS will
      automatically clean up any non-database files so importing them
      is pointless.
 
diff --git a/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js b/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js
index af89f21..4c654c3 100644
--- a/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js
+++ b/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js
@@ -245,7 +245,8 @@ const installOpfsVfs = function callee(options){
     opfsIoMethods.$iVersion = 1;
     opfsVfs.$iVersion = 2/*yes, two*/;
     opfsVfs.$szOsFile = capi.sqlite3_file.structInfo.sizeof;
-    opfsVfs.$mxPathname = 1024/*sure, why not?*/;
+    opfsVfs.$mxPathname = 1024/* sure, why not? The OPFS name length limit
+                                 is undocumented/unspecified. */;
     opfsVfs.$zName = wasm.allocCString("opfs");
     // All C-side memory of opfsVfs is zeroed out, but just to be explicit:
     opfsVfs.$xDlOpen = opfsVfs.$xDlError = opfsVfs.$xDlSym = opfsVfs.$xDlClose = null;
@@ -422,11 +423,26 @@ const installOpfsVfs = function callee(options){
     });
     state.opfsFlags = Object.assign(Object.create(null),{
       /**
-         Flag for use with xOpen(). "opfs-unlock-asap=1" enables
-         this. See defaultUnlockAsap, below.
+         Flag for use with xOpen(). URI flag "opfs-unlock-asap=1"
+         enables this. See defaultUnlockAsap, below.
        */
       OPFS_UNLOCK_ASAP: 0x01,
       /**
+         Flag for use with xOpen(). URI flag "delete-before-open=1"
+         tells the VFS to delete the db file before attempting to open
+         it. This can be used, e.g., to replace a db which has been
+         corrupted (without forcing us to expose a delete/unlink()
+         function in the public API).
+
+         Failure to unlink the file is ignored but may lead to
+         downstream errors.  An unlink can fail if, e.g., another tab
+         has the handle open.
+
+         It goes without saying that deleting a file out from under another
+         instance results in Undefined Behavior.
+      */
+      OPFS_UNLINK_BEFORE_OPEN: 0x02,
+      /**
          If true, any async routine which implicitly acquires a sync
          access handle (i.e. an OPFS lock) will release that locks at
          the end of the call which acquires it. If false, such
@@ -874,13 +890,17 @@ const installOpfsVfs = function callee(options){
         let opfsFlags = 0;
         if(0===zName){
           zName = randomFilename();
-        }else if('number'===typeof zName){
+        }else if(wasm.isPtr(zName)){
           if(capi.sqlite3_uri_boolean(zName, "opfs-unlock-asap", 0)){
             /* -----------------------^^^^^ MUST pass the untranslated
                C-string here. */
             opfsFlags |= state.opfsFlags.OPFS_UNLOCK_ASAP;
           }
+          if(capi.sqlite3_uri_boolean(zName, "delete-before-open", 0)){
+            opfsFlags |= state.opfsFlags.OPFS_UNLINK_BEFORE_OPEN;
+          }
           zName = wasm.cstrToJs(zName);
+          //warn("xOpen zName =",zName, "opfsFlags =",opfsFlags);
         }
         const fh = Object.create(null);
         fh.fid = pFile;
@@ -994,27 +1014,6 @@ const installOpfsVfs = function callee(options){
     opfsUtil.randomFilename = randomFilename;
 
     /**
-       Re-registers the OPFS VFS. This is intended only for odd use
-       cases which have to call sqlite3_shutdown() as part of their
-       initialization process, which will unregister the VFS
-       registered by installOpfsVfs(). If passed a truthy value, the
-       OPFS VFS is registered as the default VFS, else it is not made
-       the default. Returns the result of the the
-       sqlite3_vfs_register() call.
-
-       Design note: the problem of having to re-register things after
-       a shutdown/initialize pair is more general. How to best plug
-       that in to the library is unclear. In particular, we cannot
-       hook in to any C-side calls to sqlite3_initialize(), so we
-       cannot add an after-initialize callback mechanism.
-    */
-    opfsUtil.registerVfs = (asDefault=false)=>{
-      return wasm.exports.sqlite3_vfs_register(
-        opfsVfs.pointer, asDefault ? 1 : 0
-      );
-    };
-
-    /**
        Returns a promise which resolves to an object which represents
        all files and directories in the OPFS tree. The top-most object
        has two properties: `dirs` is an array of directory entries
@@ -1213,16 +1212,18 @@ const installOpfsVfs = function callee(options){
        Asynchronously imports the given bytes (a byte array or
        ArrayBuffer) into the given database file.
 
+       Results are undefined if the given db name refers to an opened
+       db.
+
        If passed a function for its second argument, its behaviour
-       changes to async and it imports its data in chunks fed to it by
-       the given callback function. It calls the callback (which may
-       be async) repeatedly, expecting either a Uint8Array or
-       ArrayBuffer (to denote new input) or undefined (to denote
-       EOF). For so long as the callback continues to return
-       non-undefined, it will append incoming data to the given
-       VFS-hosted database file. When called this way, the resolved
-       value of the returned Promise is the number of bytes written to
-       the target file.
+       changes: imports its data in chunks fed to it by the given
+       callback function. It calls the callback (which may be async)
+       repeatedly, expecting either a Uint8Array or ArrayBuffer (to
+       denote new input) or undefined (to denote EOF). For so long as
+       the callback continues to return non-undefined, it will append
+       incoming data to the given VFS-hosted database file. When
+       called this way, the resolved value of the returned Promise is
+       the number of bytes written to the target file.
 
        It very specifically requires the input to be an SQLite3
        database and throws if that's not the case.  It does so in
diff --git a/ext/wasm/api/sqlite3-v-helper.js b/ext/wasm/api/sqlite3-vtab-helper.c-pp.js
index e63da8a..7359ea3 100644
--- a/ext/wasm/api/sqlite3-v-helper.js
+++ b/ext/wasm/api/sqlite3-vtab-helper.c-pp.js
@@ -10,19 +10,13 @@
 */
 
 /**
-   This file installs sqlite3.vfs, and object which exists to assist
-   in the creation of JavaScript implementations of sqlite3_vfs, along
-   with its virtual table counterpart, sqlite3.vtab.
+   This file installs sqlite3.vtab, a namespace of helpers for use in
+   the creation of JavaScript implementations virtual tables.
 */
 'use strict';
 globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
   const wasm = sqlite3.wasm, capi = sqlite3.capi, toss = sqlite3.util.toss3;
-  const vfs = Object.create(null), vtab = Object.create(null);
-
-  const StructBinder = sqlite3.StructBinder
-  /* we require a local alias b/c StructBinder is removed from the sqlite3
-     object during the final steps of the API cleanup. */;
-  sqlite3.vfs = vfs;
+  const vtab = Object.create(null);
   sqlite3.vtab = vtab;
 
   const sii = capi.sqlite3_index_info;
@@ -73,257 +67,6 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
   };
 
   /**
-     Installs a StructBinder-bound function pointer member of the
-     given name and function in the given StructType target object.
-
-     It creates a WASM proxy for the given function and arranges for
-     that proxy to be cleaned up when tgt.dispose() is called. Throws
-     on the slightest hint of error, e.g. tgt is-not-a StructType,
-     name does not map to a struct-bound member, etc.
-
-     As a special case, if the given function is a pointer, then
-     `wasm.functionEntry()` is used to validate that it is a known
-     function. If so, it is used as-is with no extra level of proxying
-     or cleanup, else an exception is thrown. It is legal to pass a
-     value of 0, indicating a NULL pointer, with the caveat that 0
-     _is_ a legal function pointer in WASM but it will not be accepted
-     as such _here_. (Justification: the function at address zero must
-     be one which initially came from the WASM module, not a method we
-     want to bind to a virtual table or VFS.)
-
-     This function returns a proxy for itself which is bound to tgt
-     and takes 2 args (name,func). That function returns the same
-     thing as this one, permitting calls to be chained.
-
-     If called with only 1 arg, it has no side effects but returns a
-     func with the same signature as described above.
-
-     ACHTUNG: because we cannot generically know how to transform JS
-     exceptions into result codes, the installed functions do no
-     automatic catching of exceptions. It is critical, to avoid
-     undefined behavior in the C layer, that methods mapped via
-     this function do not throw. The exception, as it were, to that
-     rule is...
-
-     If applyArgcCheck is true then each JS function (as opposed to
-     function pointers) gets wrapped in a proxy which asserts that it
-     is passed the expected number of arguments, throwing if the
-     argument count does not match expectations. That is only intended
-     for dev-time usage for sanity checking, and will leave the C
-     environment in an undefined state.
-  */
-  const installMethod = function callee(
-    tgt, name, func, applyArgcCheck = callee.installMethodArgcCheck
-  ){
-    if(!(tgt instanceof StructBinder.StructType)){
-      toss("Usage error: target object is-not-a StructType.");
-    }else if(!(func instanceof Function) && !wasm.isPtr(func)){
-      toss("Usage errror: expecting a Function or WASM pointer to one.");
-    }
-    if(1===arguments.length){
-      return (n,f)=>callee(tgt, n, f, applyArgcCheck);
-    }
-    if(!callee.argcProxy){
-      callee.argcProxy = function(tgt, funcName, func,sig){
-        return function(...args){
-          if(func.length!==arguments.length){
-            toss("Argument mismatch for",
-                 tgt.structInfo.name+"::"+funcName
-                 +": Native signature is:",sig);
-          }
-          return func.apply(this, args);
-        }
-      };
-      /* An ondispose() callback for use with
-         StructBinder-created types. */
-      callee.removeFuncList = function(){
-        if(this.ondispose.__removeFuncList){
-          this.ondispose.__removeFuncList.forEach(
-            (v,ndx)=>{
-              if('number'===typeof v){
-                try{wasm.uninstallFunction(v)}
-                catch(e){/*ignore*/}
-              }
-              /* else it's a descriptive label for the next number in
-                 the list. */
-            }
-          );
-          delete this.ondispose.__removeFuncList;
-        }
-      };
-    }/*static init*/
-    const sigN = tgt.memberSignature(name);
-    if(sigN.length<2){
-      toss("Member",name,"does not have a function pointer signature:",sigN);
-    }
-    const memKey = tgt.memberKey(name);
-    const fProxy = (applyArgcCheck && !wasm.isPtr(func))
-    /** This middle-man proxy is only for use during development, to
-        confirm that we always pass the proper number of
-        arguments. We know that the C-level code will always use the
-        correct argument count. */
-          ? callee.argcProxy(tgt, memKey, func, sigN)
-          : func;
-    if(wasm.isPtr(fProxy)){
-      if(fProxy && !wasm.functionEntry(fProxy)){
-        toss("Pointer",fProxy,"is not a WASM function table entry.");
-      }
-      tgt[memKey] = fProxy;
-    }else{
-      const pFunc = wasm.installFunction(fProxy, tgt.memberSignature(name, true));
-      tgt[memKey] = pFunc;
-      if(!tgt.ondispose || !tgt.ondispose.__removeFuncList){
-        tgt.addOnDispose('ondispose.__removeFuncList handler',
-                         callee.removeFuncList);
-        tgt.ondispose.__removeFuncList = [];
-      }
-      tgt.ondispose.__removeFuncList.push(memKey, pFunc);
-    }
-    return (n,f)=>callee(tgt, n, f, applyArgcCheck);
-  }/*installMethod*/;
-  installMethod.installMethodArgcCheck = false;
-
-  /**
-     Installs methods into the given StructType-type instance. Each
-     entry in the given methods object must map to a known member of
-     the given StructType, else an exception will be triggered.  See
-     installMethod() for more details, including the semantics of the
-     3rd argument.
-
-     As an exception to the above, if any two or more methods in the
-     2nd argument are the exact same function, installMethod() is
-     _not_ called for the 2nd and subsequent instances, and instead
-     those instances get assigned the same method pointer which is
-     created for the first instance. This optimization is primarily to
-     accommodate special handling of sqlite3_module::xConnect and
-     xCreate methods.
-
-     On success, returns its first argument. Throws on error.
-  */
-  const installMethods = function(
-    structInstance, methods, applyArgcCheck = installMethod.installMethodArgcCheck
-  ){
-    const seen = new Map /* map of <Function, memberName> */;
-    for(const k of Object.keys(methods)){
-      const m = methods[k];
-      const prior = seen.get(m);
-      if(prior){
-        const mkey = structInstance.memberKey(k);
-        structInstance[mkey] = structInstance[structInstance.memberKey(prior)];
-      }else{
-        installMethod(structInstance, k, m, applyArgcCheck);
-        seen.set(m, k);
-      }
-    }
-    return structInstance;
-  };
-
-  /**
-     Equivalent to calling installMethod(this,...arguments) with a
-     first argument of this object. If called with 1 or 2 arguments
-     and the first is an object, it's instead equivalent to calling
-     installMethods(this,...arguments).
-  */
-  StructBinder.StructType.prototype.installMethod = function callee(
-    name, func, applyArgcCheck = installMethod.installMethodArgcCheck
-  ){
-    return (arguments.length < 3 && name && 'object'===typeof name)
-      ? installMethods(this, ...arguments)
-      : installMethod(this, ...arguments);
-  };
-
-  /**
-     Equivalent to calling installMethods() with a first argument
-     of this object.
-  */
-  StructBinder.StructType.prototype.installMethods = function(
-    methods, applyArgcCheck = installMethod.installMethodArgcCheck
-  ){
-    return installMethods(this, methods, applyArgcCheck);
-  };
-
-  /**
-     Uses sqlite3_vfs_register() to register this
-     sqlite3.capi.sqlite3_vfs. This object must have already been
-     filled out properly. If the first argument is truthy, the VFS is
-     registered as the default VFS, else it is not.
-
-     On success, returns this object. Throws on error.
-  */
-  capi.sqlite3_vfs.prototype.registerVfs = function(asDefault=false){
-    if(!(this instanceof sqlite3.capi.sqlite3_vfs)){
-      toss("Expecting a sqlite3_vfs-type argument.");
-    }
-    const rc = capi.sqlite3_vfs_register(this, asDefault ? 1 : 0);
-    if(rc){
-      toss("sqlite3_vfs_register(",this,") failed with rc",rc);
-    }
-    if(this.pointer !== capi.sqlite3_vfs_find(this.$zName)){
-      toss("BUG: sqlite3_vfs_find(vfs.$zName) failed for just-installed VFS",
-           this);
-    }
-    return this;
-  };
-
-  /**
-     A wrapper for installMethods() or registerVfs() to reduce
-     installation of a VFS and/or its I/O methods to a single
-     call.
-
-     Accepts an object which contains the properties "io" and/or
-     "vfs", each of which is itself an object with following properties:
-
-     - `struct`: an sqlite3.StructType-type struct. This must be a
-       populated (except for the methods) object of type
-       sqlite3_io_methods (for the "io" entry) or sqlite3_vfs (for the
-       "vfs" entry).
-
-     - `methods`: an object mapping sqlite3_io_methods method names
-       (e.g. 'xClose') to JS implementations of those methods. The JS
-       implementations must be call-compatible with their native
-       counterparts.
-
-     For each of those object, this function passes its (`struct`,
-     `methods`, (optional) `applyArgcCheck`) properties to
-     installMethods().
-
-     If the `vfs` entry is set then:
-
-     - Its `struct` property's registerVfs() is called. The
-       `vfs` entry may optionally have an `asDefault` property, which
-       gets passed as the argument to registerVfs().
-
-     - If `struct.$zName` is falsy and the entry has a string-type
-       `name` property, `struct.$zName` is set to the C-string form of
-       that `name` value before registerVfs() is called. That string
-       gets added to the on-dispose state of the struct.
-
-     On success returns this object. Throws on error.
-  */
-  vfs.installVfs = function(opt){
-    let count = 0;
-    const propList = ['io','vfs'];
-    for(const key of propList){
-      const o = opt[key];
-      if(o){
-        ++count;
-        installMethods(o.struct, o.methods, !!o.applyArgcCheck);
-        if('vfs'===key){
-          if(!o.struct.$zName && 'string'===typeof o.name){
-            o.struct.addOnDispose(
-              o.struct.$zName = wasm.allocCString(o.name)
-            );
-          }
-          o.struct.registerVfs(!!o.asDefault);
-        }
-      }
-    }
-    if(!count) toss("Misuse: installVfs() options object requires at least",
-                    "one of:", propList);
-    return this;
-  };
-
-  /**
      Internal factory function for xVtab and xCursor impls.
   */
   const __xWrapFactory = function(methodName,StructType){
@@ -457,30 +200,6 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
   vtab.xIndexInfo = (pIdxInfo)=>new capi.sqlite3_index_info(pIdxInfo);
 
   /**
-     Given an error object, this function returns
-     sqlite3.capi.SQLITE_NOMEM if (e instanceof
-     sqlite3.WasmAllocError), else it returns its
-     second argument. Its intended usage is in the methods
-     of a sqlite3_vfs or sqlite3_module:
-
-     ```
-     try{
-      let rc = ...
-      return rc;
-     }catch(e){
-       return sqlite3.vtab.exceptionToRc(e, sqlite3.capi.SQLITE_XYZ);
-       // where SQLITE_XYZ is some call-appropriate result code.
-     }
-     ```
-  */
-  /**vfs.exceptionToRc = vtab.exceptionToRc =
-    (e, defaultRc=capi.SQLITE_ERROR)=>(
-      (e instanceof sqlite3.WasmAllocError)
-        ? capi.SQLITE_NOMEM
-        : defaultRc
-    );*/
-
-  /**
      Given an sqlite3_module method name and error object, this
      function returns sqlite3.capi.SQLITE_NOMEM if (e instanceof
      sqlite3.WasmAllocError), else it returns its second argument. Its
@@ -526,20 +245,6 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
   vtab.xError.errorReporter = 1 ? console.error.bind(console) : false;
 
   /**
-     "The problem" with this is that it introduces an outer function with
-     a different arity than the passed-in method callback. That means we
-     cannot do argc validation on these. Additionally, some methods (namely
-     xConnect) may have call-specific error handling. It would be a shame to
-     hard-coded that per-method support in this function.
-  */
-  /** vtab.methodCatcher = function(methodName, method, defaultErrRc=capi.SQLITE_ERROR){
-    return function(...args){
-      try { method(...args); }
-      }catch(e){ return vtab.xError(methodName, e, defaultRc) }
-  };
-  */
-
-  /**
      A helper for sqlite3_vtab::xRowid() and xUpdate()
      implementations. It must be passed the final argument to one of
      those methods (an output pointer to an int64 row ID) and the
@@ -685,12 +390,12 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
             remethods[k] = fwrap(k, m);
           }
         }
-        installMethods(mod, remethods, false);
+        mod.installMethods(remethods, false);
       }else{
         // No automatic exception handling. Trust the client
         // to not throw.
-        installMethods(
-          mod, methods, !!opt.applyArgcCheck/*undocumented option*/
+        mod.installMethods(
+          methods, !!opt.applyArgcCheck/*undocumented option*/
         );
       }
       if(0===mod.$iVersion){
diff --git a/ext/wasm/api/sqlite3-wasm.c b/ext/wasm/api/sqlite3-wasm.c
index 618d0f0..48ae229 100644
--- a/ext/wasm/api/sqlite3-wasm.c
+++ b/ext/wasm/api/sqlite3-wasm.c
@@ -238,28 +238,28 @@
 ** Another option is to malloc() a chunk of our own and call that our
 ** "stack".
 */
-SQLITE_WASM_EXPORT void * sqlite3_wasm_stack_end(void){
+SQLITE_WASM_EXPORT void * sqlite3__wasm_stack_end(void){
   extern void __heap_base
     /* see https://stackoverflow.com/questions/10038964 */;
   return &__heap_base;
 }
-SQLITE_WASM_EXPORT void * sqlite3_wasm_stack_begin(void){
+SQLITE_WASM_EXPORT void * sqlite3__wasm_stack_begin(void){
   extern void __data_end;
   return &__data_end;
 }
 static void * pWasmStackPtr = 0;
-SQLITE_WASM_EXPORT void * sqlite3_wasm_stack_ptr(void){
-  if(!pWasmStackPtr) pWasmStackPtr = sqlite3_wasm_stack_end();
+SQLITE_WASM_EXPORT void * sqlite3__wasm_stack_ptr(void){
+  if(!pWasmStackPtr) pWasmStackPtr = sqlite3__wasm_stack_end();
   return pWasmStackPtr;
 }
-SQLITE_WASM_EXPORT void sqlite3_wasm_stack_restore(void * p){
+SQLITE_WASM_EXPORT void sqlite3__wasm_stack_restore(void * p){
   pWasmStackPtr = p;
 }
-SQLITE_WASM_EXPORT void * sqlite3_wasm_stack_alloc(int n){
+SQLITE_WASM_EXPORT void * sqlite3__wasm_stack_alloc(int n){
   if(n<=0) return 0;
   n = (n + 7) & ~7 /* align to 8-byte boundary */;
-  unsigned char * const p = (unsigned char *)sqlite3_wasm_stack_ptr();
-  unsigned const char * const b = (unsigned const char *)sqlite3_wasm_stack_begin();
+  unsigned char * const p = (unsigned char *)sqlite3__wasm_stack_ptr();
+  unsigned const char * const b = (unsigned const char *)sqlite3__wasm_stack_begin();
   if(b + n >= p || b + n < b/*overflow*/) return 0;
   return pWasmStackPtr = p - n;
 }
@@ -267,7 +267,7 @@ SQLITE_WASM_EXPORT void * sqlite3_wasm_stack_alloc(int n){
 
 /*
 ** State for the "pseudo-stack" allocator implemented in
-** sqlite3_wasm_pstack_xyz(). In order to avoid colliding with
+** sqlite3__wasm_pstack_xyz(). In order to avoid colliding with
 ** Emscripten-controled stack space, it carves out a bit of stack
 ** memory to use for that purpose. This memory ends up in the
 ** WASM-managed memory, such that routines which manipulate the wasm
@@ -291,14 +291,14 @@ static struct {
 /*
 ** Returns the current pstack position.
 */
-SQLITE_WASM_EXPORT void * sqlite3_wasm_pstack_ptr(void){
+SQLITE_WASM_EXPORT void * sqlite3__wasm_pstack_ptr(void){
   return PStack.pPos;
 }
 /*
 ** Sets the pstack position poitner to p. Results are undefined if the
-** given value did not come from sqlite3_wasm_pstack_ptr().
+** given value did not come from sqlite3__wasm_pstack_ptr().
 */
-SQLITE_WASM_EXPORT void sqlite3_wasm_pstack_restore(unsigned char * p){
+SQLITE_WASM_EXPORT void sqlite3__wasm_pstack_restore(unsigned char * p){
   assert(p>=PStack.pBegin && p<=PStack.pEnd && p>=PStack.pPos);
   assert(0==((unsigned long long)p & 0x7));
   if(p>=PStack.pBegin && p<=PStack.pEnd /*&& p>=PStack.pPos*/){
@@ -313,7 +313,7 @@ SQLITE_WASM_EXPORT void sqlite3_wasm_pstack_restore(unsigned char * p){
 ** JS code from having to do so, and most uses of the pstack will
 ** call for doing so).
 */
-SQLITE_WASM_EXPORT void * sqlite3_wasm_pstack_alloc(int n){
+SQLITE_WASM_EXPORT void * sqlite3__wasm_pstack_alloc(int n){
   if( n<=0 ) return 0;
   //if( n & 0x7 ) n += 8 - (n & 0x7) /* align to 8-byte boundary */;
   n = (n + 7) & ~7 /* align to 8-byte boundary */;
@@ -324,9 +324,9 @@ SQLITE_WASM_EXPORT void * sqlite3_wasm_pstack_alloc(int n){
 }
 /*
 ** Return the number of bytes left which can be
-** sqlite3_wasm_pstack_alloc()'d.
+** sqlite3__wasm_pstack_alloc()'d.
 */
-SQLITE_WASM_EXPORT int sqlite3_wasm_pstack_remaining(void){
+SQLITE_WASM_EXPORT int sqlite3__wasm_pstack_remaining(void){
   assert(PStack.pPos >= PStack.pBegin);
   assert(PStack.pPos <= PStack.pEnd);
   return (int)(PStack.pPos - PStack.pBegin);
@@ -337,7 +337,7 @@ SQLITE_WASM_EXPORT int sqlite3_wasm_pstack_remaining(void){
 ** any space which is currently allocated. This value is a
 ** compile-time constant.
 */
-SQLITE_WASM_EXPORT int sqlite3_wasm_pstack_quota(void){
+SQLITE_WASM_EXPORT int sqlite3__wasm_pstack_quota(void){
   return (int)(PStack.pEnd - PStack.pBegin);
 }
 
@@ -356,7 +356,7 @@ SQLITE_WASM_EXPORT int sqlite3_wasm_pstack_quota(void){
 ** Returns err_code.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_db_error(sqlite3*db, int err_code, const char *zMsg){
+int sqlite3__wasm_db_error(sqlite3*db, int err_code, const char *zMsg){
   if( db!=0 ){
     if( 0!=zMsg ){
       const int nMsg = sqlite3Strlen30(zMsg);
@@ -380,7 +380,7 @@ struct WasmTestStruct {
 };
 typedef struct WasmTestStruct WasmTestStruct;
 SQLITE_WASM_EXPORT
-void sqlite3_wasm_test_struct(WasmTestStruct * s){
+void sqlite3__wasm_test_struct(WasmTestStruct * s){
   if(s){
     s->v4 *= 2;
     s->v8 = s->v4 * 2;
@@ -408,7 +408,7 @@ void sqlite3_wasm_test_struct(WasmTestStruct * s){
 ** increased. In debug builds that will trigger an assert().
 */
 SQLITE_WASM_EXPORT
-const char * sqlite3_wasm_enum_json(void){
+const char * sqlite3__wasm_enum_json(void){
   static char aBuffer[1024 * 20] = {0} /* where the JSON goes */;
   int n = 0, nChildren = 0, nStruct = 0
     /* output counters for figuring out where commas go */;
@@ -425,7 +425,7 @@ const char * sqlite3_wasm_enum_json(void){
 
 /* Core output macros... */
 #define lenCheck assert(zPos < zEnd - 128 \
-  && "sqlite3_wasm_enum_json() buffer is too small."); \
+  && "sqlite3__wasm_enum_json() buffer is too small."); \
   if( zPos >= zEnd - 128 ) return 0
 #define outf(format,...) \
   zPos += snprintf(zPos, ((size_t)(zEnd - zPos)), format, __VA_ARGS__); \
@@ -545,6 +545,10 @@ const char * sqlite3_wasm_enum_json(void){
     DefInt(SQLITE_CONFIG_SMALL_MALLOC);
     DefInt(SQLITE_CONFIG_SORTERREF_SIZE);
     DefInt(SQLITE_CONFIG_MEMDB_MAXSIZE);
+    /* maintenance note: we specifically do not include
+       SQLITE_CONFIG_ROWID_IN_VIEW here, on the grounds that
+       it's only for legacy support and no apps written with
+       this API require that. */
   } _DefGroup;
 
   DefGroup(dataTypes) {
@@ -1220,7 +1224,7 @@ const char * sqlite3_wasm_enum_json(void){
 ** call is returned.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_vfs_unlink(sqlite3_vfs *pVfs, const char *zName){
+int sqlite3__wasm_vfs_unlink(sqlite3_vfs *pVfs, const char *zName){
   int rc = SQLITE_MISUSE /* ??? */;
   if( 0==pVfs && 0!=zName ) pVfs = sqlite3_vfs_find(0);
   if( zName && pVfs && pVfs->xDelete ){
@@ -1238,7 +1242,7 @@ int sqlite3_wasm_vfs_unlink(sqlite3_vfs *pVfs, const char *zName){
 ** given name is open.
 */
 SQLITE_WASM_EXPORT
-sqlite3_vfs * sqlite3_wasm_db_vfs(sqlite3 *pDb, const char *zDbName){
+sqlite3_vfs * sqlite3__wasm_db_vfs(sqlite3 *pDb, const char *zDbName){
   sqlite3_vfs * pVfs = 0;
   sqlite3_file_control(pDb, zDbName ? zDbName : "main",
                        SQLITE_FCNTL_VFS_POINTER, &pVfs);
@@ -1261,7 +1265,7 @@ sqlite3_vfs * sqlite3_wasm_db_vfs(sqlite3 *pDb, const char *zDbName){
 ** SQLITE_MISUSE if pDb is NULL.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_db_reset(sqlite3 *pDb){
+int sqlite3__wasm_db_reset(sqlite3 *pDb){
   int rc = SQLITE_MISUSE;
   if( pDb ){
     sqlite3_table_column_metadata(pDb, "main", 0, 0, 0, 0, 0, 0, 0);
@@ -1288,11 +1292,11 @@ int sqlite3_wasm_db_reset(sqlite3 *pDb){
 ** takes no measures to ensure that is the case.
 **
 ** This implementation appears to work fine, but
-** sqlite3_wasm_db_serialize() is arguably the better way to achieve
+** sqlite3__wasm_db_serialize() is arguably the better way to achieve
 ** this.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_db_export_chunked( sqlite3* pDb,
+int sqlite3__wasm_db_export_chunked( sqlite3* pDb,
                                     int (*xCallback)(unsigned const char *zOut, int n) ){
   sqlite3_int64 nSize = 0;
   sqlite3_int64 nPos = 0;
@@ -1343,7 +1347,7 @@ int sqlite3_wasm_db_export_chunked( sqlite3* pDb,
 ** sqlite3_free() to free it.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_db_serialize( sqlite3 *pDb, const char *zSchema,
+int sqlite3__wasm_db_serialize( sqlite3 *pDb, const char *zSchema,
                                unsigned char **pOut,
                                sqlite3_int64 *nOut, unsigned int mFlags ){
   unsigned char * z;
@@ -1366,7 +1370,7 @@ int sqlite3_wasm_db_serialize( sqlite3 *pDb, const char *zSchema,
 ** this function's out-of-scope use of the sqlite3_vfs/file/io_methods
 ** APIs leads to triggering of assertions in the core library. Its use
 ** is now deprecated and VFS-specific APIs for importing files need to
-** be found to replace it. sqlite3_wasm_posix_create_file() is
+** be found to replace it. sqlite3__wasm_posix_create_file() is
 ** suitable for the "unix" family of VFSes.
 **
 ** Creates a new file using the I/O API of the given VFS, containing
@@ -1407,7 +1411,7 @@ int sqlite3_wasm_db_serialize( sqlite3 *pDb, const char *zSchema,
 ** support is disabled or unavailable.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_vfs_create_file( sqlite3_vfs *pVfs,
+int sqlite3__wasm_vfs_create_file( sqlite3_vfs *pVfs,
                                   const char *zFilename,
                                   const unsigned char * pData,
                                   int nData ){
@@ -1497,7 +1501,7 @@ int sqlite3_wasm_vfs_create_file( sqlite3_vfs *pVfs,
 ** SQLITE_IOERR on error.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_posix_create_file( const char *zFilename,
+int sqlite3__wasm_posix_create_file( const char *zFilename,
                                     const unsigned char * pData,
                                     int nData ){
   int rc;
@@ -1520,17 +1524,17 @@ int sqlite3_wasm_posix_create_file( const char *zFilename,
 ** for use by the sqlite project's own JS/WASM bindings.
 **
 ** Allocates sqlite3KvvfsMethods.nKeySize bytes from
-** sqlite3_wasm_pstack_alloc() and returns 0 if that allocation fails,
+** sqlite3__wasm_pstack_alloc() and returns 0 if that allocation fails,
 ** else it passes that string to kvstorageMakeKey() and returns a
 ** NUL-terminated pointer to that string. It is up to the caller to
-** use sqlite3_wasm_pstack_restore() to free the returned pointer.
+** use sqlite3__wasm_pstack_restore() to free the returned pointer.
 */
 SQLITE_WASM_EXPORT
-char * sqlite3_wasm_kvvfsMakeKeyOnPstack(const char *zClass,
+char * sqlite3__wasm_kvvfsMakeKeyOnPstack(const char *zClass,
                                          const char *zKeyIn){
   assert(sqlite3KvvfsMethods.nKeySize>24);
   char *zKeyOut =
-    (char *)sqlite3_wasm_pstack_alloc(sqlite3KvvfsMethods.nKeySize);
+    (char *)sqlite3__wasm_pstack_alloc(sqlite3KvvfsMethods.nKeySize);
   if(zKeyOut){
     kvstorageMakeKey(zClass, zKeyIn, zKeyOut);
   }
@@ -1545,7 +1549,7 @@ char * sqlite3_wasm_kvvfsMakeKeyOnPstack(const char *zClass,
 ** I/O methods and associated state.
 */
 SQLITE_WASM_EXPORT
-sqlite3_kvvfs_methods * sqlite3_wasm_kvvfs_methods(void){
+sqlite3_kvvfs_methods * sqlite3__wasm_kvvfs_methods(void){
   return &sqlite3KvvfsMethods;
 }
 
@@ -1560,7 +1564,7 @@ sqlite3_kvvfs_methods * sqlite3_wasm_kvvfs_methods(void){
 ** valid value.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_vtab_config(sqlite3 *pDb, int op, int arg){
+int sqlite3__wasm_vtab_config(sqlite3 *pDb, int op, int arg){
   switch(op){
   case SQLITE_VTAB_DIRECTONLY:
   case SQLITE_VTAB_INNOCUOUS:
@@ -1580,7 +1584,7 @@ int sqlite3_wasm_vtab_config(sqlite3 *pDb, int op, int arg){
 ** (int,int*) variadic args.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_db_config_ip(sqlite3 *pDb, int op, int arg1, int* pArg2){
+int sqlite3__wasm_db_config_ip(sqlite3 *pDb, int op, int arg1, int* pArg2){
   switch(op){
     case SQLITE_DBCONFIG_ENABLE_FKEY:
     case SQLITE_DBCONFIG_ENABLE_TRIGGER:
@@ -1613,7 +1617,7 @@ int sqlite3_wasm_db_config_ip(sqlite3 *pDb, int op, int arg1, int* pArg2){
 ** (void*,int,int) variadic args.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_db_config_pii(sqlite3 *pDb, int op, void * pArg1, int arg2, int arg3){
+int sqlite3__wasm_db_config_pii(sqlite3 *pDb, int op, void * pArg1, int arg2, int arg3){
   switch(op){
     case SQLITE_DBCONFIG_LOOKASIDE:
       return sqlite3_db_config(pDb, op, pArg1, arg2, arg3);
@@ -1629,7 +1633,7 @@ int sqlite3_wasm_db_config_pii(sqlite3 *pDb, int op, void * pArg1, int arg2, int
 ** (const char *) variadic args.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_db_config_s(sqlite3 *pDb, int op, const char *zArg){
+int sqlite3__wasm_db_config_s(sqlite3 *pDb, int op, const char *zArg){
   switch(op){
     case SQLITE_DBCONFIG_MAINDBNAME:
       return sqlite3_db_config(pDb, op, zArg);
@@ -1646,7 +1650,7 @@ int sqlite3_wasm_db_config_s(sqlite3 *pDb, int op, const char *zArg){
 ** a single integer argument.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_config_i(int op, int arg){
+int sqlite3__wasm_config_i(int op, int arg){
   return sqlite3_config(op, arg);
 }
 
@@ -1658,7 +1662,7 @@ int sqlite3_wasm_config_i(int op, int arg){
 ** two int arguments.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_config_ii(int op, int arg1, int arg2){
+int sqlite3__wasm_config_ii(int op, int arg1, int arg2){
   return sqlite3_config(op, arg1, arg2);
 }
 
@@ -1670,39 +1674,28 @@ int sqlite3_wasm_config_ii(int op, int arg1, int arg2){
 ** a single i64 argument.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_config_j(int op, sqlite3_int64 arg){
+int sqlite3__wasm_config_j(int op, sqlite3_int64 arg){
   return sqlite3_config(op, arg);
 }
 
-#if 0
-// Pending removal after verification of a workaround discussed in the
-// forum post linked to below.
 /*
 ** This function is NOT part of the sqlite3 public API. It is strictly
 ** for use by the sqlite project's own JS/WASM bindings.
 **
-** Returns a pointer to sqlite3_free(). In compliant browsers the
-** return value, when passed to sqlite3.wasm.exports.functionEntry(),
-** must resolve to the same function as
-** sqlite3.wasm.exports.sqlite3_free. i.e. from a dev console where
-** sqlite3 is exported globally, the following must be true:
-**
-** ```
-** sqlite3.wasm.functionEntry(
-**   sqlite3.wasm.exports.sqlite3_wasm_ptr_to_sqlite3_free()
-** ) === sqlite3.wasm.exports.sqlite3_free
-** ```
-**
-** Using a function to return this pointer, as opposed to exporting it
-** via sqlite3_wasm_enum_json(), is an attempt to work around a
-** Safari-specific quirk covered at
-** https://sqlite.org/forum/info/e5b20e1feb37a19a.
-**/
+** If z is not NULL, returns the result of passing z to
+** sqlite3_mprintf()'s %Q modifier (if addQuotes is true) or %q (if
+** addQuotes is 0). Returns NULL if z is NULL or on OOM.
+*/
 SQLITE_WASM_EXPORT
-void * sqlite3_wasm_ptr_to_sqlite3_free(void){
-  return (void*)sqlite3_free;
+char * sqlite3__wasm_qfmt_token(char *z, int addQuotes){
+  char * rc = 0;
+  if( z ){
+    rc = addQuotes
+      ? sqlite3_mprintf("%Q", z)
+      : sqlite3_mprintf("%q", z);
+  }
+  return rc;
 }
-#endif
 
 #if defined(__EMSCRIPTEN__) && defined(SQLITE_ENABLE_WASMFS)
 #include <emscripten/wasmfs.h>
@@ -1729,7 +1722,7 @@ void * sqlite3_wasm_ptr_to_sqlite3_free(void){
 ** defined, SQLITE_NOTFOUND is returned without side effects.
 */
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_init_wasmfs(const char *zMountPoint){
+int sqlite3__wasm_init_wasmfs(const char *zMountPoint){
   static backend_t pOpfs = 0;
   if( !zMountPoint || !*zMountPoint ) zMountPoint = "/opfs";
   if( !pOpfs ){
@@ -1749,7 +1742,7 @@ int sqlite3_wasm_init_wasmfs(const char *zMountPoint){
 }
 #else
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_init_wasmfs(const char *zUnused){
+int sqlite3__wasm_init_wasmfs(const char *zUnused){
   //emscripten_console_warn("WASMFS OPFS is not compiled in.");
   if(zUnused){/*unused*/}
   return SQLITE_NOTFOUND;
@@ -1759,51 +1752,51 @@ int sqlite3_wasm_init_wasmfs(const char *zUnused){
 #if SQLITE_WASM_TESTS
 
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_test_intptr(int * p){
+int sqlite3__wasm_test_intptr(int * p){
   return *p = *p * 2;
 }
 
 SQLITE_WASM_EXPORT
-void * sqlite3_wasm_test_voidptr(void * p){
+void * sqlite3__wasm_test_voidptr(void * p){
   return p;
 }
 
 SQLITE_WASM_EXPORT
-int64_t sqlite3_wasm_test_int64_max(void){
+int64_t sqlite3__wasm_test_int64_max(void){
   return (int64_t)0x7fffffffffffffff;
 }
 
 SQLITE_WASM_EXPORT
-int64_t sqlite3_wasm_test_int64_min(void){
-  return ~sqlite3_wasm_test_int64_max();
+int64_t sqlite3__wasm_test_int64_min(void){
+  return ~sqlite3__wasm_test_int64_max();
 }
 
 SQLITE_WASM_EXPORT
-int64_t sqlite3_wasm_test_int64_times2(int64_t x){
+int64_t sqlite3__wasm_test_int64_times2(int64_t x){
   return x * 2;
 }
 
 SQLITE_WASM_EXPORT
-void sqlite3_wasm_test_int64_minmax(int64_t * min, int64_t *max){
-  *max = sqlite3_wasm_test_int64_max();
-  *min = sqlite3_wasm_test_int64_min();
+void sqlite3__wasm_test_int64_minmax(int64_t * min, int64_t *max){
+  *max = sqlite3__wasm_test_int64_max();
+  *min = sqlite3__wasm_test_int64_min();
   /*printf("minmax: min=%lld, max=%lld\n", *min, *max);*/
 }
 
 SQLITE_WASM_EXPORT
-int64_t sqlite3_wasm_test_int64ptr(int64_t * p){
-  /*printf("sqlite3_wasm_test_int64ptr( @%lld = 0x%llx )\n", (int64_t)p, *p);*/
+int64_t sqlite3__wasm_test_int64ptr(int64_t * p){
+  /*printf("sqlite3__wasm_test_int64ptr( @%lld = 0x%llx )\n", (int64_t)p, *p);*/
   return *p = *p * 2;
 }
 
 SQLITE_WASM_EXPORT
-void sqlite3_wasm_test_stack_overflow(int recurse){
-  if(recurse) sqlite3_wasm_test_stack_overflow(recurse);
+void sqlite3__wasm_test_stack_overflow(int recurse){
+  if(recurse) sqlite3__wasm_test_stack_overflow(recurse);
 }
 
 /* For testing the 'string:dealloc' whwasmutil.xWrap() conversion. */
 SQLITE_WASM_EXPORT
-char * sqlite3_wasm_test_str_hello(int fail){
+char * sqlite3__wasm_test_str_hello(int fail){
   char * s = fail ? 0 : (char *)sqlite3_malloc(6);
   if(s){
     memcpy(s, "hello", 5);
@@ -1838,12 +1831,12 @@ char * sqlite3_wasm_test_str_hello(int fail){
 **                optional + or - sign in front, or a hexadecimal
 **                literal of the form 0x...
 */
-static int sqlite3_wasm_SQLTester_strnotglob(const char *zGlob, const char *z){
+static int sqlite3__wasm_SQLTester_strnotglob(const char *zGlob, const char *z){
   int c, c2;
   int invert;
   int seen;
   typedef int (*recurse_f)(const char *,const char *);
-  static const recurse_f recurse = sqlite3_wasm_SQLTester_strnotglob;
+  static const recurse_f recurse = sqlite3__wasm_SQLTester_strnotglob;
 
   while( (c = (*(zGlob++)))!=0 ){
     if( c=='*' ){
@@ -1918,11 +1911,10 @@ static int sqlite3_wasm_SQLTester_strnotglob(const char *zGlob, const char *z){
 }
 
 SQLITE_WASM_EXPORT
-int sqlite3_wasm_SQLTester_strglob(const char *zGlob, const char *z){
- return !sqlite3_wasm_SQLTester_strnotglob(zGlob, z);
+int sqlite3__wasm_SQLTester_strglob(const char *zGlob, const char *z){
+ return !sqlite3__wasm_SQLTester_strnotglob(zGlob, z);
 }
 
-
 #endif /* SQLITE_WASM_TESTS */
 
 #undef SQLITE_WASM_EXPORT
diff --git a/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js b/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js
index cd78ed4..55e497e 100644
--- a/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js
+++ b/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js
@@ -42,9 +42,13 @@
    - `onready` (optional, but...): this callback is called with no
    arguments when the worker fires its initial
    'sqlite3-api'/'worker1-ready' message, which it does when
-   sqlite3.initWorker1API() completes its initialization. This is
-   the simplest way to tell the worker to kick off work at the
-   earliest opportunity.
+   sqlite3.initWorker1API() completes its initialization. This is the
+   simplest way to tell the worker to kick off work at the earliest
+   opportunity, and the only way to know when the worker module has
+   completed loading. The irony of using a callback for this, instead
+   of returning a promise from sqlite3Worker1Promiser() is not lost on
+   the developers: see sqlite3Worker1Promiser.v2() which uses a
+   Promise instead.
 
    - `onunhandled` (optional): a callback which gets passed the
    message event object for any worker.onmessage() events which
@@ -156,6 +160,7 @@ globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfi
   if(!config.worker) config.worker = callee.defaultConfig.worker;
   if('function'===typeof config.worker) config.worker = config.worker();
   let dbId;
+  let promiserFunc;
   config.worker.onmessage = function(ev){
     ev = ev.data;
     debug('worker1.onmessage',ev);
@@ -163,7 +168,7 @@ globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfi
     if(!msgHandler){
       if(ev && 'sqlite3-api'===ev.type && 'worker1-ready'===ev.result) {
         /*fired one time when the Worker1 API initializes*/
-        if(config.onready) config.onready();
+        if(config.onready) config.onready(promiserFunc);
         return;
       }
       msgHandler = handlerMap[ev.type] /* check for exec per-row callback */;
@@ -192,7 +197,7 @@ globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfi
     try {msgHandler.resolve(ev)}
     catch(e){msgHandler.reject(e)}
   }/*worker.onmessage()*/;
-  return function(/*(msgType, msgArgs) || (msgEnvelope)*/){
+  return promiserFunc = function(/*(msgType, msgArgs) || (msgEnvelope)*/){
     let msg;
     if(1===arguments.length){
       msg = arguments[0];
@@ -202,7 +207,7 @@ globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfi
       msg.args = arguments[1];
       msg.dbId = msg.args.dbId;
     }else{
-      toss("Invalid arugments for sqlite3Worker1Promiser()-created factory.");
+      toss("Invalid arguments for sqlite3Worker1Promiser()-created factory.");
     }
     if(!msg.dbId && msg.type!=='open') msg.dbId = dbId;
     msg.messageId = genMsgId(msg);
@@ -246,9 +251,10 @@ globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfi
     return p;
   };
 }/*sqlite3Worker1Promiser()*/;
+
 globalThis.sqlite3Worker1Promiser.defaultConfig = {
   worker: function(){
-//#if target=es6-bundler-friendly
+//#if target=es6-module
     return new Worker(new URL("sqlite3-worker1-bundler-friendly.mjs", import.meta.url),{
       type: 'module'
     });
@@ -269,14 +275,72 @@ globalThis.sqlite3Worker1Promiser.defaultConfig = {
     return new Worker(theJs + globalThis.location.search);
 //#endif
   }
-//#ifnot target=es6-bundler-friendly
+//#ifnot target=es6-module
   .bind({
     currentScript: globalThis?.document?.currentScript
   })
 //#endif
   ,
   onerror: (...args)=>console.error('worker1 promiser error',...args)
-};
+}/*defaultConfig*/;
+
+/**
+   sqlite3Worker1Promiser.v2(), added in 3.46, works identically to
+   sqlite3Worker1Promiser() except that it returns a Promise instead
+   of relying an an onready callback in the config object. The Promise
+   resolves to the same factory function which
+   sqlite3Worker1Promiser() returns.
+
+   If config is-a function or is an object which contains an onready
+   function, that function is replaced by a proxy which will resolve
+   after calling the original function and will reject if that
+   function throws.
+*/
+sqlite3Worker1Promiser.v2 = function(config){
+  let oldFunc;
+  if( 'function' == typeof config ){
+    oldFunc = config;
+    config = {};
+  }else if('function'===typeof config?.onready){
+    oldFunc = config.onready;
+    delete config.onready;
+  }
+  const promiseProxy = Object.create(null);
+  config = Object.assign((config || Object.create(null)),{
+    onready: async function(func){
+      try {
+        if( oldFunc ) await oldFunc(func);
+        promiseProxy.resolve(func);
+      }
+      catch(e){promiseProxy.reject(e)}
+    }
+  });
+  const p = new Promise(function(resolve,reject){
+    promiseProxy.resolve = resolve;
+    promiseProxy.reject = reject;
+  });
+  try{
+    this.original(config);
+  }catch(e){
+    promiseProxy.reject(e);
+  }
+  return p;
+}.bind({
+   /* We do this because clients are
+      recommended to delete globalThis.sqlite3Worker1Promiser. */
+  original: sqlite3Worker1Promiser
+});
+
+//#if target=es6-module
+/**
+  When built as a module, we export sqlite3Worker1Promiser.v2()
+  instead of sqlite3Worker1Promise() because (A) its interface is more
+  conventional for ESM usage and (B) the ESM option export option for
+  this API did not exist until v2 was created, so there's no backwards
+  incompatibility.
+*/
+export default sqlite3Worker1Promiser.v2;
+//#endif /* target=es6-module */
 //#else
 /* Built with the omit-oo1 flag. */
 //#endif ifnot omit-oo1