Make explicit which JS APIs are for internal use only by moving the JS-bound internal-use-only functions out of client-visible reach and renaming the WASM-exported ones from sqlite3_wasm... to sqlite3__wasm... (with two underscores). These have always been documented as internal-use-only, so this is not a breaking change except for clients which have ignored the docs.

FossilOrigin-Name: 0eddc20f37988df6bce5f407b69e4a315e5cca4af104586e6fe942f0d656cccd

4 files changed, 118 insertions, 118 deletions

diff --git a/ext/wasm/api/sqlite3-api-glue.js b/ext/wasm/api/sqlite3-api-glue.js
index 29efb3e07..e12c5162c 100644
--- a/ext/wasm/api/sqlite3-api-glue.js
+++ b/ext/wasm/api/sqlite3-api-glue.js
@@ -601,16 +601,16 @@ 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 wasm.sqlite3_js_...().
   */
-  wasm.bindingSignatures.wasm = [
-    ["sqlite3_wasm_db_reset", "int", "sqlite3*"],
-    ["sqlite3_wasm_db_vfs", "sqlite3_vfs*", "sqlite3*","string"],
-    ["sqlite3_wasm_vfs_create_file", "int",
+  wasm.bindingSignatures.wasmInternal = [
+    ["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"]
+    ["sqlite3__wasm_posix_create_file", "int", "string","*", "int"],
+    ["sqlite3__wasm_vfs_unlink", "int", "sqlite3_vfs*","string"]
   ];
 
   /**
@@ -742,8 +742,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 +765,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 +785,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 +796,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 +877,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 +889,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 +898,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 +1128,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 +1254,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 +1299,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 +1394,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 +1438,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 +1446,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 +1472,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 +1480,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 +1504,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* */
@@ -1574,11 +1574,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 +1587,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.
       */
diff --git a/ext/wasm/api/sqlite3-api-prologue.js b/ext/wasm/api/sqlite3-api-prologue.js
index ef1154f6b..c784b6990 100644
--- a/ext/wasm/api/sqlite3-api-prologue.js
+++ b/ext/wasm/api/sqlite3-api-prologue.js
@@ -1061,7 +1061,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 +1083,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 +1163,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 +1175,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 +1183,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 +1256,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 +1365,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 +1391,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 +1449,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 +1551,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 +1672,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){
diff --git a/ext/wasm/api/sqlite3-api-worker1.js b/ext/wasm/api/sqlite3-api-worker1.js
index 3099c19ec..bd99f3ec8 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);
         }
       }
     },
@@ -495,12 +496,12 @@ sqlite3.initWorker1API = function(){
       }
       if(pVfs){
         /* 2022-11-02: this feature is as-yet untested except that
-           sqlite3_wasm_vfs_create_file() has been tested from the
+           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(
+          const rc = util.sqlite3__wasm_vfs_create_file(
             pVfs, oargs.filename, pMem, byteArray.byteLength
           );
           if(rc) sqlite3.SQLite3Error.toss(rc);
diff --git a/ext/wasm/api/sqlite3-wasm.c b/ext/wasm/api/sqlite3-wasm.c
index 618d0f085..bd0eb884c 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__); \
@@ -1220,7 +1220,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 +1238,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 +1261,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 +1288,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 +1343,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 +1366,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 +1407,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 +1497,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 +1520,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 +1545,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 +1560,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 +1580,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 +1613,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 +1629,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 +1646,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 +1658,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,7 +1670,7 @@ 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);
 }
 
@@ -1689,17 +1689,17 @@ int sqlite3_wasm_config_j(int op, sqlite3_int64 arg){
 **
 ** ```
 ** sqlite3.wasm.functionEntry(
-**   sqlite3.wasm.exports.sqlite3_wasm_ptr_to_sqlite3_free()
+**   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
+** via sqlite3__wasm_enum_json(), is an attempt to work around a
 ** Safari-specific quirk covered at
 ** https://sqlite.org/forum/info/e5b20e1feb37a19a.
 **/
 SQLITE_WASM_EXPORT
-void * sqlite3_wasm_ptr_to_sqlite3_free(void){
+void * sqlite3__wasm_ptr_to_sqlite3_free(void){
   return (void*)sqlite3_free;
 }
 #endif
@@ -1729,7 +1729,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 +1749,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 +1759,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 +1838,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 +1918,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