Add files using upload-large-folder tool

local-test-sqlite3-delta-02/afc-sqlite3/ext/recover/recoverfault2.test

@@ -0,0 +1,102 @@
+# 2022 August 28
+#
+# 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.
+#
+#***********************************************************************
+#
+
+source [file join [file dirname [info script]] recover_common.tcl]
+set testprefix recoverfault2
+
+
+#--------------------------------------------------------------------------
+proc compare_result {db1 db2 sql} {
+  set r1 [$db1 eval $sql]
+  set r2 [$db2 eval $sql]
+  if {$r1 != $r2} {
+    puts "r1: $r1"
+    puts "r2: $r2"
+    error "mismatch for $sql"
+  }
+  return ""
+}
+
+proc compare_dbs {db1 db2} {
+  compare_result $db1 $db2 "SELECT sql FROM sqlite_master ORDER BY 1"
+  foreach tbl [$db1 eval {SELECT name FROM sqlite_master WHERE type='table'}] {
+    compare_result $db1 $db2 "SELECT * FROM $tbl"
+  }
+}
+#--------------------------------------------------------------------------
+
+do_execsql_test 1.0 "
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t1 VALUES(2, '\012hello\015world\012today\n');
+"
+faultsim_save_and_close
+
+proc my_sql_hook {sql} {
+  lappend ::lSql $sql
+  return 0
+}
+
+do_faultsim_test 1 -faults oom* -prep {
+  catch { db2 close }
+  faultsim_restore_and_reopen
+  set ::lSql [list]
+} -body {
+  set R [sqlite3_recover_init_sql db main my_sql_hook]
+  $R run
+  $R finish
+} -test {
+  faultsim_test_result {0 {}} {1 {}}
+  if {$testrc==0} {
+    sqlite3 db2 ""
+    db2 eval [join $::lSql ";"]
+    compare_dbs db db2
+    db2 close
+  }
+}
+
+ifcapable utf16 {
+  reset_db
+  do_execsql_test 2.0 "
+    PRAGMA encoding='utf-16';
+    CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+    INSERT INTO t1 VALUES(2, '\012hello\015world\012today\n');
+  "
+  faultsim_save_and_close
+  
+  proc my_sql_hook {sql} {
+    lappend ::lSql $sql
+    return 0
+  }
+  
+  do_faultsim_test 2 -faults oom-t* -prep {
+    catch { db2 close }
+    faultsim_restore_and_reopen
+    set ::lSql [list]
+  } -body {
+    set R [sqlite3_recover_init_sql db main my_sql_hook]
+    $R run
+    $R finish
+  } -test {
+    faultsim_test_result {0 {}} {1 {}}
+    if {$testrc==0} {
+      sqlite3 db2 ""
+      db2 eval [join $::lSql ";"]
+      compare_dbs db db2
+      db2 close
+    }
+  }
+}
+
+
+
+finish_test
+

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/SQLTester/GNUmakefile

@@ -0,0 +1,55 @@
+#!/this/is/make
+#
+# This makefile compiles SQLTester test files into something
+# we can readily import into JavaScript.
+all:
+
+SHELL := $(shell which bash 2>/dev/null)
+MAKEFILE := $(lastword $(MAKEFILE_LIST))
+CLEAN_FILES :=
+DISTCLEAN_FILES := ./--dummy-- *~
+
+test-list.mjs := test-list.mjs
+test-list.mjs.gz := $(test-list.mjs).gz
+CLEAN_FILES += $(test-list.mjs)
+
+tests.dir := $(firstword $(wildcard tests ../../jni/src/tests))
+$(info test script dir=$(tests.dir))
+
+tests.all := $(wildcard $(tests.dir)/*.test)
+
+bin.touint8array := ./touint8array
+$(bin.touint8array): $(bin.touint8array).c $(MAKEFILE)
+	$(CC) -o $@ $<
+CLEAN_FILES += $(bin.touint8array)
+
+ifneq (,$(tests.all))
+$(test-list.mjs): $(bin.touint8array) $(tests.all) $(MAKEFILE)
+	@{\
+		echo 'export default ['; \
+		sep=''; \
+		for f in $(sort $(tests.all)); do \
+			echo -en $$sep'{"name": "'$${f##*/}'", "content":'; \
+			$(bin.touint8array) < $$f; \
+			echo -n '}'; \
+			sep=',\n'; \
+		done; \
+	echo '];'; \
+	} > $@
+	@echo "Created $@"
+$(test-list.mjs.gz): $(test-list.mjs)
+	gzip -c $< > $@
+CLEAN_FILES += $(test-list.mjs.gz)
+all: $(test-list.mjs.gz)
+else
+	@echo "Cannot build $(test-list.mjs) for lack of input test files."; \
+		echo "Symlink ./tests to a directory containing SQLTester-format "; \
+		echo "test scripts named *.test, then try again"; \
+		exit 1
+endif
+
+.PHONY: clean distclean
+clean:
+	-rm -f $(CLEAN_FILES)
+distclean: clean
+	-rm -f $(DISTCLEAN_FILES)

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/README.md

@@ -0,0 +1,166 @@
+# sqlite3-api.js And Friends
+
+This is the README for the files `sqlite3-*.js` and
+`sqlite3-wasm.c`. This collection of files is used to build a
+single-file distribution of the sqlite3 WASM API. It is broken into
+multiple JS files because:
+
+1. To facilitate including or excluding certain components for
+   specific use cases. e.g. by removing `sqlite3-api-oo1.js` if the
+   OO#1 API is not needed.
+
+2. To facilitate modularizing the pieces for use in different WASM
+   build environments. e.g. the files `post-js-*.js` are for use with
+   Emscripten's `--post-js` feature, and nowhere else.
+
+3. Certain components must be in their own standalone files in order
+   to be loaded as JS Workers.
+
+Note that the structure described here is the current state of things,
+as of this writing, but is not set in stone forever and may change
+at any time.
+
+The overall idea is that the following files get concatenated
+together, in the listed order, the resulting file is loaded by a
+browser client:
+
+- **`sqlite3-api-prologue.js`**\  
+  Contains the initial bootstrap setup of the sqlite3 API
+  objects. This is exposed as a function, rather than objects, so that
+  the next step can pass in a config object which abstracts away parts
+  of the WASM environment, to facilitate plugging it in to arbitrary
+  WASM toolchains.
+- **`../common/whwasmutil.js`**\  
+  A semi-third-party collection of JS/WASM utility code intended to
+  replace much of the Emscripten glue. The sqlite3 APIs internally use
+  these APIs instead of their Emscripten counterparts, in order to be
+  more portable to arbitrary WASM toolchains. This API is
+  configurable, in principle, for use with arbitrary WASM
+  toolchains. It is "semi-third-party" in that it was created in order
+  to support this tree but is standalone and maintained together
+  with...
+- **`../jaccwabyt/jaccwabyt.js`**\  
+  Another semi-third-party API which creates bindings between JS
+  and C structs, such that changes to the struct state from either JS
+  or C are visible to the other end of the connection. This is also an
+  independent spinoff project, conceived for the sqlite3 project but
+  maintained separately.
+- **`sqlite3-api-glue.js`**\  
+  Invokes functionality exposed by the previous two files to flesh out
+  low-level parts of `sqlite3-api-prologue.js`. Most of these pieces
+  related to populating the `sqlite3.capi.wasm` object. This file
+  also deletes most global-scope symbols the above files create,
+  effectively moving them into the scope being used for initializing
+  the API.
+- **`<build>/sqlite3-api-build-version.js`**\  
+  Gets created by the build process and populates the
+  `sqlite3.version` object. This part is not critical, but records the
+  version of the library against which this module was built.
+- **`sqlite3-api-oo1.js`**\  
+  Provides a high-level object-oriented wrapper to the lower-level C
+  API, colloquially known as OO API #1. Its API is similar to other
+  high-level sqlite3 JS wrappers and should feel relatively familiar
+  to anyone familiar with such APIs. That said, it is not a "required
+  component" and can be elided from builds which do not want it.
+- **`sqlite3-api-worker1.js`**\  
+  A Worker-thread-based API which uses OO API #1 to provide an
+  interface to a database which can be driven from the main Window
+  thread via the Worker message-passing interface. Like OO API #1,
+  this is an optional component, offering one of any number of
+  potential implementations for such an API.
+    - **`sqlite3-worker1.js`**\  
+      Is not part of the amalgamated sources and is intended to be
+      loaded by a client Worker thread. It loads the sqlite3 module
+      and runs the Worker #1 API which is implemented in
+      `sqlite3-api-worker1.js`.
+    - **`sqlite3-worker1-promiser.js`**\  
+      Is likewise not part of the amalgamated sources and provides
+      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-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
+  for database files in a browser. It requires...
+    - **`sqlite3-opfs-async-proxy.js`**\  
+      is the asynchronous backend part of the OPFS proxy. It speaks
+      directly to the (async) OPFS API and channels those results back
+      to its synchronous counterpart. This file, because it must be
+      started in its own Worker, is not part of the amalgamation.
+- **`sqlite3-vfs-opfs-sahpool.c-pp.js`**\  
+  is another sqlite3 VFS supporting the OPFS, but uses a completely
+  different approach that the above-listed one.
+- **`sqlite3-api-cleanup.js`**\  
+  The previous files do not immediately extend the library. Instead
+  they add callback functions to be called during its
+  bootstrapping. Some also temporarily create global objects in order
+  to communicate their state to the files which follow them. This file
+  cleans up any dangling globals and runs the API bootstrapping
+  process, which is what finally executes the initialization code
+  installed by the previous files. As of this writing, this code
+  ensures that the previous files leave no more than a single global
+  symbol installed. When adapting the API for non-Emscripten
+  toolchains, this "should" be the only file where changes are needed.
+
+
+**Files with the extension `.c-pp.js`** are intended [to be processed
+with `c-pp`](#c-pp), noting that such preprocessing may be applied
+after all of the relevant files are concatenated. That extension is
+used primarily to keep the code maintainers cognisant of the fact that
+those files contain constructs which may not run as-is in any given
+JavaScript environment.
+
+The build process glues those files together, resulting in
+`sqlite3-api.js`, which is everything except for the
+`pre/post-js-*.js` files, and `sqlite3.js`, which is the
+Emscripten-generated amalgamated output and includes the
+`pre/post-js-*.js` parts, as well as the Emscripten-provided module
+loading pieces.
+
+The non-JS outlier file is `sqlite3-wasm.c`: it is a proxy for
+`sqlite3.c` which `#include`'s that file and adds a couple more
+WASM-specific helper functions, at least one of which requires access
+to private/static `sqlite3.c` internals. `sqlite3.wasm` is compiled
+from this file rather than `sqlite3.c`.
+
+The following files are part of the build process but are injected
+into the build-generated `sqlite3.js` along with `sqlite3-api.js`.
+
+- `extern-pre-js.js`\  
+  Emscripten-specific header for Emscripten's `--extern-pre-js`
+  flag. As of this writing, that file is only used for experimentation
+  purposes and holds no code relevant to the production deliverables.
+- `pre-js.c-pp.js`\  
+  Emscripten-specific header for Emscripten's `--pre-js` flag. This
+  file is intended as a place to override certain Emscripten behavior
+  before it starts up, but corner-case Emscripten bugs keep that from
+  being a reality.
+- `post-js-header.js`\  
+  Emscripten-specific header for the `--post-js` input. It opens up
+  a lexical scope by starting a post-run handler for Emscripten.
+- `post-js-footer.js`\  
+  Emscripten-specific footer for the `--post-js` input. This closes
+  off the lexical scope opened by `post-js-header.js`.
+- `extern-post-js.c-pp.js`\  
+  Emscripten-specific header for Emscripten's `--extern-post-js`
+  flag. This file overwrites the Emscripten-installed
+  `sqlite3InitModule()` function with one which, after the module is
+  loaded, also initializes the asynchronous parts of the sqlite3
+  module. For example, the OPFS VFS support.
+
+<a id='c-pp'></a>
+Preprocessing of Source Files
+------------------------------------------------------------------------
+
+Certain files in the build require preprocessing to filter in/out
+parts which differ between vanilla JS, ES6 Modules, and node.js
+builds. The preprocessor application itself is in
+[`c-pp.c`](/file/ext/wasm/c-pp.c) and the complete technical details
+of such preprocessing are maintained in
+[`GNUMakefile`](/file/ext/wasm/GNUmakefile).

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/post-js-footer.js

@@ -0,0 +1,4 @@
+/* The current function scope was opened via post-js-header.js, which
+   gets prepended to this at build-time. This file closes that
+   scope. */
+})/*postRun.push(...)*/;

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/pre-js.c-pp.js

@@ -0,0 +1,121 @@
+/**
+   BEGIN FILE: api/pre-js.js
+
+   This file is intended to be prepended to the sqlite3.js build using
+   Emscripten's --pre-js=THIS_FILE flag (or equivalent).
+*/
+
+// See notes in extern-post-js.js
+const sqlite3InitModuleState = globalThis.sqlite3InitModuleState
+      || Object.assign(Object.create(null),{
+        debugModule: ()=>{}
+      });
+delete globalThis.sqlite3InitModuleState;
+sqlite3InitModuleState.debugModule('globalThis.location =',globalThis.location);
+
+//#ifnot target=es6-bundler-friendly
+/**
+   This custom locateFile() tries to figure out where to load `path`
+   from. The intent is to provide a way for foo/bar/X.js loaded from a
+   Worker constructor or importScripts() to be able to resolve
+   foo/bar/X.wasm (in the latter case, with some help):
+
+   1) If URL param named the same as `path` is set, it is returned.
+
+   2) If sqlite3InitModuleState.sqlite3Dir is set, then (thatName + path)
+      is returned (note that it's assumed to end with '/').
+
+   3) If this code is running in the main UI thread AND it was loaded
+      from a SCRIPT tag, the directory part of that URL is used
+      as the prefix. (This form of resolution unfortunately does not
+      function for scripts loaded via importScripts().)
+
+   4) If none of the above apply, (prefix+path) is returned.
+*/
+Module['locateFile'] = function(path, prefix) {
+//#if target=es6-module
+  return new URL(path, import.meta.url).href;
+//#else
+  'use strict';
+  let theFile;
+  const up = this.urlParams;
+  if(up.has(path)){
+    theFile = up.get(path);
+  }else if(this.sqlite3Dir){
+    theFile = this.sqlite3Dir + path;
+  }else if(this.scriptDir){
+    theFile = this.scriptDir + path;
+  }else{
+    theFile = prefix + path;
+  }
+  this.debugModule(
+    "locateFile(",arguments[0], ',', arguments[1],")",
+    'sqlite3InitModuleState.scriptDir =',this.scriptDir,
+    'up.entries() =',Array.from(up.entries()),
+    "result =", theFile
+  );
+  return theFile;
+//#endif target=es6-module
+}.bind(sqlite3InitModuleState);
+//#endif ifnot target=es6-bundler-friendly
+
+//#if custom-Module.instantiateModule
+/**
+   Bug warning: a custom Module.instantiateWasm() does not work
+   in WASMFS builds:
+
+   https://github.com/emscripten-core/emscripten/issues/17951
+
+   In such builds we must disable this.
+*/
+const xNameOfInstantiateWasm =
+//#if wasmfs
+  false
+//#else
+  true /* This works, but it does not have the testing coverage in the
+          wild which Emscripten's default impl does, so we'll save
+          this option until we really need a custom
+          Module.instantiateWasm() */
+//#endif
+      ? 'instantiateWasm'
+      : 'emscripten-bug-17951';
+Module[xNameOfInstantiateWasm] = function callee(imports,onSuccess){
+  imports.env.foo = function(){};
+  const uri = Module.locateFile(
+    callee.uri, (
+      ('undefined'===typeof scriptDirectory/*var defined by Emscripten glue*/)
+        ? "" : scriptDirectory)
+  );
+  sqlite3InitModuleState.debugModule(
+    "instantiateWasm() uri =", uri
+  );
+  //console.warn("Custom instantiateModule",uri);
+  const wfetch = ()=>fetch(uri, {credentials: 'same-origin'});
+  const loadWasm = WebAssembly.instantiateStreaming
+        ? async ()=>{
+          return WebAssembly.instantiateStreaming(wfetch(), imports)
+            .then((arg)=>onSuccess(arg.instance, arg.module));
+        }
+        : async ()=>{ // Safari < v15
+          return wfetch()
+            .then(response => response.arrayBuffer())
+            .then(bytes => WebAssembly.instantiate(bytes, imports))
+            .then((arg)=>onSuccess(arg.instance, arg.module));
+        };
+  loadWasm();
+  return {};
+};
+/*
+  It is literally impossible to reliably get the name of _this_ script
+  at runtime, so impossible to derive X.wasm from script name
+  X.js. Thus we need, at build-time, to redefine
+  Module[xNameOfInstantiateWasm].uri by appending it to a build-specific
+  copy of this file with the name of the wasm file. This is apparently
+  why Emscripten hard-codes the name of the wasm file into their glue
+  scripts.
+*/
+Module[xNameOfInstantiateWasm].uri = 'sqlite3.wasm';
+//#endif custom-Module.instantiateModule
+/* END FILE: api/pre-js.js, noting that the build process may add a
+   line after this one to change the above .uri to a build-specific
+   one. */

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-api-cleanup.js

@@ -0,0 +1,63 @@
+/*
+  2022-07-22
+
+  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 is the tail end of the sqlite3-api.js constellation,
+  intended to be appended after all other sqlite3-api-*.js files so
+  that it can finalize any setup and clean up any global symbols
+  temporarily used for setting up the API's various subsystems.
+*/
+'use strict';
+if('undefined' !== typeof Module){ // presumably an Emscripten build
+  /**
+     Install a suitable default configuration for sqlite3ApiBootstrap().
+  */
+  const SABC = Object.assign(
+    Object.create(null), {
+      exports: ('undefined'===typeof wasmExports)
+        ? Module['asm']/* emscripten <=3.1.43 */
+        : wasmExports  /* emscripten >=3.1.44 */,
+      memory: Module.wasmMemory /* gets set if built with -sIMPORTED_MEMORY */
+    },
+    globalThis.sqlite3ApiConfig || {}
+  );
+
+  /**
+     For current (2022-08-22) purposes, automatically call
+     sqlite3ApiBootstrap().  That decision will be revisited at some
+     point, as we really want client code to be able to call this to
+     configure certain parts. Clients may modify
+     globalThis.sqlite3ApiBootstrap.defaultConfig to tweak the default
+     configuration used by a no-args call to sqlite3ApiBootstrap(),
+     but must have first loaded their WASM module in order to be
+     able to provide the necessary configuration state.
+  */
+  //console.warn("globalThis.sqlite3ApiConfig = ",globalThis.sqlite3ApiConfig);
+  globalThis.sqlite3ApiConfig = SABC;
+  let sqlite3;
+  try{
+    sqlite3 = globalThis.sqlite3ApiBootstrap();
+  }catch(e){
+    console.error("sqlite3ApiBootstrap() error:",e);
+    throw e;
+  }finally{
+    delete globalThis.sqlite3ApiBootstrap;
+    delete globalThis.sqlite3ApiConfig;
+  }
+
+  Module.sqlite3 = sqlite3 /* Needed for customized sqlite3InitModule() to be able to
+                              pass the sqlite3 object off to the client. */;
+}else{
+  console.warn("This is not running in an Emscripten module context, so",
+               "globalThis.sqlite3ApiBootstrap() is _not_ being called due to lack",
+               "of config info for the WASM environment.",
+               "It must be called manually.");
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-api-worker1.c-pp.js

@@ -0,0 +1,656 @@
+//#ifnot omit-oo1
+/**
+  2022-07-22
+
+  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 implements the initializer for SQLite's "Worker API #1", a
+  very basic DB access API intended to be scripted from a main window
+  thread via Worker-style messages. Because of limitations in that
+  type of communication, this API is minimalistic and only capable of
+  serving relatively basic DB requests (e.g. it cannot process nested
+  query loops concurrently).
+
+  This file requires that the core C-style sqlite3 API and OO API #1
+  have been loaded.
+*/
+
+/**
+  sqlite3.initWorker1API() implements a Worker-based wrapper around
+  SQLite3 OO API #1, colloquially known as "Worker API #1".
+
+  In order to permit this API to be loaded in worker threads without
+  automatically registering onmessage handlers, initializing the
+  worker API requires calling initWorker1API(). If this function is
+  called from a non-worker thread then it throws an exception.  It
+  must only be called once per Worker.
+
+  When initialized, it installs message listeners to receive Worker
+  messages and then it posts a message in the form:
+
+  ```
+  {type:'sqlite3-api', result:'worker1-ready'}
+  ```
+
+  to let the client know that it has been initialized. Clients may
+  optionally depend on this function not returning until
+  initialization is complete, as the initialization is synchronous.
+  In some contexts, however, listening for the above message is
+  a better fit.
+
+  Note that the worker-based interface can be slightly quirky because
+  of its async nature. In particular, any number of messages may be posted
+  to the worker before it starts handling any of them. If, e.g., an
+  "open" operation fails, any subsequent messages will fail. The
+  Promise-based wrapper for this API (`sqlite3-worker1-promiser.js`)
+  is more comfortable to use in that regard.
+
+  The documentation for the input and output worker messages for
+  this API follows...
+
+  ====================================================================
+  Common message format...
+
+  Each message posted to the worker has an operation-independent
+  envelope and operation-dependent arguments:
+
+  ```
+  {
+    type: string, // one of: 'open', 'close', 'exec', 'export', 'config-get'
+
+    messageId: OPTIONAL arbitrary value. The worker will copy it as-is
+    into response messages to assist in client-side dispatching.
+
+    dbId: a db identifier string (returned by 'open') which tells the
+    operation which database instance to work on. If not provided, the
+    first-opened db is used. This is an "opaque" value, with no
+    inherently useful syntax or information. Its value is subject to
+    change with any given build of this API and cannot be used as a
+    basis for anything useful beyond its one intended purpose.
+
+    args: ...operation-dependent arguments...
+
+    // the framework may add other properties for testing or debugging
+    // purposes.
+
+  }
+  ```
+
+  Response messages, posted back to the main thread, look like:
+
+  ```
+  {
+    type: string. Same as above except for error responses, which have the type
+    'error',
+
+    messageId: same value, if any, provided by the inbound message
+
+    dbId: the id of the db which was operated on, if any, as returned
+    by the corresponding 'open' operation.
+
+    result: ...operation-dependent result...
+
+  }
+  ```
+
+  ====================================================================
+  Error responses
+
+  Errors are reported messages in an operation-independent format:
+
+  ```
+  {
+    type: "error",
+
+    messageId: ...as above...,
+
+    dbId: ...as above...
+
+    result: {
+
+      operation: type of the triggering operation: 'open', 'close', ...
+
+      message: ...error message text...
+
+      errorClass: string. The ErrorClass.name property from the thrown exception.
+
+      input: the message object which triggered the error.
+
+      stack: _if available_, a stack trace array.
+
+    }
+
+  }
+  ```
+
+
+  ====================================================================
+  "config-get"
+
+  This operation fetches the serializable parts of the sqlite3 API
+  configuration.
+
+  Message format:
+
+  ```
+  {
+    type: "config-get",
+    messageId: ...as above...,
+    args: currently ignored and may be elided.
+  }
+  ```
+
+  Response:
+
+  ```
+  {
+    type: "config-get",
+    messageId: ...as above...,
+    result: {
+
+      version: sqlite3.version object
+
+      bigIntEnabled: bool. True if BigInt support is enabled.
+
+      vfsList: result of sqlite3.capi.sqlite3_js_vfs_list()
+   }
+  }
+  ```
+
+
+  ====================================================================
+  "open" a database
+
+  Message format:
+
+  ```
+  {
+    type: "open",
+    messageId: ...as above...,
+    args:{
+
+      filename [=":memory:" or "" (unspecified)]: the db filename.
+      See the sqlite3.oo1.DB constructor for peculiarities and
+      transformations,
+
+      vfs: sqlite3_vfs name. Ignored if filename is ":memory:" or "".
+           This may change how the given filename is resolved.
+    }
+  }
+  ```
+
+  Response:
+
+  ```
+  {
+    type: "open",
+    messageId: ...as above...,
+    result: {
+      filename: db filename, possibly differing from the input.
+
+      dbId: an opaque ID value which must be passed in the message
+      envelope to other calls in this API to tell them which db to
+      use. If it is not provided to future calls, they will default to
+      operating on the least-recently-opened db. This property is, for
+      API consistency's sake, also part of the containing message
+      envelope.  Only the `open` operation includes it in the `result`
+      property.
+
+      persistent: true if the given filename resides in the
+      known-persistent storage, else false.
+
+      vfs: name of the VFS the "main" db is using.
+   }
+  }
+  ```
+
+  ====================================================================
+  "close" a database
+
+  Message format:
+
+  ```
+  {
+    type: "close",
+    messageId: ...as above...
+    dbId: ...as above...
+    args: OPTIONAL {unlink: boolean}
+  }
+  ```
+
+  If the `dbId` does not refer to an opened ID, this is a no-op. If
+  the `args` object contains a truthy `unlink` value then the database
+  will be unlinked (deleted) after closing it. The inability to close a
+  db (because it's not opened) or delete its file does not trigger an
+  error.
+
+  Response:
+
+  ```
+  {
+    type: "close",
+    messageId: ...as above...,
+    result: {
+
+      filename: filename of closed db, or undefined if no db was closed
+
+    }
+  }
+  ```
+
+  ====================================================================
+  "exec" SQL
+
+  All SQL execution is processed through the exec operation. It offers
+  most of the features of the oo1.DB.exec() method, with a few limitations
+  imposed by the state having to cross thread boundaries.
+
+  Message format:
+
+  ```
+  {
+    type: "exec",
+    messageId: ...as above...
+    dbId: ...as above...
+    args: string (SQL) or {... see below ...}
+  }
+  ```
+
+  Response:
+
+  ```
+  {
+    type: "exec",
+    messageId: ...as above...,
+    dbId: ...as above...
+    result: {
+      input arguments, possibly modified. See below.
+    }
+  }
+  ```
+
+  The arguments are in the same form accepted by oo1.DB.exec(), with
+  the exceptions noted below.
+
+  If the `countChanges` arguments property (added in version 3.43) is
+  truthy then the `result` property contained by the returned object
+  will have a `changeCount` property which holds the number of changes
+  made by the provided SQL. Because the SQL may contain an arbitrary
+  number of statements, the `changeCount` is calculated by calling
+  `sqlite3_total_changes()` before and after the SQL is evaluated. If
+  the value of `countChanges` is 64 then the `changeCount` property
+  will be returned as a 64-bit integer in the form of a BigInt (noting
+  that that will trigger an exception if used in a BigInt-incapable
+  build).  In the latter case, the number of changes is calculated by
+  calling `sqlite3_total_changes64()` before and after the SQL is
+  evaluated.
+
+  A function-type args.callback property cannot cross
+  the window/Worker boundary, so is not useful here. If
+  args.callback is a string then it is assumed to be a
+  message type key, in which case a callback function will be
+  applied which posts each row result via:
+
+  postMessage({type: thatKeyType,
+               rowNumber: 1-based-#,
+               row: theRow,
+               columnNames: anArray
+               })
+
+  And, at the end of the result set (whether or not any result rows
+  were produced), it will post an identical message with
+  (row=undefined, rowNumber=null) to alert the caller than the result
+  set is completed. Note that a row value of `null` is a legal row
+  result for certain arg.rowMode values.
+
+    (Design note: we don't use (row=undefined, rowNumber=undefined) to
+    indicate end-of-results because fetching those would be
+    indistinguishable from fetching from an empty object unless the
+    client used hasOwnProperty() (or similar) to distinguish "missing
+    property" from "property with the undefined value".  Similarly,
+    `null` is a legal value for `row` in some case , whereas the db
+    layer won't emit a result value of `undefined`.)
+
+  The callback proxy must not recurse into this interface. An exec()
+  call will tie up the Worker thread, causing any recursion attempt
+  to wait until the first exec() is completed.
+
+  The response is the input options object (or a synthesized one if
+  passed only a string), noting that options.resultRows and
+  options.columnNames may be populated by the call to db.exec().
+
+
+  ====================================================================
+  "export" the current db
+
+  To export the underlying database as a byte array...
+
+  Message format:
+
+  ```
+  {
+    type: "export",
+    messageId: ...as above...,
+    dbId: ...as above...
+  }
+  ```
+
+  Response:
+
+  ```
+  {
+    type: "export",
+    messageId: ...as above...,
+    dbId: ...as above...
+    result: {
+      byteArray: Uint8Array (as per sqlite3_js_db_export()),
+      filename: the db filename,
+      mimetype: "application/x-sqlite3"
+    }
+  }
+  ```
+
+*/
+globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
+const util = sqlite3.util;
+sqlite3.initWorker1API = function(){
+  'use strict';
+  const toss = (...args)=>{throw new Error(args.join(' '))};
+  if(!(globalThis.WorkerGlobalScope instanceof Function)){
+    toss("initWorker1API() must be run from a Worker thread.");
+  }
+  const sqlite3 = this.sqlite3 || toss("Missing this.sqlite3 object.");
+  const DB = sqlite3.oo1.DB;
+
+  /**
+     Returns the app-wide unique ID for the given db, creating one if
+     needed.
+  */
+  const getDbId = function(db){
+    let id = wState.idMap.get(db);
+    if(id) return id;
+    id = 'db#'+(++wState.idSeq)+'@'+db.pointer;
+    /** ^^^ can't simply use db.pointer b/c closing/opening may re-use
+        the same address, which could map pending messages to a wrong
+        instance. */
+    wState.idMap.set(db, id);
+    return id;
+  };
+
+  /**
+     Internal helper for managing Worker-level state.
+  */
+  const wState = {
+    /**
+       Each opened DB is added to this.dbList, and the first entry in
+       that list is the default db. As each db is closed, its entry is
+       removed from the list.
+    */
+    dbList: [],
+    /** Sequence number of dbId generation. */
+    idSeq: 0,
+    /** Map of DB instances to dbId. */
+    idMap: new WeakMap,
+    /** Temp holder for "transferable" postMessage() state. */
+    xfer: [],
+    open: function(opt){
+      const db = new DB(opt);
+      this.dbs[getDbId(db)] = db;
+      if(this.dbList.indexOf(db)<0) this.dbList.push(db);
+      return db;
+    },
+    close: function(db,alsoUnlink){
+      if(db){
+        delete this.dbs[getDbId(db)];
+        const filename = db.filename;
+        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){
+          util.sqlite3__wasm_vfs_unlink(pVfs, filename);
+        }
+      }
+    },
+    /**
+       Posts the given worker message value. If xferList is provided,
+       it must be an array, in which case a copy of it passed as
+       postMessage()'s second argument and xferList.length is set to
+       0.
+    */
+    post: function(msg,xferList){
+      if(xferList && xferList.length){
+        globalThis.postMessage( msg, Array.from(xferList) );
+        xferList.length = 0;
+      }else{
+        globalThis.postMessage(msg);
+      }
+    },
+    /** Map of DB IDs to DBs. */
+    dbs: Object.create(null),
+    /** Fetch the DB for the given id. Throw if require=true and the
+        id is not valid, else return the db or undefined. */
+    getDb: function(id,require=true){
+      return this.dbs[id]
+        || (require ? toss("Unknown (or closed) DB ID:",id) : undefined);
+    }
+  };
+
+  /** Throws if the given db is falsy or not opened, else returns its
+      argument. */
+  const affirmDbOpen = function(db = wState.dbList[0]){
+    return (db && db.pointer) ? db : toss("DB is not opened.");
+  };
+
+  /** Extract dbId from the given message payload. */
+  const getMsgDb = function(msgData,affirmExists=true){
+    const db = wState.getDb(msgData.dbId,false) || wState.dbList[0];
+    return affirmExists ? affirmDbOpen(db) : db;
+  };
+
+  const getDefaultDbId = function(){
+    return wState.dbList[0] && getDbId(wState.dbList[0]);
+  };
+
+  const isSpecialDbFilename = (n)=>{
+    return ""===n || ':'===n[0];
+  };
+
+  /**
+     A level of "organizational abstraction" for the Worker1
+     API. Each method in this object must map directly to a Worker1
+     message type key. The onmessage() dispatcher attempts to
+     dispatch all inbound messages to a method of this object,
+     passing it the event.data part of the inbound event object. All
+     methods must return a plain Object containing any result
+     state, which the dispatcher may amend. All methods must throw
+     on error.
+  */
+  const wMsgHandler = {
+    open: function(ev){
+      const oargs = Object.create(null), args = (ev.args || Object.create(null));
+      if(args.simulateError){ // undocumented internal testing option
+        toss("Throwing because of simulateError flag.");
+      }
+      const rc = Object.create(null);
+      oargs.vfs = args.vfs;
+      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");
+      rc.dbId = getDbId(db);
+      rc.vfs = db.dbVfsName();
+      return rc;
+    },
+
+    close: function(ev){
+      const db = getMsgDb(ev,false);
+      const response = {
+        filename: db && db.filename
+      };
+      if(db){
+        const doUnlink = ((ev.args && 'object'===typeof ev.args)
+                         ? !!ev.args.unlink : false);
+        wState.close(db, doUnlink);
+      }
+      return response;
+    },
+
+    exec: function(ev){
+      const rc = (
+        'string'===typeof ev.args
+      ) ? {sql: ev.args} : (ev.args || Object.create(null));
+      if('stmt'===rc.rowMode){
+        toss("Invalid rowMode for 'exec': stmt mode",
+             "does not work in the Worker API.");
+      }else if(!rc.sql){
+        toss("'exec' requires input SQL.");
+      }
+      const db = getMsgDb(ev);
+      if(rc.callback || Array.isArray(rc.resultRows)){
+        // Part of a copy-avoidance optimization for blobs
+        db._blobXfer = wState.xfer;
+      }
+      const theCallback = rc.callback;
+      let rowNumber = 0;
+      const hadColNames = !!rc.columnNames;
+      if('string' === typeof theCallback){
+        if(!hadColNames) rc.columnNames = [];
+        /* Treat this as a worker message type and post each
+           row as a message of that type. */
+        rc.callback = function(row,stmt){
+          wState.post({
+            type: theCallback,
+            columnNames: rc.columnNames,
+            rowNumber: ++rowNumber,
+            row: row
+          }, wState.xfer);
+        }
+      }
+      try {
+        const changeCount = !!rc.countChanges
+              ? db.changes(true,(64===rc.countChanges))
+              : undefined;
+        db.exec(rc);
+        if(undefined !== changeCount){
+          rc.changeCount = db.changes(true,64===rc.countChanges) - changeCount;
+        }
+        if(rc.callback instanceof Function){
+          rc.callback = theCallback;
+          /* Post a sentinel message to tell the client that the end
+             of the result set has been reached (possibly with zero
+             rows). */
+          wState.post({
+            type: theCallback,
+            columnNames: rc.columnNames,
+            rowNumber: null /*null to distinguish from "property not set"*/,
+            row: undefined /*undefined because null is a legal row value
+                             for some rowType values, but undefined is not*/
+          });
+        }
+      }finally{
+        delete db._blobXfer;
+        if(rc.callback) rc.callback = theCallback;
+      }
+      return rc;
+    }/*exec()*/,
+
+    'config-get': function(){
+      const rc = Object.create(null), src = sqlite3.config;
+      [
+        'bigIntEnabled'
+      ].forEach(function(k){
+        if(Object.getOwnPropertyDescriptor(src, k)) rc[k] = src[k];
+      });
+      rc.version = sqlite3.version;
+      rc.vfsList = sqlite3.capi.sqlite3_js_vfs_list();
+      return rc;
+    },
+
+    /**
+       Exports the database to a byte array, as per
+       sqlite3_serialize(). Response is an object:
+
+       {
+         byteArray:  Uint8Array (db file contents),
+         filename: the current db filename,
+         mimetype: 'application/x-sqlite3'
+       }
+    */
+    export: function(ev){
+      const db = getMsgDb(ev);
+      const response = {
+        byteArray: sqlite3.capi.sqlite3_js_db_export(db.pointer),
+        filename: db.filename,
+        mimetype: 'application/x-sqlite3'
+      };
+      wState.xfer.push(response.byteArray.buffer);
+      return response;
+    }/*export()*/,
+
+    toss: function(ev){
+      toss("Testing worker exception");
+    }
+  }/*wMsgHandler*/;
+
+  globalThis.onmessage = async function(ev){
+    ev = ev.data;
+    let result, dbId = ev.dbId, evType = ev.type;
+    const arrivalTime = performance.now();
+    try {
+      if(wMsgHandler.hasOwnProperty(evType) &&
+         wMsgHandler[evType] instanceof Function){
+        result = await wMsgHandler[evType](ev);
+      }else{
+        toss("Unknown db worker message type:",ev.type);
+      }
+    }catch(err){
+      evType = 'error';
+      result = {
+        operation: ev.type,
+        message: err.message,
+        errorClass: err.name,
+        input: ev
+      };
+      if(err.stack){
+        result.stack = ('string'===typeof err.stack)
+          ? err.stack.split(/\n\s*/) : err.stack;
+      }
+      if(0) sqlite3.config.warn("Worker is propagating an exception to main thread.",
+                                "Reporting it _here_ for the stack trace:",err,result);
+    }
+    if(!dbId){
+      dbId = result.dbId/*from 'open' cmd*/
+        || getDefaultDbId();
+    }
+    // Timing info is primarily for use in testing this API. It's not part of
+    // the public API. arrivalTime = when the worker got the message.
+    wState.post({
+      type: evType,
+      dbId: dbId,
+      messageId: ev.messageId,
+      workerReceivedTime: arrivalTime,
+      workerRespondTime: performance.now(),
+      departureTime: ev.departureTime,
+      // TODO: move the timing bits into...
+      //timing:{
+      //  departure: ev.departureTime,
+      //  workerReceived: arrivalTime,
+      //  workerResponse: performance.now();
+      //},
+      result: result
+    }, wState.xfer);
+  };
+  globalThis.postMessage({type:'sqlite3-api',result:'worker1-ready'});
+}.bind({sqlite3});
+});
+//#else
+/* Built with the omit-oo1 flag. */
+//#endif ifnot omit-oo1

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-wasm.c

@@ -0,0 +1,1950 @@
+/*
+** This file requires access to sqlite3.c static state in order to
+** implement certain WASM-specific features, and thus directly
+** includes that file. Unlike the rest of sqlite3.c, this file
+** requires compiling with -std=c99 (or equivalent, or a later C
+** version) because it makes use of features not available in C89.
+**
+** At its simplest, to build sqlite3.wasm either place this file
+** in the same directory as sqlite3.c/h before compilation or use the
+** -I/path flag to tell the compiler where to find both of those
+** files, then compile this file. For example:
+**
+** emcc -o sqlite3.wasm ... -I/path/to/sqlite3-c-and-h sqlite3-wasm.c
+*/
+#define SQLITE_WASM
+#ifdef SQLITE_WASM_ENABLE_C_TESTS
+#  undef SQLITE_WASM_ENABLE_C_TESTS
+#  define SQLITE_WASM_ENABLE_C_TESTS 1
+/*
+** Code blocked off by SQLITE_WASM_ENABLE_C_TESTS is intended solely
+** for use in unit/regression testing. They may be safely omitted from
+** client-side builds. The main unit test script, tester1.js, will
+** skip related tests if it doesn't find the corresponding functions
+** in the WASM exports.
+*/
+#else
+#  define SQLITE_WASM_ENABLE_C_TESTS 0
+#endif
+
+/*
+** Threading and file locking: JS is single-threaded. Each Worker
+** thread is a separate instance of the JS engine so can never access
+** the same db handle as another thread, thus multi-threading support
+** is unnecessary in the library. Because the filesystems are virtual
+** and local to a given wasm runtime instance, two Workers can never
+** access the same db file at once, with the exception of OPFS.
+**
+** Summary: except for the case of OPFS, which supports locking using
+** its own API, threading and file locking support are unnecessary in
+** the wasm build.
+*/
+
+/*
+** Undefine any SQLITE_... config flags which we specifically do not
+** want defined. Please keep these alphabetized.
+*/
+#undef SQLITE_OMIT_DESERIALIZE
+#undef SQLITE_OMIT_MEMORYDB
+
+/*
+** Define any SQLITE_... config defaults we want if they aren't
+** overridden by the builder. Please keep these alphabetized.
+*/
+
+/**********************************************************************/
+/* SQLITE_D... */
+#ifndef SQLITE_DEFAULT_CACHE_SIZE
+/*
+** The OPFS impls benefit tremendously from an increased cache size
+** when working on large workloads, e.g. speedtest1 --size 50 or
+** higher. On smaller workloads, e.g. speedtest1 --size 25, they
+** clearly benefit from having 4mb of cache, but not as much as a
+** larger cache benefits the larger workloads. Speed differences
+** between 2x and nearly 3x have been measured with ample page cache.
+*/
+# define SQLITE_DEFAULT_CACHE_SIZE -16384
+#endif
+#if !defined(SQLITE_DEFAULT_PAGE_SIZE)
+/*
+** OPFS performance is improved by approx. 12% with a page size of 8kb
+** instead of 4kb. Performance with 16kb is equivalent to 8kb.
+**
+** Performance difference of kvvfs with a page size of 8kb compared to
+** 4kb, as measured by speedtest1 --size 4, is indeterminate:
+** measurements are all over the place either way and not
+** significantly different.
+*/
+# define SQLITE_DEFAULT_PAGE_SIZE 8192
+#endif
+#ifndef SQLITE_DEFAULT_UNIX_VFS
+# define SQLITE_DEFAULT_UNIX_VFS "unix-none"
+#endif
+#undef SQLITE_DQS
+#define SQLITE_DQS 0
+
+/**********************************************************************/
+/* SQLITE_ENABLE_... */
+/*
+** Unconditionally enable API_ARMOR in the WASM build. It ensures that
+** public APIs behave predictable in the face of passing illegal NULLs
+** or ranges which might otherwise invoke undefined behavior.
+*/
+#undef SQLITE_ENABLE_API_ARMOR
+#define SQLITE_ENABLE_API_ARMOR 1
+
+/**********************************************************************/
+/* SQLITE_O... */
+#undef SQLITE_OMIT_DEPRECATED
+#define SQLITE_OMIT_DEPRECATED 1
+#undef SQLITE_OMIT_LOAD_EXTENSION
+#define SQLITE_OMIT_LOAD_EXTENSION 1
+#undef SQLITE_OMIT_SHARED_CACHE
+#define SQLITE_OMIT_SHARED_CACHE 1
+#undef SQLITE_OMIT_UTF16
+#define SQLITE_OMIT_UTF16 1
+#undef SQLITE_OS_KV_OPTIONAL
+#define SQLITE_OS_KV_OPTIONAL 1
+
+/**********************************************************************/
+/* SQLITE_S... */
+#ifndef SQLITE_STRICT_SUBTYPE
+# define SQLITE_STRICT_SUBTYPE 1
+#endif
+
+/**********************************************************************/
+/* SQLITE_T... */
+#ifndef SQLITE_TEMP_STORE
+# define SQLITE_TEMP_STORE 2
+#endif
+#ifndef SQLITE_THREADSAFE
+# define SQLITE_THREADSAFE 0
+#endif
+
+/**********************************************************************/
+/* SQLITE_USE_... */
+#ifndef SQLITE_USE_URI
+#  define SQLITE_USE_URI 1
+#endif
+
+#ifdef SQLITE_WASM_EXTRA_INIT
+#  define SQLITE_EXTRA_INIT sqlite3_wasm_extra_init
+#endif
+
+/*
+** If SQLITE_WASM_BARE_BONES is defined, undefine most of the ENABLE
+** macros.
+*/
+#ifdef SQLITE_WASM_BARE_BONES
+#  undef  SQLITE_ENABLE_DBPAGE_VTAB
+#  undef  SQLITE_ENABLE_DBSTAT_VTAB
+#  undef  SQLITE_ENABLE_EXPLAIN_COMMENTS
+#  undef  SQLITE_ENABLE_FTS5
+#  undef  SQLITE_ENABLE_OFFSET_SQL_FUNC
+#  undef  SQLITE_ENABLE_PREUPDATE_HOOK
+#  undef  SQLITE_ENABLE_RTREE
+#  undef  SQLITE_ENABLE_SESSION
+#  undef  SQLITE_ENABLE_STMTVTAB
+#  undef  SQLITE_OMIT_AUTHORIZATION
+#  define SQLITE_OMIT_AUTHORIZATION
+#  undef  SQLITE_OMIT_GET_TABLE
+#  define SQLITE_OMIT_GET_TABLE
+#  undef  SQLITE_OMIT_INCRBLOB
+#  define SQLITE_OMIT_INCRBLOB
+#  undef  SQLITE_OMIT_INTROSPECTION_PRAGMAS
+#  define SQLITE_OMIT_INTROSPECTION_PRAGMAS
+#  undef  SQLITE_OMIT_JSON
+#  define SQLITE_OMIT_JSON
+#  undef  SQLITE_OMIT_PROGRESS_CALLBACK
+#  define SQLITE_OMIT_PROGRESS_CALLBACK
+#  undef  SQLITE_OMIT_WAL
+#  define SQLITE_OMIT_WAL
+/*
+  The following OMITs do not work with the standard amalgamation, so
+  require a custom build:
+
+  fossil clean -x
+  ./configure
+  OPTS='...' make -e sqlite3
+
+  where ... has a -D... for each of the following OMIT flags:
+
+#  undef SQLITE_OMIT_EXPLAIN
+#  define SQLITE_OMIT_EXPLAIN
+
+#  undef SQLITE_OMIT_TRIGGER
+#  define SQLITE_OMIT_TRIGGER
+
+#  undef SQLITE_OMIT_VIRTUALTABLE
+#  define SQLITE_OMIT_VIRTUALTABLE
+
+#  undef SQLITE_OMIT_WINDOWFUNC
+#  define SQLITE_OMIT_WINDOWFUNC
+
+  As of this writing (2024-07-25), such a build fails in various ways
+  for as-yet-unknown reasons.
+*/
+#endif
+
+#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_WASM_BARE_BONES)
+#  define SQLITE_WASM_HAS_VTAB 1
+#else
+#  define SQLITE_WASM_HAS_VTAB 0
+#endif
+
+#include <assert.h>
+
+/*
+** SQLITE_WASM_EXPORT is functionally identical to EMSCRIPTEN_KEEPALIVE
+** but is not Emscripten-specific. It explicitly marks functions for
+** export into the target wasm file without requiring explicit listing
+** of those functions in Emscripten's -sEXPORTED_FUNCTIONS=... list
+** (or equivalent in other build platforms). Any function with neither
+** this attribute nor which is listed as an explicit export will not
+** be exported from the wasm file (but may still be used internally
+** within the wasm file).
+**
+** The functions in this file (sqlite3-wasm.c) which require exporting
+** are marked with this flag. They may also be added to any explicit
+** build-time export list but need not be. All of these APIs are
+** intended for use only within the project's own JS/WASM code, and
+** not by client code, so an argument can be made for reducing their
+** visibility by not including them in any build-time export lists.
+**
+** 2022-09-11: it's not yet _proven_ that this approach works in
+** non-Emscripten builds. If not, such builds will need to export
+** those using the --export=... wasm-ld flag (or equivalent). As of
+** this writing we are tied to Emscripten for various reasons
+** and cannot test the library with other build environments.
+*/
+#define SQLITE_WASM_EXPORT __attribute__((used,visibility("default")))
+// See also:
+//__attribute__((export_name("theExportedName"), used, visibility("default")))
+
+/*
+** Which sqlite3.c we're using needs to be configurable to enable
+** building against a custom copy, e.g. the SEE variant. Note that we
+** #include the .c file, rather than the header, so that the WASM
+** extensions have access to private API internals.
+**
+** The caveat here is that custom variants need to account for
+** exporting any necessary symbols (e.g. sqlite3_activate_see()).  We
+** cannot export them from here using SQLITE_WASM_EXPORT because that
+** attribute (apparently) has to be part of the function definition.
+*/
+#ifndef SQLITE_C
+# define SQLITE_C sqlite3.c /* yes, .c instead of .h. */
+#endif
+#define INC__STRINGIFY_(f) #f
+#define INC__STRINGIFY(f) INC__STRINGIFY_(f)
+#include INC__STRINGIFY(SQLITE_C)
+#undef INC__STRINGIFY_
+#undef INC__STRINGIFY
+#undef SQLITE_C
+
+#if 0
+/*
+** An EXPERIMENT in implementing a stack-based allocator analog to
+** Emscripten's stackSave(), stackAlloc(), stackRestore().
+** Unfortunately, this cannot work together with Emscripten because
+** Emscripten defines its own native one and we'd stomp on each
+** other's memory. Other than that complication, basic tests show it
+** to work just fine.
+**
+** Another option is to malloc() a chunk of our own and call that our
+** "stack".
+*/
+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){
+  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();
+  return pWasmStackPtr;
+}
+SQLITE_WASM_EXPORT void sqlite3__wasm_stack_restore(void * p){
+  pWasmStackPtr = p;
+}
+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();
+  if(b + n >= p || b + n < b/*overflow*/) return 0;
+  return pWasmStackPtr = p - n;
+}
+#endif /* stack allocator experiment */
+
+/*
+** State for the "pseudo-stack" allocator implemented in
+** 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
+** heap can also be used to manipulate this memory.
+**
+** This particular allocator is intended for small allocations such as
+** storage for output pointers. We cannot reasonably size it large
+** enough for general-purpose string conversions because some of our
+** tests use input files (strings) of 16MB+.
+*/
+static unsigned char PStack_mem[512 * 8] = {0};
+static struct {
+  unsigned const char * const pBegin;/* Start (inclusive) of memory */
+  unsigned const char * const pEnd;  /* One-after-the-end of memory */
+  unsigned char * pPos;              /* Current stack pointer */
+} PStack = {
+  &PStack_mem[0],
+  &PStack_mem[0] + sizeof(PStack_mem),
+  &PStack_mem[0] + sizeof(PStack_mem)
+};
+/*
+** Returns the current pstack position.
+*/
+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().
+*/
+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*/){
+    PStack.pPos = p;
+  }
+}
+/*
+** Allocate and zero out n bytes from the pstack. Returns a pointer to
+** the memory on success, 0 on error (including a negative n value). n
+** is always adjusted to be a multiple of 8 and returned memory is
+** always zeroed out before returning (because this keeps the client
+** 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){
+  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 */;
+  if( PStack.pBegin + n > PStack.pPos /*not enough space left*/
+      || PStack.pBegin + n <= PStack.pBegin /*overflow*/ ) return 0;
+  memset((PStack.pPos = PStack.pPos - n), 0, (unsigned int)n);
+  return PStack.pPos;
+}
+/*
+** Return the number of bytes left which can be
+** sqlite3__wasm_pstack_alloc()'d.
+*/
+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);
+}
+
+/*
+** Return the total number of bytes available in the pstack, including
+** any space which is currently allocated. This value is a
+** compile-time constant.
+*/
+SQLITE_WASM_EXPORT int sqlite3__wasm_pstack_quota(void){
+  return (int)(PStack.pEnd - PStack.pBegin);
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** For purposes of certain hand-crafted C/Wasm function bindings, we
+** need a way of reporting errors which is consistent with the rest of
+** the C API, as opposed to throwing JS exceptions. To that end, this
+** internal-use-only function is a thin proxy around
+** sqlite3ErrorWithMessage(). The intent is that it only be used from
+** Wasm bindings such as sqlite3_prepare_v2/v3(), and definitely not
+** from client code.
+**
+** Returns err_code.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_db_error(sqlite3*db, int err_code, const char *zMsg){
+  if( db!=0 ){
+    if( 0!=zMsg ){
+      const int nMsg = sqlite3Strlen30(zMsg);
+      sqlite3_mutex_enter(sqlite3_db_mutex(db));
+      sqlite3ErrorWithMsg(db, err_code, "%.*s", nMsg, zMsg);
+      sqlite3_mutex_leave(sqlite3_db_mutex(db));
+    }else{
+      sqlite3ErrorWithMsg(db, err_code, NULL);
+    }
+  }
+  return err_code;
+}
+
+#if SQLITE_WASM_ENABLE_C_TESTS
+struct WasmTestStruct {
+  int v4;
+  void * ppV;
+  const char * cstr;
+  int64_t v8;
+  void (*xFunc)(void*);
+};
+typedef struct WasmTestStruct WasmTestStruct;
+SQLITE_WASM_EXPORT
+void sqlite3__wasm_test_struct(WasmTestStruct * s){
+  if(s){
+    s->v4 *= 2;
+    s->v8 = s->v4 * 2;
+    s->ppV = s;
+    s->cstr = __FILE__;
+    if(s->xFunc) s->xFunc(s);
+  }
+  return;
+}
+#endif /* SQLITE_WASM_ENABLE_C_TESTS */
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings. Unlike the
+** rest of the sqlite3 API, this part requires C99 for snprintf() and
+** variadic macros.
+**
+** Returns a string containing a JSON-format "enum" of C-level
+** constants and struct-related metadata intended to be imported into
+** the JS environment. The JSON is initialized the first time this
+** function is called and that result is reused for all future calls.
+**
+** If this function returns NULL then it means that the internal
+** buffer is not large enough for the generated JSON and needs to be
+** increased. In debug builds that will trigger an assert().
+*/
+SQLITE_WASM_EXPORT
+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 */;
+  char * zPos = &aBuffer[1] /* skip first byte for now to help protect
+                            ** against a small race condition */;
+  char const * const zEnd = &aBuffer[0] + sizeof(aBuffer) /* one-past-the-end */;
+  if(aBuffer[0]) return aBuffer;
+  /* Leave aBuffer[0] at 0 until the end to help guard against a tiny
+  ** race condition. If this is called twice concurrently, they might
+  ** end up both writing to aBuffer, but they'll both write the same
+  ** thing, so that's okay. If we set byte 0 up front then the 2nd
+  ** instance might return and use the string before the 1st instance
+  ** is done filling it. */
+
+/* Core output macros... */
+#define lenCheck assert(zPos < zEnd - 128 \
+  && "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__); \
+  lenCheck
+#define out(TXT) outf("%s",TXT)
+#define CloseBrace(LEVEL) \
+  assert(LEVEL<5); memset(zPos, '}', LEVEL); zPos+=LEVEL; lenCheck
+
+/* Macros for emitting maps of integer- and string-type macros to
+** their values. */
+#define DefGroup(KEY) n = 0; \
+  outf("%s\"" #KEY "\": {",(nChildren++ ? "," : ""));
+#define DefInt(KEY)                                     \
+  outf("%s\"%s\": %d", (n++ ? ", " : ""), #KEY, (int)KEY)
+#define DefStr(KEY)                                     \
+  outf("%s\"%s\": \"%s\"", (n++ ? ", " : ""), #KEY, KEY)
+#define _DefGroup CloseBrace(1)
+
+  /* The following groups are sorted alphabetic by group name. */
+  DefGroup(access){
+    DefInt(SQLITE_ACCESS_EXISTS);
+    DefInt(SQLITE_ACCESS_READWRITE);
+    DefInt(SQLITE_ACCESS_READ)/*docs say this is unused*/;
+  } _DefGroup;
+
+  DefGroup(authorizer){
+    DefInt(SQLITE_DENY);
+    DefInt(SQLITE_IGNORE);
+    DefInt(SQLITE_CREATE_INDEX);
+    DefInt(SQLITE_CREATE_TABLE);
+    DefInt(SQLITE_CREATE_TEMP_INDEX);
+    DefInt(SQLITE_CREATE_TEMP_TABLE);
+    DefInt(SQLITE_CREATE_TEMP_TRIGGER);
+    DefInt(SQLITE_CREATE_TEMP_VIEW);
+    DefInt(SQLITE_CREATE_TRIGGER);
+    DefInt(SQLITE_CREATE_VIEW);
+    DefInt(SQLITE_DELETE);
+    DefInt(SQLITE_DROP_INDEX);
+    DefInt(SQLITE_DROP_TABLE);
+    DefInt(SQLITE_DROP_TEMP_INDEX);
+    DefInt(SQLITE_DROP_TEMP_TABLE);
+    DefInt(SQLITE_DROP_TEMP_TRIGGER);
+    DefInt(SQLITE_DROP_TEMP_VIEW);
+    DefInt(SQLITE_DROP_TRIGGER);
+    DefInt(SQLITE_DROP_VIEW);
+    DefInt(SQLITE_INSERT);
+    DefInt(SQLITE_PRAGMA);
+    DefInt(SQLITE_READ);
+    DefInt(SQLITE_SELECT);
+    DefInt(SQLITE_TRANSACTION);
+    DefInt(SQLITE_UPDATE);
+    DefInt(SQLITE_ATTACH);
+    DefInt(SQLITE_DETACH);
+    DefInt(SQLITE_ALTER_TABLE);
+    DefInt(SQLITE_REINDEX);
+    DefInt(SQLITE_ANALYZE);
+    DefInt(SQLITE_CREATE_VTABLE);
+    DefInt(SQLITE_DROP_VTABLE);
+    DefInt(SQLITE_FUNCTION);
+    DefInt(SQLITE_SAVEPOINT);
+    //DefInt(SQLITE_COPY) /* No longer used */;
+    DefInt(SQLITE_RECURSIVE);
+  } _DefGroup;
+
+  DefGroup(blobFinalizers) {
+    /* SQLITE_STATIC/TRANSIENT need to be handled explicitly as
+    ** integers to avoid casting-related warnings. */
+    out("\"SQLITE_STATIC\":0, \"SQLITE_TRANSIENT\":-1");
+    outf(",\"SQLITE_WASM_DEALLOC\": %lld",
+         (sqlite3_int64)(sqlite3_free));
+  } _DefGroup;
+
+  DefGroup(changeset){
+#ifdef SQLITE_CHANGESETSTART_INVERT
+    DefInt(SQLITE_CHANGESETSTART_INVERT);
+    DefInt(SQLITE_CHANGESETAPPLY_NOSAVEPOINT);
+    DefInt(SQLITE_CHANGESETAPPLY_INVERT);
+    DefInt(SQLITE_CHANGESETAPPLY_IGNORENOOP);
+
+    DefInt(SQLITE_CHANGESET_DATA);
+    DefInt(SQLITE_CHANGESET_NOTFOUND);
+    DefInt(SQLITE_CHANGESET_CONFLICT);
+    DefInt(SQLITE_CHANGESET_CONSTRAINT);
+    DefInt(SQLITE_CHANGESET_FOREIGN_KEY);
+
+    DefInt(SQLITE_CHANGESET_OMIT);
+    DefInt(SQLITE_CHANGESET_REPLACE);
+    DefInt(SQLITE_CHANGESET_ABORT);
+#endif
+  } _DefGroup;
+
+  DefGroup(config){
+    DefInt(SQLITE_CONFIG_SINGLETHREAD);
+    DefInt(SQLITE_CONFIG_MULTITHREAD);
+    DefInt(SQLITE_CONFIG_SERIALIZED);
+    DefInt(SQLITE_CONFIG_MALLOC);
+    DefInt(SQLITE_CONFIG_GETMALLOC);
+    DefInt(SQLITE_CONFIG_SCRATCH);
+    DefInt(SQLITE_CONFIG_PAGECACHE);
+    DefInt(SQLITE_CONFIG_HEAP);
+    DefInt(SQLITE_CONFIG_MEMSTATUS);
+    DefInt(SQLITE_CONFIG_MUTEX);
+    DefInt(SQLITE_CONFIG_GETMUTEX);
+/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */
+    DefInt(SQLITE_CONFIG_LOOKASIDE);
+    DefInt(SQLITE_CONFIG_PCACHE);
+    DefInt(SQLITE_CONFIG_GETPCACHE);
+    DefInt(SQLITE_CONFIG_LOG);
+    DefInt(SQLITE_CONFIG_URI);
+    DefInt(SQLITE_CONFIG_PCACHE2);
+    DefInt(SQLITE_CONFIG_GETPCACHE2);
+    DefInt(SQLITE_CONFIG_COVERING_INDEX_SCAN);
+    DefInt(SQLITE_CONFIG_SQLLOG);
+    DefInt(SQLITE_CONFIG_MMAP_SIZE);
+    DefInt(SQLITE_CONFIG_WIN32_HEAPSIZE);
+    DefInt(SQLITE_CONFIG_PCACHE_HDRSZ);
+    DefInt(SQLITE_CONFIG_PMASZ);
+    DefInt(SQLITE_CONFIG_STMTJRNL_SPILL);
+    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) {
+    DefInt(SQLITE_INTEGER);
+    DefInt(SQLITE_FLOAT);
+    DefInt(SQLITE_TEXT);
+    DefInt(SQLITE_BLOB);
+    DefInt(SQLITE_NULL);
+  } _DefGroup;
+
+  DefGroup(dbConfig){
+    DefInt(SQLITE_DBCONFIG_MAINDBNAME);
+    DefInt(SQLITE_DBCONFIG_LOOKASIDE);
+    DefInt(SQLITE_DBCONFIG_ENABLE_FKEY);
+    DefInt(SQLITE_DBCONFIG_ENABLE_TRIGGER);
+    DefInt(SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION);
+    DefInt(SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE);
+    DefInt(SQLITE_DBCONFIG_ENABLE_QPSG);
+    DefInt(SQLITE_DBCONFIG_TRIGGER_EQP);
+    DefInt(SQLITE_DBCONFIG_RESET_DATABASE);
+    DefInt(SQLITE_DBCONFIG_DEFENSIVE);
+    DefInt(SQLITE_DBCONFIG_WRITABLE_SCHEMA);
+    DefInt(SQLITE_DBCONFIG_LEGACY_ALTER_TABLE);
+    DefInt(SQLITE_DBCONFIG_DQS_DML);
+    DefInt(SQLITE_DBCONFIG_DQS_DDL);
+    DefInt(SQLITE_DBCONFIG_ENABLE_VIEW);
+    DefInt(SQLITE_DBCONFIG_LEGACY_FILE_FORMAT);
+    DefInt(SQLITE_DBCONFIG_TRUSTED_SCHEMA);
+    DefInt(SQLITE_DBCONFIG_STMT_SCANSTATUS);
+    DefInt(SQLITE_DBCONFIG_REVERSE_SCANORDER);
+    DefInt(SQLITE_DBCONFIG_MAX);
+  } _DefGroup;
+
+  DefGroup(dbStatus){
+    DefInt(SQLITE_DBSTATUS_LOOKASIDE_USED);
+    DefInt(SQLITE_DBSTATUS_CACHE_USED);
+    DefInt(SQLITE_DBSTATUS_SCHEMA_USED);
+    DefInt(SQLITE_DBSTATUS_STMT_USED);
+    DefInt(SQLITE_DBSTATUS_LOOKASIDE_HIT);
+    DefInt(SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE);
+    DefInt(SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL);
+    DefInt(SQLITE_DBSTATUS_CACHE_HIT);
+    DefInt(SQLITE_DBSTATUS_CACHE_MISS);
+    DefInt(SQLITE_DBSTATUS_CACHE_WRITE);
+    DefInt(SQLITE_DBSTATUS_DEFERRED_FKS);
+    DefInt(SQLITE_DBSTATUS_CACHE_USED_SHARED);
+    DefInt(SQLITE_DBSTATUS_CACHE_SPILL);
+    DefInt(SQLITE_DBSTATUS_MAX);
+  } _DefGroup;
+
+  DefGroup(encodings) {
+    /* Noting that the wasm binding only aims to support UTF-8. */
+    DefInt(SQLITE_UTF8);
+    DefInt(SQLITE_UTF16LE);
+    DefInt(SQLITE_UTF16BE);
+    DefInt(SQLITE_UTF16);
+    /*deprecated DefInt(SQLITE_ANY); */
+    DefInt(SQLITE_UTF16_ALIGNED);
+  } _DefGroup;
+
+  DefGroup(fcntl) {
+    DefInt(SQLITE_FCNTL_LOCKSTATE);
+    DefInt(SQLITE_FCNTL_GET_LOCKPROXYFILE);
+    DefInt(SQLITE_FCNTL_SET_LOCKPROXYFILE);
+    DefInt(SQLITE_FCNTL_LAST_ERRNO);
+    DefInt(SQLITE_FCNTL_SIZE_HINT);
+    DefInt(SQLITE_FCNTL_CHUNK_SIZE);
+    DefInt(SQLITE_FCNTL_FILE_POINTER);
+    DefInt(SQLITE_FCNTL_SYNC_OMITTED);
+    DefInt(SQLITE_FCNTL_WIN32_AV_RETRY);
+    DefInt(SQLITE_FCNTL_PERSIST_WAL);
+    DefInt(SQLITE_FCNTL_OVERWRITE);
+    DefInt(SQLITE_FCNTL_VFSNAME);
+    DefInt(SQLITE_FCNTL_POWERSAFE_OVERWRITE);
+    DefInt(SQLITE_FCNTL_PRAGMA);
+    DefInt(SQLITE_FCNTL_BUSYHANDLER);
+    DefInt(SQLITE_FCNTL_TEMPFILENAME);
+    DefInt(SQLITE_FCNTL_MMAP_SIZE);
+    DefInt(SQLITE_FCNTL_TRACE);
+    DefInt(SQLITE_FCNTL_HAS_MOVED);
+    DefInt(SQLITE_FCNTL_SYNC);
+    DefInt(SQLITE_FCNTL_COMMIT_PHASETWO);
+    DefInt(SQLITE_FCNTL_WIN32_SET_HANDLE);
+    DefInt(SQLITE_FCNTL_WAL_BLOCK);
+    DefInt(SQLITE_FCNTL_ZIPVFS);
+    DefInt(SQLITE_FCNTL_RBU);
+    DefInt(SQLITE_FCNTL_VFS_POINTER);
+    DefInt(SQLITE_FCNTL_JOURNAL_POINTER);
+    DefInt(SQLITE_FCNTL_WIN32_GET_HANDLE);
+    DefInt(SQLITE_FCNTL_PDB);
+    DefInt(SQLITE_FCNTL_BEGIN_ATOMIC_WRITE);
+    DefInt(SQLITE_FCNTL_COMMIT_ATOMIC_WRITE);
+    DefInt(SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE);
+    DefInt(SQLITE_FCNTL_LOCK_TIMEOUT);
+    DefInt(SQLITE_FCNTL_DATA_VERSION);
+    DefInt(SQLITE_FCNTL_SIZE_LIMIT);
+    DefInt(SQLITE_FCNTL_CKPT_DONE);
+    DefInt(SQLITE_FCNTL_RESERVE_BYTES);
+    DefInt(SQLITE_FCNTL_CKPT_START);
+    DefInt(SQLITE_FCNTL_EXTERNAL_READER);
+    DefInt(SQLITE_FCNTL_CKSM_FILE);
+    DefInt(SQLITE_FCNTL_RESET_CACHE);
+  } _DefGroup;
+
+  DefGroup(flock) {
+    DefInt(SQLITE_LOCK_NONE);
+    DefInt(SQLITE_LOCK_SHARED);
+    DefInt(SQLITE_LOCK_RESERVED);
+    DefInt(SQLITE_LOCK_PENDING);
+    DefInt(SQLITE_LOCK_EXCLUSIVE);
+  } _DefGroup;
+
+  DefGroup(ioCap) {
+    DefInt(SQLITE_IOCAP_ATOMIC);
+    DefInt(SQLITE_IOCAP_ATOMIC512);
+    DefInt(SQLITE_IOCAP_ATOMIC1K);
+    DefInt(SQLITE_IOCAP_ATOMIC2K);
+    DefInt(SQLITE_IOCAP_ATOMIC4K);
+    DefInt(SQLITE_IOCAP_ATOMIC8K);
+    DefInt(SQLITE_IOCAP_ATOMIC16K);
+    DefInt(SQLITE_IOCAP_ATOMIC32K);
+    DefInt(SQLITE_IOCAP_ATOMIC64K);
+    DefInt(SQLITE_IOCAP_SAFE_APPEND);
+    DefInt(SQLITE_IOCAP_SEQUENTIAL);
+    DefInt(SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN);
+    DefInt(SQLITE_IOCAP_POWERSAFE_OVERWRITE);
+    DefInt(SQLITE_IOCAP_IMMUTABLE);
+    DefInt(SQLITE_IOCAP_BATCH_ATOMIC);
+  } _DefGroup;
+
+  DefGroup(limits) {
+    DefInt(SQLITE_MAX_ALLOCATION_SIZE);
+    DefInt(SQLITE_LIMIT_LENGTH);
+    DefInt(SQLITE_MAX_LENGTH);
+    DefInt(SQLITE_LIMIT_SQL_LENGTH);
+    DefInt(SQLITE_MAX_SQL_LENGTH);
+    DefInt(SQLITE_LIMIT_COLUMN);
+    DefInt(SQLITE_MAX_COLUMN);
+    DefInt(SQLITE_LIMIT_EXPR_DEPTH);
+    DefInt(SQLITE_MAX_EXPR_DEPTH);
+    DefInt(SQLITE_LIMIT_COMPOUND_SELECT);
+    DefInt(SQLITE_MAX_COMPOUND_SELECT);
+    DefInt(SQLITE_LIMIT_VDBE_OP);
+    DefInt(SQLITE_MAX_VDBE_OP);
+    DefInt(SQLITE_LIMIT_FUNCTION_ARG);
+    DefInt(SQLITE_MAX_FUNCTION_ARG);
+    DefInt(SQLITE_LIMIT_ATTACHED);
+    DefInt(SQLITE_MAX_ATTACHED);
+    DefInt(SQLITE_LIMIT_LIKE_PATTERN_LENGTH);
+    DefInt(SQLITE_MAX_LIKE_PATTERN_LENGTH);
+    DefInt(SQLITE_LIMIT_VARIABLE_NUMBER);
+    DefInt(SQLITE_MAX_VARIABLE_NUMBER);
+    DefInt(SQLITE_LIMIT_TRIGGER_DEPTH);
+    DefInt(SQLITE_MAX_TRIGGER_DEPTH);
+    DefInt(SQLITE_LIMIT_WORKER_THREADS);
+    DefInt(SQLITE_MAX_WORKER_THREADS);
+  } _DefGroup;
+
+  DefGroup(openFlags) {
+    /* Noting that not all of these will have any effect in
+    ** WASM-space. */
+    DefInt(SQLITE_OPEN_READONLY);
+    DefInt(SQLITE_OPEN_READWRITE);
+    DefInt(SQLITE_OPEN_CREATE);
+    DefInt(SQLITE_OPEN_URI);
+    DefInt(SQLITE_OPEN_MEMORY);
+    DefInt(SQLITE_OPEN_NOMUTEX);
+    DefInt(SQLITE_OPEN_FULLMUTEX);
+    DefInt(SQLITE_OPEN_SHAREDCACHE);
+    DefInt(SQLITE_OPEN_PRIVATECACHE);
+    DefInt(SQLITE_OPEN_EXRESCODE);
+    DefInt(SQLITE_OPEN_NOFOLLOW);
+    /* OPEN flags for use with VFSes... */
+    DefInt(SQLITE_OPEN_MAIN_DB);
+    DefInt(SQLITE_OPEN_MAIN_JOURNAL);
+    DefInt(SQLITE_OPEN_TEMP_DB);
+    DefInt(SQLITE_OPEN_TEMP_JOURNAL);
+    DefInt(SQLITE_OPEN_TRANSIENT_DB);
+    DefInt(SQLITE_OPEN_SUBJOURNAL);
+    DefInt(SQLITE_OPEN_SUPER_JOURNAL);
+    DefInt(SQLITE_OPEN_WAL);
+    DefInt(SQLITE_OPEN_DELETEONCLOSE);
+    DefInt(SQLITE_OPEN_EXCLUSIVE);
+  } _DefGroup;
+
+  DefGroup(prepareFlags) {
+    DefInt(SQLITE_PREPARE_PERSISTENT);
+    DefInt(SQLITE_PREPARE_NORMALIZE);
+    DefInt(SQLITE_PREPARE_NO_VTAB);
+  } _DefGroup;
+
+  DefGroup(resultCodes) {
+    DefInt(SQLITE_OK);
+    DefInt(SQLITE_ERROR);
+    DefInt(SQLITE_INTERNAL);
+    DefInt(SQLITE_PERM);
+    DefInt(SQLITE_ABORT);
+    DefInt(SQLITE_BUSY);
+    DefInt(SQLITE_LOCKED);
+    DefInt(SQLITE_NOMEM);
+    DefInt(SQLITE_READONLY);
+    DefInt(SQLITE_INTERRUPT);
+    DefInt(SQLITE_IOERR);
+    DefInt(SQLITE_CORRUPT);
+    DefInt(SQLITE_NOTFOUND);
+    DefInt(SQLITE_FULL);
+    DefInt(SQLITE_CANTOPEN);
+    DefInt(SQLITE_PROTOCOL);
+    DefInt(SQLITE_EMPTY);
+    DefInt(SQLITE_SCHEMA);
+    DefInt(SQLITE_TOOBIG);
+    DefInt(SQLITE_CONSTRAINT);
+    DefInt(SQLITE_MISMATCH);
+    DefInt(SQLITE_MISUSE);
+    DefInt(SQLITE_NOLFS);
+    DefInt(SQLITE_AUTH);
+    DefInt(SQLITE_FORMAT);
+    DefInt(SQLITE_RANGE);
+    DefInt(SQLITE_NOTADB);
+    DefInt(SQLITE_NOTICE);
+    DefInt(SQLITE_WARNING);
+    DefInt(SQLITE_ROW);
+    DefInt(SQLITE_DONE);
+    // Extended Result Codes
+    DefInt(SQLITE_ERROR_MISSING_COLLSEQ);
+    DefInt(SQLITE_ERROR_RETRY);
+    DefInt(SQLITE_ERROR_SNAPSHOT);
+    DefInt(SQLITE_IOERR_READ);
+    DefInt(SQLITE_IOERR_SHORT_READ);
+    DefInt(SQLITE_IOERR_WRITE);
+    DefInt(SQLITE_IOERR_FSYNC);
+    DefInt(SQLITE_IOERR_DIR_FSYNC);
+    DefInt(SQLITE_IOERR_TRUNCATE);
+    DefInt(SQLITE_IOERR_FSTAT);
+    DefInt(SQLITE_IOERR_UNLOCK);
+    DefInt(SQLITE_IOERR_RDLOCK);
+    DefInt(SQLITE_IOERR_DELETE);
+    DefInt(SQLITE_IOERR_BLOCKED);
+    DefInt(SQLITE_IOERR_NOMEM);
+    DefInt(SQLITE_IOERR_ACCESS);
+    DefInt(SQLITE_IOERR_CHECKRESERVEDLOCK);
+    DefInt(SQLITE_IOERR_LOCK);
+    DefInt(SQLITE_IOERR_CLOSE);
+    DefInt(SQLITE_IOERR_DIR_CLOSE);
+    DefInt(SQLITE_IOERR_SHMOPEN);
+    DefInt(SQLITE_IOERR_SHMSIZE);
+    DefInt(SQLITE_IOERR_SHMLOCK);
+    DefInt(SQLITE_IOERR_SHMMAP);
+    DefInt(SQLITE_IOERR_SEEK);
+    DefInt(SQLITE_IOERR_DELETE_NOENT);
+    DefInt(SQLITE_IOERR_MMAP);
+    DefInt(SQLITE_IOERR_GETTEMPPATH);
+    DefInt(SQLITE_IOERR_CONVPATH);
+    DefInt(SQLITE_IOERR_VNODE);
+    DefInt(SQLITE_IOERR_AUTH);
+    DefInt(SQLITE_IOERR_BEGIN_ATOMIC);
+    DefInt(SQLITE_IOERR_COMMIT_ATOMIC);
+    DefInt(SQLITE_IOERR_ROLLBACK_ATOMIC);
+    DefInt(SQLITE_IOERR_DATA);
+    DefInt(SQLITE_IOERR_CORRUPTFS);
+    DefInt(SQLITE_LOCKED_SHAREDCACHE);
+    DefInt(SQLITE_LOCKED_VTAB);
+    DefInt(SQLITE_BUSY_RECOVERY);
+    DefInt(SQLITE_BUSY_SNAPSHOT);
+    DefInt(SQLITE_BUSY_TIMEOUT);
+    DefInt(SQLITE_CANTOPEN_NOTEMPDIR);
+    DefInt(SQLITE_CANTOPEN_ISDIR);
+    DefInt(SQLITE_CANTOPEN_FULLPATH);
+    DefInt(SQLITE_CANTOPEN_CONVPATH);
+    //DefInt(SQLITE_CANTOPEN_DIRTYWAL)/*docs say not used*/;
+    DefInt(SQLITE_CANTOPEN_SYMLINK);
+    DefInt(SQLITE_CORRUPT_VTAB);
+    DefInt(SQLITE_CORRUPT_SEQUENCE);
+    DefInt(SQLITE_CORRUPT_INDEX);
+    DefInt(SQLITE_READONLY_RECOVERY);
+    DefInt(SQLITE_READONLY_CANTLOCK);
+    DefInt(SQLITE_READONLY_ROLLBACK);
+    DefInt(SQLITE_READONLY_DBMOVED);
+    DefInt(SQLITE_READONLY_CANTINIT);
+    DefInt(SQLITE_READONLY_DIRECTORY);
+    DefInt(SQLITE_ABORT_ROLLBACK);
+    DefInt(SQLITE_CONSTRAINT_CHECK);
+    DefInt(SQLITE_CONSTRAINT_COMMITHOOK);
+    DefInt(SQLITE_CONSTRAINT_FOREIGNKEY);
+    DefInt(SQLITE_CONSTRAINT_FUNCTION);
+    DefInt(SQLITE_CONSTRAINT_NOTNULL);
+    DefInt(SQLITE_CONSTRAINT_PRIMARYKEY);
+    DefInt(SQLITE_CONSTRAINT_TRIGGER);
+    DefInt(SQLITE_CONSTRAINT_UNIQUE);
+    DefInt(SQLITE_CONSTRAINT_VTAB);
+    DefInt(SQLITE_CONSTRAINT_ROWID);
+    DefInt(SQLITE_CONSTRAINT_PINNED);
+    DefInt(SQLITE_CONSTRAINT_DATATYPE);
+    DefInt(SQLITE_NOTICE_RECOVER_WAL);
+    DefInt(SQLITE_NOTICE_RECOVER_ROLLBACK);
+    DefInt(SQLITE_WARNING_AUTOINDEX);
+    DefInt(SQLITE_AUTH_USER);
+    DefInt(SQLITE_OK_LOAD_PERMANENTLY);
+    //DefInt(SQLITE_OK_SYMLINK) /* internal use only */;
+  } _DefGroup;
+
+  DefGroup(serialize){
+    DefInt(SQLITE_SERIALIZE_NOCOPY);
+    DefInt(SQLITE_DESERIALIZE_FREEONCLOSE);
+    DefInt(SQLITE_DESERIALIZE_READONLY);
+    DefInt(SQLITE_DESERIALIZE_RESIZEABLE);
+  } _DefGroup;
+
+  DefGroup(session){
+#ifdef SQLITE_SESSION_CONFIG_STRMSIZE
+    DefInt(SQLITE_SESSION_CONFIG_STRMSIZE);
+    DefInt(SQLITE_SESSION_OBJCONFIG_SIZE);
+#endif
+  } _DefGroup;
+
+  DefGroup(sqlite3Status){
+    DefInt(SQLITE_STATUS_MEMORY_USED);
+    DefInt(SQLITE_STATUS_PAGECACHE_USED);
+    DefInt(SQLITE_STATUS_PAGECACHE_OVERFLOW);
+    //DefInt(SQLITE_STATUS_SCRATCH_USED) /* NOT USED */;
+    //DefInt(SQLITE_STATUS_SCRATCH_OVERFLOW) /* NOT USED */;
+    DefInt(SQLITE_STATUS_MALLOC_SIZE);
+    DefInt(SQLITE_STATUS_PARSER_STACK);
+    DefInt(SQLITE_STATUS_PAGECACHE_SIZE);
+    //DefInt(SQLITE_STATUS_SCRATCH_SIZE) /* NOT USED */;
+    DefInt(SQLITE_STATUS_MALLOC_COUNT);
+  } _DefGroup;
+
+  DefGroup(stmtStatus){
+    DefInt(SQLITE_STMTSTATUS_FULLSCAN_STEP);
+    DefInt(SQLITE_STMTSTATUS_SORT);
+    DefInt(SQLITE_STMTSTATUS_AUTOINDEX);
+    DefInt(SQLITE_STMTSTATUS_VM_STEP);
+    DefInt(SQLITE_STMTSTATUS_REPREPARE);
+    DefInt(SQLITE_STMTSTATUS_RUN);
+    DefInt(SQLITE_STMTSTATUS_FILTER_MISS);
+    DefInt(SQLITE_STMTSTATUS_FILTER_HIT);
+    DefInt(SQLITE_STMTSTATUS_MEMUSED);
+  } _DefGroup;
+
+  DefGroup(syncFlags) {
+    DefInt(SQLITE_SYNC_NORMAL);
+    DefInt(SQLITE_SYNC_FULL);
+    DefInt(SQLITE_SYNC_DATAONLY);
+  } _DefGroup;
+
+  DefGroup(trace) {
+    DefInt(SQLITE_TRACE_STMT);
+    DefInt(SQLITE_TRACE_PROFILE);
+    DefInt(SQLITE_TRACE_ROW);
+    DefInt(SQLITE_TRACE_CLOSE);
+  } _DefGroup;
+
+  DefGroup(txnState){
+    DefInt(SQLITE_TXN_NONE);
+    DefInt(SQLITE_TXN_READ);
+    DefInt(SQLITE_TXN_WRITE);
+  } _DefGroup;
+
+  DefGroup(udfFlags) {
+    DefInt(SQLITE_DETERMINISTIC);
+    DefInt(SQLITE_DIRECTONLY);
+    DefInt(SQLITE_INNOCUOUS);
+    DefInt(SQLITE_SUBTYPE);
+    DefInt(SQLITE_RESULT_SUBTYPE);
+  } _DefGroup;
+
+  DefGroup(version) {
+    DefInt(SQLITE_VERSION_NUMBER);
+    DefStr(SQLITE_VERSION);
+    DefStr(SQLITE_SOURCE_ID);
+  } _DefGroup;
+
+  DefGroup(vtab) {
+#if SQLITE_WASM_HAS_VTAB
+    DefInt(SQLITE_INDEX_SCAN_UNIQUE);
+    DefInt(SQLITE_INDEX_CONSTRAINT_EQ);
+    DefInt(SQLITE_INDEX_CONSTRAINT_GT);
+    DefInt(SQLITE_INDEX_CONSTRAINT_LE);
+    DefInt(SQLITE_INDEX_CONSTRAINT_LT);
+    DefInt(SQLITE_INDEX_CONSTRAINT_GE);
+    DefInt(SQLITE_INDEX_CONSTRAINT_MATCH);
+    DefInt(SQLITE_INDEX_CONSTRAINT_LIKE);
+    DefInt(SQLITE_INDEX_CONSTRAINT_GLOB);
+    DefInt(SQLITE_INDEX_CONSTRAINT_REGEXP);
+    DefInt(SQLITE_INDEX_CONSTRAINT_NE);
+    DefInt(SQLITE_INDEX_CONSTRAINT_ISNOT);
+    DefInt(SQLITE_INDEX_CONSTRAINT_ISNOTNULL);
+    DefInt(SQLITE_INDEX_CONSTRAINT_ISNULL);
+    DefInt(SQLITE_INDEX_CONSTRAINT_IS);
+    DefInt(SQLITE_INDEX_CONSTRAINT_LIMIT);
+    DefInt(SQLITE_INDEX_CONSTRAINT_OFFSET);
+    DefInt(SQLITE_INDEX_CONSTRAINT_FUNCTION);
+    DefInt(SQLITE_VTAB_CONSTRAINT_SUPPORT);
+    DefInt(SQLITE_VTAB_INNOCUOUS);
+    DefInt(SQLITE_VTAB_DIRECTONLY);
+    DefInt(SQLITE_VTAB_USES_ALL_SCHEMAS);
+    DefInt(SQLITE_ROLLBACK);
+    //DefInt(SQLITE_IGNORE); // Also used by sqlite3_authorizer() callback
+    DefInt(SQLITE_FAIL);
+    //DefInt(SQLITE_ABORT); // Also an error code
+    DefInt(SQLITE_REPLACE);
+#endif /*SQLITE_WASM_HAS_VTAB*/
+  } _DefGroup;
+
+#undef DefGroup
+#undef DefStr
+#undef DefInt
+#undef _DefGroup
+
+  /*
+  ** Emit an array of "StructBinder" struct descripions, which look
+  ** like:
+  **
+  ** {
+  **   "name": "MyStruct",
+  **   "sizeof": 16,
+  **   "members": {
+  **     "member1": {"offset": 0,"sizeof": 4,"signature": "i"},
+  **     "member2": {"offset": 4,"sizeof": 4,"signature": "p"},
+  **     "member3": {"offset": 8,"sizeof": 8,"signature": "j"}
+  **   }
+  ** }
+  **
+  ** Detailed documentation for those bits are in the docs for the
+  ** Jaccwabyt JS-side component.
+  */
+
+  /** Macros for emitting StructBinder description. */
+#define StructBinder__(TYPE)                 \
+  n = 0;                                     \
+  outf("%s{", (nStruct++ ? ", " : ""));      \
+  out("\"name\": \"" # TYPE "\",");          \
+  outf("\"sizeof\": %d", (int)sizeof(TYPE)); \
+  out(",\"members\": {");
+#define StructBinder_(T) StructBinder__(T)
+  /** ^^^ indirection needed to expand CurrentStruct */
+#define StructBinder StructBinder_(CurrentStruct)
+#define _StructBinder CloseBrace(2)
+#define M(MEMBER,SIG)                                         \
+  outf("%s\"%s\": "                                           \
+       "{\"offset\":%d,\"sizeof\": %d,\"signature\":\"%s\"}", \
+       (n++ ? ", " : ""), #MEMBER,                            \
+       (int)offsetof(CurrentStruct,MEMBER),                   \
+       (int)sizeof(((CurrentStruct*)0)->MEMBER),              \
+       SIG)
+
+  nStruct = 0;
+  out(", \"structs\": ["); {
+
+#define CurrentStruct sqlite3_vfs
+    StructBinder {
+      M(iVersion,          "i");
+      M(szOsFile,          "i");
+      M(mxPathname,        "i");
+      M(pNext,             "p");
+      M(zName,             "s");
+      M(pAppData,          "p");
+      M(xOpen,             "i(pppip)");
+      M(xDelete,           "i(ppi)");
+      M(xAccess,           "i(ppip)");
+      M(xFullPathname,     "i(ppip)");
+      M(xDlOpen,           "p(pp)");
+      M(xDlError,          "p(pip)");
+      M(xDlSym,            "p()");
+      M(xDlClose,          "v(pp)");
+      M(xRandomness,       "i(pip)");
+      M(xSleep,            "i(pi)");
+      M(xCurrentTime,      "i(pp)");
+      M(xGetLastError,     "i(pip)");
+      M(xCurrentTimeInt64, "i(pp)");
+      M(xSetSystemCall,    "i(ppp)");
+      M(xGetSystemCall,    "p(pp)");
+      M(xNextSystemCall,   "p(pp)");
+    } _StructBinder;
+#undef CurrentStruct
+
+#define CurrentStruct sqlite3_io_methods
+    StructBinder {
+      M(iVersion,               "i");
+      M(xClose,                 "i(p)");
+      M(xRead,                  "i(ppij)");
+      M(xWrite,                 "i(ppij)");
+      M(xTruncate,              "i(pj)");
+      M(xSync,                  "i(pi)");
+      M(xFileSize,              "i(pp)");
+      M(xLock,                  "i(pi)");
+      M(xUnlock,                "i(pi)");
+      M(xCheckReservedLock,     "i(pp)");
+      M(xFileControl,           "i(pip)");
+      M(xSectorSize,            "i(p)");
+      M(xDeviceCharacteristics, "i(p)");
+      M(xShmMap,                "i(piiip)");
+      M(xShmLock,               "i(piii)");
+      M(xShmBarrier,            "v(p)");
+      M(xShmUnmap,              "i(pi)");
+      M(xFetch,                 "i(pjip)");
+      M(xUnfetch,               "i(pjp)");
+    } _StructBinder;
+#undef CurrentStruct
+
+#define CurrentStruct sqlite3_file
+    StructBinder {
+      M(pMethods, "p");
+    } _StructBinder;
+#undef CurrentStruct
+
+#define CurrentStruct sqlite3_kvvfs_methods
+    StructBinder {
+      M(xRead,    "i(sspi)");
+      M(xWrite,   "i(sss)");
+      M(xDelete,  "i(ss)");
+      M(nKeySize, "i");
+    } _StructBinder;
+#undef CurrentStruct
+
+
+#if SQLITE_WASM_HAS_VTAB
+#define CurrentStruct sqlite3_vtab
+    StructBinder {
+      M(pModule, "p");
+      M(nRef,    "i");
+      M(zErrMsg, "p");
+    } _StructBinder;
+#undef CurrentStruct
+
+#define CurrentStruct sqlite3_vtab_cursor
+    StructBinder {
+      M(pVtab, "p");
+    } _StructBinder;
+#undef CurrentStruct
+
+#define CurrentStruct sqlite3_module
+    StructBinder {
+      M(iVersion,       "i");
+      M(xCreate,        "i(ppippp)");
+      M(xConnect,       "i(ppippp)");
+      M(xBestIndex,     "i(pp)");
+      M(xDisconnect,    "i(p)");
+      M(xDestroy,       "i(p)");
+      M(xOpen,          "i(pp)");
+      M(xClose,         "i(p)");
+      M(xFilter,        "i(pisip)");
+      M(xNext,          "i(p)");
+      M(xEof,           "i(p)");
+      M(xColumn,        "i(ppi)");
+      M(xRowid,         "i(pp)");
+      M(xUpdate,        "i(pipp)");
+      M(xBegin,         "i(p)");
+      M(xSync,          "i(p)");
+      M(xCommit,        "i(p)");
+      M(xRollback,      "i(p)");
+      M(xFindFunction,  "i(pispp)");
+      M(xRename,        "i(ps)");
+      // ^^^ v1. v2+ follows...
+      M(xSavepoint,     "i(pi)");
+      M(xRelease,       "i(pi)");
+      M(xRollbackTo,    "i(pi)");
+      // ^^^ v2. v3+ follows...
+      M(xShadowName,    "i(s)");
+    } _StructBinder;
+#undef CurrentStruct
+
+    /**
+     ** Workaround: in order to map the various inner structs from
+     ** sqlite3_index_info, we have to uplift those into constructs we
+     ** can access by type name. These structs _must_ match their
+     ** in-sqlite3_index_info counterparts byte for byte.
+    */
+    typedef struct {
+      int iColumn;
+      unsigned char op;
+      unsigned char usable;
+      int iTermOffset;
+    } sqlite3_index_constraint;
+    typedef struct {
+      int iColumn;
+      unsigned char desc;
+    } sqlite3_index_orderby;
+    typedef struct {
+      int argvIndex;
+      unsigned char omit;
+    } sqlite3_index_constraint_usage;
+    { /* Validate that the above struct sizeof()s match
+      ** expectations. We could improve upon this by
+      ** checking the offsetof() for each member. */
+      const sqlite3_index_info siiCheck;
+#define IndexSzCheck(T,M)           \
+      (sizeof(T) == sizeof(*siiCheck.M))
+      if(!IndexSzCheck(sqlite3_index_constraint,aConstraint)
+         || !IndexSzCheck(sqlite3_index_orderby,aOrderBy)
+         || !IndexSzCheck(sqlite3_index_constraint_usage,aConstraintUsage)){
+        assert(!"sizeof mismatch in sqlite3_index_... struct(s)");
+        return 0;
+      }
+#undef IndexSzCheck
+    }
+
+#define CurrentStruct sqlite3_index_constraint
+    StructBinder {
+      M(iColumn,        "i");
+      M(op,             "C");
+      M(usable,         "C");
+      M(iTermOffset,    "i");
+    } _StructBinder;
+#undef CurrentStruct
+
+#define CurrentStruct sqlite3_index_orderby
+    StructBinder {
+      M(iColumn,   "i");
+      M(desc,      "C");
+    } _StructBinder;
+#undef CurrentStruct
+
+#define CurrentStruct sqlite3_index_constraint_usage
+    StructBinder {
+      M(argvIndex,  "i");
+      M(omit,       "C");
+    } _StructBinder;
+#undef CurrentStruct
+
+#define CurrentStruct sqlite3_index_info
+    StructBinder {
+      M(nConstraint,        "i");
+      M(aConstraint,        "p");
+      M(nOrderBy,           "i");
+      M(aOrderBy,           "p");
+      M(aConstraintUsage,   "p");
+      M(idxNum,             "i");
+      M(idxStr,             "p");
+      M(needToFreeIdxStr,   "i");
+      M(orderByConsumed,    "i");
+      M(estimatedCost,      "d");
+      M(estimatedRows,      "j");
+      M(idxFlags,           "i");
+      M(colUsed,            "j");
+    } _StructBinder;
+#undef CurrentStruct
+
+#endif /*SQLITE_WASM_HAS_VTAB*/
+
+#if SQLITE_WASM_ENABLE_C_TESTS
+#define CurrentStruct WasmTestStruct
+    StructBinder {
+      M(v4,    "i");
+      M(cstr,  "s");
+      M(ppV,   "p");
+      M(v8,    "j");
+      M(xFunc, "v(p)");
+    } _StructBinder;
+#undef CurrentStruct
+#endif /*SQLITE_WASM_ENABLE_C_TESTS*/
+
+  } out( "]"/*structs*/);
+
+  out("}"/*top-level object*/);
+  *zPos = 0;
+  aBuffer[0] = '{'/*end of the race-condition workaround*/;
+  return aBuffer;
+#undef StructBinder
+#undef StructBinder_
+#undef StructBinder__
+#undef M
+#undef _StructBinder
+#undef CloseBrace
+#undef out
+#undef outf
+#undef lenCheck
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** This function invokes the xDelete method of the given VFS (or the
+** default VFS if pVfs is NULL), passing on the given filename. If
+** zName is NULL, no default VFS is found, or it has no xDelete
+** method, SQLITE_MISUSE is returned, else the result of the xDelete()
+** call is returned.
+*/
+SQLITE_WASM_EXPORT
+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 ){
+    rc = pVfs->xDelete(pVfs, zName, 1);
+  }
+  return rc;
+}
+
+/*
+** 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 the given DB's VFS for the given DB name,
+** defaulting to "main" if zDbName is 0. Returns 0 if no db with the
+** given name is open.
+*/
+SQLITE_WASM_EXPORT
+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);
+  return pVfs;
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** This function resets the given db pointer's database as described at
+**
+** https://sqlite.org/c3ref/c_dbconfig_defensive.html#sqlitedbconfigresetdatabase
+**
+** But beware: virtual tables destroyed that way do not have their
+** xDestroy() called, so will leak if they require that function for
+** proper cleanup.
+**
+** Returns 0 on success, an SQLITE_xxx code on error. Returns
+** SQLITE_MISUSE if pDb is NULL.
+*/
+SQLITE_WASM_EXPORT
+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);
+    rc = sqlite3_db_config(pDb, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0);
+    if( 0==rc ){
+      rc = sqlite3_exec(pDb, "VACUUM", 0, 0, 0);
+      sqlite3_db_config(pDb, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);
+    }
+  }
+  return rc;
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** Uses the given database's VFS xRead to stream the db file's
+** contents out to the given callback. The callback gets a single
+** chunk of size n (its 2nd argument) on each call and must return 0
+** on success, non-0 on error. This function returns 0 on success,
+** SQLITE_NOTFOUND if no db is open, or propagates any other non-0
+** code from the callback. Note that this is not thread-friendly: it
+** expects that it will be the only thread reading the db file and
+** 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
+** this.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_db_export_chunked( sqlite3* pDb,
+                                    int (*xCallback)(unsigned const char *zOut, int n) ){
+  sqlite3_int64 nSize = 0;
+  sqlite3_int64 nPos = 0;
+  sqlite3_file * pFile = 0;
+  unsigned char buf[1024 * 8];
+  int nBuf = (int)sizeof(buf);
+  int rc = pDb
+    ? sqlite3_file_control(pDb, "main",
+                           SQLITE_FCNTL_FILE_POINTER, &pFile)
+    : SQLITE_NOTFOUND;
+  if( rc ) return rc;
+  rc = pFile->pMethods->xFileSize(pFile, &nSize);
+  if( rc ) return rc;
+  if(nSize % nBuf){
+    /* DB size is not an even multiple of the buffer size. Reduce
+    ** buffer size so that we do not unduly inflate the db size
+    ** with zero-padding when exporting. */
+    if(0 == nSize % 4096) nBuf = 4096;
+    else if(0 == nSize % 2048) nBuf = 2048;
+    else if(0 == nSize % 1024) nBuf = 1024;
+    else nBuf = 512;
+  }
+  for( ; 0==rc && nPos<nSize; nPos += nBuf ){
+    rc = pFile->pMethods->xRead(pFile, buf, nBuf, nPos);
+    if( SQLITE_IOERR_SHORT_READ == rc ){
+      rc = (nPos + nBuf) < nSize ? rc : 0/*assume EOF*/;
+    }
+    if( 0==rc ) rc = xCallback(buf, nBuf);
+  }
+  return rc;
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** A proxy for sqlite3_serialize() which serializes the schema zSchema
+** of pDb, placing the serialized output in pOut and nOut. nOut may be
+** NULL. If zSchema is NULL then "main" is assumed. If pDb or pOut are
+** NULL then SQLITE_MISUSE is returned. If allocation of the
+** serialized copy fails, SQLITE_NOMEM is returned.  On success, 0 is
+** returned and `*pOut` will contain a pointer to the memory unless
+** mFlags includes SQLITE_SERIALIZE_NOCOPY and the database has no
+** contiguous memory representation, in which case `*pOut` will be
+** NULL but 0 will be returned.
+**
+** If `*pOut` is not NULL, the caller is responsible for passing it to
+** sqlite3_free() to free it.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_db_serialize( sqlite3 *pDb, const char *zSchema,
+                               unsigned char **pOut,
+                               sqlite3_int64 *nOut, unsigned int mFlags ){
+  unsigned char * z;
+  if( !pDb || !pOut ) return SQLITE_MISUSE;
+  if( nOut ) *nOut = 0;
+  z = sqlite3_serialize(pDb, zSchema ? zSchema : "main", nOut, mFlags);
+  if( z || (SQLITE_SERIALIZE_NOCOPY & mFlags) ){
+    *pOut = z;
+    return 0;
+  }else{
+    return SQLITE_NOMEM;
+  }
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** ACHTUNG: it was discovered on 2023-08-11 that, with SQLITE_DEBUG,
+** 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
+** suitable for the "unix" family of VFSes.
+**
+** Creates a new file using the I/O API of the given VFS, containing
+** the given number of bytes of the given data. If the file exists, it
+** is truncated to the given length and populated with the given
+** data.
+**
+** This function exists so that we can implement the equivalent of
+** Emscripten's FS.createDataFile() in a VFS-agnostic way. This
+** functionality is intended for use in uploading database files.
+**
+** Not all VFSes support this functionality, e.g. the "kvvfs" does
+** not.
+**
+** If pVfs is NULL, sqlite3_vfs_find(0) is used.
+**
+** If zFile is NULL, pVfs is NULL (and sqlite3_vfs_find(0) returns
+** NULL), or nData is negative, SQLITE_MISUSE are returned.
+**
+** On success, it creates a new file with the given name, populated
+** with the fist nData bytes of pData. If pData is NULL, the file is
+** created and/or truncated to nData bytes.
+**
+** Whether or not directory components of zFilename are created
+** automatically or not is unspecified: that detail is left to the
+** VFS. The "opfs" VFS, for example, creates them.
+**
+** If an error happens while populating or truncating the file, the
+** target file will be deleted (if needed) if this function created
+** it. If this function did not create it, it is not deleted but may
+** be left in an undefined state.
+**
+** Returns 0 on success. On error, it returns a code described above
+** or propagates a code from one of the I/O methods.
+**
+** Design note: nData is an integer, instead of int64, for WASM
+** portability, so that the API can still work in builds where BigInt
+** support is disabled or unavailable.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_vfs_create_file( sqlite3_vfs *pVfs,
+                                  const char *zFilename,
+                                  const unsigned char * pData,
+                                  int nData ){
+  int rc;
+  sqlite3_file *pFile = 0;
+  sqlite3_io_methods const *pIo;
+  const int openFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
+#if 0 && defined(SQLITE_DEBUG)
+    | SQLITE_OPEN_MAIN_JOURNAL
+    /* ^^^^ This is for testing a horrible workaround to avoid
+       triggering a specific assert() in os_unix.c:unixOpen(). Please
+       do not enable this in real builds. */
+#endif
+    ;
+  int flagsOut = 0;
+  int fileExisted = 0;
+  int doUnlock = 0;
+  const unsigned char *pPos = pData;
+  const int blockSize = 512
+    /* Because we are using pFile->pMethods->xWrite() for writing, and
+    ** it may have a buffer limit related to sqlite3's pager size, we
+    ** conservatively write in 512-byte blocks (smallest page
+    ** size). */;
+  //fprintf(stderr, "pVfs=%p, zFilename=%s, nData=%d\n", pVfs, zFilename, nData);
+  if( !pVfs ) pVfs = sqlite3_vfs_find(0);
+  if( !pVfs || !zFilename || nData<0 ) return SQLITE_MISUSE;
+  pVfs->xAccess(pVfs, zFilename, SQLITE_ACCESS_EXISTS, &fileExisted);
+  rc = sqlite3OsOpenMalloc(pVfs, zFilename, &pFile, openFlags, &flagsOut);
+#if 0
+# define RC fprintf(stderr,"create_file(%s,%s) @%d rc=%d\n", \
+                    pVfs->zName, zFilename, __LINE__, rc);
+#else
+# define RC
+#endif
+  RC;
+  if(rc) return rc;
+  pIo = pFile->pMethods;
+  if( pIo->xLock ) {
+    /* We need xLock() in order to accommodate the OPFS VFS, as it
+    ** obtains a writeable handle via the lock operation and releases
+    ** it in xUnlock(). If we don't do those here, we have to add code
+    ** to the VFS to account check whether it was locked before
+    ** xFileSize(), xTruncate(), and the like, and release the lock
+    ** only if it was unlocked when the op was started. */
+    rc = pIo->xLock(pFile, SQLITE_LOCK_EXCLUSIVE);
+    RC;
+    doUnlock = 0==rc;
+  }
+  if( 0==rc ){
+    rc = pIo->xTruncate(pFile, nData);
+    RC;
+  }
+  if( 0==rc && 0!=pData && nData>0 ){
+    while( 0==rc && nData>0 ){
+      const int n = nData>=blockSize ? blockSize : nData;
+      rc = pIo->xWrite(pFile, pPos, n, (sqlite3_int64)(pPos - pData));
+      RC;
+      nData -= n;
+      pPos += n;
+    }
+    if( 0==rc && nData>0 ){
+      assert( nData<blockSize );
+      rc = pIo->xWrite(pFile, pPos, nData,
+                       (sqlite3_int64)(pPos - pData));
+      RC;
+    }
+  }
+  if( pIo->xUnlock && doUnlock!=0 ){
+    pIo->xUnlock(pFile, SQLITE_LOCK_NONE);
+  }
+  pIo->xClose(pFile);
+  if( rc!=0 && 0==fileExisted ){
+    pVfs->xDelete(pVfs, zFilename, 1);
+  }
+  RC;
+#undef RC
+  return rc;
+}
+
+/**
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** Creates or overwrites a file using the POSIX file API,
+** i.e. Emscripten's virtual filesystem. Creates or truncates
+** zFilename, appends pData bytes to it, and returns 0 on success or
+** SQLITE_IOERR on error.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_posix_create_file( const char *zFilename,
+                                    const unsigned char * pData,
+                                    int nData ){
+  int rc;
+  FILE * pFile = 0;
+  int fileExisted = 0;
+  size_t nWrote = 1;
+
+  if( !zFilename || nData<0 || (pData==0 && nData>0) ) return SQLITE_MISUSE;
+  pFile = fopen(zFilename, "w");
+  if( 0==pFile ) return SQLITE_IOERR;
+  if( nData>0 ){
+    nWrote = fwrite(pData, (size_t)nData, 1, pFile);
+  }
+  fclose(pFile);
+  return 1==nWrote ? 0 : SQLITE_IOERR;
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** 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,
+** 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.
+*/
+SQLITE_WASM_EXPORT
+char * sqlite3__wasm_kvvfsMakeKeyOnPstack(const char *zClass,
+                                         const char *zKeyIn){
+  assert(sqlite3KvvfsMethods.nKeySize>24);
+  char *zKeyOut =
+    (char *)sqlite3__wasm_pstack_alloc(sqlite3KvvfsMethods.nKeySize);
+  if(zKeyOut){
+    kvstorageMakeKey(zClass, zKeyIn, zKeyOut);
+  }
+  return zKeyOut;
+}
+
+/*
+** 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 the pointer to the singleton object which holds the kvvfs
+** I/O methods and associated state.
+*/
+SQLITE_WASM_EXPORT
+sqlite3_kvvfs_methods * sqlite3__wasm_kvvfs_methods(void){
+  return &sqlite3KvvfsMethods;
+}
+
+#if SQLITE_WASM_HAS_VTAB
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** This is a proxy for the variadic sqlite3_vtab_config() which passes
+** its argument on, or not, to sqlite3_vtab_config(), depending on the
+** value of its 2nd argument. Returns the result of
+** sqlite3_vtab_config(), or SQLITE_MISUSE if the 2nd arg is not a
+** valid value.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_vtab_config(sqlite3 *pDb, int op, int arg){
+  switch(op){
+  case SQLITE_VTAB_DIRECTONLY:
+  case SQLITE_VTAB_INNOCUOUS:
+    return sqlite3_vtab_config(pDb, op);
+  case SQLITE_VTAB_CONSTRAINT_SUPPORT:
+    return sqlite3_vtab_config(pDb, op, arg);
+  default:
+    return SQLITE_MISUSE;
+  }
+}
+#endif /*SQLITE_WASM_HAS_VTAB*/
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** Wrapper for the variants of sqlite3_db_config() which take
+** (int,int*) variadic args.
+*/
+SQLITE_WASM_EXPORT
+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:
+    case SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER:
+    case SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION:
+    case SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE:
+    case SQLITE_DBCONFIG_ENABLE_QPSG:
+    case SQLITE_DBCONFIG_TRIGGER_EQP:
+    case SQLITE_DBCONFIG_RESET_DATABASE:
+    case SQLITE_DBCONFIG_DEFENSIVE:
+    case SQLITE_DBCONFIG_WRITABLE_SCHEMA:
+    case SQLITE_DBCONFIG_LEGACY_ALTER_TABLE:
+    case SQLITE_DBCONFIG_DQS_DML:
+    case SQLITE_DBCONFIG_DQS_DDL:
+    case SQLITE_DBCONFIG_ENABLE_VIEW:
+    case SQLITE_DBCONFIG_LEGACY_FILE_FORMAT:
+    case SQLITE_DBCONFIG_TRUSTED_SCHEMA:
+    case SQLITE_DBCONFIG_STMT_SCANSTATUS:
+    case SQLITE_DBCONFIG_REVERSE_SCANORDER:
+      return sqlite3_db_config(pDb, op, arg1, pArg2);
+    default: return SQLITE_MISUSE;
+  }
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** Wrapper for the variants of sqlite3_db_config() which take
+** (void*,int,int) variadic args.
+*/
+SQLITE_WASM_EXPORT
+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);
+    default: return SQLITE_MISUSE;
+  }
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** Wrapper for the variants of sqlite3_db_config() which take
+** (const char *) variadic args.
+*/
+SQLITE_WASM_EXPORT
+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);
+    default: return SQLITE_MISUSE;
+  }
+}
+
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** Binding for combinations of sqlite3_config() arguments which take
+** a single integer argument.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_config_i(int op, int arg){
+  return sqlite3_config(op, arg);
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** Binding for combinations of sqlite3_config() arguments which take
+** two int arguments.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_config_ii(int op, int arg1, int arg2){
+  return sqlite3_config(op, arg1, arg2);
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** Binding for combinations of sqlite3_config() arguments which take
+** a single i64 argument.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_config_j(int op, sqlite3_int64 arg){
+  return sqlite3_config(op, arg);
+}
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings.
+**
+** 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
+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;
+}
+
+#if defined(__EMSCRIPTEN__) && defined(SQLITE_ENABLE_WASMFS)
+#include <emscripten/console.h>
+#include <emscripten/wasmfs.h>
+
+/*
+** This function is NOT part of the sqlite3 public API. It is strictly
+** for use by the sqlite project's own JS/WASM bindings, specifically
+** only when building with Emscripten's WASMFS support.
+**
+** This function should only be called if the JS side detects the
+** existence of the Origin-Private FileSystem (OPFS) APIs in the
+** client. The first time it is called, this function instantiates a
+** WASMFS backend impl for OPFS. On success, subsequent calls are
+** no-ops.
+**
+** This function may be passed a "mount point" name, which must have a
+** leading "/" and is currently restricted to a single path component,
+** e.g. "/foo" is legal but "/foo/" and "/foo/bar" are not. If it is
+** NULL or empty, it defaults to "/opfs".
+**
+** Returns 0 on success, SQLITE_NOMEM if instantiation of the backend
+** object fails, SQLITE_IOERR if mkdir() of the zMountPoint dir in
+** the virtual FS fails. In builds compiled without SQLITE_ENABLE_WASMFS
+** defined, SQLITE_NOTFOUND is returned without side effects.
+*/
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_init_wasmfs(const char *zMountPoint){
+  static backend_t pOpfs = 0;
+  if( !zMountPoint || !*zMountPoint ) zMountPoint = "/opfs";
+  if( !pOpfs ){
+    pOpfs = wasmfs_create_opfs_backend();
+  }
+  /** It's not enough to instantiate the backend. We have to create a
+      mountpoint in the VFS and attach the backend to it. */
+  if( pOpfs && 0!=access(zMountPoint, F_OK) ){
+    /* Note that this check and is not robust but it will
+       hypothetically suffice for the transient wasm-based virtual
+       filesystem we're currently running in. */
+    const int rc = wasmfs_create_directory(zMountPoint, 0777, pOpfs);
+    /*emscripten_console_logf("OPFS mkdir(%s) rc=%d", zMountPoint, rc);*/
+    if(rc) return SQLITE_IOERR;
+  }
+  return pOpfs ? 0 : SQLITE_NOMEM;
+}
+#else
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_init_wasmfs(const char *zUnused){
+  //emscripten_console_warn("WASMFS OPFS is not compiled in.");
+  if(zUnused){/*unused*/}
+  return SQLITE_NOTFOUND;
+}
+#endif /* __EMSCRIPTEN__ && SQLITE_ENABLE_WASMFS */
+
+#if SQLITE_WASM_ENABLE_C_TESTS
+
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_test_intptr(int * p){
+  return *p = *p * 2;
+}
+
+SQLITE_WASM_EXPORT
+void * sqlite3__wasm_test_voidptr(void * p){
+  return p;
+}
+
+SQLITE_WASM_EXPORT
+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();
+}
+
+SQLITE_WASM_EXPORT
+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();
+  /*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);*/
+  return *p = *p * 2;
+}
+
+SQLITE_WASM_EXPORT
+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 * s = fail ? 0 : (char *)sqlite3_malloc(6);
+  if(s){
+    memcpy(s, "hello", 5);
+    s[5] = 0;
+  }
+  return s;
+}
+
+/*
+** For testing using SQLTester scripts.
+**
+** Return non-zero if string z matches glob pattern zGlob and zero if the
+** pattern does not match.
+**
+** To repeat:
+**
+**         zero == no match
+**     non-zero == match
+**
+** Globbing rules:
+**
+**      '*'       Matches any sequence of zero or more characters.
+**
+**      '?'       Matches exactly one character.
+**
+**     [...]      Matches one character from the enclosed list of
+**                characters.
+**
+**     [^...]     Matches one character not in the enclosed list.
+**
+**      '#'       Matches any sequence of one or more digits with an
+**                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){
+  int c, c2;
+  int invert;
+  int seen;
+  typedef int (*recurse_f)(const char *,const char *);
+  static const recurse_f recurse = sqlite3__wasm_SQLTester_strnotglob;
+
+  while( (c = (*(zGlob++)))!=0 ){
+    if( c=='*' ){
+      while( (c=(*(zGlob++))) == '*' || c=='?' ){
+        if( c=='?' && (*(z++))==0 ) return 0;
+      }
+      if( c==0 ){
+        return 1;
+      }else if( c=='[' ){
+        while( *z && recurse(zGlob-1,z)==0 ){
+          z++;
+        }
+        return (*z)!=0;
+      }
+      while( (c2 = (*(z++)))!=0 ){
+        while( c2!=c ){
+          c2 = *(z++);
+          if( c2==0 ) return 0;
+        }
+        if( recurse(zGlob,z) ) return 1;
+      }
+      return 0;
+    }else if( c=='?' ){
+      if( (*(z++))==0 ) return 0;
+    }else if( c=='[' ){
+      int prior_c = 0;
+      seen = 0;
+      invert = 0;
+      c = *(z++);
+      if( c==0 ) return 0;
+      c2 = *(zGlob++);
+      if( c2=='^' ){
+        invert = 1;
+        c2 = *(zGlob++);
+      }
+      if( c2==']' ){
+        if( c==']' ) seen = 1;
+        c2 = *(zGlob++);
+      }
+      while( c2 && c2!=']' ){
+        if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
+          c2 = *(zGlob++);
+          if( c>=prior_c && c<=c2 ) seen = 1;
+          prior_c = 0;
+        }else{
+          if( c==c2 ){
+            seen = 1;
+          }
+          prior_c = c2;
+        }
+        c2 = *(zGlob++);
+      }
+      if( c2==0 || (seen ^ invert)==0 ) return 0;
+    }else if( c=='#' ){
+      if( z[0]=='0'
+       && (z[1]=='x' || z[1]=='X')
+       && sqlite3Isxdigit(z[2])
+      ){
+        z += 3;
+        while( sqlite3Isxdigit(z[0]) ){ z++; }
+      }else{
+        if( (z[0]=='-' || z[0]=='+') && sqlite3Isdigit(z[1]) ) z++;
+        if( !sqlite3Isdigit(z[0]) ) return 0;
+        z++;
+        while( sqlite3Isdigit(z[0]) ){ z++; }
+      }
+    }else{
+      if( c!=(*(z++)) ) return 0;
+    }
+  }
+  return *z==0;
+}
+
+SQLITE_WASM_EXPORT
+int sqlite3__wasm_SQLTester_strglob(const char *zGlob, const char *z){
+ return !sqlite3__wasm_SQLTester_strnotglob(zGlob, z);
+}
+
+#endif /* SQLITE_WASM_ENABLE_C_TESTS */
+
+#undef SQLITE_WASM_EXPORT
+#undef SQLITE_WASM_HAS_VTAB
+#undef SQLITE_WASM_BARE_BONES
+#undef SQLITE_WASM_ENABLE_C_TESTS

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/fiddle/fiddle-worker.js

@@ -0,0 +1,381 @@
+/*
+  2022-05-20
+
+  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 is the JS Worker file for the sqlite3 fiddle app. It loads the
+  sqlite3 wasm module and offers access to the db via the Worker
+  message-passing interface.
+
+  Forewarning: this API is still very much Under Construction and
+  subject to any number of changes as experience reveals what those
+  need to be.
+
+  Because we can have only a single message handler, as opposed to an
+  arbitrary number of discrete event listeners like with DOM elements,
+  we have to define a lower-level message API. Messages abstractly
+  look like:
+
+  { type: string, data: type-specific value }
+
+  Where 'type' is used for dispatching and 'data' is a
+  'type'-dependent value.
+
+  The 'type' values expected by each side of the main/worker
+  connection vary. The types are described below but subject to
+  change at any time as this experiment evolves.
+
+  Workers-to-Main types
+
+  - stdout, stderr: indicate stdout/stderr output from the wasm
+    layer. The data property is the string of the output, noting
+    that the emscripten binding emits these one line at a time. Thus,
+    if a C-side puts() emits multiple lines in a single call, the JS
+    side will see that as multiple calls. Example:
+
+    {type:'stdout', data: 'Hi, world.'}
+
+  - module: Status text. This is intended to alert the main thread
+    about module loading status so that, e.g., the main thread can
+    update a progress widget and DTRT when the module is finished
+    loading and available for work. Status messages come in the form
+
+    {type:'module', data:{
+        type:'status',
+        data: {text:string|null, step:1-based-integer}
+    }
+
+    with an incrementing step value for each subsequent message. When
+    the module loading is complete, a message with a text value of
+    null is posted.
+
+  - working: data='start'|'end'. Indicates that work is about to be
+    sent to the module or has just completed. This can be used, e.g.,
+    to disable UI elements which should not be activated while work
+    is pending. Example:
+
+    {type:'working', data:'start'}
+
+  Main-to-Worker types:
+
+  - shellExec: data=text to execute as if it had been entered in the
+    sqlite3 CLI shell app (as opposed to sqlite3_exec()). This event
+    causes the worker to emit a 'working' event (data='start') before
+    it starts and a 'working' event (data='end') when it finished. If
+    called while work is currently being executed it emits stderr
+    message instead of doing actual work, as the underlying db cannot
+    handle concurrent tasks. Example:
+
+    {type:'shellExec', data: 'select * from sqlite_master'}
+
+  - More TBD as the higher-level db layer develops.
+*/
+
+/*
+  Apparent browser(s) bug: console messages emitted may be duplicated
+  in the console, even though they're provably only run once. See:
+
+  https://stackoverflow.com/questions/49659464
+
+  Noting that it happens in Firefox as well as Chrome. Harmless but
+  annoying.
+*/
+"use strict";
+(function(){
+  /**
+     Posts a message in the form {type,data}. If passed more than 2
+     args, the 3rd must be an array of "transferable" values to pass
+     as the 2nd argument to postMessage(). */
+  const wMsg =
+        (type,data,transferables)=>{
+          postMessage({type, data}, transferables || []);
+        };
+  const stdout = (...args)=>wMsg('stdout', args);
+  const stderr = (...args)=>wMsg('stderr', args);
+  const toss = (...args)=>{
+    throw new Error(args.join(' '));
+  };
+  const fixmeOPFS = "(FIXME: won't work with OPFS-over-sqlite3_vfs.)";
+  let sqlite3 /* gets assigned when the wasm module is loaded */;
+
+  self.onerror = function(/*message, source, lineno, colno, error*/) {
+    const err = arguments[4];
+    if(err && 'ExitStatus'==err.name){
+      /* This is relevant for the sqlite3 shell binding but not the
+         lower-level binding. */
+      fiddleModule.isDead = true;
+      stderr("FATAL ERROR:", err.message);
+      stderr("Restarting the app requires reloading the page.");
+      wMsg('error', err);
+    }
+    console.error(err);
+    fiddleModule.setStatus('Exception thrown, see JavaScript console: '+err);
+  };
+
+  const Sqlite3Shell = {
+    /** Returns the name of the currently-opened db. */
+    dbFilename: function f(){
+      if(!f._) f._ = sqlite3.wasm.xWrap('fiddle_db_filename', "string", ['string']);
+      return f._(0);
+    },
+    dbHandle: function f(){
+      if(!f._) f._ = sqlite3.wasm.xWrap("fiddle_db_handle", "sqlite3*");
+      return f._();
+    },
+    dbIsOpfs: function f(){
+      return sqlite3.opfs && sqlite3.capi.sqlite3_js_db_uses_vfs(
+        this.dbHandle(), "opfs"
+      );
+    },
+    runMain: function f(){
+      if(f.argv) return 0===f.argv.rc;
+      const dbName = "/fiddle.sqlite3";
+      f.argv = [
+        'sqlite3-fiddle.wasm',
+        '-bail', '-safe',
+        dbName
+        /* Reminder: because of how we run fiddle, we have to ensure
+           that any argv strings passed to its main() are valid until
+           the wasm environment shuts down. */
+      ];
+      const capi = sqlite3.capi, wasm = sqlite3.wasm;
+      /* We need to call sqlite3_shutdown() in order to avoid numerous
+         legitimate warnings from the shell about it being initialized
+         after sqlite3_initialize() has been called. This means,
+         however, that any initialization done by the JS code may need
+         to be re-done (e.g.  re-registration of dynamically-loaded
+         VFSes). We need a more generic approach to running such
+         init-level code. */
+      capi.sqlite3_shutdown();
+      f.argv.pArgv = wasm.allocMainArgv(f.argv);
+      f.argv.rc = wasm.exports.fiddle_main(
+        f.argv.length, f.argv.pArgv
+      );
+      if(f.argv.rc){
+        stderr("Fatal error initializing sqlite3 shell.");
+        fiddleModule.isDead = true;
+        return false;
+      }
+      stdout("SQLite version", capi.sqlite3_libversion(),
+             capi.sqlite3_sourceid().substr(0,19));
+      stdout('Welcome to the "fiddle" shell.');
+      if(capi.sqlite3_vfs_find("opfs")){
+        stdout("\nOPFS is available. To open a persistent db, use:\n\n",
+               "  .open file:name?vfs=opfs\n\nbut note that some",
+               "features (e.g. upload) do not yet work with OPFS.");
+      }
+      stdout('\nEnter ".help" for usage hints.');
+      this.exec([ // initialization commands...
+        '.nullvalue NULL',
+        '.headers on'
+      ].join('\n'));
+      return true;
+    },
+    /**
+       Runs the given text through the shell as if it had been typed
+       in by a user. Fires a working/start event before it starts and
+       working/end event when it finishes.
+    */
+    exec: function f(sql){
+      if(!f._){
+        if(!this.runMain()) return;
+        f._ = sqlite3.wasm.xWrap('fiddle_exec', null, ['string']);
+      }
+      if(fiddleModule.isDead){
+        stderr("shell module has exit()ed. Cannot run SQL.");
+        return;
+      }
+      wMsg('working','start');
+      try {
+        if(f._running){
+          stderr('Cannot run multiple commands concurrently.');
+        }else if(sql){
+          if(Array.isArray(sql)) sql = sql.join('');
+          f._running = true;
+          f._(sql);
+        }
+      }finally{
+        delete f._running;
+        wMsg('working','end');
+      }
+    },
+    resetDb: function f(){
+      if(!f._) f._ = sqlite3.wasm.xWrap('fiddle_reset_db', null);
+      stdout("Resetting database.");
+      f._();
+      stdout("Reset",this.dbFilename());
+    },
+    /* Interrupt can't work: this Worker is tied up working, so won't get the
+       interrupt event which would be needed to perform the interrupt. */
+    interrupt: function f(){
+      if(!f._) f._ = sqlite3.wasm.xWrap('fiddle_interrupt', null);
+      stdout("Requesting interrupt.");
+      f._();
+    }
+  };
+
+  self.onmessage = function f(ev){
+    ev = ev.data;
+    if(!f.cache){
+      f.cache = {
+        prevFilename: null
+      };
+    }
+    //console.debug("worker: onmessage.data",ev);
+    switch(ev.type){
+        case 'shellExec': Sqlite3Shell.exec(ev.data); return;
+        case 'db-reset': Sqlite3Shell.resetDb(); return;
+        case 'interrupt': Sqlite3Shell.interrupt(); return;
+          /** Triggers the export of the current db. Fires an
+              event in the form:
+
+              {type:'db-export',
+                data:{
+                  filename: name of db,
+                  buffer: contents of the db file (Uint8Array),
+                  error: on error, a message string and no buffer property.
+                }
+              }
+          */
+        case 'db-export': {
+          const fn = Sqlite3Shell.dbFilename();
+          stdout("Exporting",fn+".");
+          const fn2 = fn ? fn.split(/[/\\]/).pop() : null;
+          try{
+            if(!fn2) toss("DB appears to be closed.");
+            const buffer = sqlite3.capi.sqlite3_js_db_export(
+              Sqlite3Shell.dbHandle()
+            );
+            wMsg('db-export',{filename: fn2, buffer: buffer.buffer}, [buffer.buffer]);
+          }catch(e){
+            console.error("Export failed:",e);
+            /* Post a failure message so that UI elements disabled
+               during the export can be re-enabled. */
+            wMsg('db-export',{
+              filename: fn,
+              error: e.message
+            });
+          }
+          return;
+        }
+        case 'open': {
+          /* Expects: {
+               buffer: ArrayBuffer | Uint8Array,
+               filename: the filename for the db. Any dir part is
+                         stripped.
+              }
+          */
+          const opt = ev.data;
+          let buffer = opt.buffer;
+          stderr('open():',fixmeOPFS);
+          if(buffer instanceof ArrayBuffer){
+            buffer = new Uint8Array(buffer);
+          }else if(!(buffer instanceof Uint8Array)){
+            stderr("'open' expects {buffer:Uint8Array} containing an uploaded db.");
+            return;
+          }
+          const fn = (
+            opt.filename
+              ? opt.filename.split(/[/\\]/).pop().replace('"','_')
+              : ("db-"+((Math.random() * 10000000) | 0)+
+                 "-"+((Math.random() * 10000000) | 0)+".sqlite3")
+          );
+          try {
+            /* We cannot delete the existing db file until the new one
+               is installed, which means that we risk overflowing our
+               quota (if any) by having both the previous and current
+               db briefly installed in the virtual filesystem. */
+            const fnAbs = '/'+fn;
+            const oldName = Sqlite3Shell.dbFilename();
+            if(oldName && oldName===fnAbs){
+              /* We cannot create the replacement file while the current file
+                 is opened, nor does the shell have a .close command, so we
+                 must temporarily switch to another db... */
+              Sqlite3Shell.exec('.open :memory:');
+              fiddleModule.FS.unlink(fnAbs);
+            }
+            fiddleModule.FS.createDataFile("/", fn, buffer, true, true);
+            Sqlite3Shell.exec('.open "'+fnAbs+'"');
+            if(oldName && oldName!==fnAbs){
+              try{fiddleModule.fsUnlink(oldName)}
+              catch(e){/*ignored*/}
+            }
+            stdout("Replaced DB with",fn+".");
+          }catch(e){
+            stderr("Error installing db",fn+":",e.message);
+          }
+          return;
+        }
+    };
+    console.warn("Unknown fiddle-worker message type:",ev);
+  };
+
+  /**
+     emscripten module for use with build mode -sMODULARIZE.
+  */
+  const fiddleModule = {
+    print: stdout,
+    printErr: stderr,
+    /**
+       Intercepts status updates from the emscripting module init
+       and fires worker events with a type of 'status' and a
+       payload of:
+
+       {
+       text: string | null, // null at end of load process
+       step: integer // starts at 1, increments 1 per call
+       }
+
+       We have no way of knowing in advance how many steps will
+       be processed/posted, so creating a "percentage done" view is
+       not really practical. One can be approximated by giving it a
+       current value of message.step and max value of message.step+1,
+       though.
+
+       When work is finished, a message with a text value of null is
+       submitted.
+
+       After a message with text==null is posted, the module may later
+       post messages about fatal problems, e.g. an exit() being
+       triggered, so it is recommended that UI elements for posting
+       status messages not be outright removed from the DOM when
+       text==null, and that they instead be hidden until/unless
+       text!=null.
+    */
+    setStatus: function f(text){
+      if(!f.last) f.last = { step: 0, text: '' };
+      else if(text === f.last.text) return;
+      f.last.text = text;
+      wMsg('module',{
+        type:'status',
+        data:{step: ++f.last.step, text: text||null}
+      });
+    }
+  };
+
+  importScripts('fiddle-module.js'+self.location.search);
+  /**
+     initFiddleModule() is installed via fiddle-module.js due to
+     building with:
+
+     emcc ... -sMODULARIZE=1 -sEXPORT_NAME=initFiddleModule
+  */
+  sqlite3InitModule(fiddleModule).then((_sqlite3)=>{
+    sqlite3 = _sqlite3;
+    console.warn("Installing sqlite3 module globally (in Worker)",
+                 "for use in the dev console.", sqlite3);
+    globalThis.sqlite3 = sqlite3;
+    const dbVfs = sqlite3.wasm.xWrap('fiddle_db_vfs', "*", ['string']);
+    fiddleModule.fsUnlink = (fn)=>fiddleModule.FS.unlink(fn);
+    wMsg('fiddle-ready');
+  }).catch(e=>{
+    console.error("Fiddle worker init failed:",e);
+  });
+})();

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/jaccwabyt/jaccwabyt.js

@@ -0,0 +1,696 @@
+/**
+  2022-06-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.
+
+  ***********************************************************************
+
+  The Jaccwabyt API is documented in detail in an external file,
+  _possibly_ called jaccwabyt.md in the same directory as this file.
+
+  Project homes:
+  - https://fossil.wanderinghorse.net/r/jaccwabyt
+  - https://sqlite.org/src/dir/ext/wasm/jaccwabyt
+
+*/
+'use strict';
+globalThis.Jaccwabyt = function StructBinderFactory(config){
+/* ^^^^ it is recommended that clients move that object into wherever
+   they'd like to have it and delete the self-held copy ("self" being
+   the global window or worker object).  This API does not require the
+   global reference - it is simply installed as a convenience for
+   connecting these bits to other co-developed code before it gets
+   removed from the global namespace.
+*/
+
+  /** Throws a new Error, the message of which is the concatenation
+      all args with a space between each. */
+  const toss = (...args)=>{throw new Error(args.join(' '))};
+
+  /**
+     Implementing function bindings revealed significant
+     shortcomings in Emscripten's addFunction()/removeFunction()
+     interfaces:
+
+     https://github.com/emscripten-core/emscripten/issues/17323
+
+     Until those are resolved, or a suitable replacement can be
+     implemented, our function-binding API will be more limited
+     and/or clumsier to use than initially hoped.
+  */
+  if(!(config.heap instanceof WebAssembly.Memory)
+     && !(config.heap instanceof Function)){
+    toss("config.heap must be WebAssembly.Memory instance or a function.");
+  }
+  ['alloc','dealloc'].forEach(function(k){
+    (config[k] instanceof Function) ||
+      toss("Config option '"+k+"' must be a function.");
+  });
+  const SBF = StructBinderFactory;
+  const heap = (config.heap instanceof Function)
+        ? config.heap : (()=>new Uint8Array(config.heap.buffer)),
+        alloc = config.alloc,
+        dealloc = config.dealloc,
+        log = config.log || console.log.bind(console),
+        memberPrefix = (config.memberPrefix || ""),
+        memberSuffix = (config.memberSuffix || ""),
+        bigIntEnabled = (undefined===config.bigIntEnabled
+                         ? !!globalThis['BigInt64Array'] : !!config.bigIntEnabled),
+        BigInt = globalThis['BigInt'],
+        BigInt64Array = globalThis['BigInt64Array'],
+        /* Undocumented (on purpose) config options: */
+        ptrSizeof = config.ptrSizeof || 4,
+        ptrIR = config.ptrIR || 'i32'
+  ;
+
+  if(!SBF.debugFlags){
+    SBF.__makeDebugFlags = function(deriveFrom=null){
+      /* This is disgustingly overengineered. :/ */
+      if(deriveFrom && deriveFrom.__flags) deriveFrom = deriveFrom.__flags;
+      const f = function f(flags){
+        if(0===arguments.length){
+          return f.__flags;
+        }
+        if(flags<0){
+          delete f.__flags.getter; delete f.__flags.setter;
+          delete f.__flags.alloc; delete f.__flags.dealloc;
+        }else{
+          f.__flags.getter  = 0!==(0x01 & flags);
+          f.__flags.setter  = 0!==(0x02 & flags);
+          f.__flags.alloc   = 0!==(0x04 & flags);
+          f.__flags.dealloc = 0!==(0x08 & flags);
+        }
+        return f._flags;
+      };
+      Object.defineProperty(f,'__flags', {
+        iterable: false, writable: false,
+        value: Object.create(deriveFrom)
+      });
+      if(!deriveFrom) f(0);
+      return f;
+    };
+    SBF.debugFlags = SBF.__makeDebugFlags();
+  }/*static init*/
+
+  const isLittleEndian = (function() {
+    const buffer = new ArrayBuffer(2);
+    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
+    // Int16Array uses the platform's endianness.
+    return new Int16Array(buffer)[0] === 256;
+  })();
+  /**
+     Some terms used in the internal docs:
+
+     StructType: a struct-wrapping class generated by this
+     framework.
+     DEF: struct description object.
+     SIG: struct member signature string.
+  */
+
+  /** True if SIG s looks like a function signature, else
+      false. */
+  const isFuncSig = (s)=>'('===s[1];
+  /** True if SIG s is-a pointer signature. */
+  const isPtrSig = (s)=>'p'===s || 'P'===s;
+  const isAutoPtrSig = (s)=>'P'===s /*EXPERIMENTAL*/;
+  const sigLetter = (s)=>isFuncSig(s) ? 'p' : s[0];
+  /** Returns the WASM IR form of the Emscripten-conventional letter
+      at SIG s[0]. Throws for an unknown SIG. */
+  const sigIR = function(s){
+    switch(sigLetter(s)){
+        case 'c': case 'C': return 'i8';
+        case 'i': return 'i32';
+        case 'p': case 'P': case 's': return ptrIR;
+        case 'j': return 'i64';
+        case 'f': return 'float';
+        case 'd': return 'double';
+    }
+    toss("Unhandled signature IR:",s);
+  };
+
+  const affirmBigIntArray = BigInt64Array
+        ? ()=>true : ()=>toss('BigInt64Array is not available.');
+  /** Returns the name of a DataView getter method corresponding
+      to the given SIG. */
+  const sigDVGetter = function(s){
+    switch(sigLetter(s)) {
+        case 'p': case 'P': case 's': {
+          switch(ptrSizeof){
+              case 4: return 'getInt32';
+              case 8: return affirmBigIntArray() && 'getBigInt64';
+          }
+          break;
+        }
+        case 'i': return 'getInt32';
+        case 'c': return 'getInt8';
+        case 'C': return 'getUint8';
+        case 'j': return affirmBigIntArray() && 'getBigInt64';
+        case 'f': return 'getFloat32';
+        case 'd': return 'getFloat64';
+    }
+    toss("Unhandled DataView getter for signature:",s);
+  };
+  /** Returns the name of a DataView setter method corresponding
+      to the given SIG. */
+  const sigDVSetter = function(s){
+    switch(sigLetter(s)){
+        case 'p': case 'P': case 's': {
+          switch(ptrSizeof){
+              case 4: return 'setInt32';
+              case 8: return affirmBigIntArray() && 'setBigInt64';
+          }
+          break;
+        }
+        case 'i': return 'setInt32';
+        case 'c': return 'setInt8';
+        case 'C': return 'setUint8';
+        case 'j': return affirmBigIntArray() && 'setBigInt64';
+        case 'f': return 'setFloat32';
+        case 'd': return 'setFloat64';
+    }
+    toss("Unhandled DataView setter for signature:",s);
+  };
+  /**
+     Returns either Number of BigInt, depending on the given
+     SIG. This constructor is used in property setters to coerce
+     the being-set value to the correct size.
+  */
+  const sigDVSetWrapper = function(s){
+    switch(sigLetter(s)) {
+        case 'i': case 'f': case 'c': case 'C': case 'd': return Number;
+        case 'j': return affirmBigIntArray() && BigInt;
+        case 'p': case 'P': case 's':
+          switch(ptrSizeof){
+              case 4: return Number;
+              case 8: return affirmBigIntArray() && BigInt;
+          }
+          break;
+    }
+    toss("Unhandled DataView set wrapper for signature:",s);
+  };
+
+  /** Returns the given struct and member name in a form suitable for
+      debugging and error output. */
+  const sPropName = (s,k)=>s+'::'+k;
+
+  const __propThrowOnSet = function(structName,propName){
+    return ()=>toss(sPropName(structName,propName),"is read-only.");
+  };
+
+  /**
+     In order to completely hide StructBinder-bound struct
+     pointers from JS code, we store them in a scope-local
+     WeakMap which maps the struct-bound objects to their WASM
+     pointers. The pointers are accessible via
+     boundObject.pointer, which is gated behind an accessor
+     function, but are not exposed anywhere else in the
+     object. The main intention of that is to make it impossible
+     for stale copies to be made.
+  */
+  const __instancePointerMap = new WeakMap();
+
+  /** Property name for the pointer-is-external marker. */
+  const xPtrPropName = '(pointer-is-external)';
+
+  /** Frees the obj.pointer memory and clears the pointer
+      property. */
+  const __freeStruct = function(ctor, obj, m){
+    if(!m) m = __instancePointerMap.get(obj);
+    if(m) {
+      __instancePointerMap.delete(obj);
+      if(Array.isArray(obj.ondispose)){
+        let x;
+        while((x = obj.ondispose.shift())){
+          try{
+            if(x instanceof Function) x.call(obj);
+            else if(x instanceof StructType) x.dispose();
+            else if('number' === typeof x) dealloc(x);
+            // else ignore. Strings are permitted to annotate entries
+            // to assist in debugging.
+          }catch(e){
+            console.warn("ondispose() for",ctor.structName,'@',
+                         m,'threw. NOT propagating it.',e);
+          }
+        }
+      }else if(obj.ondispose instanceof Function){
+        try{obj.ondispose()}
+        catch(e){
+          /*do not rethrow: destructors must not throw*/
+          console.warn("ondispose() for",ctor.structName,'@',
+                       m,'threw. NOT propagating it.',e);
+        }
+      }
+      delete obj.ondispose;
+      if(ctor.debugFlags.__flags.dealloc){
+        log("debug.dealloc:",(obj[xPtrPropName]?"EXTERNAL":""),
+            ctor.structName,"instance:",
+            ctor.structInfo.sizeof,"bytes @"+m);
+      }
+      if(!obj[xPtrPropName]) dealloc(m);
+    }
+  };
+
+  /** Returns a skeleton for a read-only property accessor wrapping
+      value v. */
+  const rop = (v)=>{return {configurable: false, writable: false,
+                            iterable: false, value: v}};
+
+  /** Allocates obj's memory buffer based on the size defined in
+      ctor.structInfo.sizeof. */
+  const __allocStruct = function(ctor, obj, m){
+    let fill = !m;
+    if(m) Object.defineProperty(obj, xPtrPropName, rop(m));
+    else{
+      m = alloc(ctor.structInfo.sizeof);
+      if(!m) toss("Allocation of",ctor.structName,"structure failed.");
+    }
+    try {
+      if(ctor.debugFlags.__flags.alloc){
+        log("debug.alloc:",(fill?"":"EXTERNAL"),
+            ctor.structName,"instance:",
+            ctor.structInfo.sizeof,"bytes @"+m);
+      }
+      if(fill) heap().fill(0, m, m + ctor.structInfo.sizeof);
+      __instancePointerMap.set(obj, m);
+    }catch(e){
+      __freeStruct(ctor, obj, m);
+      throw e;
+    }
+  };
+  /** Gets installed as the memoryDump() method of all structs. */
+  const __memoryDump = function(){
+    const p = this.pointer;
+    return p
+      ? new Uint8Array(heap().slice(p, p+this.structInfo.sizeof))
+      : null;
+  };
+
+  const __memberKey = (k)=>memberPrefix + k + memberSuffix;
+  const __memberKeyProp = rop(__memberKey);
+
+  /**
+     Looks up a struct member in structInfo.members. Throws if found
+     if tossIfNotFound is true, else returns undefined if not
+     found. The given name may be either the name of the
+     structInfo.members key (faster) or the key as modified by the
+     memberPrefix and memberSuffix settings.
+  */
+  const __lookupMember = function(structInfo, memberName, tossIfNotFound=true){
+    let m = structInfo.members[memberName];
+    if(!m && (memberPrefix || memberSuffix)){
+      // Check for a match on members[X].key
+      for(const v of Object.values(structInfo.members)){
+        if(v.key===memberName){ m = v; break; }
+      }
+      if(!m && tossIfNotFound){
+        toss(sPropName(structInfo.name,memberName),'is not a mapped struct member.');
+      }
+    }
+    return m;
+  };
+
+  /**
+     Uses __lookupMember(obj.structInfo,memberName) to find a member,
+     throwing if not found. Returns its signature, either in this
+     framework's native format or in Emscripten format.
+  */
+  const __memberSignature = function f(obj,memberName,emscriptenFormat=false){
+    if(!f._) f._ = (x)=>x.replace(/[^vipPsjrdcC]/g,"").replace(/[pPscC]/g,'i');
+    const m = __lookupMember(obj.structInfo, memberName, true);
+    return emscriptenFormat ? f._(m.signature) : m.signature;
+  };
+
+  const __ptrPropDescriptor = {
+    configurable: false, enumerable: false,
+    get: function(){return __instancePointerMap.get(this)},
+    set: ()=>toss("Cannot assign the 'pointer' property of a struct.")
+    // Reminder: leaving `set` undefined makes assignments
+    // to the property _silently_ do nothing. Current unit tests
+    // rely on it throwing, though.
+  };
+
+  /** Impl of X.memberKeys() for StructType and struct ctors. */
+  const __structMemberKeys = rop(function(){
+    const a = [];
+    for(const k of Object.keys(this.structInfo.members)){
+      a.push(this.memberKey(k));
+    }
+    return a;
+  });
+
+  const __utf8Decoder = new TextDecoder('utf-8');
+  const __utf8Encoder = new TextEncoder();
+  /** Internal helper to use in operations which need to distinguish
+      between SharedArrayBuffer heap memory and non-shared heap. */
+  const __SAB = ('undefined'===typeof SharedArrayBuffer)
+        ? function(){} : SharedArrayBuffer;
+  const __utf8Decode = function(arrayBuffer, begin, end){
+    return __utf8Decoder.decode(
+      (arrayBuffer.buffer instanceof __SAB)
+        ? arrayBuffer.slice(begin, end)
+        : arrayBuffer.subarray(begin, end)
+    );
+  };
+  /**
+     Uses __lookupMember() to find the given obj.structInfo key.
+     Returns that member if it is a string, else returns false. If the
+     member is not found, throws if tossIfNotFound is true, else
+     returns false.
+   */
+  const __memberIsString = function(obj,memberName, tossIfNotFound=false){
+    const m = __lookupMember(obj.structInfo, memberName, tossIfNotFound);
+    return (m && 1===m.signature.length && 's'===m.signature[0]) ? m : false;
+  };
+
+  /**
+     Given a member description object, throws if member.signature is
+     not valid for assigning to or interpretation as a C-style string.
+     It optimistically assumes that any signature of (i,p,s) is
+     C-string compatible.
+  */
+  const __affirmCStringSignature = function(member){
+    if('s'===member.signature) return;
+    toss("Invalid member type signature for C-string value:",
+         JSON.stringify(member));
+  };
+
+  /**
+     Looks up the given member in obj.structInfo. If it has a
+     signature of 's' then it is assumed to be a C-style UTF-8 string
+     and a decoded copy of the string at its address is returned. If
+     the signature is of any other type, it throws. If an s-type
+     member's address is 0, `null` is returned.
+  */
+  const __memberToJsString = function f(obj,memberName){
+    const m = __lookupMember(obj.structInfo, memberName, true);
+    __affirmCStringSignature(m);
+    const addr = obj[m.key];
+    //log("addr =",addr,memberName,"m =",m);
+    if(!addr) return null;
+    let pos = addr;
+    const mem = heap();
+    for( ; mem[pos]!==0; ++pos ) {
+      //log("mem[",pos,"]",mem[pos]);
+    };
+    //log("addr =",addr,"pos =",pos);
+    return (addr===pos) ? "" : __utf8Decode(mem, addr, pos);
+  };
+
+  /**
+     Adds value v to obj.ondispose, creating ondispose,
+     or converting it to an array, if needed.
+  */
+  const __addOnDispose = function(obj, ...v){
+    if(obj.ondispose){
+      if(!Array.isArray(obj.ondispose)){
+        obj.ondispose = [obj.ondispose];
+      }
+    }else{
+      obj.ondispose = [];
+    }
+    obj.ondispose.push(...v);
+  };
+
+  /**
+     Allocates a new UTF-8-encoded, NUL-terminated copy of the given
+     JS string and returns its address relative to heap(). If
+     allocation returns 0 this function throws. Ownership of the
+     memory is transfered to the caller, who must eventually pass it
+     to the configured dealloc() function.
+  */
+  const __allocCString = function(str){
+    const u = __utf8Encoder.encode(str);
+    const mem = alloc(u.length+1);
+    if(!mem) toss("Allocation error while duplicating string:",str);
+    const h = heap();
+    //let i = 0;
+    //for( ; i < u.length; ++i ) h[mem + i] = u[i];
+    h.set(u, mem);
+    h[mem + u.length] = 0;
+    //log("allocCString @",mem," =",u);
+    return mem;
+  };
+
+  /**
+     Sets the given struct member of obj to a dynamically-allocated,
+     UTF-8-encoded, NUL-terminated copy of str. It is up to the caller
+     to free any prior memory, if appropriate. The newly-allocated
+     string is added to obj.ondispose so will be freed when the object
+     is disposed.
+
+     The given name may be either the name of the structInfo.members
+     key (faster) or the key as modified by the memberPrefix and
+     memberSuffix settings.
+  */
+  const __setMemberCString = function(obj, memberName, str){
+    const m = __lookupMember(obj.structInfo, memberName, true);
+    __affirmCStringSignature(m);
+    /* Potential TODO: if obj.ondispose contains obj[m.key] then
+       dealloc that value and clear that ondispose entry */
+    const mem = __allocCString(str);
+    obj[m.key] = mem;
+    __addOnDispose(obj, mem);
+    return obj;
+  };
+
+  /**
+     Prototype for all StructFactory instances (the constructors
+     returned from StructBinder).
+  */
+  const StructType = function ctor(structName, structInfo){
+    if(arguments[2]!==rop){
+      toss("Do not call the StructType constructor",
+           "from client-level code.");
+    }
+    Object.defineProperties(this,{
+      //isA: rop((v)=>v instanceof ctor),
+      structName: rop(structName),
+      structInfo: rop(structInfo)
+    });
+  };
+
+  /**
+     Properties inherited by struct-type-specific StructType instances
+     and (indirectly) concrete struct-type instances.
+  */
+  StructType.prototype = Object.create(null, {
+    dispose: rop(function(){__freeStruct(this.constructor, this)}),
+    lookupMember: rop(function(memberName, tossIfNotFound=true){
+      return __lookupMember(this.structInfo, memberName, tossIfNotFound);
+    }),
+    memberToJsString: rop(function(memberName){
+      return __memberToJsString(this, memberName);
+    }),
+    memberIsString: rop(function(memberName, tossIfNotFound=true){
+      return __memberIsString(this, memberName, tossIfNotFound);
+    }),
+    memberKey: __memberKeyProp,
+    memberKeys: __structMemberKeys,
+    memberSignature: rop(function(memberName, emscriptenFormat=false){
+      return __memberSignature(this, memberName, emscriptenFormat);
+    }),
+    memoryDump: rop(__memoryDump),
+    pointer: __ptrPropDescriptor,
+    setMemberCString: rop(function(memberName, str){
+      return __setMemberCString(this, memberName, str);
+    })
+  });
+  // Function-type non-Property inherited members 
+  Object.assign(StructType.prototype,{
+    addOnDispose: function(...v){
+      __addOnDispose(this,...v);
+      return this;
+    }
+  });
+
+  /**
+     "Static" properties for StructType.
+  */
+  Object.defineProperties(StructType, {
+    allocCString: rop(__allocCString),
+    isA: rop((v)=>v instanceof StructType),
+    hasExternalPointer: rop((v)=>(v instanceof StructType) && !!v[xPtrPropName]),
+    memberKey: __memberKeyProp
+  });
+
+  const isNumericValue = (v)=>Number.isFinite(v) || (v instanceof (BigInt || Number));
+
+  /**
+     Pass this a StructBinder-generated prototype, and the struct
+     member description object. It will define property accessors for
+     proto[memberKey] which read from/write to memory in
+     this.pointer. It modifies descr to make certain downstream
+     operations much simpler.
+  */
+  const makeMemberWrapper = function f(ctor,name, descr){
+    if(!f._){
+      /*cache all available getters/setters/set-wrappers for
+        direct reuse in each accessor function. */
+      f._ = {getters: {}, setters: {}, sw:{}};
+      const a = ['i','c','C','p','P','s','f','d','v()'];
+      if(bigIntEnabled) a.push('j');
+      a.forEach(function(v){
+        //const ir = sigIR(v);
+        f._.getters[v] = sigDVGetter(v) /* DataView[MethodName] values for GETTERS */;
+        f._.setters[v] = sigDVSetter(v) /* DataView[MethodName] values for SETTERS */;
+        f._.sw[v] = sigDVSetWrapper(v)  /* BigInt or Number ctor to wrap around values
+                                           for conversion */;
+      });
+      const rxSig1 = /^[ipPsjfdcC]$/,
+            rxSig2 = /^[vipPsjfdcC]\([ipPsjfdcC]*\)$/;
+      f.sigCheck = function(obj, name, key,sig){
+        if(Object.prototype.hasOwnProperty.call(obj, key)){
+          toss(obj.structName,'already has a property named',key+'.');
+        }
+        rxSig1.test(sig) || rxSig2.test(sig)
+          || toss("Malformed signature for",
+                  sPropName(obj.structName,name)+":",sig);
+      };
+    }
+    const key = ctor.memberKey(name);
+    f.sigCheck(ctor.prototype, name, key, descr.signature);
+    descr.key = key;
+    descr.name = name;
+    const sigGlyph = sigLetter(descr.signature);
+    const xPropName = sPropName(ctor.prototype.structName,key);
+    const dbg = ctor.prototype.debugFlags.__flags;
+    /*
+      TODO?: set prototype of descr to an object which can set/fetch
+      its prefered representation, e.g. conversion to string or mapped
+      function. Advantage: we can avoid doing that via if/else if/else
+      in the get/set methods.
+    */
+    const prop = Object.create(null);
+    prop.configurable = false;
+    prop.enumerable = false;
+    prop.get = function(){
+      if(dbg.getter){
+        log("debug.getter:",f._.getters[sigGlyph],"for", sigIR(sigGlyph),
+            xPropName,'@', this.pointer,'+',descr.offset,'sz',descr.sizeof);
+      }
+      let rc = (
+        new DataView(heap().buffer, this.pointer + descr.offset, descr.sizeof)
+      )[f._.getters[sigGlyph]](0, isLittleEndian);
+      if(dbg.getter) log("debug.getter:",xPropName,"result =",rc);
+      return rc;
+    };
+    if(descr.readOnly){
+      prop.set = __propThrowOnSet(ctor.prototype.structName,key);
+    }else{
+      prop.set = function(v){
+        if(dbg.setter){
+          log("debug.setter:",f._.setters[sigGlyph],"for", sigIR(sigGlyph),
+              xPropName,'@', this.pointer,'+',descr.offset,'sz',descr.sizeof, v);
+        }
+        if(!this.pointer){
+          toss("Cannot set struct property on disposed instance.");
+        }
+        if(null===v) v = 0;
+        else while(!isNumericValue(v)){
+          if(isAutoPtrSig(descr.signature) && (v instanceof StructType)){
+            // It's a struct instance: let's store its pointer value!
+            v = v.pointer || 0;
+            if(dbg.setter) log("debug.setter:",xPropName,"resolved to",v);
+            break;
+          }
+          toss("Invalid value for pointer-type",xPropName+'.');
+        }
+        (
+          new DataView(heap().buffer, this.pointer + descr.offset, descr.sizeof)
+        )[f._.setters[sigGlyph]](0, f._.sw[sigGlyph](v), isLittleEndian);
+      };
+    }
+    Object.defineProperty(ctor.prototype, key, prop);
+  }/*makeMemberWrapper*/;
+  
+  /**
+     The main factory function which will be returned to the
+     caller.
+  */
+  const StructBinder = function StructBinder(structName, structInfo){
+    if(1===arguments.length){
+      structInfo = structName;
+      structName = structInfo.name;
+    }else if(!structInfo.name){
+      structInfo.name = structName;
+    }
+    if(!structName) toss("Struct name is required.");
+    let lastMember = false;
+    Object.keys(structInfo.members).forEach((k)=>{
+      // Sanity checks of sizeof/offset info...
+      const m = structInfo.members[k];
+      if(!m.sizeof) toss(structName,"member",k,"is missing sizeof.");
+      else if(m.sizeof===1){
+        (m.signature === 'c' || m.signature === 'C') ||
+          toss("Unexpected sizeof==1 member",
+               sPropName(structInfo.name,k),
+               "with signature",m.signature);
+      }else{
+        // sizes and offsets of size-1 members may be odd values, but
+        // others may not.
+        if(0!==(m.sizeof%4)){
+          console.warn("Invalid struct member description =",m,"from",structInfo);
+          toss(structName,"member",k,"sizeof is not aligned. sizeof="+m.sizeof);
+        }
+        if(0!==(m.offset%4)){
+          console.warn("Invalid struct member description =",m,"from",structInfo);
+          toss(structName,"member",k,"offset is not aligned. offset="+m.offset);
+        }
+      }
+      if(!lastMember || lastMember.offset < m.offset) lastMember = m;
+    });
+    if(!lastMember) toss("No member property descriptions found.");
+    else if(structInfo.sizeof < lastMember.offset+lastMember.sizeof){
+      toss("Invalid struct config:",structName,
+           "max member offset ("+lastMember.offset+") ",
+           "extends past end of struct (sizeof="+structInfo.sizeof+").");
+    }
+    const debugFlags = rop(SBF.__makeDebugFlags(StructBinder.debugFlags));
+    /** Constructor for the StructCtor. */
+    const StructCtor = function StructCtor(externalMemory){
+      if(!(this instanceof StructCtor)){
+        toss("The",structName,"constructor may only be called via 'new'.");
+      }else if(arguments.length){
+        if(externalMemory!==(externalMemory|0) || externalMemory<=0){
+          toss("Invalid pointer value for",structName,"constructor.");
+        }
+        __allocStruct(StructCtor, this, externalMemory);
+      }else{
+        __allocStruct(StructCtor, this);
+      }
+    };
+    Object.defineProperties(StructCtor,{
+      debugFlags: debugFlags,
+      isA: rop((v)=>v instanceof StructCtor),
+      memberKey: __memberKeyProp,
+      memberKeys: __structMemberKeys,
+      methodInfoForKey: rop(function(mKey){
+      }),
+      structInfo: rop(structInfo),
+      structName: rop(structName)
+    });
+    StructCtor.prototype = new StructType(structName, structInfo, rop);
+    Object.defineProperties(StructCtor.prototype,{
+      debugFlags: debugFlags,
+      constructor: rop(StructCtor)
+      /*if we assign StructCtor.prototype and don't do
+        this then StructCtor!==instance.constructor!*/
+    });
+    Object.keys(structInfo.members).forEach(
+      (name)=>makeMemberWrapper(StructCtor, name, structInfo.members[name])
+    );
+    return StructCtor;
+  };
+  StructBinder.StructType = StructType;
+  StructBinder.config = config;
+  StructBinder.allocCString = __allocCString;
+  if(!StructBinder.debugFlags){
+    StructBinder.debugFlags = SBF.__makeDebugFlags(SBF.debugFlags);
+  }
+  return StructBinder;
+}/*StructBinderFactory*/;