@swmansion/popcorn 0.2.0-rc.1 → 0.2.0-rc.2

package/dist/AtomVM.mjs

@@ -1,48 +1,10 @@
-// This code implements the `-sMODULARIZE` settings by taking the generated
-// JS program code (INNER_JS_CODE) and wrapping it in a factory function.
-
-// When targetting node and ES6 we use `await import ..` in the generated code
-// so the outer function needs to be marked as async.
-async function Module(moduleArg = {}) {
+var Module = (() => {
+  
+  return (
+async function(moduleArg = {}) {
   var moduleRtn;
 
 // include: shell.js
-// include: minimum_runtime_check.js
-(function() {
-  // "30.0.0" -> 300000
-  function humanReadableVersionToPacked(str) {
-    str = str.split("-")[0];
-    // Remove any trailing part from e.g. "12.53.3-alpha"
-    var vers = str.split(".").slice(0, 3);
-    while (vers.length < 3) vers.push("00");
-    vers = vers.map((n, i, arr) => n.padStart(2, "0"));
-    return vers.join("");
-  }
-  // 300000 -> "30.0.0"
-  var packedVersionToHumanReadable = n => [ n / 1e4 | 0, (n / 100 | 0) % 100, n % 100 ].join(".");
-  var TARGET_NOT_SUPPORTED = 2147483647;
-  var currentNodeVersion = typeof process !== "undefined" && process?.versions?.node ? humanReadableVersionToPacked(process.versions.node) : TARGET_NOT_SUPPORTED;
-  if (currentNodeVersion < TARGET_NOT_SUPPORTED) {
-    throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
-  }
-  if (currentNodeVersion < 2147483647) {
-    throw new Error(`This emscripten-generated code requires node v${packedVersionToHumanReadable(2147483647)} (detected v${packedVersionToHumanReadable(currentNodeVersion)})`);
-  }
-  var currentSafariVersion = typeof navigator !== "undefined" && navigator?.userAgent?.includes("Safari/") && navigator.userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/) ? humanReadableVersionToPacked(navigator.userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/)[1]) : TARGET_NOT_SUPPORTED;
-  if (currentSafariVersion < 15e4) {
-    throw new Error(`This emscripten-generated code requires Safari v${packedVersionToHumanReadable(15e4)} (detected v${currentSafariVersion})`);
-  }
-  var currentFirefoxVersion = typeof navigator !== "undefined" && navigator?.userAgent?.match(/Firefox\/(\d+(?:\.\d+)?)/) ? parseFloat(navigator.userAgent.match(/Firefox\/(\d+(?:\.\d+)?)/)[1]) : TARGET_NOT_SUPPORTED;
-  if (currentFirefoxVersion < 114) {
-    throw new Error(`This emscripten-generated code requires Firefox v114 (detected v${currentFirefoxVersion})`);
-  }
-  var currentChromeVersion = typeof navigator !== "undefined" && navigator?.userAgent?.match(/Chrome\/(\d+(?:\.\d+)?)/) ? parseFloat(navigator.userAgent.match(/Chrome\/(\d+(?:\.\d+)?)/)[1]) : TARGET_NOT_SUPPORTED;
-  if (currentChromeVersion < 85) {
-    throw new Error(`This emscripten-generated code requires Chrome v85 (detected v${currentChromeVersion})`);
-  }
-})();
-
-// end include: minimum_runtime_check.js
 // The Module object: Our interface to the outside world. We import
 // and export values on it. There are various ways Module can be used:
 // 1. Not defined. We create it here
@@ -58,16 +20,24 @@ async function Module(moduleArg = {}) {
 // can continue to use Module afterwards as well.
 var Module = moduleArg;
 
+// Set up the promise that indicates the Module is initialized
+var readyPromiseResolve, readyPromiseReject;
+
+var readyPromise = new Promise((resolve, reject) => {
+  readyPromiseResolve = resolve;
+  readyPromiseReject = reject;
+});
+
 // Determine the runtime environment we are in. You can customize this by
 // setting the ENVIRONMENT setting at compile time (see settings.js).
 // Attempt to auto-detect the environment
-var ENVIRONMENT_IS_WEB = !!globalThis.window;
+var ENVIRONMENT_IS_WEB = typeof window == "object";
 
-var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
 
 // N.b. Electron.js environment is simultaneously a NODE-environment, but
 // also a web environment.
-var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
+var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
 
 var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
 
@@ -86,7 +56,7 @@ if (ENVIRONMENT_IS_PTHREAD) {
 
 // --pre-jses are emitted after the Module integration code, so that they can
 // refer to Module (if they choose; they can also define Module)
-// include: /var/folders/49/x629zf3j4jd1nq2_dndmhc340000gn/T/popcorn-swm.ANkseGitYY/atomvm/src/platforms/emscripten/src/atomvm.pre.js
+// include: /tmp/popcorn-swm.J66P2Dx/atomvm/src/platforms/emscripten/src/atomvm.pre.js
 /*
  * This file is part of AtomVM.
  *
@@ -158,7 +128,7 @@ function ensureValidResult(result) {
   throw new Error(message);
 }
 
-// end include: /var/folders/49/x629zf3j4jd1nq2_dndmhc340000gn/T/popcorn-swm.ANkseGitYY/atomvm/src/platforms/emscripten/src/atomvm.pre.js
+// end include: /tmp/popcorn-swm.J66P2Dx/atomvm/src/platforms/emscripten/src/atomvm.pre.js
 var arguments_ = [];
 
 var thisProgram = "./this.program";
@@ -182,14 +152,16 @@ function locateFile(path) {
 // Hooks that are implemented differently in different runtime environments.
 var readAsync, readBinary;
 
-if (ENVIRONMENT_IS_SHELL) ; else // Note that this includes Node.js workers when relevant (pthreads is enabled).
+if (ENVIRONMENT_IS_SHELL) {
+  if ((typeof process == "object" && typeof require === "function") || typeof window == "object" || typeof WorkerGlobalScope != "undefined") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
+} else // Note that this includes Node.js workers when relevant (pthreads is enabled).
 // Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
 // ENVIRONMENT_IS_NODE.
 if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
   try {
     scriptDirectory = new URL(".", _scriptName).href;
   } catch {}
-  if (!(globalThis.window || globalThis.WorkerGlobalScope)) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
+  if (!(typeof window == "object" || typeof WorkerGlobalScope != "undefined")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
   {
     // include: web_or_worker_shell_read.js
     if (ENVIRONMENT_IS_WORKER) {
@@ -220,6 +192,8 @@ var out = console.log.bind(console);
 
 var err = console.error.bind(console);
 
+var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";
+
 // perform assertions in shell.js after we set up out() and err(), as otherwise
 // if an assertion fails it cannot print the message
 assert(ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_NODE, "Pthreads do not work in this environment yet (need Web Workers, or an alternative to them)");
@@ -240,11 +214,13 @@ assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at bui
 //    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
 var wasmBinary;
 
-if (!globalThis.WebAssembly) {
+if (typeof WebAssembly != "object") {
   err("no native wasm support detected");
 }
 
 // Wasm globals
+var wasmMemory;
+
 // For sending to workers.
 var wasmModule;
 
@@ -272,12 +248,18 @@ var EXITSTATUS;
 
 // We used to include malloc/free by default in the past. Show a helpful error in
 // builds with assertions.
+// Memory management
+var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /* BigInt64Array type is not correctly defined in closure
+/** not-@type {!BigInt64Array} */ HEAP64, /** @type {!Float64Array} */ HEAPF64;
+
+var runtimeInitialized = false;
+
 /**
  * Indicates whether filename is delivered via file protocol (as opposed to http/https)
  * @noinline
  */ var isFileURI = filename => filename.startsWith("file://");
 
-// include: runtime_common.js
+// include: runtime_shared.js
 // include: runtime_stack_check.js
 // Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
 function writeStackCookie() {
@@ -292,9 +274,9 @@ function writeStackCookie() {
   // The stack grow downwards towards _emscripten_stack_get_end.
   // We write cookies to the final two words in the stack and detect if they are
   // ever overwritten.
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((max) >> 2), "storing")] = 34821223;
+  SAFE_HEAP_STORE(((max) >> 2) * 4, 34821223, 4);
   checkInt32(34821223);
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((max) + (4)) >> 2), "storing")] = 2310721022;
+  SAFE_HEAP_STORE((((max) + (4)) >> 2) * 4, 2310721022, 4);
   checkInt32(2310721022);
 }
 
@@ -305,8 +287,8 @@ function checkStackCookie() {
   if (max == 0) {
     max += 4;
   }
-  var cookie1 = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((max) >> 2), "loading")];
-  var cookie2 = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((max) + (4)) >> 2), "loading")];
+  var cookie1 = SAFE_HEAP_LOAD(((max) >> 2) * 4, 4, 1);
+  var cookie2 = SAFE_HEAP_LOAD((((max) + (4)) >> 2) * 4, 4, 1);
   if (cookie1 != 34821223 || cookie2 != 2310721022) {
     abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
   }
@@ -325,7 +307,7 @@ function dbg(...args) {
   var h16 = new Int16Array(1);
   var h8 = new Int8Array(h16.buffer);
   h16[0] = 25459;
-  if (h8[0] !== 115 || h8[1] !== 99) abort("Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)");
+  if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";
 })();
 
 function consumedModuleProp(prop) {
@@ -339,10 +321,6 @@ function consumedModuleProp(prop) {
   }
 }
 
-function makeInvalidEarlyAccess(name) {
-  return () => assert(false, `call to '${name}' via reference taken before Wasm module initialization`);
-}
-
 function ignoredModuleProp(prop) {
   if (Object.getOwnPropertyDescriptor(Module, prop)) {
     abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
@@ -351,11 +329,54 @@ function ignoredModuleProp(prop) {
 
 // forcing the filesystem exports a few things by default
 function isExportedByForceFilesystem(name) {
-  return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_preloadFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
+  return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
   name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
 }
 
+/**
+ * Intercept access to a global symbol.  This enables us to give informative
+ * warnings/errors when folks attempt to use symbols they did not include in
+ * their build, or no symbols that no longer exist.
+ */ function hookGlobalSymbolAccess(sym, func) {
+  if (typeof globalThis != "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
+    Object.defineProperty(globalThis, sym, {
+      configurable: true,
+      get() {
+        func();
+        return undefined;
+      }
+    });
+  }
+}
+
+function missingGlobal(sym, msg) {
+  hookGlobalSymbolAccess(sym, () => {
+    warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);
+  });
+}
+
+missingGlobal("buffer", "Please use HEAP8.buffer or wasmMemory.buffer");
+
+missingGlobal("asm", "Please use wasmExports instead");
+
 function missingLibrarySymbol(sym) {
+  hookGlobalSymbolAccess(sym, () => {
+    // Can't `abort()` here because it would break code that does runtime
+    // checks.  e.g. `if (typeof SDL === 'undefined')`.
+    var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;
+    // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in
+    // library.js, which means $name for a JS name with no prefix, or name
+    // for a JS name like _name.
+    var librarySymbol = sym;
+    if (!librarySymbol.startsWith("_")) {
+      librarySymbol = "$" + sym;
+    }
+    msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;
+    if (isExportedByForceFilesystem(sym)) {
+      msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
+    }
+    warnOnce(msg);
+  });
   // Any symbol that is not included from the JS library is also (by definition)
   // not exported on the Module object.
   unexportedRuntimeSymbol(sym);
@@ -427,19 +448,64 @@ var checkInt32 = value => checkInt(value, 32, MIN_INT32, MAX_UINT32);
 var checkInt64 = value => checkInt(value, 64, MIN_INT64, MAX_UINT64);
 
 // end include: runtime_debug.js
+// include: memoryprofiler.js
+// end include: memoryprofiler.js
 // include: runtime_safe_heap.js
-function SAFE_HEAP_INDEX(arr, idx, action) {
-  const bytes = arr.BYTES_PER_ELEMENT;
-  const dest = idx * bytes;
-  if (idx <= 0) abort(`segmentation fault ${action} ${bytes} bytes at address ${dest}`);
+/** @param {number|boolean=} isFloat */ function getSafeHeapType(bytes, isFloat) {
+  switch (bytes) {
+   case 1:
+    return "i8";
+
+   case 2:
+    return "i16";
+
+   case 4:
+    return isFloat ? "float" : "i32";
+
+   case 8:
+    return isFloat ? "double" : "i64";
+
+   default:
+    abort(`getSafeHeapType() invalid bytes=${bytes}`);
+  }
+}
+
+/** @param {number|boolean=} isFloat */ function SAFE_HEAP_STORE(dest, value, bytes, isFloat) {
+  if (dest <= 0) abort(`segmentation fault storing ${bytes} bytes to address ${dest}`);
+  if (dest % bytes !== 0) abort(`alignment error storing to address ${dest}, which was expected to be aligned to a multiple of ${bytes}`);
   if (runtimeInitialized) {
     var brk = _sbrk(0);
-    if (dest + bytes > brk) abort(`segmentation fault, exceeded the top of the available dynamic heap when ${action} ${bytes} bytes at address ${dest}. DYNAMICTOP=${brk}`);
+    if (dest + bytes > brk) abort(`segmentation fault, exceeded the top of the available dynamic heap when storing ${bytes} bytes to address ${dest}. DYNAMICTOP=${brk}`);
     if (brk < _emscripten_stack_get_base()) abort(`brk >= _emscripten_stack_get_base() (brk=${brk}, _emscripten_stack_get_base()=${_emscripten_stack_get_base()})`);
     // sbrk-managed memory must be above the stack
     if (brk > wasmMemory.buffer.byteLength) abort(`brk <= wasmMemory.buffer.byteLength (brk=${brk}, wasmMemory.buffer.byteLength=${wasmMemory.buffer.byteLength})`);
   }
-  return idx;
+  setValue_safe(dest, value, getSafeHeapType(bytes, isFloat));
+  return value;
+}
+
+function SAFE_HEAP_STORE_D(dest, value, bytes) {
+  return SAFE_HEAP_STORE(dest, value, bytes, true);
+}
+
+/** @param {number|boolean=} isFloat */ function SAFE_HEAP_LOAD(dest, bytes, unsigned, isFloat) {
+  if (dest <= 0) abort(`segmentation fault loading ${bytes} bytes from address ${dest}`);
+  if (dest % bytes !== 0) abort(`alignment error loading from address ${dest}, which was expected to be aligned to a multiple of ${bytes}`);
+  if (runtimeInitialized) {
+    var brk = _sbrk(0);
+    if (dest + bytes > brk) abort(`segmentation fault, exceeded the top of the available dynamic heap when loading ${bytes} bytes from address ${dest}. DYNAMICTOP=${brk}`);
+    if (brk < _emscripten_stack_get_base()) abort(`brk >= _emscripten_stack_get_base() (brk=${brk}, _emscripten_stack_get_base()=${_emscripten_stack_get_base()})`);
+    // sbrk-managed memory must be above the stack
+    if (brk > wasmMemory.buffer.byteLength) abort(`brk <= wasmMemory.buffer.byteLength (brk=${brk}, wasmMemory.buffer.byteLength=${wasmMemory.buffer.byteLength})`);
+  }
+  var type = getSafeHeapType(bytes, isFloat);
+  var ret = getValue_safe(dest, type);
+  if (unsigned) ret = unSign(ret, parseInt(type.slice(1), 10));
+  return ret;
+}
+
+function SAFE_HEAP_LOAD_D(dest, bytes, unsigned) {
+  return SAFE_HEAP_LOAD(dest, bytes, unsigned, true);
 }
 
 function segfault() {
@@ -451,7 +517,7 @@ function alignfault() {
 }
 
 // end include: runtime_safe_heap.js
-var readyPromiseResolve, readyPromiseReject;
+var wasmModuleReceived;
 
 // include: runtime_pthread.js
 // Pthread Web Worker handling code.
@@ -461,8 +527,6 @@ var readyPromiseResolve, readyPromiseReject;
 // including the main thread).
 var workerID = 0;
 
-var startWorker;
-
 if (ENVIRONMENT_IS_PTHREAD) {
   // Thread-local guard variable for one-time init of the JS state
   var initializedJS = false;
@@ -483,7 +547,7 @@ if (ENVIRONMENT_IS_PTHREAD) {
         let messageQueue = [];
         self.onmessage = e => messageQueue.push(e);
         // And add a callback for when the runtime is initialized.
-        startWorker = () => {
+        self.startWorker = instance => {
           // Notify the main thread that this thread has loaded.
           postMessage({
             cmd: "loaded"
@@ -516,9 +580,7 @@ if (ENVIRONMENT_IS_PTHREAD) {
         }
         wasmMemory = msgData.wasmMemory;
         updateMemoryViews();
-        wasmModule = msgData.wasmModule;
-        createWasm();
-        run();
+        wasmModuleReceived(msgData.wasmModule);
       } else if (cmd === "run") {
         assert(msgData.pthread_ptr);
         // Call inside JS module to set up the stack frame for this pthread in JS module scope.
@@ -567,14 +629,6 @@ if (ENVIRONMENT_IS_PTHREAD) {
 
 // ENVIRONMENT_IS_PTHREAD
 // end include: runtime_pthread.js
-// Memory management
-var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float64Array} */ HEAPF64;
-
-// BigInt64Array type is not correctly defined in closure
-var /** not-@type {!BigInt64Array} */ HEAP64;
-
-var runtimeInitialized = false;
-
 function updateMemoryViews() {
   var b = wasmMemory.buffer;
   HEAP8 = new Int8Array(b);
@@ -582,16 +636,18 @@ function updateMemoryViews() {
   HEAPU8 = new Uint8Array(b);
   HEAP32 = new Int32Array(b);
   HEAPU32 = new Uint32Array(b);
+  HEAPF32 = new Float32Array(b);
   HEAPF64 = new Float64Array(b);
   HEAP64 = new BigInt64Array(b);
   new BigUint64Array(b);
 }
 
+// end include: runtime_shared.js
+assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, "JS engine does not provide full typed array support");
+
 // In non-standalone/normal mode, we create the memory here.
 // include: runtime_init_memory.js
 // Create the wasm memory. (Note: this only applies if IMPORTED_MEMORY is defined)
-var wasmMemory;
-
 // check for full engine support (use string 'subarray' to avoid closure compiler confusion)
 function initMemory() {
   if ((ENVIRONMENT_IS_PTHREAD)) {
@@ -612,11 +668,6 @@ function initMemory() {
 }
 
 // end include: runtime_init_memory.js
-// include: memoryprofiler.js
-// end include: memoryprofiler.js
-// end include: runtime_common.js
-assert(globalThis.Int32Array && globalThis.Float64Array && Int32Array.prototype.subarray && Int32Array.prototype.set, "JS engine does not provide full typed array support");
-
 function preRun() {
   assert(!ENVIRONMENT_IS_PTHREAD);
   // PThreads reuse the runtime from the main thread.
@@ -634,7 +685,7 @@ function preRun() {
 function initRuntime() {
   assert(!runtimeInitialized);
   runtimeInitialized = true;
-  if (ENVIRONMENT_IS_PTHREAD) return startWorker();
+  if (ENVIRONMENT_IS_PTHREAD) return startWorker(Module);
   checkStackCookie();
   // Begin ATINITS hooks
   if (!Module["noFSInit"] && !FS.initialized) FS.init();
@@ -666,6 +717,84 @@ function postRun() {
   callRuntimeCallbacks(onPostRuns);
 }
 
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// Module.preRun (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+
+var dependenciesFulfilled = null;
+
+// overridden to take different actions when all run dependencies are fulfilled
+var runDependencyTracking = {};
+
+var runDependencyWatcher = null;
+
+function getUniqueRunDependency(id) {
+  var orig = id;
+  while (1) {
+    if (!runDependencyTracking[id]) return id;
+    id = orig + Math.random();
+  }
+}
+
+function addRunDependency(id) {
+  runDependencies++;
+  Module["monitorRunDependencies"]?.(runDependencies);
+  if (id) {
+    assert(!runDependencyTracking[id]);
+    runDependencyTracking[id] = 1;
+    if (runDependencyWatcher === null && typeof setInterval != "undefined") {
+      // Check for missing dependencies every few seconds
+      runDependencyWatcher = setInterval(() => {
+        if (ABORT) {
+          clearInterval(runDependencyWatcher);
+          runDependencyWatcher = null;
+          return;
+        }
+        var shown = false;
+        for (var dep in runDependencyTracking) {
+          if (!shown) {
+            shown = true;
+            err("still waiting on run dependencies:");
+          }
+          err(`dependency: ${dep}`);
+        }
+        if (shown) {
+          err("(end of list)");
+        }
+      }, 1e4);
+    }
+  } else {
+    err("warning: run dependency added without ID");
+  }
+}
+
+function removeRunDependency(id) {
+  runDependencies--;
+  Module["monitorRunDependencies"]?.(runDependencies);
+  if (id) {
+    assert(runDependencyTracking[id]);
+    delete runDependencyTracking[id];
+  } else {
+    err("warning: run dependency removed without ID");
+  }
+  if (runDependencies == 0) {
+    if (runDependencyWatcher !== null) {
+      clearInterval(runDependencyWatcher);
+      runDependencyWatcher = null;
+    }
+    if (dependenciesFulfilled) {
+      var callback = dependenciesFulfilled;
+      dependenciesFulfilled = null;
+      callback();
+    }
+  }
+}
+
 /** @param {string|number=} what */ function abort(what) {
   Module["onAbort"]?.(what);
   what = "Aborted(" + what + ")";
@@ -686,7 +815,7 @@ function postRun() {
   // though it can.
   // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
   /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what);
-  readyPromiseReject?.(e);
+  readyPromiseReject(e);
   // Throw the error whether or not MODULARIZE is set because abort is used
   // in code paths apart from instantiation where an exception is expected
   // to be thrown when abort is called.
@@ -721,8 +850,6 @@ function getBinarySync(file) {
   if (readBinary) {
     return readBinary(file);
   }
-  // Throwing a plain string here, even though it not normally adviables since
-  // this gets turning into an `abort` in instantiateArrayBuffer.
   throw "both async and sync fetching of the wasm failed";
 }
 
@@ -747,15 +874,15 @@ async function instantiateArrayBuffer(binaryFile, imports) {
   } catch (reason) {
     err(`failed to asynchronously prepare wasm: ${reason}`);
     // Warn on some common problems.
-    if (isFileURI(binaryFile)) {
-      err(`warning: Loading from a file URI (${binaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
+    if (isFileURI(wasmBinaryFile)) {
+      err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
     }
     abort(reason);
   }
 }
 
 async function instantiateAsync(binary, binaryFile, imports) {
-  if (!binary) {
+  if (!binary && typeof WebAssembly.instantiateStreaming == "function") {
     try {
       var response = fetch(binaryFile, {
         credentials: "same-origin"
@@ -790,11 +917,13 @@ async function createWasm() {
   /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) {
     wasmExports = instance.exports;
     registerTLSInit(wasmExports["_emscripten_tls_init"]);
-    assignWasmExports(wasmExports);
     // We now have the Wasm module loaded up, keep a reference to the compiled module so we can post it to the workers.
     wasmModule = module;
+    removeRunDependency("wasm-instantiate");
     return wasmExports;
   }
+  // wait for the pthread pool (if any)
+  addRunDependency("wasm-instantiate");
   // Prefer streaming instantiation if available.
   // Async compilation can be confusing when an error on the page overwrites Module
   // (for example, if the order of elements is wrong, and the one defining Module is
@@ -817,8 +946,8 @@ async function createWasm() {
   if (Module["instantiateWasm"]) {
     return new Promise((resolve, reject) => {
       try {
-        Module["instantiateWasm"](info, (inst, mod) => {
-          resolve(receiveInstance(inst, mod));
+        Module["instantiateWasm"](info, (mod, inst) => {
+          resolve(receiveInstance(mod, inst));
         });
       } catch (e) {
         err(`Module.instantiateWasm callback failed with error: ${e}`);
@@ -827,16 +956,25 @@ async function createWasm() {
     });
   }
   if ((ENVIRONMENT_IS_PTHREAD)) {
-    // Instantiate from the module that was recieved via postMessage from
-    // the main thread. We can just use sync instantiation in the worker.
-    assert(wasmModule, "wasmModule should have been received via postMessage");
-    var instance = new WebAssembly.Instance(wasmModule, getWasmImports());
-    return receiveInstance(instance, wasmModule);
+    return new Promise(resolve => {
+      wasmModuleReceived = module => {
+        // Instantiate from the module posted from the main thread.
+        // We can just use sync instantiation in the worker.
+        var instance = new WebAssembly.Instance(module, getWasmImports());
+        resolve(receiveInstance(instance, module));
+      };
+    });
   }
   wasmBinaryFile ??= findWasmBinary();
-  var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
-  var exports$1 = receiveInstantiationResult(result);
-  return exports$1;
+  try {
+    var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+    var exports$1 = receiveInstantiationResult(result);
+    return exports$1;
+  } catch (e) {
+    // If instantiation fails, reject the module ready promise.
+    readyPromiseReject(e);
+    return Promise.reject(e);
+  }
 }
 
 // end include: preamble.js
@@ -940,15 +1078,15 @@ var stackAlloc = sz => __emscripten_stack_alloc(sz);
     var arg = callArgs[i];
     if (typeof arg == "bigint") {
       // The prefix is non-zero to indicate a bigint.
-      HEAP64[SAFE_HEAP_INDEX(HEAP64, b + 2 * i, "storing")] = 1n;
-      HEAP64[SAFE_HEAP_INDEX(HEAP64, b + 2 * i + 1, "storing")] = arg;
+      HEAP64[b + 2 * i] = 1n;
+      HEAP64[b + 2 * i + 1] = arg;
     } else {
       // The prefix is zero to indicate a JS Number.
-      HEAP64[SAFE_HEAP_INDEX(HEAP64, b + 2 * i, "storing")] = 0n;
-      HEAPF64[SAFE_HEAP_INDEX(HEAPF64, b + 2 * i + 1, "storing")] = arg;
+      HEAP64[b + 2 * i] = 0n;
+      SAFE_HEAP_STORE_D((b + 2 * i + 1) * 8, arg, 8);
     }
   }
-  var rtn = __emscripten_run_js_on_main_thread(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync);
+  var rtn = __emscripten_run_on_main_thread_js(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync);
   stackRestore(sp);
   return rtn;
 };
@@ -991,7 +1129,7 @@ function exitOnMainThread(returnCode) {
   // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down
   if (keepRuntimeAlive() && !implicit) {
     var msg = `program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`;
-    readyPromiseReject?.(msg);
+    readyPromiseReject(msg);
     err(msg);
   }
   _proc_exit(status);
@@ -1000,8 +1138,8 @@ function exitOnMainThread(returnCode) {
 var _exit = exitJS;
 
 var ptrToString = ptr => {
-  assert(typeof ptr === "number", `ptrToString expects a number, got ${typeof ptr}`);
-  // Convert to 32-bit unsigned value
+  assert(typeof ptr === "number");
+  // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
   ptr >>>= 0;
   return "0x" + ptr.toString(16).padStart(8, "0");
 };
@@ -1013,8 +1151,18 @@ var PThread = {
   pthreads: {},
   nextWorkerID: 1,
   init() {
+    if ((!(ENVIRONMENT_IS_PTHREAD))) {
+      PThread.initMainThread();
+    }
+  },
+  initMainThread() {
+    // MINIMAL_RUNTIME takes care of calling loadWasmModuleToAllWorkers
+    // in postamble_minimal.js
+    addOnPreRun(() => {
+      addRunDependency("loading-workers");
+      PThread.loadWasmModuleToAllWorkers(() => removeRunDependency("loading-workers"));
+    });
   },
-  initMainThread() {},
   terminateAllThreads: () => {
     assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! terminateAllThreads() can only ever be called from main application thread!");
     // Attempt to kill all workers.  Sadly (at least on the web) there is no
@@ -1079,10 +1227,7 @@ var PThread = {
       } else if (cmd === "spawnThread") {
         spawnThread(d);
       } else if (cmd === "cleanupThread") {
-        // cleanupThread needs to be run via callUserCallback since it calls
-        // back into user code to free thread data. Without this it's possible
-        // the unwind or ExitStatus exception could escape here.
-        callUserCallback(() => cleanupThread(d.thread));
+        cleanupThread(d.thread);
       } else if (cmd === "loaded") {
         worker.loaded = true;
         onFinishedLoading(worker);
@@ -1127,6 +1272,9 @@ var PThread = {
       "workerID": worker.workerID
     });
   }),
+  loadWasmModuleToAllWorkers(onMaybeReady) {
+    onMaybeReady();
+  },
   allocateUnusedWorker() {
     var worker;
     // If we're using module output, use bundler-friendly pattern.
@@ -1169,9 +1317,9 @@ var onPostRuns = [];
 
 var addOnPostRun = cb => onPostRuns.push(cb);
 
-function establishStackSpace(pthread_ptr) {
-  var stackHigh = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((pthread_ptr) + (52)) >> 2), "loading")];
-  var stackSize = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((pthread_ptr) + (56)) >> 2), "loading")];
+var establishStackSpace = pthread_ptr => {
+  var stackHigh = SAFE_HEAP_LOAD((((pthread_ptr) + (52)) >> 2) * 4, 4, 1);
+  var stackSize = SAFE_HEAP_LOAD((((pthread_ptr) + (56)) >> 2) * 4, 4, 1);
   var stackLow = stackHigh - stackSize;
   assert(stackHigh != 0);
   assert(stackLow != 0);
@@ -1184,6 +1332,38 @@ function establishStackSpace(pthread_ptr) {
   // Write the stack cookie last, after we have set up the proper bounds and
   // current position of the stack.
   writeStackCookie();
+};
+
+function getValue_safe(ptr, type = "i8") {
+  if (type.endsWith("*")) type = "*";
+  switch (type) {
+   case "i1":
+    return HEAP8[ptr];
+
+   case "i8":
+    return HEAP8[ptr];
+
+   case "i16":
+    return HEAP16[((ptr) >> 1)];
+
+   case "i32":
+    return HEAP32[((ptr) >> 2)];
+
+   case "i64":
+    return HEAP64[((ptr) >> 3)];
+
+   case "float":
+    return HEAPF32[((ptr) >> 2)];
+
+   case "double":
+    return HEAPF64[((ptr) >> 3)];
+
+   case "*":
+    return HEAPU32[((ptr) >> 2)];
+
+   default:
+    abort(`invalid type for getValue: ${type}`);
+  }
 }
 
 var invokeEntryPoint = (ptr, arg) => {
@@ -1210,14 +1390,11 @@ var invokeEntryPoint = (ptr, arg) => {
   var result = (a1 => dynCall_ii(ptr, a1))(arg);
   checkStackCookie();
   function finish(result) {
-    // In MINIMAL_RUNTIME the noExitRuntime concept does not apply to
-    // pthreads. To exit a pthread with live runtime, use the function
-    // emscripten_unwind_to_js_event_loop() in the pthread body.
     if (keepRuntimeAlive()) {
       EXITSTATUS = result;
-      return;
+    } else {
+      __emscripten_thread_exit(result);
     }
-    __emscripten_thread_exit(result);
   }
   finish(result);
 };
@@ -1230,6 +1407,60 @@ var runtimeKeepalivePush = () => {
   runtimeKeepaliveCounter += 1;
 };
 
+function setValue_safe(ptr, value, type = "i8") {
+  if (type.endsWith("*")) type = "*";
+  switch (type) {
+   case "i1":
+    HEAP8[ptr] = value;
+    checkInt8(value);
+    break;
+
+   case "i8":
+    HEAP8[ptr] = value;
+    checkInt8(value);
+    break;
+
+   case "i16":
+    HEAP16[((ptr) >> 1)] = value;
+    checkInt16(value);
+    break;
+
+   case "i32":
+    HEAP32[((ptr) >> 2)] = value;
+    checkInt32(value);
+    break;
+
+   case "i64":
+    HEAP64[((ptr) >> 3)] = BigInt(value);
+    checkInt64(value);
+    break;
+
+   case "float":
+    HEAPF32[((ptr) >> 2)] = value;
+    break;
+
+   case "double":
+    HEAPF64[((ptr) >> 3)] = value;
+    break;
+
+   case "*":
+    HEAPU32[((ptr) >> 2)] = value;
+    break;
+
+   default:
+    abort(`invalid type for setValue: ${type}`);
+  }
+}
+
+var unSign = (value, bits) => {
+  if (value >= 0) {
+    return value;
+  }
+  // Need some trickery, since if bits == 32, we are right at the limit of the
+  // bits JS uses in bitshifts
+  return bits <= 32 ? 2 * Math.abs(1 << (bits - 1)) + value : Math.pow(2, bits) + value;
+};
+
 var warnOnce = text => {
   warnOnce.shown ||= {};
   if (!warnOnce.shown[text]) {
@@ -1238,17 +1469,7 @@ var warnOnce = text => {
   }
 };
 
-var UTF8Decoder = globalThis.TextDecoder && new TextDecoder;
-
-var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
-  var maxIdx = idx + maxBytesToRead;
-  // TextDecoder needs to know the byte length in advance, it doesn't stop on
-  // null terminator by itself.
-  // As a tiny code save trick, compare idx against maxIdx using a negation,
-  // so that maxBytesToRead=undefined/NaN means Infinity.
-  while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
-  return idx;
-};
+var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined;
 
 /**
      * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
@@ -1257,15 +1478,22 @@ var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
      * heapOrArray is either a regular array, or a JavaScript typed array view.
      * @param {number=} idx
      * @param {number=} maxBytesToRead
-     * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
      * @return {string}
-     */ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
-  var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead);
-  // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it.
+     */ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => {
+  var endIdx = idx + maxBytesToRead;
+  var endPtr = idx;
+  // TextDecoder needs to know the byte length in advance, it doesn't stop on
+  // null terminator by itself.  Also, use the length info to avoid running tiny
+  // strings through TextDecoder, since .subarray() allocates garbage.
+  // (As a tiny code save trick, compare endPtr against endIdx using a negation,
+  // so that undefined/NaN means Infinity)
+  while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
   if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
     return UTF8Decoder.decode(heapOrArray.buffer instanceof ArrayBuffer ? heapOrArray.subarray(idx, endPtr) : heapOrArray.slice(idx, endPtr));
   }
   var str = "";
+  // If building with TextDecoder, we have already computed the string length
+  // above, so test loop end condition against that
   while (idx < endPtr) {
     // For UTF8 byte structure, see:
     // http://en.wikipedia.org/wiki/UTF-8#Description
@@ -1307,10 +1535,12 @@ var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
      *   maximum number of bytes to read. You can omit this parameter to scan the
      *   string until the first 0 byte. If maxBytesToRead is passed, and the string
      *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
-     *   string will cut short at that byte index.
-     * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
+     *   string will cut short at that byte index (i.e. maxBytesToRead will not
+     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
+     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
+     *   JS JIT optimizations off, so it is worth to consider consistently using one
      * @return {string}
-     */ var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
+     */ var UTF8ToString = (ptr, maxBytesToRead) => {
   assert(typeof ptr == "number", `UTF8ToString expects a number (got ${typeof ptr})`);
   return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
 };
@@ -1322,7 +1552,7 @@ function pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg) {
   return ___pthread_create_js(pthread_ptr, attr, startRoutine, arg);
 }
 
-var _emscripten_has_threading_support = () => !!globalThis.SharedArrayBuffer;
+var _emscripten_has_threading_support = () => typeof SharedArrayBuffer != "undefined";
 
 var ___pthread_create_js = (pthread_ptr, attr, startRoutine, arg) => {
   if (!_emscripten_has_threading_support()) {
@@ -1511,10 +1741,19 @@ var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
   var endIdx = outIdx + maxBytesToWrite - 1;
   // -1 for string null terminator.
   for (var i = 0; i < str.length; ++i) {
+    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+    // unit, not a Unicode code point of the character! So decode
+    // UTF16->UTF32->UTF8.
+    // See http://unicode.org/faq/utf_bom.html#utf16-3
     // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
     // and https://www.ietf.org/rfc/rfc2279.txt
     // and https://tools.ietf.org/html/rfc3629
-    var u = str.codePointAt(i);
+    var u = str.charCodeAt(i);
+    // possibly a lead surrogate
+    if (u >= 55296 && u <= 57343) {
+      var u1 = str.charCodeAt(++i);
+      u = 65536 + ((u & 1023) << 10) | (u1 & 1023);
+    }
     if (u <= 127) {
       if (outIdx >= endIdx) break;
       heap[outIdx++] = u;
@@ -1534,9 +1773,6 @@ var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
       heap[outIdx++] = 128 | ((u >> 12) & 63);
       heap[outIdx++] = 128 | ((u >> 6) & 63);
       heap[outIdx++] = 128 | (u & 63);
-      // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16.
-      // We need to manually skip over the second code unit for correct iteration.
-      i++;
     }
   }
   // Null-terminate the pointer to the buffer.
@@ -1555,7 +1791,7 @@ var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
 var FS_stdin_getChar = () => {
   if (!FS_stdin_getChar_buffer.length) {
     var result = null;
-    if (globalThis.window?.prompt) {
+    if (typeof window != "undefined" && typeof window.prompt == "function") {
       // Browser.
       result = window.prompt("Input: ");
       // returns null on cancel
@@ -2022,6 +2258,61 @@ var MEMFS = {
   }
 };
 
+var asyncLoad = async url => {
+  var arrayBuffer = await readAsync(url);
+  assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`);
+  return new Uint8Array(arrayBuffer);
+};
+
+var FS_createDataFile = (...args) => FS.createDataFile(...args);
+
+var preloadPlugins = [];
+
+var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
+  // Ensure plugins are ready.
+  if (typeof Browser != "undefined") Browser.init();
+  var handled = false;
+  preloadPlugins.forEach(plugin => {
+    if (handled) return;
+    if (plugin["canHandle"](fullname)) {
+      plugin["handle"](byteArray, fullname, finish, onerror);
+      handled = true;
+    }
+  });
+  return handled;
+};
+
+var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
+  // TODO we should allow people to just pass in a complete filename instead
+  // of parent and name being that we just join them anyways
+  var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+  var dep = getUniqueRunDependency(`cp ${fullname}`);
+  // might have several active requests for the same fullname
+  function processData(byteArray) {
+    function finish(byteArray) {
+      preFinish?.();
+      if (!dontCreateFile) {
+        FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+      }
+      onload?.();
+      removeRunDependency(dep);
+    }
+    if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
+      onerror?.();
+      removeRunDependency(dep);
+    })) {
+      return;
+    }
+    finish(byteArray);
+  }
+  addRunDependency(dep);
+  if (typeof url == "string") {
+    asyncLoad(url).then(processData, onerror);
+  } else {
+    processData(url);
+  }
+};
+
 var FS_modeStringToFlags = str => {
   var flagModes = {
     "r": 0,
@@ -2316,120 +2607,6 @@ var ERRNO_CODES = {
   "ESTRPIPE": 135
 };
 
-var asyncLoad = async url => {
-  var arrayBuffer = await readAsync(url);
-  assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`);
-  return new Uint8Array(arrayBuffer);
-};
-
-var FS_createDataFile = (...args) => FS.createDataFile(...args);
-
-var getUniqueRunDependency = id => {
-  var orig = id;
-  while (1) {
-    if (!runDependencyTracking[id]) return id;
-    id = orig + Math.random();
-  }
-};
-
-var runDependencies = 0;
-
-var dependenciesFulfilled = null;
-
-var runDependencyTracking = {};
-
-var runDependencyWatcher = null;
-
-var removeRunDependency = id => {
-  runDependencies--;
-  Module["monitorRunDependencies"]?.(runDependencies);
-  assert(id, "removeRunDependency requires an ID");
-  assert(runDependencyTracking[id]);
-  delete runDependencyTracking[id];
-  if (runDependencies == 0) {
-    if (runDependencyWatcher !== null) {
-      clearInterval(runDependencyWatcher);
-      runDependencyWatcher = null;
-    }
-    if (dependenciesFulfilled) {
-      var callback = dependenciesFulfilled;
-      dependenciesFulfilled = null;
-      callback();
-    }
-  }
-};
-
-var addRunDependency = id => {
-  runDependencies++;
-  Module["monitorRunDependencies"]?.(runDependencies);
-  assert(id, "addRunDependency requires an ID");
-  assert(!runDependencyTracking[id]);
-  runDependencyTracking[id] = 1;
-  if (runDependencyWatcher === null && globalThis.setInterval) {
-    // Check for missing dependencies every few seconds
-    runDependencyWatcher = setInterval(() => {
-      if (ABORT) {
-        clearInterval(runDependencyWatcher);
-        runDependencyWatcher = null;
-        return;
-      }
-      var shown = false;
-      for (var dep in runDependencyTracking) {
-        if (!shown) {
-          shown = true;
-          err("still waiting on run dependencies:");
-        }
-        err(`dependency: ${dep}`);
-      }
-      if (shown) {
-        err("(end of list)");
-      }
-    }, 1e4);
-  }
-};
-
-var preloadPlugins = [];
-
-var FS_handledByPreloadPlugin = async (byteArray, fullname) => {
-  // Ensure plugins are ready.
-  if (typeof Browser != "undefined") Browser.init();
-  for (var plugin of preloadPlugins) {
-    if (plugin["canHandle"](fullname)) {
-      assert(plugin["handle"].constructor.name === "AsyncFunction", "Filesystem plugin handlers must be async functions (See #24914)");
-      return plugin["handle"](byteArray, fullname);
-    }
-  }
-  // In no plugin handled this file then return the original/unmodified
-  // byteArray.
-  return byteArray;
-};
-
-var FS_preloadFile = async (parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish) => {
-  // TODO we should allow people to just pass in a complete filename instead
-  // of parent and name being that we just join them anyways
-  var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
-  var dep = getUniqueRunDependency(`cp ${fullname}`);
-  // might have several active requests for the same fullname
-  addRunDependency(dep);
-  try {
-    var byteArray = url;
-    if (typeof url == "string") {
-      byteArray = await asyncLoad(url);
-    }
-    byteArray = await FS_handledByPreloadPlugin(byteArray, fullname);
-    preFinish?.();
-    if (!dontCreateFile) {
-      FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
-    }
-  } finally {
-    removeRunDependency(dep);
-  }
-};
-
-var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
-  FS_preloadFile(parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish).then(onload).catch(onerror);
-};
-
 var FS = {
   root: null,
   mounts: [],
@@ -2557,9 +2734,6 @@ var FS = {
           current_path = PATH.dirname(current_path);
           if (FS.isRoot(current)) {
             path = current_path + "/" + parts.slice(i + 1).join("/");
-            // We're making progress here, don't let many consecutive ..'s
-            // lead to ELOOP
-            nlinks--;
             continue linkloop;
           } else {
             current = current.parent;
@@ -3568,29 +3742,33 @@ var FS = {
     opts.flags = opts.flags || 0;
     opts.encoding = opts.encoding || "binary";
     if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
-      abort(`Invalid encoding type "${opts.encoding}"`);
+      throw new Error(`Invalid encoding type "${opts.encoding}"`);
     }
+    var ret;
     var stream = FS.open(path, opts.flags);
     var stat = FS.stat(path);
     var length = stat.size;
     var buf = new Uint8Array(length);
     FS.read(stream, buf, 0, length, 0);
     if (opts.encoding === "utf8") {
-      buf = UTF8ArrayToString(buf);
+      ret = UTF8ArrayToString(buf);
+    } else if (opts.encoding === "binary") {
+      ret = buf;
     }
     FS.close(stream);
-    return buf;
+    return ret;
   },
   writeFile(path, data, opts = {}) {
     opts.flags = opts.flags || 577;
     var stream = FS.open(path, opts.flags, opts.mode);
     if (typeof data == "string") {
-      data = new Uint8Array(intArrayFromString(data));
-    }
-    if (ArrayBuffer.isView(data)) {
+      var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
+      var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
+      FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
+    } else if (ArrayBuffer.isView(data)) {
       FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
     } else {
-      abort("Unsupported data type");
+      throw new Error("Unsupported data type");
     }
     FS.close(stream);
   },
@@ -3896,12 +4074,13 @@ var FS = {
   },
   forceLoadFile(obj) {
     if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
-    if (globalThis.XMLHttpRequest) {
-      abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+    if (typeof XMLHttpRequest != "undefined") {
+      throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
     } else {
       // Command-line.
       try {
         obj.contents = readBinary(obj.url);
+        obj.usedBytes = obj.contents.length;
       } catch (e) {
         throw new FS.ErrnoError(29);
       }
@@ -3930,7 +4109,7 @@ var FS = {
         var xhr = new XMLHttpRequest;
         xhr.open("HEAD", url, false);
         xhr.send(null);
-        if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) abort("Couldn't load " + url + ". Status: " + xhr.status);
+        if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
         var datalength = Number(xhr.getResponseHeader("Content-length"));
         var header;
         var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
@@ -3940,8 +4119,8 @@ var FS = {
         if (!hasByteServing) chunkSize = datalength;
         // Function to get a range from the remote URL.
         var doXHR = (from, to) => {
-          if (from > to) abort("invalid range (" + from + ", " + to + ") or no bytes requested!");
-          if (to > datalength - 1) abort("only " + datalength + " bytes available! programmer error!");
+          if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+          if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
           // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
           var xhr = new XMLHttpRequest;
           xhr.open("GET", url, false);
@@ -3952,7 +4131,7 @@ var FS = {
             xhr.overrideMimeType("text/plain; charset=x-user-defined");
           }
           xhr.send(null);
-          if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) abort("Couldn't load " + url + ". Status: " + xhr.status);
+          if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
           if (xhr.response !== undefined) {
             return new Uint8Array(/** @type{Array<number>} */ (xhr.response || []));
           }
@@ -3968,7 +4147,7 @@ var FS = {
           if (typeof lazyArray.chunks[chunkNum] == "undefined") {
             lazyArray.chunks[chunkNum] = doXHR(start, end);
           }
-          if (typeof lazyArray.chunks[chunkNum] == "undefined") abort("doXHR failed!");
+          if (typeof lazyArray.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!");
           return lazyArray.chunks[chunkNum];
         });
         if (usesGzip || !datalength) {
@@ -3996,8 +4175,8 @@ var FS = {
         return this._chunkSize;
       }
     }
-    if (globalThis.XMLHttpRequest) {
-      if (!ENVIRONMENT_IS_WORKER) abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");
+    if (typeof XMLHttpRequest != "undefined") {
+      if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
       var lazyArray = new LazyUint8Array;
       var properties = {
         isDevice: false,
@@ -4119,64 +4298,64 @@ var SYSCALLS = {
     return dir + "/" + path;
   },
   writeStat(buf, stat) {
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((buf) >> 2), "storing")] = stat.dev;
+    SAFE_HEAP_STORE(((buf) >> 2) * 4, stat.dev, 4);
     checkInt32(stat.dev);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (4)) >> 2), "storing")] = stat.mode;
+    SAFE_HEAP_STORE((((buf) + (4)) >> 2) * 4, stat.mode, 4);
     checkInt32(stat.mode);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (8)) >> 2), "storing")] = stat.nlink;
+    SAFE_HEAP_STORE((((buf) + (8)) >> 2) * 4, stat.nlink, 4);
     checkInt32(stat.nlink);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (12)) >> 2), "storing")] = stat.uid;
+    SAFE_HEAP_STORE((((buf) + (12)) >> 2) * 4, stat.uid, 4);
     checkInt32(stat.uid);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (16)) >> 2), "storing")] = stat.gid;
+    SAFE_HEAP_STORE((((buf) + (16)) >> 2) * 4, stat.gid, 4);
     checkInt32(stat.gid);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (20)) >> 2), "storing")] = stat.rdev;
+    SAFE_HEAP_STORE((((buf) + (20)) >> 2) * 4, stat.rdev, 4);
     checkInt32(stat.rdev);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (24)) >> 3), "storing")] = BigInt(stat.size);
+    HEAP64[(((buf) + (24)) >> 3)] = BigInt(stat.size);
     checkInt64(stat.size);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((buf) + (32)) >> 2), "storing")] = 4096;
+    SAFE_HEAP_STORE((((buf) + (32)) >> 2) * 4, 4096, 4);
     checkInt32(4096);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((buf) + (36)) >> 2), "storing")] = stat.blocks;
+    SAFE_HEAP_STORE((((buf) + (36)) >> 2) * 4, stat.blocks, 4);
     checkInt32(stat.blocks);
     var atime = stat.atime.getTime();
     var mtime = stat.mtime.getTime();
     var ctime = stat.ctime.getTime();
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (40)) >> 3), "storing")] = BigInt(Math.floor(atime / 1e3));
+    HEAP64[(((buf) + (40)) >> 3)] = BigInt(Math.floor(atime / 1e3));
     checkInt64(Math.floor(atime / 1e3));
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (48)) >> 2), "storing")] = (atime % 1e3) * 1e3 * 1e3;
+    SAFE_HEAP_STORE((((buf) + (48)) >> 2) * 4, (atime % 1e3) * 1e3 * 1e3, 4);
     checkInt32((atime % 1e3) * 1e3 * 1e3);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (56)) >> 3), "storing")] = BigInt(Math.floor(mtime / 1e3));
+    HEAP64[(((buf) + (56)) >> 3)] = BigInt(Math.floor(mtime / 1e3));
     checkInt64(Math.floor(mtime / 1e3));
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (64)) >> 2), "storing")] = (mtime % 1e3) * 1e3 * 1e3;
+    SAFE_HEAP_STORE((((buf) + (64)) >> 2) * 4, (mtime % 1e3) * 1e3 * 1e3, 4);
     checkInt32((mtime % 1e3) * 1e3 * 1e3);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (72)) >> 3), "storing")] = BigInt(Math.floor(ctime / 1e3));
+    HEAP64[(((buf) + (72)) >> 3)] = BigInt(Math.floor(ctime / 1e3));
     checkInt64(Math.floor(ctime / 1e3));
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (80)) >> 2), "storing")] = (ctime % 1e3) * 1e3 * 1e3;
+    SAFE_HEAP_STORE((((buf) + (80)) >> 2) * 4, (ctime % 1e3) * 1e3 * 1e3, 4);
     checkInt32((ctime % 1e3) * 1e3 * 1e3);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (88)) >> 3), "storing")] = BigInt(stat.ino);
+    HEAP64[(((buf) + (88)) >> 3)] = BigInt(stat.ino);
     checkInt64(stat.ino);
     return 0;
   },
   writeStatFs(buf, stats) {
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (4)) >> 2), "storing")] = stats.bsize;
+    SAFE_HEAP_STORE((((buf) + (4)) >> 2) * 4, stats.bsize, 4);
     checkInt32(stats.bsize);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (60)) >> 2), "storing")] = stats.bsize;
+    SAFE_HEAP_STORE((((buf) + (40)) >> 2) * 4, stats.bsize, 4);
     checkInt32(stats.bsize);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (8)) >> 3), "storing")] = BigInt(stats.blocks);
-    checkInt64(stats.blocks);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (16)) >> 3), "storing")] = BigInt(stats.bfree);
-    checkInt64(stats.bfree);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (24)) >> 3), "storing")] = BigInt(stats.bavail);
-    checkInt64(stats.bavail);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (32)) >> 3), "storing")] = BigInt(stats.files);
-    checkInt64(stats.files);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((buf) + (40)) >> 3), "storing")] = BigInt(stats.ffree);
-    checkInt64(stats.ffree);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (48)) >> 2), "storing")] = stats.fsid;
+    SAFE_HEAP_STORE((((buf) + (8)) >> 2) * 4, stats.blocks, 4);
+    checkInt32(stats.blocks);
+    SAFE_HEAP_STORE((((buf) + (12)) >> 2) * 4, stats.bfree, 4);
+    checkInt32(stats.bfree);
+    SAFE_HEAP_STORE((((buf) + (16)) >> 2) * 4, stats.bavail, 4);
+    checkInt32(stats.bavail);
+    SAFE_HEAP_STORE((((buf) + (20)) >> 2) * 4, stats.files, 4);
+    checkInt32(stats.files);
+    SAFE_HEAP_STORE((((buf) + (24)) >> 2) * 4, stats.ffree, 4);
+    checkInt32(stats.ffree);
+    SAFE_HEAP_STORE((((buf) + (28)) >> 2) * 4, stats.fsid, 4);
     checkInt32(stats.fsid);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (64)) >> 2), "storing")] = stats.flags;
+    SAFE_HEAP_STORE((((buf) + (44)) >> 2) * 4, stats.flags, 4);
     checkInt32(stats.flags);
     // ST_NOSUID
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((buf) + (56)) >> 2), "storing")] = stats.namelen;
+    SAFE_HEAP_STORE((((buf) + (36)) >> 2) * 4, stats.namelen, 4);
     checkInt32(stats.namelen);
   },
   doMsync(addr, stream, len, flags, offset) {
@@ -4221,7 +4400,7 @@ function ___syscall_dup3(fd, newfd, flags) {
 /** @suppress {duplicate } */ var syscallGetVarargI = () => {
   assert(SYSCALLS.varargs != undefined);
   // the `+` prepended here is necessary to convince the JSCompiler that varargs is indeed a number.
-  var ret = HEAP32[SAFE_HEAP_INDEX(HEAP32, ((+SYSCALLS.varargs) >> 2), "loading")];
+  var ret = SAFE_HEAP_LOAD(((+SYSCALLS.varargs) >> 2) * 4, 4, 0);
   SYSCALLS.varargs += 4;
   return ret;
 };
@@ -4268,7 +4447,7 @@ function ___syscall_fcntl64(fd, cmd, varargs) {
         var arg = syscallGetVarargP();
         var offset = 0;
         // We're always unlocked.
-        HEAP16[SAFE_HEAP_INDEX(HEAP16, (((arg) + (offset)) >> 1), "storing")] = 2;
+        SAFE_HEAP_STORE((((arg) + (offset)) >> 1) * 2, 2, 2);
         checkInt16(2);
         return 0;
       }
@@ -4350,13 +4529,13 @@ function ___syscall_getdents64(fd, dirp, count) {
         8;
       }
       assert(id);
-      HEAP64[SAFE_HEAP_INDEX(HEAP64, ((dirp + pos) >> 3), "storing")] = BigInt(id);
+      HEAP64[((dirp + pos) >> 3)] = BigInt(id);
       checkInt64(id);
-      HEAP64[SAFE_HEAP_INDEX(HEAP64, (((dirp + pos) + (8)) >> 3), "storing")] = BigInt((idx + 1) * struct_size);
+      HEAP64[(((dirp + pos) + (8)) >> 3)] = BigInt((idx + 1) * struct_size);
       checkInt64((idx + 1) * struct_size);
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((dirp + pos) + (16)) >> 1), "storing")] = 280;
+      SAFE_HEAP_STORE((((dirp + pos) + (16)) >> 1) * 2, 280, 2);
       checkInt16(280);
-      HEAP8[SAFE_HEAP_INDEX(HEAP8, (dirp + pos) + (18), "storing")] = type;
+      SAFE_HEAP_STORE((dirp + pos) + (18), type, 1);
       checkInt8(type);
       stringToUTF8(name, dirp + pos + 19, 256);
       pos += struct_size;
@@ -4387,16 +4566,16 @@ function ___syscall_ioctl(fd, op, varargs) {
         if (stream.tty.ops.ioctl_tcgets) {
           var termios = stream.tty.ops.ioctl_tcgets(stream);
           var argp = syscallGetVarargP();
-          HEAP32[SAFE_HEAP_INDEX(HEAP32, ((argp) >> 2), "storing")] = termios.c_iflag || 0;
+          SAFE_HEAP_STORE(((argp) >> 2) * 4, termios.c_iflag || 0, 4);
           checkInt32(termios.c_iflag || 0);
-          HEAP32[SAFE_HEAP_INDEX(HEAP32, (((argp) + (4)) >> 2), "storing")] = termios.c_oflag || 0;
+          SAFE_HEAP_STORE((((argp) + (4)) >> 2) * 4, termios.c_oflag || 0, 4);
           checkInt32(termios.c_oflag || 0);
-          HEAP32[SAFE_HEAP_INDEX(HEAP32, (((argp) + (8)) >> 2), "storing")] = termios.c_cflag || 0;
+          SAFE_HEAP_STORE((((argp) + (8)) >> 2) * 4, termios.c_cflag || 0, 4);
           checkInt32(termios.c_cflag || 0);
-          HEAP32[SAFE_HEAP_INDEX(HEAP32, (((argp) + (12)) >> 2), "storing")] = termios.c_lflag || 0;
+          SAFE_HEAP_STORE((((argp) + (12)) >> 2) * 4, termios.c_lflag || 0, 4);
           checkInt32(termios.c_lflag || 0);
           for (var i = 0; i < 32; i++) {
-            HEAP8[SAFE_HEAP_INDEX(HEAP8, (argp + i) + (17), "storing")] = termios.c_cc[i] || 0;
+            SAFE_HEAP_STORE((argp + i) + (17), termios.c_cc[i] || 0, 1);
             checkInt8(termios.c_cc[i] || 0);
           }
           return 0;
@@ -4419,13 +4598,13 @@ function ___syscall_ioctl(fd, op, varargs) {
         if (!stream.tty) return -59;
         if (stream.tty.ops.ioctl_tcsets) {
           var argp = syscallGetVarargP();
-          var c_iflag = HEAP32[SAFE_HEAP_INDEX(HEAP32, ((argp) >> 2), "loading")];
-          var c_oflag = HEAP32[SAFE_HEAP_INDEX(HEAP32, (((argp) + (4)) >> 2), "loading")];
-          var c_cflag = HEAP32[SAFE_HEAP_INDEX(HEAP32, (((argp) + (8)) >> 2), "loading")];
-          var c_lflag = HEAP32[SAFE_HEAP_INDEX(HEAP32, (((argp) + (12)) >> 2), "loading")];
+          var c_iflag = SAFE_HEAP_LOAD(((argp) >> 2) * 4, 4, 0);
+          var c_oflag = SAFE_HEAP_LOAD((((argp) + (4)) >> 2) * 4, 4, 0);
+          var c_cflag = SAFE_HEAP_LOAD((((argp) + (8)) >> 2) * 4, 4, 0);
+          var c_lflag = SAFE_HEAP_LOAD((((argp) + (12)) >> 2) * 4, 4, 0);
           var c_cc = [];
           for (var i = 0; i < 32; i++) {
-            c_cc.push(HEAP8[SAFE_HEAP_INDEX(HEAP8, (argp + i) + (17), "loading")]);
+            c_cc.push(SAFE_HEAP_LOAD((argp + i) + (17), 1, 0));
           }
           return stream.tty.ops.ioctl_tcsets(stream.tty, op, {
             c_iflag,
@@ -4442,7 +4621,7 @@ function ___syscall_ioctl(fd, op, varargs) {
       {
         if (!stream.tty) return -59;
         var argp = syscallGetVarargP();
-        HEAP32[SAFE_HEAP_INDEX(HEAP32, ((argp) >> 2), "storing")] = 0;
+        SAFE_HEAP_STORE(((argp) >> 2) * 4, 0, 4);
         checkInt32(0);
         return 0;
       }
@@ -4453,7 +4632,6 @@ function ___syscall_ioctl(fd, op, varargs) {
         return -28;
       }
 
-     case 21537:
      case 21531:
       {
         var argp = syscallGetVarargP();
@@ -4468,9 +4646,9 @@ function ___syscall_ioctl(fd, op, varargs) {
         if (stream.tty.ops.ioctl_tiocgwinsz) {
           var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
           var argp = syscallGetVarargP();
-          HEAP16[SAFE_HEAP_INDEX(HEAP16, ((argp) >> 1), "storing")] = winsize[0];
+          SAFE_HEAP_STORE(((argp) >> 1) * 2, winsize[0], 2);
           checkInt16(winsize[0]);
-          HEAP16[SAFE_HEAP_INDEX(HEAP16, (((argp) + (2)) >> 1), "storing")] = winsize[1];
+          SAFE_HEAP_STORE((((argp) + (2)) >> 1) * 2, winsize[1], 2);
           checkInt16(winsize[1]);
         }
         return 0;
@@ -4751,9 +4929,9 @@ function ___syscall_pipe(fdPtr) {
       throw new FS.ErrnoError(21);
     }
     var res = PIPEFS.createPipe();
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, ((fdPtr) >> 2), "storing")] = res.readable_fd;
+    SAFE_HEAP_STORE(((fdPtr) >> 2) * 4, res.readable_fd, 4);
     checkInt32(res.readable_fd);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((fdPtr) + (4)) >> 2), "storing")] = res.writable_fd;
+    SAFE_HEAP_STORE((((fdPtr) + (4)) >> 2) * 4, res.writable_fd, 4);
     checkInt32(res.writable_fd);
     return 0;
   } catch (e) {
@@ -4767,12 +4945,12 @@ function ___syscall_unlinkat(dirfd, path, flags) {
   try {
     path = SYSCALLS.getStr(path);
     path = SYSCALLS.calculateAt(dirfd, path);
-    if (!flags) {
+    if (flags === 0) {
       FS.unlink(path);
     } else if (flags === 512) {
       FS.rmdir(path);
     } else {
-      return -28;
+      abort("Invalid flags passed to unlinkat");
     }
     return 0;
   } catch (e) {
@@ -4812,14 +4990,7 @@ var handleException = e => {
 var maybeExit = () => {
   if (!keepRuntimeAlive()) {
     try {
-      if (ENVIRONMENT_IS_PTHREAD) {
-        // exit the current thread, but only if there is one active.
-        // TODO(https://github.com/emscripten-core/emscripten/issues/25076):
-        // Unify this check with the runtimeExited check above
-        if (_pthread_self()) __emscripten_thread_exit(EXITSTATUS);
-        return;
-      }
-      _exit(EXITSTATUS);
+      if (ENVIRONMENT_IS_PTHREAD) __emscripten_thread_exit(EXITSTATUS); else _exit(EXITSTATUS);
     } catch (e) {
       handleException(e);
     }
@@ -4840,7 +5011,7 @@ var callUserCallback = func => {
 };
 
 var __emscripten_thread_mailbox_await = pthread_ptr => {
-  if (Atomics.waitAsync) {
+  if (typeof Atomics.waitAsync === "function") {
     // Wait on the pthread's initial self-pointer field because it is easy and
     // safe to access from sending threads that need to notify the waiting
     // thread.
@@ -4853,13 +5024,9 @@ var __emscripten_thread_mailbox_await = pthread_ptr => {
   }
 };
 
-var checkMailbox = () => callUserCallback(() => {
+var checkMailbox = () => {
   // Only check the mailbox if we have a live pthread runtime. We implement
   // pthread_self to return 0 if there is no live runtime.
-  // TODO(https://github.com/emscripten-core/emscripten/issues/25076):
-  // Is this check still needed?  `callUserCallback` is supposed to
-  // ensure the runtime is alive, and if `_pthread_self` is NULL then the
-  // runtime certainly is *not* alive, so this should be a redundant check.
   var pthread_ptr = _pthread_self();
   if (pthread_ptr) {
     // If we are using Atomics.waitAsync as our notification mechanism, wait
@@ -4867,9 +5034,9 @@ var checkMailbox = () => callUserCallback(() => {
     // work that could otherwise arrive after we've finished processing the
     // mailbox and before we're ready for the next notification.
     __emscripten_thread_mailbox_await(pthread_ptr);
-    __emscripten_check_mailbox();
+    callUserCallback(__emscripten_check_mailbox);
   }
-});
+};
 
 var __emscripten_notify_mailbox_postmessage = (targetThread, currThreadId) => {
   if (targetThread == currThreadId) {
@@ -4902,12 +5069,12 @@ var __emscripten_receive_on_main_thread_js = (funcIndex, emAsmAddr, callingThrea
   proxiedJSCallArgs.length = numCallArgs;
   var b = ((args) >> 3);
   for (var i = 0; i < numCallArgs; i++) {
-    if (HEAP64[SAFE_HEAP_INDEX(HEAP64, b + 2 * i, "loading")]) {
+    if (HEAP64[b + 2 * i]) {
       // It's a BigInt.
-      proxiedJSCallArgs[i] = HEAP64[SAFE_HEAP_INDEX(HEAP64, b + 2 * i + 1, "loading")];
+      proxiedJSCallArgs[i] = HEAP64[b + 2 * i + 1];
     } else {
       // It's a Number.
-      proxiedJSCallArgs[i] = HEAPF64[SAFE_HEAP_INDEX(HEAPF64, b + 2 * i + 1, "loading")];
+      proxiedJSCallArgs[i] = SAFE_HEAP_LOAD_D((b + 2 * i + 1) * 8, 8, 0);
     }
   }
   // Proxied JS library funcs use funcIndex and EM_ASM functions use emAsmAddr
@@ -4947,23 +5114,23 @@ var bigintToI53Checked = num => (num < INT53_MIN || num > INT53_MAX) ? NaN : Num
 function __gmtime_js(time, tmPtr) {
   time = bigintToI53Checked(time);
   var date = new Date(time * 1e3);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, ((tmPtr) >> 2), "storing")] = date.getUTCSeconds();
+  SAFE_HEAP_STORE(((tmPtr) >> 2) * 4, date.getUTCSeconds(), 4);
   checkInt32(date.getUTCSeconds());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (4)) >> 2), "storing")] = date.getUTCMinutes();
+  SAFE_HEAP_STORE((((tmPtr) + (4)) >> 2) * 4, date.getUTCMinutes(), 4);
   checkInt32(date.getUTCMinutes());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (8)) >> 2), "storing")] = date.getUTCHours();
+  SAFE_HEAP_STORE((((tmPtr) + (8)) >> 2) * 4, date.getUTCHours(), 4);
   checkInt32(date.getUTCHours());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (12)) >> 2), "storing")] = date.getUTCDate();
+  SAFE_HEAP_STORE((((tmPtr) + (12)) >> 2) * 4, date.getUTCDate(), 4);
   checkInt32(date.getUTCDate());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (16)) >> 2), "storing")] = date.getUTCMonth();
+  SAFE_HEAP_STORE((((tmPtr) + (16)) >> 2) * 4, date.getUTCMonth(), 4);
   checkInt32(date.getUTCMonth());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (20)) >> 2), "storing")] = date.getUTCFullYear() - 1900;
+  SAFE_HEAP_STORE((((tmPtr) + (20)) >> 2) * 4, date.getUTCFullYear() - 1900, 4);
   checkInt32(date.getUTCFullYear() - 1900);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (24)) >> 2), "storing")] = date.getUTCDay();
+  SAFE_HEAP_STORE((((tmPtr) + (24)) >> 2) * 4, date.getUTCDay(), 4);
   checkInt32(date.getUTCDay());
   var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
   var yday = ((date.getTime() - start) / (1e3 * 60 * 60 * 24)) | 0;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (28)) >> 2), "storing")] = yday;
+  SAFE_HEAP_STORE((((tmPtr) + (28)) >> 2) * 4, yday, 4);
   checkInt32(yday);
 }
 
@@ -4984,31 +5151,31 @@ var ydayFromDate = date => {
 function __localtime_js(time, tmPtr) {
   time = bigintToI53Checked(time);
   var date = new Date(time * 1e3);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, ((tmPtr) >> 2), "storing")] = date.getSeconds();
+  SAFE_HEAP_STORE(((tmPtr) >> 2) * 4, date.getSeconds(), 4);
   checkInt32(date.getSeconds());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (4)) >> 2), "storing")] = date.getMinutes();
+  SAFE_HEAP_STORE((((tmPtr) + (4)) >> 2) * 4, date.getMinutes(), 4);
   checkInt32(date.getMinutes());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (8)) >> 2), "storing")] = date.getHours();
+  SAFE_HEAP_STORE((((tmPtr) + (8)) >> 2) * 4, date.getHours(), 4);
   checkInt32(date.getHours());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (12)) >> 2), "storing")] = date.getDate();
+  SAFE_HEAP_STORE((((tmPtr) + (12)) >> 2) * 4, date.getDate(), 4);
   checkInt32(date.getDate());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (16)) >> 2), "storing")] = date.getMonth();
+  SAFE_HEAP_STORE((((tmPtr) + (16)) >> 2) * 4, date.getMonth(), 4);
   checkInt32(date.getMonth());
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (20)) >> 2), "storing")] = date.getFullYear() - 1900;
+  SAFE_HEAP_STORE((((tmPtr) + (20)) >> 2) * 4, date.getFullYear() - 1900, 4);
   checkInt32(date.getFullYear() - 1900);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (24)) >> 2), "storing")] = date.getDay();
+  SAFE_HEAP_STORE((((tmPtr) + (24)) >> 2) * 4, date.getDay(), 4);
   checkInt32(date.getDay());
   var yday = ydayFromDate(date) | 0;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (28)) >> 2), "storing")] = yday;
+  SAFE_HEAP_STORE((((tmPtr) + (28)) >> 2) * 4, yday, 4);
   checkInt32(yday);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (36)) >> 2), "storing")] = -(date.getTimezoneOffset() * 60);
+  SAFE_HEAP_STORE((((tmPtr) + (36)) >> 2) * 4, -(date.getTimezoneOffset() * 60), 4);
   checkInt32(-(date.getTimezoneOffset() * 60));
   // Attention: DST is in December in South, and some regions don't have DST at all.
   var start = new Date(date.getFullYear(), 0, 1);
   var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
   var winterOffset = start.getTimezoneOffset();
   var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((tmPtr) + (32)) >> 2), "storing")] = dst;
+  SAFE_HEAP_STORE((((tmPtr) + (32)) >> 2) * 4, dst, 4);
   checkInt32(dst);
 }
 
@@ -5031,8 +5198,9 @@ var __tzset_js = (timezone, daylight, std_name, dst_name) => {
   // Coordinated Universal Time (UTC) and local standard time."), the same
   // as returned by stdTimezoneOffset.
   // See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((timezone) >> 2), "storing")] = stdTimezoneOffset * 60;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, ((daylight) >> 2), "storing")] = Number(winterOffset != summerOffset);
+  SAFE_HEAP_STORE(((timezone) >> 2) * 4, stdTimezoneOffset * 60, 4);
+  checkInt32(stdTimezoneOffset * 60);
+  SAFE_HEAP_STORE(((daylight) >> 2) * 4, Number(winterOffset != summerOffset), 4);
   checkInt32(Number(winterOffset != summerOffset));
   var extractZone = timezoneOffset => {
     // Why inverse sign?
@@ -5078,7 +5246,7 @@ function _clock_time_get(clk_id, ignored_precision, ptime) {
   }
   // "now" is in ms, and wasi times are in ns.
   var nsec = Math.round(now * 1e3 * 1e3);
-  HEAP64[SAFE_HEAP_INDEX(HEAP64, ((ptime) >> 3), "storing")] = BigInt(nsec);
+  HEAP64[((ptime) >> 3)] = BigInt(nsec);
   checkInt64(nsec);
   return 0;
 }
@@ -5094,7 +5262,7 @@ var readEmAsmArgs = (sigPtr, buf) => {
   var ch;
   // Most arguments are i32s, so shift the buffer pointer so it is a plain
   // index into HEAP32.
-  while (ch = HEAPU8[SAFE_HEAP_INDEX(HEAPU8, sigPtr++, "loading")]) {
+  while (ch = SAFE_HEAP_LOAD(sigPtr++, 1, 1)) {
     var chr = String.fromCharCode(ch);
     var validChars = [ "d", "f", "i", "p" ];
     // In WASM_BIGINT mode we support passing i64 values as bigint.
@@ -5106,7 +5274,7 @@ var readEmAsmArgs = (sigPtr, buf) => {
     wide &= (ch != 112);
     buf += wide && (buf % 8) ? 4 : 0;
     readEmAsmArgsArray.push(// Special case for pointers under wasm64 or CAN_ADDRESS_2GB mode.
-    ch == 112 ? HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((buf) >> 2), "loading")] : ch == 106 ? HEAP64[SAFE_HEAP_INDEX(HEAP64, ((buf) >> 3), "loading")] : ch == 105 ? HEAP32[SAFE_HEAP_INDEX(HEAP32, ((buf) >> 2), "loading")] : HEAPF64[SAFE_HEAP_INDEX(HEAPF64, ((buf) >> 3), "loading")]);
+    ch == 112 ? SAFE_HEAP_LOAD(((buf) >> 2) * 4, 4, 1) : ch == 106 ? HEAP64[((buf) >> 3)] : ch == 105 ? SAFE_HEAP_LOAD(((buf) >> 2) * 4, 4, 0) : SAFE_HEAP_LOAD_D(((buf) >> 3) * 8, 8, 0));
     buf += wide ? 8 : 4;
   }
   return readEmAsmArgsArray;
@@ -5342,24 +5510,36 @@ var JSEvents = {
   }
 };
 
-var fillBatteryEventData = (eventStruct, battery) => {
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, ((eventStruct) >> 3), "storing")] = battery.chargingTime;
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (8)) >> 3), "storing")] = battery.dischargingTime;
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (16)) >> 3), "storing")] = battery.level;
-  HEAP8[SAFE_HEAP_INDEX(HEAP8, (eventStruct) + (24), "storing")] = battery.charging;
-  checkInt8(battery.charging);
+var fillBatteryEventData = (eventStruct, e) => {
+  SAFE_HEAP_STORE_D(((eventStruct) >> 3) * 8, e.chargingTime, 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (8)) >> 3) * 8, e.dischargingTime, 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (16)) >> 3) * 8, e.level, 8);
+  SAFE_HEAP_STORE((eventStruct) + (24), e.charging, 1);
+  checkInt8(e.charging);
+};
+
+var battery = () => navigator.battery || navigator.mozBattery || navigator.webkitBattery;
+
+var maybeCStringToJsString = cString => cString > 2 ? UTF8ToString(cString) : cString;
+
+/** @type {Object} */ var specialHTMLTargets = [ 0, typeof document != "undefined" ? document : 0, typeof window != "undefined" ? window : 0 ];
+
+var findEventTarget = target => {
+  target = maybeCStringToJsString(target);
+  var domElement = specialHTMLTargets[target] || (typeof document != "undefined" ? document.querySelector(target) : null);
+  return domElement;
 };
 
-var registerBatteryEventCallback = (battery, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
+var registerBatteryEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
   targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
   JSEvents.batteryEvent ||= _malloc(32);
   var batteryEventHandlerFunc = (e = event) => {
     var batteryEvent = targetThread ? _malloc(32) : JSEvents.batteryEvent;
-    fillBatteryEventData(batteryEvent, battery);
+    fillBatteryEventData(batteryEvent, battery());
     if (targetThread) __emscripten_run_callback_on_thread(targetThread, callbackfunc, eventTypeId, batteryEvent, userData); else if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, batteryEvent, userData)) e.preventDefault();
   };
   var eventHandler = {
-    target: battery,
+    target: findEventTarget(target),
     eventTypeString,
     callbackfunc,
     handlerFunc: batteryEventHandlerFunc,
@@ -5368,33 +5548,17 @@ var registerBatteryEventCallback = (battery, userData, useCapture, callbackfunc,
   return JSEvents.registerOrRemoveHandler(eventHandler);
 };
 
-var hasBatteryAPI = () => typeof navigator != "undefined" && navigator.getBattery;
-
-var _emscripten_set_batterychargingchange_callback_on_thread = function(userData, callbackfunc, targetThread) {
+function _emscripten_set_batterychargingchange_callback_on_thread(userData, callbackfunc, targetThread) {
   if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(12, 0, 1, userData, callbackfunc, targetThread);
-  if (!hasBatteryAPI()) return -1;
-  navigator.getBattery().then(b => {
-    registerBatteryEventCallback(b, userData, true, callbackfunc, 29, "chargingchange", targetThread);
-  });
-};
+  if (!battery()) return -1;
+  return registerBatteryEventCallback(battery(), userData, true, callbackfunc, 29, "chargingchange", targetThread);
+}
 
-var _emscripten_set_batterylevelchange_callback_on_thread = function(userData, callbackfunc, targetThread) {
+function _emscripten_set_batterylevelchange_callback_on_thread(userData, callbackfunc, targetThread) {
   if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(13, 0, 1, userData, callbackfunc, targetThread);
-  if (!hasBatteryAPI()) return -1;
-  navigator.getBattery().then(b => {
-    registerBatteryEventCallback(b, userData, true, callbackfunc, 30, "levelchange", targetThread);
-  });
-};
-
-var maybeCStringToJsString = cString => cString > 2 ? UTF8ToString(cString) : cString;
-
-/** @type {Object} */ var specialHTMLTargets = [ 0, typeof document != "undefined" ? document : 0, typeof window != "undefined" ? window : 0 ];
-
-var findEventTarget = target => {
-  target = maybeCStringToJsString(target);
-  var domElement = specialHTMLTargets[target] || (typeof document != "undefined" ? document.querySelector(target) : null);
-  return domElement;
-};
+  if (!battery()) return -1;
+  return registerBatteryEventCallback(battery(), userData, true, callbackfunc, 30, "levelchange", targetThread);
+}
 
 var registerBeforeUnloadEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) => {
   var beforeUnloadEventHandlerFunc = (e = event) => {
@@ -5461,24 +5625,24 @@ var getBoundingClientRect = e => specialHTMLTargets.indexOf(e) < 0 ? e.getBoundi
 
 var fillMouseEventData = (eventStruct, e, target) => {
   assert(eventStruct % 4 == 0);
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, ((eventStruct) >> 3), "storing")] = e.timeStamp;
+  SAFE_HEAP_STORE_D(((eventStruct) >> 3) * 8, e.timeStamp, 8);
   var idx = ((eventStruct) >> 2);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 2, "storing")] = e.screenX;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 3, "storing")] = e.screenY;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 4, "storing")] = e.clientX;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 5, "storing")] = e.clientY;
-  HEAP8[SAFE_HEAP_INDEX(HEAP8, eventStruct + 24, "storing")] = e.ctrlKey;
-  HEAP8[SAFE_HEAP_INDEX(HEAP8, eventStruct + 25, "storing")] = e.shiftKey;
-  HEAP8[SAFE_HEAP_INDEX(HEAP8, eventStruct + 26, "storing")] = e.altKey;
-  HEAP8[SAFE_HEAP_INDEX(HEAP8, eventStruct + 27, "storing")] = e.metaKey;
-  HEAP16[SAFE_HEAP_INDEX(HEAP16, idx * 2 + 14, "storing")] = e.button;
-  HEAP16[SAFE_HEAP_INDEX(HEAP16, idx * 2 + 15, "storing")] = e.buttons;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 8, "storing")] = e["movementX"];
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 9, "storing")] = e["movementY"];
+  SAFE_HEAP_STORE((idx + 2) * 4, e.screenX, 4);
+  SAFE_HEAP_STORE((idx + 3) * 4, e.screenY, 4);
+  SAFE_HEAP_STORE((idx + 4) * 4, e.clientX, 4);
+  SAFE_HEAP_STORE((idx + 5) * 4, e.clientY, 4);
+  SAFE_HEAP_STORE(eventStruct + 24, e.ctrlKey, 1);
+  SAFE_HEAP_STORE(eventStruct + 25, e.shiftKey, 1);
+  SAFE_HEAP_STORE(eventStruct + 26, e.altKey, 1);
+  SAFE_HEAP_STORE(eventStruct + 27, e.metaKey, 1);
+  SAFE_HEAP_STORE((idx * 2 + 14) * 2, e.button, 2);
+  SAFE_HEAP_STORE((idx * 2 + 15) * 2, e.buttons, 2);
+  SAFE_HEAP_STORE((idx + 8) * 4, e["movementX"], 4);
+  SAFE_HEAP_STORE((idx + 9) * 4, e["movementY"], 4);
   // Note: rect contains doubles (truncated to placate SAFE_HEAP, which is the same behaviour when writing to HEAP32 anyway)
   var rect = getBoundingClientRect(target);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 10, "storing")] = e.clientX - (rect.left | 0);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 11, "storing")] = e.clientY - (rect.top | 0);
+  SAFE_HEAP_STORE((idx + 10) * 4, e.clientX - (rect.left | 0), 4);
+  SAFE_HEAP_STORE((idx + 11) * 4, e.clientY - (rect.top | 0), 4);
 };
 
 var registerMouseEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
@@ -5524,15 +5688,15 @@ var fillDeviceMotionEventData = (eventStruct, e, target) => {
   a = a || {};
   ag = ag || {};
   rr = rr || {};
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, ((eventStruct) >> 3), "storing")] = a["x"];
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (8)) >> 3), "storing")] = a["y"];
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (16)) >> 3), "storing")] = a["z"];
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (24)) >> 3), "storing")] = ag["x"];
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (32)) >> 3), "storing")] = ag["y"];
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (40)) >> 3), "storing")] = ag["z"];
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (48)) >> 3), "storing")] = rr["alpha"];
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (56)) >> 3), "storing")] = rr["beta"];
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (64)) >> 3), "storing")] = rr["gamma"];
+  SAFE_HEAP_STORE_D(((eventStruct) >> 3) * 8, a["x"], 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (8)) >> 3) * 8, a["y"], 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (16)) >> 3) * 8, a["z"], 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (24)) >> 3) * 8, ag["x"], 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (32)) >> 3) * 8, ag["y"], 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (40)) >> 3) * 8, ag["z"], 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (48)) >> 3) * 8, rr["alpha"], 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (56)) >> 3) * 8, rr["beta"], 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (64)) >> 3) * 8, rr["gamma"], 8);
 };
 
 var registerDeviceMotionEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
@@ -5563,10 +5727,10 @@ function _emscripten_set_devicemotion_callback_on_thread(userData, useCapture, c
 }
 
 var fillDeviceOrientationEventData = (eventStruct, e, target) => {
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, ((eventStruct) >> 3), "storing")] = e.alpha;
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (8)) >> 3), "storing")] = e.beta;
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct) + (16)) >> 3), "storing")] = e.gamma;
-  HEAP8[SAFE_HEAP_INDEX(HEAP8, (eventStruct) + (24), "storing")] = e.absolute;
+  SAFE_HEAP_STORE_D(((eventStruct) >> 3) * 8, e.alpha, 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (8)) >> 3) * 8, e.beta, 8);
+  SAFE_HEAP_STORE_D((((eventStruct) + (16)) >> 3) * 8, e.gamma, 8);
+  SAFE_HEAP_STORE((eventStruct) + (24), e.absolute, 1);
   checkInt8(e.absolute);
 };
 
@@ -5612,17 +5776,12 @@ function _emscripten_set_focusout_callback_on_thread(target, userData, useCaptur
   return registerFocusEventCallback(target, userData, useCapture, callbackfunc, 15, "focusout", targetThread);
 }
 
-function getFullscreenElement() {
-  return document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.webkitCurrentFullScreenElement || document.msFullscreenElement;
-}
-
 var fillFullscreenChangeEventData = eventStruct => {
-  var fullscreenElement = getFullscreenElement();
+  var fullscreenElement = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement;
   var isFullscreen = !!fullscreenElement;
-  // Assigning a boolean to HEAP32 with expected type coercion.
-  /** @suppress{checkTypes} */ HEAP8[SAFE_HEAP_INDEX(HEAP8, eventStruct, "storing")] = isFullscreen;
+  SAFE_HEAP_STORE(eventStruct, isFullscreen, 1);
   checkInt8(isFullscreen);
-  HEAP8[SAFE_HEAP_INDEX(HEAP8, (eventStruct) + (1), "storing")] = JSEvents.fullscreenEnabled();
+  SAFE_HEAP_STORE((eventStruct) + (1), JSEvents.fullscreenEnabled(), 1);
   checkInt8(JSEvents.fullscreenEnabled());
   // If transitioning to fullscreen, report info about the element that is now fullscreen.
   // If transitioning to windowed mode, report info about the element that just was fullscreen.
@@ -5631,13 +5790,13 @@ var fillFullscreenChangeEventData = eventStruct => {
   var id = reportedElement?.id || "";
   stringToUTF8(nodeName, eventStruct + 2, 128);
   stringToUTF8(id, eventStruct + 130, 128);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (260)) >> 2), "storing")] = reportedElement ? reportedElement.clientWidth : 0;
+  SAFE_HEAP_STORE((((eventStruct) + (260)) >> 2) * 4, reportedElement ? reportedElement.clientWidth : 0, 4);
   checkInt32(reportedElement ? reportedElement.clientWidth : 0);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (264)) >> 2), "storing")] = reportedElement ? reportedElement.clientHeight : 0;
+  SAFE_HEAP_STORE((((eventStruct) + (264)) >> 2) * 4, reportedElement ? reportedElement.clientHeight : 0, 4);
   checkInt32(reportedElement ? reportedElement.clientHeight : 0);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (268)) >> 2), "storing")] = screen.width;
+  SAFE_HEAP_STORE((((eventStruct) + (268)) >> 2) * 4, screen.width, 4);
   checkInt32(screen.width);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (272)) >> 2), "storing")] = screen.height;
+  SAFE_HEAP_STORE((((eventStruct) + (272)) >> 2) * 4, screen.height, 4);
   checkInt32(screen.height);
   if (isFullscreen) {
     JSEvents.previousFullscreenElement = fullscreenElement;
@@ -5667,40 +5826,40 @@ function _emscripten_set_fullscreenchange_callback_on_thread(target, userData, u
   if (!JSEvents.fullscreenEnabled()) return -1;
   target = findEventTarget(target);
   if (!target) return -4;
+  // Unprefixed Fullscreen API shipped in Chromium 71 (https://bugs.chromium.org/p/chromium/issues/detail?id=383813)
   // As of Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitfullscreenchange. TODO: revisit this check once Safari ships unprefixed version.
   registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "webkitfullscreenchange", targetThread);
   return registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "fullscreenchange", targetThread);
 }
 
 var fillGamepadEventData = (eventStruct, e) => {
-  HEAPF64[SAFE_HEAP_INDEX(HEAPF64, ((eventStruct) >> 3), "storing")] = e.timestamp;
+  SAFE_HEAP_STORE_D(((eventStruct) >> 3) * 8, e.timestamp, 8);
   for (var i = 0; i < e.axes.length; ++i) {
-    HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct + i * 8) + (16)) >> 3), "storing")] = e.axes[i];
+    SAFE_HEAP_STORE_D((((eventStruct + i * 8) + (16)) >> 3) * 8, e.axes[i], 8);
   }
   for (var i = 0; i < e.buttons.length; ++i) {
     if (typeof e.buttons[i] == "object") {
-      HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct + i * 8) + (528)) >> 3), "storing")] = e.buttons[i].value;
+      SAFE_HEAP_STORE_D((((eventStruct + i * 8) + (528)) >> 3) * 8, e.buttons[i].value, 8);
     } else {
-      HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((eventStruct + i * 8) + (528)) >> 3), "storing")] = e.buttons[i];
+      SAFE_HEAP_STORE_D((((eventStruct + i * 8) + (528)) >> 3) * 8, e.buttons[i], 8);
     }
   }
   for (var i = 0; i < e.buttons.length; ++i) {
     if (typeof e.buttons[i] == "object") {
-      HEAP8[SAFE_HEAP_INDEX(HEAP8, (eventStruct + i) + (1040), "storing")] = e.buttons[i].pressed;
+      SAFE_HEAP_STORE((eventStruct + i) + (1040), e.buttons[i].pressed, 1);
       checkInt8(e.buttons[i].pressed);
     } else {
-      // Assigning a boolean to HEAP32, that's ok, but Closure would like to warn about it:
-      /** @suppress {checkTypes} */ HEAP8[SAFE_HEAP_INDEX(HEAP8, (eventStruct + i) + (1040), "storing")] = e.buttons[i] == 1;
+      SAFE_HEAP_STORE((eventStruct + i) + (1040), e.buttons[i] == 1, 1);
       checkInt8(e.buttons[i] == 1);
     }
   }
-  HEAP8[SAFE_HEAP_INDEX(HEAP8, (eventStruct) + (1104), "storing")] = e.connected;
+  SAFE_HEAP_STORE((eventStruct) + (1104), e.connected, 1);
   checkInt8(e.connected);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (1108)) >> 2), "storing")] = e.index;
+  SAFE_HEAP_STORE((((eventStruct) + (1108)) >> 2) * 4, e.index, 4);
   checkInt32(e.index);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (8)) >> 2), "storing")] = e.axes.length;
+  SAFE_HEAP_STORE((((eventStruct) + (8)) >> 2) * 4, e.axes.length, 4);
   checkInt32(e.axes.length);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (12)) >> 2), "storing")] = e.buttons.length;
+  SAFE_HEAP_STORE((((eventStruct) + (12)) >> 2) * 4, e.buttons.length, 4);
   checkInt32(e.buttons.length);
   stringToUTF8(e.id, eventStruct + 1112, 64);
   stringToUTF8(e.mapping, eventStruct + 1176, 64);
@@ -5755,17 +5914,17 @@ var registerKeyEventCallback = (target, userData, useCapture, callbackfunc, even
     assert(e);
     var keyEventData = targetThread ? _malloc(160) : JSEvents.keyEvent;
     // This allocated block is passed as satellite data to the proxied function call, so the call frees up the data block when done.
-    HEAPF64[SAFE_HEAP_INDEX(HEAPF64, ((keyEventData) >> 3), "storing")] = e.timeStamp;
+    SAFE_HEAP_STORE_D(((keyEventData) >> 3) * 8, e.timeStamp, 8);
     var idx = ((keyEventData) >> 2);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 2, "storing")] = e.location;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, keyEventData + 12, "storing")] = e.ctrlKey;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, keyEventData + 13, "storing")] = e.shiftKey;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, keyEventData + 14, "storing")] = e.altKey;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, keyEventData + 15, "storing")] = e.metaKey;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, keyEventData + 16, "storing")] = e.repeat;
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 5, "storing")] = e.charCode;
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 6, "storing")] = e.keyCode;
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, idx + 7, "storing")] = e.which;
+    SAFE_HEAP_STORE((idx + 2) * 4, e.location, 4);
+    SAFE_HEAP_STORE(keyEventData + 12, e.ctrlKey, 1);
+    SAFE_HEAP_STORE(keyEventData + 13, e.shiftKey, 1);
+    SAFE_HEAP_STORE(keyEventData + 14, e.altKey, 1);
+    SAFE_HEAP_STORE(keyEventData + 15, e.metaKey, 1);
+    SAFE_HEAP_STORE(keyEventData + 16, e.repeat, 1);
+    SAFE_HEAP_STORE((idx + 5) * 4, e.charCode, 4);
+    SAFE_HEAP_STORE((idx + 6) * 4, e.keyCode, 4);
+    SAFE_HEAP_STORE((idx + 7) * 4, e.which, 4);
     stringToUTF8(e.key || "", keyEventData + 32, 32);
     stringToUTF8(e.code || "", keyEventData + 64, 32);
     stringToUTF8(e.char || "", keyEventData + 96, 32);
@@ -5858,9 +6017,9 @@ var fillOrientationChangeEventData = eventStruct => {
     // fallback for Safari earlier than 16.4 (March 2023)
     orientationAngle = window.orientation;
   }
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, ((eventStruct) >> 2), "storing")] = orientationIndex;
+  SAFE_HEAP_STORE(((eventStruct) >> 2) * 4, orientationIndex, 4);
   checkInt32(orientationIndex);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (4)) >> 2), "storing")] = orientationAngle;
+  SAFE_HEAP_STORE((((eventStruct) + (4)) >> 2) * 4, orientationAngle, 4);
   checkInt32(orientationAngle);
 };
 
@@ -5889,10 +6048,9 @@ function _emscripten_set_orientationchange_callback_on_thread(userData, useCaptu
 }
 
 var fillPointerlockChangeEventData = eventStruct => {
-  var pointerLockElement = document.pointerLockElement;
+  var pointerLockElement = document.pointerLockElement || document.mozPointerLockElement || document.webkitPointerLockElement || document.msPointerLockElement;
   var isPointerlocked = !!pointerLockElement;
-  // Assigning a boolean to HEAP32 with expected type coercion.
-  /** @suppress{checkTypes} */ HEAP8[SAFE_HEAP_INDEX(HEAP8, eventStruct, "storing")] = isPointerlocked;
+  SAFE_HEAP_STORE(eventStruct, isPointerlocked, 1);
   checkInt8(isPointerlocked);
   var nodeName = JSEvents.getNodeNameForTarget(pointerLockElement);
   var id = pointerLockElement?.id || "";
@@ -5918,13 +6076,17 @@ var registerPointerlockChangeEventCallback = (target, userData, useCapture, call
   return JSEvents.registerOrRemoveHandler(eventHandler);
 };
 
-function _emscripten_set_pointerlockchange_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+/** @suppress {missingProperties} */ function _emscripten_set_pointerlockchange_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
   if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(38, 0, 1, target, userData, useCapture, callbackfunc, targetThread);
-  if (!document.body?.requestPointerLock) {
+  // TODO: Currently not supported in pthreads or in --proxy-to-worker mode. (In pthreads mode, document object is not defined)
+  if (!document || !document.body || (!document.body.requestPointerLock && !document.body.mozRequestPointerLock && !document.body.webkitRequestPointerLock && !document.body.msRequestPointerLock)) {
     return -1;
   }
   target = findEventTarget(target);
   if (!target) return -4;
+  registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "mozpointerlockchange", targetThread);
+  registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "webkitpointerlockchange", targetThread);
+  registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "mspointerlockchange", targetThread);
   return registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "pointerlockchange", targetThread);
 }
 
@@ -5943,13 +6105,17 @@ var registerPointerlockErrorEventCallback = (target, userData, useCapture, callb
   return JSEvents.registerOrRemoveHandler(eventHandler);
 };
 
-function _emscripten_set_pointerlockerror_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+/** @suppress {missingProperties} */ function _emscripten_set_pointerlockerror_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
   if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(39, 0, 1, target, userData, useCapture, callbackfunc, targetThread);
-  if (!document.body?.requestPointerLock) {
+  // TODO: Currently not supported in pthreads or in --proxy-to-worker mode. (In pthreads mode, document object is not defined)
+  if (!document || !document.body.requestPointerLock && !document.body.mozRequestPointerLock && !document.body.webkitRequestPointerLock && !document.body.msRequestPointerLock) {
     return -1;
   }
   target = findEventTarget(target);
   if (!target) return -4;
+  registerPointerlockErrorEventCallback(target, userData, useCapture, callbackfunc, 38, "mozpointerlockerror", targetThread);
+  registerPointerlockErrorEventCallback(target, userData, useCapture, callbackfunc, 38, "webkitpointerlockerror", targetThread);
+  registerPointerlockErrorEventCallback(target, userData, useCapture, callbackfunc, 38, "mspointerlockerror", targetThread);
   return registerPointerlockErrorEventCallback(target, userData, useCapture, callbackfunc, 38, "pointerlockerror", targetThread);
 }
 
@@ -5972,25 +6138,25 @@ var registerUiEventCallback = (target, userData, useCapture, callbackfunc, event
       return;
     }
     var uiEvent = targetThread ? _malloc(36) : JSEvents.uiEvent;
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, ((uiEvent) >> 2), "storing")] = 0;
+    SAFE_HEAP_STORE(((uiEvent) >> 2) * 4, 0, 4);
     checkInt32(0);
     // always zero for resize and scroll
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((uiEvent) + (4)) >> 2), "storing")] = b.clientWidth;
+    SAFE_HEAP_STORE((((uiEvent) + (4)) >> 2) * 4, b.clientWidth, 4);
     checkInt32(b.clientWidth);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((uiEvent) + (8)) >> 2), "storing")] = b.clientHeight;
+    SAFE_HEAP_STORE((((uiEvent) + (8)) >> 2) * 4, b.clientHeight, 4);
     checkInt32(b.clientHeight);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((uiEvent) + (12)) >> 2), "storing")] = innerWidth;
+    SAFE_HEAP_STORE((((uiEvent) + (12)) >> 2) * 4, innerWidth, 4);
     checkInt32(innerWidth);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((uiEvent) + (16)) >> 2), "storing")] = innerHeight;
+    SAFE_HEAP_STORE((((uiEvent) + (16)) >> 2) * 4, innerHeight, 4);
     checkInt32(innerHeight);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((uiEvent) + (20)) >> 2), "storing")] = outerWidth;
+    SAFE_HEAP_STORE((((uiEvent) + (20)) >> 2) * 4, outerWidth, 4);
     checkInt32(outerWidth);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((uiEvent) + (24)) >> 2), "storing")] = outerHeight;
+    SAFE_HEAP_STORE((((uiEvent) + (24)) >> 2) * 4, outerHeight, 4);
     checkInt32(outerHeight);
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((uiEvent) + (28)) >> 2), "storing")] = pageXOffset | 0;
+    SAFE_HEAP_STORE((((uiEvent) + (28)) >> 2) * 4, pageXOffset | 0, 4);
     checkInt32(pageXOffset | 0);
     // scroll offsets are float
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((uiEvent) + (32)) >> 2), "storing")] = pageYOffset | 0;
+    SAFE_HEAP_STORE((((uiEvent) + (32)) >> 2) * 4, pageYOffset | 0, 4);
     checkInt32(pageYOffset | 0);
     if (targetThread) __emscripten_run_callback_on_thread(targetThread, callbackfunc, eventTypeId, uiEvent, userData); else if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, uiEvent, userData)) e.preventDefault();
   };
@@ -6040,34 +6206,34 @@ var registerTouchEventCallback = (target, userData, useCapture, callbackfunc, ev
       touches[t.identifier].onTarget = 1;
     }
     var touchEvent = targetThread ? _malloc(1552) : JSEvents.touchEvent;
-    HEAPF64[SAFE_HEAP_INDEX(HEAPF64, ((touchEvent) >> 3), "storing")] = e.timeStamp;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, touchEvent + 12, "storing")] = e.ctrlKey;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, touchEvent + 13, "storing")] = e.shiftKey;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, touchEvent + 14, "storing")] = e.altKey;
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, touchEvent + 15, "storing")] = e.metaKey;
+    SAFE_HEAP_STORE_D(((touchEvent) >> 3) * 8, e.timeStamp, 8);
+    SAFE_HEAP_STORE(touchEvent + 12, e.ctrlKey, 1);
+    SAFE_HEAP_STORE(touchEvent + 13, e.shiftKey, 1);
+    SAFE_HEAP_STORE(touchEvent + 14, e.altKey, 1);
+    SAFE_HEAP_STORE(touchEvent + 15, e.metaKey, 1);
     var idx = touchEvent + 16;
     var targetRect = getBoundingClientRect(target);
     var numTouches = 0;
     for (let t of Object.values(touches)) {
       var idx32 = ((idx) >> 2);
       // Pre-shift the ptr to index to HEAP32 to save code size
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 0, "storing")] = t.identifier;
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 1, "storing")] = t.screenX;
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 2, "storing")] = t.screenY;
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 3, "storing")] = t.clientX;
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 4, "storing")] = t.clientY;
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 5, "storing")] = t.pageX;
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 6, "storing")] = t.pageY;
-      HEAP8[SAFE_HEAP_INDEX(HEAP8, idx + 28, "storing")] = t.isChanged;
-      HEAP8[SAFE_HEAP_INDEX(HEAP8, idx + 29, "storing")] = t.onTarget;
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 8, "storing")] = t.clientX - (targetRect.left | 0);
-      HEAP32[SAFE_HEAP_INDEX(HEAP32, idx32 + 9, "storing")] = t.clientY - (targetRect.top | 0);
+      SAFE_HEAP_STORE((idx32 + 0) * 4, t.identifier, 4);
+      SAFE_HEAP_STORE((idx32 + 1) * 4, t.screenX, 4);
+      SAFE_HEAP_STORE((idx32 + 2) * 4, t.screenY, 4);
+      SAFE_HEAP_STORE((idx32 + 3) * 4, t.clientX, 4);
+      SAFE_HEAP_STORE((idx32 + 4) * 4, t.clientY, 4);
+      SAFE_HEAP_STORE((idx32 + 5) * 4, t.pageX, 4);
+      SAFE_HEAP_STORE((idx32 + 6) * 4, t.pageY, 4);
+      SAFE_HEAP_STORE(idx + 28, t.isChanged, 1);
+      SAFE_HEAP_STORE(idx + 29, t.onTarget, 1);
+      SAFE_HEAP_STORE((idx32 + 8) * 4, t.clientX - (targetRect.left | 0), 4);
+      SAFE_HEAP_STORE((idx32 + 9) * 4, t.clientY - (targetRect.top | 0), 4);
       idx += 48;
       if (++numTouches > 31) {
         break;
       }
     }
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((touchEvent) + (8)) >> 2), "storing")] = numTouches;
+    SAFE_HEAP_STORE((((touchEvent) + (8)) >> 2) * 4, numTouches, 4);
     checkInt32(numTouches);
     if (targetThread) __emscripten_run_callback_on_thread(targetThread, callbackfunc, eventTypeId, touchEvent, userData); else if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, touchEvent, userData)) e.preventDefault();
   };
@@ -6105,10 +6271,9 @@ function _emscripten_set_touchstart_callback_on_thread(target, userData, useCapt
 var fillVisibilityChangeEventData = eventStruct => {
   var visibilityStates = [ "hidden", "visible", "prerender", "unloaded" ];
   var visibilityState = visibilityStates.indexOf(document.visibilityState);
-  // Assigning a boolean to HEAP32 with expected type coercion.
-  /** @suppress{checkTypes} */ HEAP8[SAFE_HEAP_INDEX(HEAP8, eventStruct, "storing")] = document.hidden;
+  SAFE_HEAP_STORE(eventStruct, document.hidden, 1);
   checkInt8(document.hidden);
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventStruct) + (4)) >> 2), "storing")] = visibilityState;
+  SAFE_HEAP_STORE((((eventStruct) + (4)) >> 2) * 4, visibilityState, 4);
   checkInt32(visibilityState);
 };
 
@@ -6146,10 +6311,10 @@ var registerWheelEventCallback = (target, userData, useCapture, callbackfunc, ev
     var wheelEvent = targetThread ? _malloc(96) : JSEvents.wheelEvent;
     // This allocated block is passed as satellite data to the proxied function call, so the call frees up the data block when done.
     fillMouseEventData(wheelEvent, e, target);
-    HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((wheelEvent) + (64)) >> 3), "storing")] = e["deltaX"];
-    HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((wheelEvent) + (72)) >> 3), "storing")] = e["deltaY"];
-    HEAPF64[SAFE_HEAP_INDEX(HEAPF64, (((wheelEvent) + (80)) >> 3), "storing")] = e["deltaZ"];
-    HEAP32[SAFE_HEAP_INDEX(HEAP32, (((wheelEvent) + (88)) >> 2), "storing")] = e["deltaMode"];
+    SAFE_HEAP_STORE_D((((wheelEvent) + (64)) >> 3) * 8, e["deltaX"], 8);
+    SAFE_HEAP_STORE_D((((wheelEvent) + (72)) >> 3) * 8, e["deltaY"], 8);
+    SAFE_HEAP_STORE_D((((wheelEvent) + (80)) >> 3) * 8, e["deltaZ"], 8);
+    SAFE_HEAP_STORE((((wheelEvent) + (88)) >> 2) * 4, e["deltaMode"], 4);
     checkInt32(e["deltaMode"]);
     if (targetThread) __emscripten_run_callback_on_thread(targetThread, callbackfunc, eventTypeId, wheelEvent, userData); else if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, wheelEvent, userData)) e.preventDefault();
   };
@@ -6176,64 +6341,63 @@ function _emscripten_set_wheel_callback_on_thread(target, userData, useCapture,
 }
 
 var Fetch = {
-  async openDatabase(dbname, dbversion) {
-    return new Promise((resolve, reject) => {
-      try {
-        var openRequest = indexedDB.open(dbname, dbversion);
-      } catch (e) {
-        return reject(e);
+  openDatabase(dbname, dbversion, onsuccess, onerror) {
+    try {
+      var openRequest = indexedDB.open(dbname, dbversion);
+    } catch (e) {
+      return onerror(e);
+    }
+    openRequest.onupgradeneeded = event => {
+      var db = /** @type {IDBDatabase} */ (event.target.result);
+      if (db.objectStoreNames.contains("FILES")) {
+        db.deleteObjectStore("FILES");
       }
-      openRequest.onupgradeneeded = event => {
-        var db = /** @type {IDBDatabase} */ (event.target.result);
-        if (db.objectStoreNames.contains("FILES")) {
-          db.deleteObjectStore("FILES");
-        }
-        db.createObjectStore("FILES");
-      };
-      openRequest.onsuccess = event => resolve(event.target.result);
-      openRequest.onerror = reject;
-    });
+      db.createObjectStore("FILES");
+    };
+    openRequest.onsuccess = event => onsuccess(event.target.result);
+    openRequest.onerror = onerror;
   },
-  async init() {
+  init() {
     Fetch.xhrs = new HandleAllocator;
     if (ENVIRONMENT_IS_PTHREAD) return;
-    addRunDependency("library_fetch_init");
-    try {
-      var db = await Fetch.openDatabase("emscripten_filesystem", 1);
+    var onsuccess = db => {
       Fetch.dbInstance = db;
-    } catch (e) {
+      removeRunDependency("library_fetch_init");
+    };
+    var onerror = () => {
       Fetch.dbInstance = false;
-    } finally {
       removeRunDependency("library_fetch_init");
-    }
+    };
+    addRunDependency("library_fetch_init");
+    Fetch.openDatabase("emscripten_filesystem", 1, onsuccess, onerror);
   }
 };
 
 function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
-  var url = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (8)) >> 2), "loading")];
+  var url = SAFE_HEAP_LOAD((((fetch) + (8)) >> 2) * 4, 4, 1);
   if (!url) {
-    onerror(fetch, "no url specified!");
+    onerror(fetch, 0, "no url specified!");
     return;
   }
   var url_ = UTF8ToString(url);
   var fetch_attr = fetch + 108;
   var requestMethod = UTF8ToString(fetch_attr + 0);
   requestMethod ||= "GET";
-  var timeoutMsecs = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (56)) >> 2), "loading")];
-  var userName = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (68)) >> 2), "loading")];
-  var password = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (72)) >> 2), "loading")];
-  var requestHeaders = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (76)) >> 2), "loading")];
-  var overriddenMimeType = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (80)) >> 2), "loading")];
-  var dataPtr = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (84)) >> 2), "loading")];
-  var dataLength = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (88)) >> 2), "loading")];
-  var fetchAttributes = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (52)) >> 2), "loading")];
+  var timeoutMsecs = SAFE_HEAP_LOAD((((fetch_attr) + (56)) >> 2) * 4, 4, 1);
+  var userName = SAFE_HEAP_LOAD((((fetch_attr) + (68)) >> 2) * 4, 4, 1);
+  var password = SAFE_HEAP_LOAD((((fetch_attr) + (72)) >> 2) * 4, 4, 1);
+  var requestHeaders = SAFE_HEAP_LOAD((((fetch_attr) + (76)) >> 2) * 4, 4, 1);
+  var overriddenMimeType = SAFE_HEAP_LOAD((((fetch_attr) + (80)) >> 2) * 4, 4, 1);
+  var dataPtr = SAFE_HEAP_LOAD((((fetch_attr) + (84)) >> 2) * 4, 4, 1);
+  var dataLength = SAFE_HEAP_LOAD((((fetch_attr) + (88)) >> 2) * 4, 4, 1);
+  var fetchAttributes = SAFE_HEAP_LOAD((((fetch_attr) + (52)) >> 2) * 4, 4, 1);
   var fetchAttrLoadToMemory = !!(fetchAttributes & 1);
   var fetchAttrStreamData = !!(fetchAttributes & 2);
   var fetchAttrSynchronous = !!(fetchAttributes & 64);
   var userNameStr = userName ? UTF8ToString(userName) : undefined;
   var passwordStr = password ? UTF8ToString(password) : undefined;
   var xhr = new XMLHttpRequest;
-  xhr.withCredentials = !!HEAPU8[SAFE_HEAP_INDEX(HEAPU8, (fetch_attr) + (60), "loading")];
+  xhr.withCredentials = !!SAFE_HEAP_LOAD((fetch_attr) + (60), 1, 1);
   xhr.open(requestMethod, url_, !fetchAttrSynchronous, userNameStr, passwordStr);
   if (!fetchAttrSynchronous) xhr.timeout = timeoutMsecs;
   // XHR timeout field is only accessible in async XHRs, and must be set after .open() but before .send().
@@ -6247,9 +6411,9 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
   }
   if (requestHeaders) {
     for (;;) {
-      var key = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((requestHeaders) >> 2), "loading")];
+      var key = SAFE_HEAP_LOAD(((requestHeaders) >> 2) * 4, 4, 1);
       if (!key) break;
-      var value = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((requestHeaders) + (4)) >> 2), "loading")];
+      var value = SAFE_HEAP_LOAD((((requestHeaders) + (4)) >> 2) * 4, 4, 1);
       if (!value) break;
       requestHeaders += 8;
       var keyStr = UTF8ToString(key);
@@ -6258,7 +6422,7 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
     }
   }
   var id = Fetch.xhrs.allocate(xhr);
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((fetch) >> 2), "storing")] = id;
+  SAFE_HEAP_STORE(((fetch) >> 2) * 4, id, 4);
   checkInt32(id);
   var data = (dataPtr && dataLength) ? HEAPU8.slice(dataPtr, dataPtr + dataLength) : null;
   // TODO: Support specifying custom headers to the request.
@@ -6269,7 +6433,7 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
   function saveResponseAndStatus() {
     var ptr = 0;
     var ptrLen = 0;
-    if (xhr.response && fetchAttrLoadToMemory && HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (12)) >> 2), "loading")] === 0) {
+    if (xhr.response && fetchAttrLoadToMemory && SAFE_HEAP_LOAD((((fetch) + (12)) >> 2) * 4, 4, 1) === 0) {
       ptrLen = xhr.response.byteLength;
     }
     if (ptrLen > 0) {
@@ -6278,7 +6442,7 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
       ptr = _malloc(ptrLen);
       HEAPU8.set(new Uint8Array(/** @type{Array<number>} */ (xhr.response)), ptr);
     }
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (12)) >> 2), "storing")] = ptr;
+    SAFE_HEAP_STORE((((fetch) + (12)) >> 2) * 4, ptr, 4);
     writeI53ToI64(fetch + 16, ptrLen);
     writeI53ToI64(fetch + 24, 0);
     var len = xhr.response ? xhr.response.byteLength : 0;
@@ -6288,17 +6452,11 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
       // the most recent XHR.onprogress handler.
       writeI53ToI64(fetch + 32, len);
     }
-    HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = xhr.readyState;
+    SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, xhr.readyState, 2);
     checkInt16(xhr.readyState);
-    HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = xhr.status;
+    SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, xhr.status, 2);
     checkInt16(xhr.status);
     if (xhr.statusText) stringToUTF8(xhr.statusText, fetch + 44, 64);
-    if (fetchAttrSynchronous) {
-      // The response url pointer malloc()ed here has the same lifetime as the emscripten_fetch_t structure itself has, and is
-      // freed when emscripten_fetch_close() is called.
-      var ruPtr = stringToNewUTF8(xhr.responseURL);
-      HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (200)) >> 2), "storing")] = ruPtr;
-    }
   }
   xhr.onload = e => {
     // check if xhr was aborted by user and don't try to call back
@@ -6307,9 +6465,9 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
     }
     saveResponseAndStatus();
     if (xhr.status >= 200 && xhr.status < 300) {
-      onsuccess(fetch, xhr, e);
+      onsuccess?.(fetch, xhr, e);
     } else {
-      onerror(fetch, e);
+      onerror?.(fetch, xhr, e);
     }
   };
   xhr.onerror = e => {
@@ -6318,14 +6476,14 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
       return;
     }
     saveResponseAndStatus();
-    onerror(fetch, e);
+    onerror?.(fetch, xhr, e);
   };
   xhr.ontimeout = e => {
     // check if xhr was aborted by user and don't try to call back
     if (!Fetch.xhrs.has(id)) {
       return;
     }
-    onerror(fetch, e);
+    onerror?.(fetch, xhr, e);
   };
   xhr.onprogress = e => {
     // check if xhr was aborted by user and don't try to call back
@@ -6340,20 +6498,21 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
       ptr = _malloc(ptrLen);
       HEAPU8.set(new Uint8Array(/** @type{Array<number>} */ (xhr.response)), ptr);
     }
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (12)) >> 2), "storing")] = ptr;
+    SAFE_HEAP_STORE((((fetch) + (12)) >> 2) * 4, ptr, 4);
     writeI53ToI64(fetch + 16, ptrLen);
     writeI53ToI64(fetch + 24, e.loaded - ptrLen);
     writeI53ToI64(fetch + 32, e.total);
-    HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = xhr.readyState;
+    SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, xhr.readyState, 2);
     checkInt16(xhr.readyState);
-    var status = xhr.status;
     // If loading files from a source that does not give HTTP status code, assume success if we get data bytes
-    if (xhr.readyState >= 3 && xhr.status === 0 && e.loaded > 0) status = 200;
-    HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = status;
-    checkInt16(status);
+    if (xhr.readyState >= 3 && xhr.status === 0 && e.loaded > 0) xhr.status = 200;
+    SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, xhr.status, 2);
+    checkInt16(xhr.status);
     if (xhr.statusText) stringToUTF8(xhr.statusText, fetch + 44, 64);
-    onprogress(fetch, e);
-    _free(ptr);
+    onprogress?.(fetch, xhr, e);
+    if (ptr) {
+      _free(ptr);
+    }
   };
   xhr.onreadystatechange = e => {
     // check if xhr was aborted by user and don't try to call back
@@ -6361,47 +6520,34 @@ function fetchXHR(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
       runtimeKeepalivePop();
       return;
     }
-    HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = xhr.readyState;
+    SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, xhr.readyState, 2);
     checkInt16(xhr.readyState);
     if (xhr.readyState >= 2) {
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = xhr.status;
+      SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, xhr.status, 2);
       checkInt16(xhr.status);
     }
-    if (!fetchAttrSynchronous && (xhr.readyState === 2 && xhr.responseURL.length > 0)) {
-      // The response url pointer malloc()ed here has the same lifetime as the emscripten_fetch_t structure itself has, and is
-      // freed when emscripten_fetch_close() is called.
-      var ruPtr = stringToNewUTF8(xhr.responseURL);
-      HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (200)) >> 2), "storing")] = ruPtr;
-    }
-    onreadystatechange(fetch, e);
+    onreadystatechange?.(fetch, xhr, e);
   };
   try {
     xhr.send(data);
   } catch (e) {
-    onerror(fetch, e);
+    onerror?.(fetch, xhr, e);
   }
 }
 
-var readI53FromI64 = ptr => HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((ptr) >> 2), "loading")] + HEAP32[SAFE_HEAP_INDEX(HEAP32, (((ptr) + (4)) >> 2), "loading")] * 4294967296;
+var readI53FromI64 = ptr => SAFE_HEAP_LOAD(((ptr) >> 2) * 4, 4, 1) + SAFE_HEAP_LOAD((((ptr) + (4)) >> 2) * 4, 4, 0) * 4294967296;
 
-var readI53FromU64 = ptr => HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((ptr) >> 2), "loading")] + HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((ptr) + (4)) >> 2), "loading")] * 4294967296;
+var readI53FromU64 = ptr => SAFE_HEAP_LOAD(((ptr) >> 2) * 4, 4, 1) + SAFE_HEAP_LOAD((((ptr) + (4)) >> 2) * 4, 4, 1) * 4294967296;
 
 var writeI53ToI64 = (ptr, num) => {
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((ptr) >> 2), "storing")] = num;
+  SAFE_HEAP_STORE(((ptr) >> 2) * 4, num, 4);
   checkInt32(num);
-  var lower = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((ptr) >> 2), "loading")];
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((ptr) + (4)) >> 2), "storing")] = (num - lower) / 4294967296;
+  var lower = SAFE_HEAP_LOAD(((ptr) >> 2) * 4, 4, 1);
+  SAFE_HEAP_STORE((((ptr) + (4)) >> 2) * 4, (num - lower) / 4294967296, 4);
   checkInt32((num - lower) / 4294967296);
   var deserialized = (num >= 0) ? readI53FromU64(ptr) : readI53FromI64(ptr);
   var offset = ((ptr) >> 2);
-  if (deserialized != num) warnOnce(`writeI53ToI64() out of range: serialized JS Number ${num} to Wasm heap as bytes lo=${ptrToString(HEAPU32[SAFE_HEAP_INDEX(HEAPU32, offset, "loading")])}, hi=${ptrToString(HEAPU32[SAFE_HEAP_INDEX(HEAPU32, offset + 1, "loading")])}, which deserializes back to ${deserialized} instead!`);
-};
-
-var stringToNewUTF8 = str => {
-  var size = lengthBytesUTF8(str) + 1;
-  var ret = _malloc(size);
-  if (ret) stringToUTF8(str, ret, size);
-  return ret;
+  if (deserialized != num) warnOnce(`writeI53ToI64() out of range: serialized JS Number ${num} to Wasm heap as bytes lo=${ptrToString(SAFE_HEAP_LOAD(offset * 4, 4, 1))}, hi=${ptrToString(SAFE_HEAP_LOAD((offset + 1) * 4, 4, 1))}, which deserializes back to ${deserialized} instead!`);
 };
 
 function fetchCacheData(/** @type {IDBDatabase} */ db, fetch, data, onsuccess, onerror) {
@@ -6410,18 +6556,18 @@ function fetchCacheData(/** @type {IDBDatabase} */ db, fetch, data, onsuccess, o
     return;
   }
   var fetch_attr = fetch + 108;
-  var destinationPath = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (64)) >> 2), "loading")];
-  destinationPath ||= HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (8)) >> 2), "loading")];
+  var destinationPath = SAFE_HEAP_LOAD((((fetch_attr) + (64)) >> 2) * 4, 4, 1);
+  destinationPath ||= SAFE_HEAP_LOAD((((fetch) + (8)) >> 2) * 4, 4, 1);
   var destinationPathStr = UTF8ToString(destinationPath);
   try {
     var transaction = db.transaction([ "FILES" ], "readwrite");
     var packages = transaction.objectStore("FILES");
     var putRequest = packages.put(data, destinationPathStr);
     putRequest.onsuccess = event => {
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = 4;
+      SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, 4, 2);
       checkInt16(4);
       // Mimic XHR readyState 4 === 'DONE: The operation is complete'
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = 200;
+      SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, 200, 2);
       checkInt16(200);
       // Mimic XHR HTTP status code 200 "OK"
       stringToUTF8("OK", fetch + 44, 64);
@@ -6431,10 +6577,10 @@ function fetchCacheData(/** @type {IDBDatabase} */ db, fetch, data, onsuccess, o
       // Most likely we got an error if IndexedDB is unwilling to store any more data for this page.
       // TODO: Can we identify and break down different IndexedDB-provided errors and convert those
       // to more HTTP status codes for more information?
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = 4;
+      SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, 4, 2);
       checkInt16(4);
       // Mimic XHR readyState 4 === 'DONE: The operation is complete'
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = 413;
+      SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, 413, 2);
       checkInt16(413);
       // Mimic XHR HTTP status code 413 "Payload Too Large"
       stringToUTF8("Payload Too Large", fetch + 44, 64);
@@ -6451,8 +6597,8 @@ function fetchLoadCachedData(db, fetch, onsuccess, onerror) {
     return;
   }
   var fetch_attr = fetch + 108;
-  var path = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (64)) >> 2), "loading")];
-  path ||= HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (8)) >> 2), "loading")];
+  var path = SAFE_HEAP_LOAD((((fetch_attr) + (64)) >> 2) * 4, 4, 1);
+  path ||= SAFE_HEAP_LOAD((((fetch) + (8)) >> 2) * 4, 4, 1);
   var pathStr = UTF8ToString(path);
   try {
     var transaction = db.transaction([ "FILES" ], "readonly");
@@ -6466,24 +6612,24 @@ function fetchLoadCachedData(db, fetch, onsuccess, onerror) {
         // freed when emscripten_fetch_close() is called.
         var ptr = _malloc(len);
         HEAPU8.set(new Uint8Array(value), ptr);
-        HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (12)) >> 2), "storing")] = ptr;
+        SAFE_HEAP_STORE((((fetch) + (12)) >> 2) * 4, ptr, 4);
         writeI53ToI64(fetch + 16, len);
         writeI53ToI64(fetch + 24, 0);
         writeI53ToI64(fetch + 32, len);
-        HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = 4;
+        SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, 4, 2);
         checkInt16(4);
         // Mimic XHR readyState 4 === 'DONE: The operation is complete'
-        HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = 200;
+        SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, 200, 2);
         checkInt16(200);
         // Mimic XHR HTTP status code 200 "OK"
         stringToUTF8("OK", fetch + 44, 64);
         onsuccess(fetch, 0, value);
       } else {
         // Succeeded to load, but the load came back with the value of undefined, treat that as an error since we never store undefined in db.
-        HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = 4;
+        SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, 4, 2);
         checkInt16(4);
         // Mimic XHR readyState 4 === 'DONE: The operation is complete'
-        HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = 404;
+        SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, 404, 2);
         checkInt16(404);
         // Mimic XHR HTTP status code 404 "Not Found"
         stringToUTF8("Not Found", fetch + 44, 64);
@@ -6491,10 +6637,10 @@ function fetchLoadCachedData(db, fetch, onsuccess, onerror) {
       }
     };
     getRequest.onerror = error => {
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = 4;
+      SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, 4, 2);
       checkInt16(4);
       // Mimic XHR readyState 4 === 'DONE: The operation is complete'
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = 404;
+      SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, 404, 2);
       checkInt16(404);
       // Mimic XHR HTTP status code 404 "Not Found"
       stringToUTF8("Not Found", fetch + 44, 64);
@@ -6511,8 +6657,8 @@ function fetchDeleteCachedData(db, fetch, onsuccess, onerror) {
     return;
   }
   var fetch_attr = fetch + 108;
-  var path = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (64)) >> 2), "loading")];
-  path ||= HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (8)) >> 2), "loading")];
+  var path = SAFE_HEAP_LOAD((((fetch_attr) + (64)) >> 2) * 4, 4, 1);
+  path ||= SAFE_HEAP_LOAD((((fetch) + (8)) >> 2) * 4, 4, 1);
   var pathStr = UTF8ToString(path);
   try {
     var transaction = db.transaction([ "FILES" ], "readwrite");
@@ -6520,24 +6666,24 @@ function fetchDeleteCachedData(db, fetch, onsuccess, onerror) {
     var request = packages.delete(pathStr);
     request.onsuccess = event => {
       var value = event.target.result;
-      HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch) + (12)) >> 2), "storing")] = 0;
+      SAFE_HEAP_STORE((((fetch) + (12)) >> 2) * 4, 0, 4);
       writeI53ToI64(fetch + 16, 0);
       writeI53ToI64(fetch + 24, 0);
       writeI53ToI64(fetch + 32, 0);
       // Mimic XHR readyState 4 === 'DONE: The operation is complete'
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = 4;
+      SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, 4, 2);
       checkInt16(4);
       // Mimic XHR HTTP status code 200 "OK"
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = 200;
+      SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, 200, 2);
       checkInt16(200);
       stringToUTF8("OK", fetch + 44, 64);
       onsuccess(fetch, 0, value);
     };
     request.onerror = error => {
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (40)) >> 1), "storing")] = 4;
+      SAFE_HEAP_STORE((((fetch) + (40)) >> 1) * 2, 4, 2);
       checkInt16(4);
       // Mimic XHR readyState 4 === 'DONE: The operation is complete'
-      HEAP16[SAFE_HEAP_INDEX(HEAP16, (((fetch) + (42)) >> 1), "storing")] = 404;
+      SAFE_HEAP_STORE((((fetch) + (42)) >> 1) * 2, 404, 2);
       checkInt16(404);
       // Mimic XHR HTTP status code 404 "Not Found"
       stringToUTF8("Not Found", fetch + 44, 64);
@@ -6553,11 +6699,11 @@ function _emscripten_start_fetch(fetch, successcb, errorcb, progresscb, readysta
   // response.
   runtimeKeepalivePush();
   var fetch_attr = fetch + 108;
-  var onsuccess = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (36)) >> 2), "loading")];
-  var onerror = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (40)) >> 2), "loading")];
-  var onprogress = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (44)) >> 2), "loading")];
-  var onreadystatechange = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (48)) >> 2), "loading")];
-  var fetchAttributes = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (52)) >> 2), "loading")];
+  var onsuccess = SAFE_HEAP_LOAD((((fetch_attr) + (36)) >> 2) * 4, 4, 1);
+  var onerror = SAFE_HEAP_LOAD((((fetch_attr) + (40)) >> 2) * 4, 4, 1);
+  var onprogress = SAFE_HEAP_LOAD((((fetch_attr) + (44)) >> 2) * 4, 4, 1);
+  var onreadystatechange = SAFE_HEAP_LOAD((((fetch_attr) + (48)) >> 2) * 4, 4, 1);
+  var fetchAttributes = SAFE_HEAP_LOAD((((fetch_attr) + (52)) >> 2) * 4, 4, 1);
   var fetchAttrSynchronous = !!(fetchAttributes & 64);
   function doCallback(f) {
     if (fetchAttrSynchronous) {
@@ -6572,18 +6718,18 @@ function _emscripten_start_fetch(fetch, successcb, errorcb, progresscb, readysta
       if (onsuccess) (a1 => dynCall_vi(onsuccess, a1))(fetch); else successcb?.(fetch);
     });
   };
-  var reportProgress = (fetch, e) => {
+  var reportProgress = (fetch, xhr, e) => {
     doCallback(() => {
       if (onprogress) (a1 => dynCall_vi(onprogress, a1))(fetch); else progresscb?.(fetch);
     });
   };
-  var reportError = (fetch, e) => {
+  var reportError = (fetch, xhr, e) => {
     runtimeKeepalivePop();
     doCallback(() => {
       if (onerror) (a1 => dynCall_vi(onerror, a1))(fetch); else errorcb?.(fetch);
     });
   };
-  var reportReadyStateChange = (fetch, e) => {
+  var reportReadyStateChange = (fetch, xhr, e) => {
     doCallback(() => {
       if (onreadystatechange) (a1 => dynCall_vi(onreadystatechange, a1))(fetch); else readystatechangecb?.(fetch);
     });
@@ -6615,8 +6761,8 @@ function _emscripten_start_fetch(fetch, successcb, errorcb, progresscb, readysta
   var fetchAttrNoDownload = !!(fetchAttributes & 32);
   if (requestMethod === "EM_IDB_STORE") {
     // TODO(?): Here we perform a clone of the data, because storing shared typed arrays to IndexedDB does not seem to be allowed.
-    var ptr = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (84)) >> 2), "loading")];
-    var size = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((fetch_attr) + (88)) >> 2), "loading")];
+    var ptr = SAFE_HEAP_LOAD((((fetch_attr) + (84)) >> 2) * 4, 4, 1);
+    var size = SAFE_HEAP_LOAD((((fetch_attr) + (88)) >> 2) * 4, 4, 1);
     fetchCacheData(Fetch.dbInstance, fetch, HEAPU8.slice(ptr, ptr + size), reportSuccess, reportError);
   } else if (requestMethod === "EM_IDB_DELETE") {
     fetchDeleteCachedData(Fetch.dbInstance, fetch, reportSuccess, reportError);
@@ -6644,7 +6790,7 @@ var WS = {
     // Singleton event pointer.  Use EmscriptenWebSocketCloseEvent, which is
     // the largest event struct
     this.socketEvent ||= _malloc(520);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((this.socketEvent) >> 2), "storing")] = socketId;
+    SAFE_HEAP_STORE(((this.socketEvent) >> 2) * 4, socketId, 4);
     checkInt32(socketId);
     return this.socketEvent;
   }
@@ -6683,7 +6829,7 @@ function _emscripten_websocket_get_buffered_amount(socketId, bufferedAmount) {
   if (!socket) {
     return -3;
   }
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((bufferedAmount) >> 2), "storing")] = socket.bufferedAmount;
+  SAFE_HEAP_STORE(((bufferedAmount) >> 2) * 4, socket.bufferedAmount, 4);
   return 0;
 }
 
@@ -6705,7 +6851,7 @@ function _emscripten_websocket_get_extensions_length(socketId, extensionsLength)
     return -3;
   }
   if (!extensionsLength) return -5;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, ((extensionsLength) >> 2), "storing")] = lengthBytesUTF8(socket.extensions) + 1;
+  SAFE_HEAP_STORE(((extensionsLength) >> 2) * 4, lengthBytesUTF8(socket.extensions) + 1, 4);
   checkInt32(lengthBytesUTF8(socket.extensions) + 1);
   return 0;
 }
@@ -6728,7 +6874,7 @@ function _emscripten_websocket_get_protocol_length(socketId, protocolLength) {
     return -3;
   }
   if (!protocolLength) return -5;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, ((protocolLength) >> 2), "storing")] = lengthBytesUTF8(socket.protocol) + 1;
+  SAFE_HEAP_STORE(((protocolLength) >> 2) * 4, lengthBytesUTF8(socket.protocol) + 1, 4);
   checkInt32(lengthBytesUTF8(socket.protocol) + 1);
   return 0;
 }
@@ -6739,7 +6885,7 @@ function _emscripten_websocket_get_ready_state(socketId, readyState) {
   if (!socket) {
     return -3;
   }
-  HEAP16[SAFE_HEAP_INDEX(HEAP16, ((readyState) >> 1), "storing")] = socket.readyState;
+  SAFE_HEAP_STORE(((readyState) >> 1) * 2, socket.readyState, 2);
   checkInt16(socket.readyState);
   return 0;
 }
@@ -6762,7 +6908,7 @@ function _emscripten_websocket_get_url_length(socketId, urlLength) {
     return -3;
   }
   if (!urlLength) return -5;
-  HEAP32[SAFE_HEAP_INDEX(HEAP32, ((urlLength) >> 2), "storing")] = lengthBytesUTF8(socket.url) + 1;
+  SAFE_HEAP_STORE(((urlLength) >> 2) * 4, lengthBytesUTF8(socket.url) + 1, 4);
   checkInt32(lengthBytesUTF8(socket.url) + 1);
   return 0;
 }
@@ -6774,14 +6920,14 @@ function _emscripten_websocket_is_supported() {
 
 function _emscripten_websocket_new(createAttributes) {
   if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(59, 0, 1, createAttributes);
-  if (!globalThis.WebSocket) {
+  if (typeof WebSocket == "undefined") {
     return -1;
   }
   if (!createAttributes) {
     return -5;
   }
-  var url = UTF8ToString(HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((createAttributes) >> 2), "loading")]);
-  var protocols = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((createAttributes) + (4)) >> 2), "loading")];
+  var url = UTF8ToString(SAFE_HEAP_LOAD(((createAttributes) >> 2) * 4, 4, 1));
+  var protocols = SAFE_HEAP_LOAD((((createAttributes) + (4)) >> 2) * 4, 4, 1);
   // TODO: Add support for createOnMainThread==false; currently all WebSocket connections are created on the main thread.
   // var createOnMainThread = HEAP8[createAttributes+2];
   var socket = protocols ? new WebSocket(url, UTF8ToString(protocols).split(",")) : new WebSocket(url);
@@ -6823,8 +6969,8 @@ function _emscripten_websocket_set_onclose_callback_on_thread(socketId, userData
   }
   socket.onclose = function(e) {
     var eventPtr = WS.getSocketEvent(socketId);
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, (eventPtr) + (4), "storing")] = e.wasClean;
-    checkInt8(e.wasClean), HEAP16[SAFE_HEAP_INDEX(HEAP16, (((eventPtr) + (6)) >> 1), "storing")] = e.code;
+    SAFE_HEAP_STORE((eventPtr) + (4), e.wasClean, 1);
+    checkInt8(e.wasClean), SAFE_HEAP_STORE((((eventPtr) + (6)) >> 1) * 2, e.code, 2);
     checkInt16(e.code), stringToUTF8(e.reason, eventPtr + 8, 512);
     ((a1, a2, a3) => dynCall_iiii(callbackFunc, a1, a2, a3))(0, eventPtr, userData);
   };
@@ -6844,6 +6990,13 @@ function _emscripten_websocket_set_onerror_callback_on_thread(socketId, userData
   return 0;
 }
 
+var stringToNewUTF8 = str => {
+  var size = lengthBytesUTF8(str) + 1;
+  var ret = _malloc(size);
+  if (ret) stringToUTF8(str, ret, size);
+  return ret;
+};
+
 function _emscripten_websocket_set_onmessage_callback_on_thread(socketId, userData, callbackFunc, thread) {
   if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(64, 0, 1, socketId, userData, callbackFunc, thread);
   var socket = WS.getSocket(socketId);
@@ -6861,8 +7014,8 @@ function _emscripten_websocket_set_onmessage_callback_on_thread(socketId, userDa
       HEAP8.set(new Uint8Array(e.data), buf);
     }
     var eventPtr = WS.getSocketEvent(socketId);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((eventPtr) + (4)) >> 2), "storing")] = buf, HEAP32[SAFE_HEAP_INDEX(HEAP32, (((eventPtr) + (8)) >> 2), "storing")] = len;
-    checkInt32(len), HEAP8[SAFE_HEAP_INDEX(HEAP8, (eventPtr) + (12), "storing")] = isText;
+    SAFE_HEAP_STORE((((eventPtr) + (4)) >> 2) * 4, buf, 4), SAFE_HEAP_STORE((((eventPtr) + (8)) >> 2) * 4, len, 4);
+    checkInt32(len), SAFE_HEAP_STORE((eventPtr) + (12), isText, 1);
     checkInt8(isText), ((a1, a2, a3) => dynCall_iiii(callbackFunc, a1, a2, a3))(0, eventPtr, userData);
     _free(buf);
   };
@@ -6893,7 +7046,7 @@ var getEnvStrings = () => {
   if (!getEnvStrings.strings) {
     // Default values.
     // Browser language detection #8751
-    var lang = ((typeof navigator == "object" && navigator.language) || "C").replace("-", "_") + ".UTF-8";
+    var lang = ((typeof navigator == "object" && navigator.languages && navigator.languages[0]) || "C").replace("-", "_") + ".UTF-8";
     var env = {
       "USER": "web_user",
       "LOGNAME": "web_user",
@@ -6925,7 +7078,8 @@ function _environ_get(__environ, environ_buf) {
   var envp = 0;
   for (var string of getEnvStrings()) {
     var ptr = environ_buf + bufSize;
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((__environ) + (envp)) >> 2), "storing")] = ptr;
+    SAFE_HEAP_STORE((((__environ) + (envp)) >> 2) * 4, ptr, 4);
+    checkInt32(ptr);
     bufSize += stringToUTF8(string, ptr, Infinity) + 1;
     envp += 4;
   }
@@ -6935,13 +7089,13 @@ function _environ_get(__environ, environ_buf) {
 function _environ_sizes_get(penviron_count, penviron_buf_size) {
   if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(67, 0, 1, penviron_count, penviron_buf_size);
   var strings = getEnvStrings();
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((penviron_count) >> 2), "storing")] = strings.length;
+  SAFE_HEAP_STORE(((penviron_count) >> 2) * 4, strings.length, 4);
   checkInt32(strings.length);
   var bufSize = 0;
   for (var string of strings) {
     bufSize += lengthBytesUTF8(string) + 1;
   }
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((penviron_buf_size) >> 2), "storing")] = bufSize;
+  SAFE_HEAP_STORE(((penviron_buf_size) >> 2) * 4, bufSize, 4);
   checkInt32(bufSize);
   return 0;
 }
@@ -6970,13 +7124,13 @@ function _fd_fdstat_get(fd, pbuf) {
       // assume is a character device, like the mouse, we have special APIs for).
       var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
     }
-    HEAP8[SAFE_HEAP_INDEX(HEAP8, pbuf, "storing")] = type;
+    SAFE_HEAP_STORE(pbuf, type, 1);
     checkInt8(type);
-    HEAP16[SAFE_HEAP_INDEX(HEAP16, (((pbuf) + (2)) >> 1), "storing")] = flags;
+    SAFE_HEAP_STORE((((pbuf) + (2)) >> 1) * 2, flags, 2);
     checkInt16(flags);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((pbuf) + (8)) >> 3), "storing")] = BigInt(rightsBase);
+    HEAP64[(((pbuf) + (8)) >> 3)] = BigInt(rightsBase);
     checkInt64(rightsBase);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, (((pbuf) + (16)) >> 3), "storing")] = BigInt(rightsInheriting);
+    HEAP64[(((pbuf) + (16)) >> 3)] = BigInt(rightsInheriting);
     checkInt64(rightsInheriting);
     return 0;
   } catch (e) {
@@ -6988,8 +7142,8 @@ function _fd_fdstat_get(fd, pbuf) {
 /** @param {number=} offset */ var doReadv = (stream, iov, iovcnt, offset) => {
   var ret = 0;
   for (var i = 0; i < iovcnt; i++) {
-    var ptr = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((iov) >> 2), "loading")];
-    var len = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((iov) + (4)) >> 2), "loading")];
+    var ptr = SAFE_HEAP_LOAD(((iov) >> 2) * 4, 4, 1);
+    var len = SAFE_HEAP_LOAD((((iov) + (4)) >> 2) * 4, 4, 1);
     iov += 8;
     var curr = FS.read(stream, HEAP8, ptr, len, offset);
     if (curr < 0) return -1;
@@ -7004,7 +7158,7 @@ function _fd_read(fd, iov, iovcnt, pnum) {
   try {
     var stream = SYSCALLS.getStreamFromFD(fd);
     var num = doReadv(stream, iov, iovcnt);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((pnum) >> 2), "storing")] = num;
+    SAFE_HEAP_STORE(((pnum) >> 2) * 4, num, 4);
     checkInt32(num);
     return 0;
   } catch (e) {
@@ -7020,7 +7174,7 @@ function _fd_seek(fd, offset, whence, newOffset) {
     if (isNaN(offset)) return 61;
     var stream = SYSCALLS.getStreamFromFD(fd);
     FS.llseek(stream, offset, whence);
-    HEAP64[SAFE_HEAP_INDEX(HEAP64, ((newOffset) >> 3), "storing")] = BigInt(stream.position);
+    HEAP64[((newOffset) >> 3)] = BigInt(stream.position);
     checkInt64(stream.position);
     if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
     // reset readdir state
@@ -7034,8 +7188,8 @@ function _fd_seek(fd, offset, whence, newOffset) {
 /** @param {number=} offset */ var doWritev = (stream, iov, iovcnt, offset) => {
   var ret = 0;
   for (var i = 0; i < iovcnt; i++) {
-    var ptr = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((iov) >> 2), "loading")];
-    var len = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, (((iov) + (4)) >> 2), "loading")];
+    var ptr = SAFE_HEAP_LOAD(((iov) >> 2) * 4, 4, 1);
+    var len = SAFE_HEAP_LOAD((((iov) + (4)) >> 2) * 4, 4, 1);
     iov += 8;
     var curr = FS.write(stream, HEAP8, ptr, len, offset);
     if (curr < 0) return -1;
@@ -7053,7 +7207,7 @@ function _fd_write(fd, iov, iovcnt, pnum) {
   try {
     var stream = SYSCALLS.getStreamFromFD(fd);
     var num = doWritev(stream, iov, iovcnt);
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((pnum) >> 2), "storing")] = num;
+    SAFE_HEAP_STORE(((pnum) >> 2) * 4, num, 4);
     checkInt32(num);
     return 0;
   } catch (e) {
@@ -7084,7 +7238,7 @@ var writeArrayToMemory = (array, buffer) => {
 /**
      * @param {string|null=} returnType
      * @param {Array=} argTypes
-     * @param {Array=} args
+     * @param {Arguments|Array=} args
      * @param {Object=} opts
      */ var ccall = (ident, returnType, argTypes, args, opts) => {
   // For fast lookup of conversion functions
@@ -7140,9 +7294,9 @@ var writeArrayToMemory = (array, buffer) => {
      * @param {Object=} opts
      */ var cwrap = (ident, returnType, argTypes, opts) => (...args) => ccall(ident, returnType, argTypes, args);
 
-FS.createPreloadedFile = FS_createPreloadedFile;
+PThread.init();
 
-FS.preloadFile = FS_preloadFile;
+FS.createPreloadedFile = FS_createPreloadedFile;
 
 FS.staticInit();
 
@@ -7178,13 +7332,6 @@ Fetch.init();
   assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
   assert(typeof Module["ENVIRONMENT"] == "undefined", "Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
   assert(typeof Module["STACK_SIZE"] == "undefined", "STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time");
-  if (Module["preInit"]) {
-    if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
-    while (Module["preInit"].length > 0) {
-      Module["preInit"].shift()();
-    }
-  }
-  consumedModuleProp("preInit");
 }
 
 // Begin runtime exports
@@ -7196,11 +7343,11 @@ Module["stringToNewUTF8"] = stringToNewUTF8;
 
 Module["FS"] = FS;
 
-var missingLibrarySymbols = [ "writeI53ToI64Clamped", "writeI53ToI64Signaling", "writeI53ToU64Clamped", "writeI53ToU64Signaling", "convertI32PairToI53", "convertI32PairToI53Checked", "convertU32PairToI53", "getTempRet0", "setTempRet0", "createNamedFunction", "zeroMemory", "growMemory", "withStackSave", "inetPton4", "inetNtop4", "inetPton6", "inetNtop6", "readSockaddr", "writeSockaddr", "runMainThreadEmAsm", "jstoi_q", "autoResumeAudioContext", "dynCallLegacy", "getDynCaller", "dynCall", "asmjsMangle", "alignMemory", "getNativeTypeSize", "addOnInit", "addOnPostCtor", "addOnPreMain", "STACK_SIZE", "STACK_ALIGN", "POINTER_SIZE", "ASSERTIONS", "convertJsFunctionToWasm", "getEmptyTableSlot", "updateTableMap", "getFunctionAddress", "addFunction", "removeFunction", "intArrayToString", "AsciiToString", "stringToAscii", "UTF16ToString", "stringToUTF16", "lengthBytesUTF16", "UTF32ToString", "stringToUTF32", "lengthBytesUTF32", "JSEvents_requestFullscreen", "JSEvents_resizeCanvasForFullscreen", "registerRestoreOldStyle", "hideEverythingExceptGivenElement", "restoreHiddenElements", "setLetterbox", "softFullscreenResizeWebGLRenderTarget", "doRequestFullscreen", "requestPointerLock", "setCanvasElementSizeCallingThread", "setCanvasElementSizeMainThread", "setCanvasElementSize", "getCanvasSizeCallingThread", "getCanvasSizeMainThread", "getCanvasElementSize", "jsStackTrace", "getCallstack", "convertPCtoSourceLocation", "wasiRightsToMuslOFlags", "wasiOFlagsToMuslOFlags", "safeSetTimeout", "setImmediateWrapped", "safeRequestAnimationFrame", "clearImmediateWrapped", "registerPostMainLoop", "registerPreMainLoop", "getPromise", "idsToPromises", "makePromiseCallback", "ExceptionInfo", "findMatchingCatch", "Browser_asyncPrepareDataCounter", "arraySum", "addDays", "getSocketFromFD", "getSocketAddress", "FS_mkdirTree", "_setNetworkCallback", "heapObjectForWebGLType", "toTypedArrayIndex", "webgl_enable_ANGLE_instanced_arrays", "webgl_enable_OES_vertex_array_object", "webgl_enable_WEBGL_draw_buffers", "webgl_enable_WEBGL_multi_draw", "webgl_enable_EXT_polygon_offset_clamp", "webgl_enable_EXT_clip_control", "webgl_enable_WEBGL_polygon_mode", "emscriptenWebGLGet", "computeUnpackAlignedImageSize", "colorChannelsInGlTextureFormat", "emscriptenWebGLGetTexPixelData", "emscriptenWebGLGetUniform", "webglGetUniformLocation", "webglPrepareUniformLocationsBeforeFirstUse", "webglGetLeftBracePos", "emscriptenWebGLGetVertexAttrib", "__glGetActiveAttribOrUniform", "writeGLArray", "emscripten_webgl_destroy_context_before_on_calling_thread", "registerWebGlEventCallback", "runAndAbortIfError", "ALLOC_NORMAL", "ALLOC_STACK", "allocate", "writeStringToMemory", "writeAsciiToMemory", "demangle", "stackTrace" ];
+var missingLibrarySymbols = [ "writeI53ToI64Clamped", "writeI53ToI64Signaling", "writeI53ToU64Clamped", "writeI53ToU64Signaling", "convertI32PairToI53", "convertI32PairToI53Checked", "convertU32PairToI53", "getTempRet0", "setTempRet0", "zeroMemory", "growMemory", "inetPton4", "inetNtop4", "inetPton6", "inetNtop6", "readSockaddr", "writeSockaddr", "emscriptenLog", "runMainThreadEmAsm", "jstoi_q", "listenOnce", "autoResumeAudioContext", "dynCallLegacy", "getDynCaller", "dynCall", "asmjsMangle", "alignMemory", "getNativeTypeSize", "addOnInit", "addOnPostCtor", "addOnPreMain", "STACK_SIZE", "STACK_ALIGN", "POINTER_SIZE", "ASSERTIONS", "uleb128Encode", "sigToWasmTypes", "generateFuncType", "convertJsFunctionToWasm", "getEmptyTableSlot", "updateTableMap", "getFunctionAddress", "addFunction", "removeFunction", "reallyNegative", "strLen", "reSign", "formatString", "intArrayToString", "AsciiToString", "stringToAscii", "UTF16ToString", "stringToUTF16", "lengthBytesUTF16", "UTF32ToString", "stringToUTF32", "lengthBytesUTF32", "JSEvents_requestFullscreen", "JSEvents_resizeCanvasForFullscreen", "registerRestoreOldStyle", "hideEverythingExceptGivenElement", "restoreHiddenElements", "setLetterbox", "softFullscreenResizeWebGLRenderTarget", "doRequestFullscreen", "requestPointerLock", "setCanvasElementSizeCallingThread", "setCanvasElementSizeMainThread", "setCanvasElementSize", "getCanvasSizeCallingThread", "getCanvasSizeMainThread", "getCanvasElementSize", "jsStackTrace", "getCallstack", "convertPCtoSourceLocation", "wasiRightsToMuslOFlags", "wasiOFlagsToMuslOFlags", "safeSetTimeout", "setImmediateWrapped", "safeRequestAnimationFrame", "clearImmediateWrapped", "registerPostMainLoop", "registerPreMainLoop", "getPromise", "idsToPromises", "makePromiseCallback", "ExceptionInfo", "findMatchingCatch", "Browser_asyncPrepareDataCounter", "arraySum", "addDays", "getSocketFromFD", "getSocketAddress", "FS_mkdirTree", "_setNetworkCallback", "heapObjectForWebGLType", "toTypedArrayIndex", "webgl_enable_ANGLE_instanced_arrays", "webgl_enable_OES_vertex_array_object", "webgl_enable_WEBGL_draw_buffers", "webgl_enable_WEBGL_multi_draw", "webgl_enable_EXT_polygon_offset_clamp", "webgl_enable_EXT_clip_control", "webgl_enable_WEBGL_polygon_mode", "emscriptenWebGLGet", "computeUnpackAlignedImageSize", "colorChannelsInGlTextureFormat", "emscriptenWebGLGetTexPixelData", "emscriptenWebGLGetUniform", "webglGetUniformLocation", "webglPrepareUniformLocationsBeforeFirstUse", "webglGetLeftBracePos", "emscriptenWebGLGetVertexAttrib", "__glGetActiveAttribOrUniform", "writeGLArray", "emscripten_webgl_destroy_context_before_on_calling_thread", "registerWebGlEventCallback", "runAndAbortIfError", "ALLOC_NORMAL", "ALLOC_STACK", "allocate", "writeStringToMemory", "writeAsciiToMemory", "demangle", "stackTrace" ];
 
 missingLibrarySymbols.forEach(missingLibrarySymbol);
 
-var unexportedSymbols = [ "run", "out", "err", "callMain", "abort", "wasmMemory", "wasmExports", "HEAPF32", "HEAPF64", "HEAP8", "HEAPU8", "HEAP16", "HEAPU16", "HEAP32", "HEAPU32", "HEAP64", "HEAPU64", "writeStackCookie", "checkStackCookie", "writeI53ToI64", "readI53FromI64", "readI53FromU64", "INT53_MAX", "INT53_MIN", "bigintToI53Checked", "stackSave", "stackRestore", "stackAlloc", "ptrToString", "exitJS", "getHeapMax", "abortOnCannotGrowMemory", "ENV", "ERRNO_CODES", "strError", "DNS", "Protocols", "Sockets", "timers", "warnOnce", "readEmAsmArgsArray", "readEmAsmArgs", "runEmAsmFunction", "getExecutableName", "handleException", "keepRuntimeAlive", "runtimeKeepalivePush", "runtimeKeepalivePop", "callUserCallback", "maybeExit", "asyncLoad", "mmapAlloc", "HandleAllocator", "wasmTable", "getUniqueRunDependency", "noExitRuntime", "addRunDependency", "removeRunDependency", "addOnPreRun", "addOnExit", "addOnPostRun", "freeTableIndexes", "functionsInTableMap", "setValue", "getValue", "PATH", "PATH_FS", "UTF8Decoder", "UTF8ArrayToString", "UTF8ToString", "stringToUTF8Array", "stringToUTF8", "lengthBytesUTF8", "intArrayFromString", "UTF16Decoder", "stringToUTF8OnStack", "writeArrayToMemory", "JSEvents", "registerKeyEventCallback", "specialHTMLTargets", "maybeCStringToJsString", "findEventTarget", "findCanvasEventTarget", "getBoundingClientRect", "fillMouseEventData", "registerMouseEventCallback", "registerWheelEventCallback", "registerUiEventCallback", "registerFocusEventCallback", "fillDeviceOrientationEventData", "registerDeviceOrientationEventCallback", "fillDeviceMotionEventData", "registerDeviceMotionEventCallback", "screenOrientation", "fillOrientationChangeEventData", "registerOrientationChangeEventCallback", "fillFullscreenChangeEventData", "registerFullscreenChangeEventCallback", "currentFullscreenStrategy", "restoreOldWindowedStyle", "fillPointerlockChangeEventData", "registerPointerlockChangeEventCallback", "registerPointerlockErrorEventCallback", "fillVisibilityChangeEventData", "registerVisibilityChangeEventCallback", "registerTouchEventCallback", "fillGamepadEventData", "registerGamepadEventCallback", "registerBeforeUnloadEventCallback", "fillBatteryEventData", "registerBatteryEventCallback", "UNWIND_CACHE", "ExitStatus", "getEnvStrings", "checkWasiClock", "doReadv", "doWritev", "initRandomFill", "randomFill", "emSetImmediate", "emClearImmediate_deps", "emClearImmediate", "promiseMap", "makePromise", "uncaughtExceptionCount", "exceptionLast", "exceptionCaught", "Browser", "requestFullscreen", "requestFullScreen", "setCanvasSize", "getUserMedia", "createContext", "getPreloadedImageData__data", "wget", "MONTH_DAYS_REGULAR", "MONTH_DAYS_LEAP", "MONTH_DAYS_REGULAR_CUMULATIVE", "MONTH_DAYS_LEAP_CUMULATIVE", "isLeapYear", "ydayFromDate", "SYSCALLS", "preloadPlugins", "FS_createPreloadedFile", "FS_preloadFile", "FS_modeStringToFlags", "FS_getMode", "FS_stdin_getChar_buffer", "FS_stdin_getChar", "FS_unlink", "FS_createPath", "FS_createDevice", "FS_readFile", "FS_root", "FS_mounts", "FS_devices", "FS_streams", "FS_nextInode", "FS_nameTable", "FS_currentPath", "FS_initialized", "FS_ignorePermissions", "FS_filesystems", "FS_syncFSRequests", "FS_readFiles", "FS_lookupPath", "FS_getPath", "FS_hashName", "FS_hashAddNode", "FS_hashRemoveNode", "FS_lookupNode", "FS_createNode", "FS_destroyNode", "FS_isRoot", "FS_isMountpoint", "FS_isFile", "FS_isDir", "FS_isLink", "FS_isChrdev", "FS_isBlkdev", "FS_isFIFO", "FS_isSocket", "FS_flagsToPermissionString", "FS_nodePermissions", "FS_mayLookup", "FS_mayCreate", "FS_mayDelete", "FS_mayOpen", "FS_checkOpExists", "FS_nextfd", "FS_getStreamChecked", "FS_getStream", "FS_createStream", "FS_closeStream", "FS_dupStream", "FS_doSetAttr", "FS_chrdev_stream_ops", "FS_major", "FS_minor", "FS_makedev", "FS_registerDevice", "FS_getDevice", "FS_getMounts", "FS_syncfs", "FS_mount", "FS_unmount", "FS_lookup", "FS_mknod", "FS_statfs", "FS_statfsStream", "FS_statfsNode", "FS_create", "FS_mkdir", "FS_mkdev", "FS_symlink", "FS_rename", "FS_rmdir", "FS_readdir", "FS_readlink", "FS_stat", "FS_fstat", "FS_lstat", "FS_doChmod", "FS_chmod", "FS_lchmod", "FS_fchmod", "FS_doChown", "FS_chown", "FS_lchown", "FS_fchown", "FS_doTruncate", "FS_truncate", "FS_ftruncate", "FS_utime", "FS_open", "FS_close", "FS_isClosed", "FS_llseek", "FS_read", "FS_write", "FS_mmap", "FS_msync", "FS_ioctl", "FS_writeFile", "FS_cwd", "FS_chdir", "FS_createDefaultDirectories", "FS_createDefaultDevices", "FS_createSpecialDirectories", "FS_createStandardStreams", "FS_staticInit", "FS_init", "FS_quit", "FS_findObject", "FS_analyzePath", "FS_createFile", "FS_createDataFile", "FS_forceLoadFile", "FS_createLazyFile", "FS_absolutePath", "FS_createFolder", "FS_createLink", "FS_joinPath", "FS_mmapAlloc", "FS_standardizePath", "MEMFS", "TTY", "PIPEFS", "SOCKFS", "tempFixedLengthArray", "miniTempWebGLFloatBuffers", "miniTempWebGLIntBuffers", "GL", "AL", "GLUT", "EGL", "GLEW", "IDBStore", "SDL", "SDL_gfx", "allocateUTF8", "allocateUTF8OnStack", "print", "printErr", "jstoi_s", "PThread", "terminateWorker", "cleanupThread", "registerTLSInit", "spawnThread", "exitOnMainThread", "proxyToMainThread", "proxiedJSCallArgs", "invokeEntryPoint", "checkMailbox", "webSockets", "WS", "WORKERFS", "Fetch", "fetchDeleteCachedData", "fetchLoadCachedData", "fetchCacheData", "fetchXHR" ];
+var unexportedSymbols = [ "run", "addRunDependency", "removeRunDependency", "out", "err", "callMain", "abort", "wasmMemory", "wasmExports", "HEAPF32", "HEAPF64", "HEAP8", "HEAPU8", "HEAP16", "HEAPU16", "HEAP32", "HEAPU32", "HEAP64", "HEAPU64", "writeStackCookie", "checkStackCookie", "writeI53ToI64", "readI53FromI64", "readI53FromU64", "INT53_MAX", "INT53_MIN", "bigintToI53Checked", "stackSave", "stackRestore", "stackAlloc", "ptrToString", "exitJS", "getHeapMax", "abortOnCannotGrowMemory", "ENV", "ERRNO_CODES", "strError", "DNS", "Protocols", "Sockets", "timers", "warnOnce", "readEmAsmArgsArray", "readEmAsmArgs", "runEmAsmFunction", "getExecutableName", "handleException", "keepRuntimeAlive", "runtimeKeepalivePush", "runtimeKeepalivePop", "callUserCallback", "maybeExit", "asyncLoad", "mmapAlloc", "HandleAllocator", "wasmTable", "noExitRuntime", "addOnPreRun", "addOnExit", "addOnPostRun", "getCFunc", "freeTableIndexes", "functionsInTableMap", "unSign", "setValue", "getValue", "PATH", "PATH_FS", "UTF8Decoder", "UTF8ArrayToString", "UTF8ToString", "stringToUTF8Array", "stringToUTF8", "lengthBytesUTF8", "intArrayFromString", "UTF16Decoder", "stringToUTF8OnStack", "writeArrayToMemory", "JSEvents", "registerKeyEventCallback", "specialHTMLTargets", "maybeCStringToJsString", "findEventTarget", "findCanvasEventTarget", "getBoundingClientRect", "fillMouseEventData", "registerMouseEventCallback", "registerWheelEventCallback", "registerUiEventCallback", "registerFocusEventCallback", "fillDeviceOrientationEventData", "registerDeviceOrientationEventCallback", "fillDeviceMotionEventData", "registerDeviceMotionEventCallback", "screenOrientation", "fillOrientationChangeEventData", "registerOrientationChangeEventCallback", "fillFullscreenChangeEventData", "registerFullscreenChangeEventCallback", "currentFullscreenStrategy", "restoreOldWindowedStyle", "fillPointerlockChangeEventData", "registerPointerlockChangeEventCallback", "registerPointerlockErrorEventCallback", "fillVisibilityChangeEventData", "registerVisibilityChangeEventCallback", "registerTouchEventCallback", "fillGamepadEventData", "registerGamepadEventCallback", "registerBeforeUnloadEventCallback", "fillBatteryEventData", "battery", "registerBatteryEventCallback", "UNWIND_CACHE", "ExitStatus", "getEnvStrings", "checkWasiClock", "doReadv", "doWritev", "initRandomFill", "randomFill", "emSetImmediate", "emClearImmediate_deps", "emClearImmediate", "promiseMap", "makePromise", "uncaughtExceptionCount", "exceptionLast", "exceptionCaught", "Browser", "getPreloadedImageData__data", "wget", "MONTH_DAYS_REGULAR", "MONTH_DAYS_LEAP", "MONTH_DAYS_REGULAR_CUMULATIVE", "MONTH_DAYS_LEAP_CUMULATIVE", "isLeapYear", "ydayFromDate", "SYSCALLS", "preloadPlugins", "FS_createPreloadedFile", "FS_modeStringToFlags", "FS_getMode", "FS_stdin_getChar_buffer", "FS_stdin_getChar", "FS_unlink", "FS_createPath", "FS_createDevice", "FS_readFile", "FS_root", "FS_mounts", "FS_devices", "FS_streams", "FS_nextInode", "FS_nameTable", "FS_currentPath", "FS_initialized", "FS_ignorePermissions", "FS_filesystems", "FS_syncFSRequests", "FS_readFiles", "FS_lookupPath", "FS_getPath", "FS_hashName", "FS_hashAddNode", "FS_hashRemoveNode", "FS_lookupNode", "FS_createNode", "FS_destroyNode", "FS_isRoot", "FS_isMountpoint", "FS_isFile", "FS_isDir", "FS_isLink", "FS_isChrdev", "FS_isBlkdev", "FS_isFIFO", "FS_isSocket", "FS_flagsToPermissionString", "FS_nodePermissions", "FS_mayLookup", "FS_mayCreate", "FS_mayDelete", "FS_mayOpen", "FS_checkOpExists", "FS_nextfd", "FS_getStreamChecked", "FS_getStream", "FS_createStream", "FS_closeStream", "FS_dupStream", "FS_doSetAttr", "FS_chrdev_stream_ops", "FS_major", "FS_minor", "FS_makedev", "FS_registerDevice", "FS_getDevice", "FS_getMounts", "FS_syncfs", "FS_mount", "FS_unmount", "FS_lookup", "FS_mknod", "FS_statfs", "FS_statfsStream", "FS_statfsNode", "FS_create", "FS_mkdir", "FS_mkdev", "FS_symlink", "FS_rename", "FS_rmdir", "FS_readdir", "FS_readlink", "FS_stat", "FS_fstat", "FS_lstat", "FS_doChmod", "FS_chmod", "FS_lchmod", "FS_fchmod", "FS_doChown", "FS_chown", "FS_lchown", "FS_fchown", "FS_doTruncate", "FS_truncate", "FS_ftruncate", "FS_utime", "FS_open", "FS_close", "FS_isClosed", "FS_llseek", "FS_read", "FS_write", "FS_mmap", "FS_msync", "FS_ioctl", "FS_writeFile", "FS_cwd", "FS_chdir", "FS_createDefaultDirectories", "FS_createDefaultDevices", "FS_createSpecialDirectories", "FS_createStandardStreams", "FS_staticInit", "FS_init", "FS_quit", "FS_findObject", "FS_analyzePath", "FS_createFile", "FS_createDataFile", "FS_forceLoadFile", "FS_createLazyFile", "FS_absolutePath", "FS_createFolder", "FS_createLink", "FS_joinPath", "FS_mmapAlloc", "FS_standardizePath", "MEMFS", "TTY", "PIPEFS", "SOCKFS", "tempFixedLengthArray", "miniTempWebGLFloatBuffers", "miniTempWebGLIntBuffers", "GL", "AL", "GLUT", "EGL", "GLEW", "IDBStore", "SDL", "SDL_gfx", "allocateUTF8", "allocateUTF8OnStack", "print", "printErr", "jstoi_s", "PThread", "terminateWorker", "cleanupThread", "registerTLSInit", "spawnThread", "exitOnMainThread", "proxyToMainThread", "proxiedJSCallArgs", "invokeEntryPoint", "checkMailbox", "webSockets", "WS", "WORKERFS", "Fetch", "fetchDeleteCachedData", "fetchLoadCachedData", "fetchCacheData", "fetchXHR" ];
 
 unexportedSymbols.forEach(unexportedRuntimeSymbol);
 
@@ -7219,19 +7366,19 @@ function checkIncomingModuleAPI() {
 }
 
 var ASM_CONSTS = {
-  78367: ($0, $1) => {
+  77551: ($0, $1) => {
     promiseMap.get($0).resolve($1);
   },
-  78403: ($0, $1) => {
+  77587: ($0, $1) => {
     promiseMap.get($0).reject($1);
   },
-  78438: ($0, $1) => {
+  77622: ($0, $1) => {
     promiseMap.get($0).resolve(UTF8ToString($1));
   },
-  78488: ($0, $1) => {
+  77672: ($0, $1) => {
     promiseMap.get($0).reject(UTF8ToString($1));
   },
-  78537: $0 => {
+  77721: $0 => {
     Module["onTrackedObjectDelete"]($0);
   }
 };
@@ -7240,11 +7387,11 @@ function js_tracked_eval(code, size, debug) {
   const keys = Module["onRunTrackedJs"](UTF8ToString(code), debug);
   const error = keys === null;
   if (error) {
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, size / HEAPU32.BYTES_PER_ELEMENT, "storing")] = 0;
+    SAFE_HEAP_STORE(size / HEAPU32.BYTES_PER_ELEMENT * 4, 0, 4);
     return 0;
   }
   const ptr = Module["_malloc"](keys.length * HEAPU32.BYTES_PER_ELEMENT);
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, size / HEAPU32.BYTES_PER_ELEMENT, "storing")] = keys.length;
+  SAFE_HEAP_STORE(size / HEAPU32.BYTES_PER_ELEMENT * 4, keys.length, 4);
   HEAPU32.set(keys, ptr / HEAPU32.BYTES_PER_ELEMENT);
   return ptr;
 }
@@ -7279,120 +7426,30 @@ function js_get_tracked_objects(keys_ptr, keys_n, sizes, statuses, objects_n, st
       byteSize = lengthBytesUTF8(object);
       stringsN += 1;
     }
-    HEAPU8[SAFE_HEAP_INDEX(HEAPU8, statusPtr / HEAPU8.BYTES_PER_ELEMENT + i, "storing")] = status;
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, sizesPtr / HEAPU32.BYTES_PER_ELEMENT + i, "storing")] = byteSize;
+    SAFE_HEAP_STORE(statusPtr / HEAPU8.BYTES_PER_ELEMENT + i, status, 1);
+    SAFE_HEAP_STORE((sizesPtr / HEAPU32.BYTES_PER_ELEMENT + i) * 4, byteSize, 4);
     allByteSize += byteSize;
   }
   const stringsPtr = Module["_malloc"](allByteSize * HEAPU8.BYTES_PER_ELEMENT);
   let currentStringsPtr = stringsPtr;
   for (let i = 0; i < n; ++i) {
-    const status = HEAPU8[SAFE_HEAP_INDEX(HEAPU8, statusPtr / HEAPU8.BYTES_PER_ELEMENT + i, "loading")];
+    const status = SAFE_HEAP_LOAD(statusPtr / HEAPU8.BYTES_PER_ELEMENT + i, 1, 1);
     if (status !== OK) {
       continue;
     }
     const string = objects[i];
-    const size = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, sizesPtr / HEAPU32.BYTES_PER_ELEMENT + i, "loading")];
+    const size = SAFE_HEAP_LOAD((sizesPtr / HEAPU32.BYTES_PER_ELEMENT + i) * 4, 4, 1);
     stringToUTF8(string, currentStringsPtr, size + 1);
     currentStringsPtr += size;
   }
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, statuses / HEAPU32.BYTES_PER_ELEMENT, "storing")] = statusPtr;
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, sizes / HEAPU32.BYTES_PER_ELEMENT, "storing")] = sizesPtr;
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, objects_n / HEAPU32.BYTES_PER_ELEMENT, "storing")] = n;
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, strings_n / HEAPU32.BYTES_PER_ELEMENT, "storing")] = stringsN;
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, all_byte_size / HEAPU32.BYTES_PER_ELEMENT, "storing")] = allByteSize;
+  SAFE_HEAP_STORE(statuses / HEAPU32.BYTES_PER_ELEMENT * 4, statusPtr, 4);
+  SAFE_HEAP_STORE(sizes / HEAPU32.BYTES_PER_ELEMENT * 4, sizesPtr, 4);
+  SAFE_HEAP_STORE(objects_n / HEAPU32.BYTES_PER_ELEMENT * 4, n, 4);
+  SAFE_HEAP_STORE(strings_n / HEAPU32.BYTES_PER_ELEMENT * 4, stringsN, 4);
+  SAFE_HEAP_STORE(all_byte_size / HEAPU32.BYTES_PER_ELEMENT * 4, allByteSize, 4);
   return stringsPtr;
 }
 
-// Imports from the Wasm binary.
-Module["_cast"] = makeInvalidEarlyAccess("_cast");
-
-Module["_call"] = makeInvalidEarlyAccess("_call");
-
-Module["_next_tracked_object_key"] = makeInvalidEarlyAccess("_next_tracked_object_key");
-
-Module["_main"] = makeInvalidEarlyAccess("_main");
-
-var _free = makeInvalidEarlyAccess("_free");
-
-var _malloc = Module["_malloc"] = makeInvalidEarlyAccess("_malloc");
-
-var _fflush = makeInvalidEarlyAccess("_fflush");
-
-var _pthread_self = makeInvalidEarlyAccess("_pthread_self");
-
-var __emscripten_proxy_main = Module["__emscripten_proxy_main"] = makeInvalidEarlyAccess("__emscripten_proxy_main");
-
-var _emscripten_stack_get_base = makeInvalidEarlyAccess("_emscripten_stack_get_base");
-
-var _emscripten_stack_get_end = makeInvalidEarlyAccess("_emscripten_stack_get_end");
-
-var __emscripten_run_callback_on_thread = makeInvalidEarlyAccess("__emscripten_run_callback_on_thread");
-
-var __emscripten_thread_init = makeInvalidEarlyAccess("__emscripten_thread_init");
-
-var __emscripten_thread_crashed = makeInvalidEarlyAccess("__emscripten_thread_crashed");
-
-var __emscripten_run_js_on_main_thread = makeInvalidEarlyAccess("__emscripten_run_js_on_main_thread");
-
-var __emscripten_thread_free_data = makeInvalidEarlyAccess("__emscripten_thread_free_data");
-
-var __emscripten_thread_exit = makeInvalidEarlyAccess("__emscripten_thread_exit");
-
-var _strerror = makeInvalidEarlyAccess("_strerror");
-
-var __emscripten_check_mailbox = makeInvalidEarlyAccess("__emscripten_check_mailbox");
-
-var _sbrk = makeInvalidEarlyAccess("_sbrk");
-
-var _emscripten_stack_init = makeInvalidEarlyAccess("_emscripten_stack_init");
-
-var _emscripten_stack_set_limits = makeInvalidEarlyAccess("_emscripten_stack_set_limits");
-
-var __emscripten_stack_restore = makeInvalidEarlyAccess("__emscripten_stack_restore");
-
-var __emscripten_stack_alloc = makeInvalidEarlyAccess("__emscripten_stack_alloc");
-
-var _emscripten_stack_get_current = makeInvalidEarlyAccess("_emscripten_stack_get_current");
-
-var dynCall_iiii = makeInvalidEarlyAccess("dynCall_iiii");
-
-var dynCall_ii = makeInvalidEarlyAccess("dynCall_ii");
-
-var dynCall_vi = makeInvalidEarlyAccess("dynCall_vi");
-
-function assignWasmExports(wasmExports) {
-  Module["_cast"] = createExportWrapper("cast", 2);
-  Module["_call"] = createExportWrapper("call", 2);
-  Module["_next_tracked_object_key"] = createExportWrapper("next_tracked_object_key", 0);
-  Module["_main"] = createExportWrapper("__main_argc_argv", 2);
-  _free = createExportWrapper("free", 1);
-  _malloc = Module["_malloc"] = createExportWrapper("malloc", 1);
-  _fflush = createExportWrapper("fflush", 1);
-  _pthread_self = createExportWrapper("pthread_self", 0);
-  __emscripten_proxy_main = Module["__emscripten_proxy_main"] = createExportWrapper("_emscripten_proxy_main", 2);
-  _emscripten_stack_get_base = wasmExports["emscripten_stack_get_base"];
-  _emscripten_stack_get_end = wasmExports["emscripten_stack_get_end"];
-  __emscripten_run_callback_on_thread = createExportWrapper("_emscripten_run_callback_on_thread", 5);
-  __emscripten_thread_init = createExportWrapper("_emscripten_thread_init", 6);
-  __emscripten_thread_crashed = createExportWrapper("_emscripten_thread_crashed", 0);
-  __emscripten_run_js_on_main_thread = createExportWrapper("_emscripten_run_js_on_main_thread", 5);
-  __emscripten_thread_free_data = createExportWrapper("_emscripten_thread_free_data", 1);
-  __emscripten_thread_exit = createExportWrapper("_emscripten_thread_exit", 1);
-  _strerror = createExportWrapper("strerror", 1);
-  __emscripten_check_mailbox = createExportWrapper("_emscripten_check_mailbox", 0);
-  _sbrk = createExportWrapper("sbrk", 1);
-  _emscripten_stack_init = wasmExports["emscripten_stack_init"];
-  _emscripten_stack_set_limits = wasmExports["emscripten_stack_set_limits"];
-  wasmExports["emscripten_stack_get_free"];
-  __emscripten_stack_restore = wasmExports["_emscripten_stack_restore"];
-  __emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"];
-  _emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"];
-  dynCall_iiii = createExportWrapper("dynCall_iiii", 4);
-  dynCall_ii = createExportWrapper("dynCall_ii", 2);
-  dynCall_vi = createExportWrapper("dynCall_vi", 2);
-  wasmExports["__indirect_function_table"];
-}
-
 var wasmImports;
 
 function assignWasmImports() {
@@ -7502,6 +7559,96 @@ function assignWasmImports() {
   };
 }
 
+var wasmExports = await createWasm();
+
+Module["_cast"] = createExportWrapper("cast", 2);
+
+Module["_call"] = createExportWrapper("call", 2);
+
+Module["_next_tracked_object_key"] = createExportWrapper("next_tracked_object_key", 0);
+
+Module["_main"] = createExportWrapper("__main_argc_argv", 2);
+
+var _free = createExportWrapper("free", 1);
+
+var _malloc = Module["_malloc"] = createExportWrapper("malloc", 1);
+
+var _fflush = createExportWrapper("fflush", 1);
+
+var _pthread_self = () => (_pthread_self = wasmExports["pthread_self"])();
+
+var __emscripten_proxy_main = Module["__emscripten_proxy_main"] = createExportWrapper("_emscripten_proxy_main", 2);
+
+var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports["emscripten_stack_get_base"])();
+
+var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports["emscripten_stack_get_end"])();
+
+var __emscripten_run_callback_on_thread = createExportWrapper("_emscripten_run_callback_on_thread", 5);
+
+var __emscripten_thread_init = createExportWrapper("_emscripten_thread_init", 6);
+
+var __emscripten_thread_crashed = createExportWrapper("_emscripten_thread_crashed", 0);
+
+var __emscripten_run_on_main_thread_js = createExportWrapper("_emscripten_run_on_main_thread_js", 5);
+
+var __emscripten_thread_free_data = createExportWrapper("_emscripten_thread_free_data", 1);
+
+var __emscripten_thread_exit = createExportWrapper("_emscripten_thread_exit", 1);
+
+var _strerror = createExportWrapper("strerror", 1);
+
+var __emscripten_check_mailbox = createExportWrapper("_emscripten_check_mailbox", 0);
+
+var _sbrk = createExportWrapper("sbrk", 1);
+
+var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports["emscripten_stack_init"])();
+
+var _emscripten_stack_set_limits = (a0, a1) => (_emscripten_stack_set_limits = wasmExports["emscripten_stack_set_limits"])(a0, a1);
+
+var __emscripten_stack_restore = a0 => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0);
+
+var __emscripten_stack_alloc = a0 => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);
+
+var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"])();
+
+Module["dynCall_vii"] = createExportWrapper("dynCall_vii", 3);
+
+Module["dynCall_iii"] = createExportWrapper("dynCall_iii", 3);
+
+Module["dynCall_jjj"] = createExportWrapper("dynCall_jjj", 3);
+
+Module["dynCall_iiiiiiiii"] = createExportWrapper("dynCall_iiiiiiiii", 9);
+
+Module["dynCall_iiiiii"] = createExportWrapper("dynCall_iiiiii", 6);
+
+var dynCall_iiii = Module["dynCall_iiii"] = createExportWrapper("dynCall_iiii", 4);
+
+Module["dynCall_iiiii"] = createExportWrapper("dynCall_iiiii", 5);
+
+Module["dynCall_iiiiiii"] = createExportWrapper("dynCall_iiiiiii", 7);
+
+var dynCall_ii = Module["dynCall_ii"] = createExportWrapper("dynCall_ii", 2);
+
+Module["dynCall_viiii"] = createExportWrapper("dynCall_viiii", 5);
+
+Module["dynCall_dd"] = createExportWrapper("dynCall_dd", 2);
+
+Module["dynCall_ddd"] = createExportWrapper("dynCall_ddd", 3);
+
+var dynCall_vi = Module["dynCall_vi"] = createExportWrapper("dynCall_vi", 2);
+
+Module["dynCall_viii"] = createExportWrapper("dynCall_viii", 4);
+
+Module["dynCall_iiiiiiii"] = createExportWrapper("dynCall_iiiiiiii", 8);
+
+Module["dynCall_i"] = createExportWrapper("dynCall_i", 1);
+
+Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji", 4);
+
+Module["dynCall_v"] = createExportWrapper("dynCall_v", 1);
+
+Module["dynCall_iidiiii"] = createExportWrapper("dynCall_iidiiii", 7);
+
 // include: postamble.js
 // === Auto-generated postamble setup entry stuff ===
 var calledRun;
@@ -7518,10 +7665,10 @@ function callMain(args = []) {
   var argv = stackAlloc((argc + 1) * 4);
   var argv_ptr = argv;
   args.forEach(arg => {
-    HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((argv_ptr) >> 2), "storing")] = stringToUTF8OnStack(arg);
+    SAFE_HEAP_STORE(((argv_ptr) >> 2) * 4, stringToUTF8OnStack(arg), 4);
     argv_ptr += 4;
   });
-  HEAPU32[SAFE_HEAP_INDEX(HEAPU32, ((argv_ptr) >> 2), "storing")] = 0;
+  SAFE_HEAP_STORE(((argv_ptr) >> 2) * 4, 0, 4);
   try {
     var ret = entryFunction(argc, argv);
     // if we're not running an evented main loop, it's time to exit
@@ -7549,7 +7696,7 @@ function run(args = arguments_) {
     return;
   }
   if ((ENVIRONMENT_IS_PTHREAD)) {
-    readyPromiseResolve?.(Module);
+    readyPromiseResolve(Module);
     initRuntime();
     return;
   }
@@ -7569,7 +7716,7 @@ function run(args = arguments_) {
     if (ABORT) return;
     initRuntime();
     preMain();
-    readyPromiseResolve?.(Module);
+    readyPromiseResolve(Module);
     Module["onRuntimeInitialized"]?.();
     consumedModuleProp("onRuntimeInitialized");
     var noInitialRun = Module["noInitialRun"] || false;
@@ -7628,32 +7775,27 @@ function checkUnflushedContent() {
   }
 }
 
-var wasmExports;
-
-if ((!(ENVIRONMENT_IS_PTHREAD))) {
-  // Call createWasm on startup if we are the main thread.
-  // Worker threads call this once they receive the module via postMessage
-  // In modularize mode the generated code is within a factory function so we
-  // can use await here (since it's not top-level-await).
-  wasmExports = await (createWasm());
-  run();
+function preInit() {
+  if (Module["preInit"]) {
+    if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
+    while (Module["preInit"].length > 0) {
+      Module["preInit"].shift()();
+    }
+  }
+  consumedModuleProp("preInit");
 }
 
+preInit();
+
+run();
+
 // end include: postamble.js
 // include: postamble_modularize.js
 // In MODULARIZE mode we wrap the generated code in a factory function
 // and return either the Module itself, or a promise of the module.
 // We assign to the `moduleRtn` global here and configure closure to see
 // this as and extern so it won't get minified.
-if (runtimeInitialized) {
-  moduleRtn = Module;
-} else {
-  // Set up the promise that indicates the Module is initialized
-  moduleRtn = new Promise((resolve, reject) => {
-    readyPromiseResolve = resolve;
-    readyPromiseReject = reject;
-  });
-}
+moduleRtn = readyPromise;
 
 // Assertion for attempting to access module properties on the incoming
 // moduleArg.  In the past we used this object as the prototype of the module
@@ -7674,13 +7816,10 @@ for (const prop of Object.keys(Module)) {
 
   return moduleRtn;
 }
-
-// Create code for detecting if we are running in a pthread.
-// Normally this detection is done when the module is itself run but
-// when running in MODULARIZE mode we need use this to know if we should
-// run the module constructor on startup (true only for pthreads).
+);
+})();
 var isPthread = globalThis.self?.name?.startsWith('em-pthread');
-
+// When running as a pthread, construct a new instance on startup
 isPthread && Module();
 
 export { Module as default };