[esm-integration] Allow for module argument processing (#24005)

This change delays module argument processing until the init function is
run. This means that at least some INCOMING_MODULE_JS_API properties can
be supported with ESM integration.

 See #24060

Author: sbc100

eslint.config.mjs

@@ -30,6 +30,7 @@ export default [{
     'src/runtime_*.js',
     'src/shell*.js',
     'src/preamble*.js',
+    'src/postlibrary.js',
     'src/postamble*.js',
     'src/closure-externs/',
     'src/embind/',

src/jsifier.mjs

@@ -10,6 +10,7 @@
 import assert from 'node:assert';
 import * as fs from 'node:fs/promises';
 import {
+  ATMODULES,
   ATEXITS,
   ATINITS,
   ATPOSTCTORS,
@@ -823,6 +824,10 @@ function(${args}) {
     }
     writeOutput('// End JS library code\n');
 
+    if (!MINIMAL_RUNTIME) {
+      includeSystemFile('postlibrary.js');
+    }
+
     if (PTHREADS) {
       writeOutput(`
 // proxiedFunctionTable specifies the list of functions that can be called
@@ -864,6 +869,7 @@ var proxiedFunctionTable = [
           asyncFuncs,
           libraryDefinitions: LibraryManager.libraryDefinitions,
           ATPRERUNS: ATPRERUNS.join('\n'),
+          ATMODULES: ATMODULES.join('\n'),
           ATINITS: ATINITS.join('\n'),
           ATPOSTCTORS: ATPOSTCTORS.join('\n'),
           ATMAINS: ATMAINS.join('\n'),

src/lib/libcore.js

@@ -2283,7 +2283,8 @@ addToLibrary({
   $wasmTable: undefined,
 #endif
 
-  $noExitRuntime: "{{{ makeModuleReceiveExpr('noExitRuntime', !EXIT_RUNTIME) }}}",
+  $noExitRuntime__postset: () => addAtModule(makeModuleReceive('noExitRuntime')),
+  $noExitRuntime: {{{ !EXIT_RUNTIME }}},
 
   // The following addOn<X> functions are for adding runtime callbacks at
   // various executions points. Each addOn<X> function has a corresponding

src/lib/libembind_gen.js

@@ -856,6 +856,9 @@ var LibraryEmbind = {
   $makeLegalFunctionName: () => { throw new Error('stub function should not be called'); },
   $runDestructors: () => { throw new Error('stub function should not be called'); },
   $createNamedFunction: () => { throw new Error('stub function should not be called'); },
+  $flushPendingDeletes: () => { throw new Error('stub function should not be called'); },
+  $setDelayFunction: () => { throw new Error('stub function should not be called'); },
+  $PureVirtualError: () => { throw new Error('stub function should not be called'); },
 };
 
 #if EMBIND_AOT

src/lib/libfs_shared.js

@@ -5,7 +5,8 @@
  */
 
 addToLibrary({
-  $preloadPlugins: "{{{ makeModuleReceiveExpr('preloadPlugins', '[]') }}}",
+  $preloadPlugins__postset: () => addAtModule(makeModuleReceive('preloadPlugins')),
+  $preloadPlugins: [],
 
 #if !MINIMAL_RUNTIME
   // Tries to handle an input byteArray using preload plugins. Returns true if

src/modules.mjs

@@ -513,7 +513,6 @@ function exportRuntimeSymbols() {
   }
 
   const exports = runtimeElements.map(maybeExport);
-  exports.unshift('// Begin runtime exports');
   const results = exports.filter((name) => name);
 
   if (ASSERTIONS && !EXPORT_ALL) {
@@ -542,7 +541,9 @@ function exportRuntimeSymbols() {
     }
   }
 
-  return results.join('\n') + '\n';
+  results.unshift('// Begin runtime exports');
+  results.push('// End runtime exports');
+  return results.join('\n  ') + '\n';
 }
 
 function exportLibrarySymbols() {
@@ -552,12 +553,12 @@ function exportLibrarySymbols() {
       results.push(exportSymbol(ident));
     }
   }
-
-  return results.join('\n') + '\n';
+  results.push('// End JS library exports');
+  return results.join('\n  ') + '\n';
 }
 
 function exportJSSymbols() {
-  return exportRuntimeSymbols() + exportLibrarySymbols();
+  return exportRuntimeSymbols() + '  ' + exportLibrarySymbols();
 }
 
 addToCompileTimeContext({

src/parseTools.mjs

@@ -720,6 +720,14 @@ function makeEval(code) {
   return ret;
 }
 
+// Add code that runs before the wasm modules is loaded.  This is the first
+// point at which the global `Module` object is guaranteed to exist. This hook
+// is mostly used to read incoming `Module` properties.
+export const ATMODULES = [];
+function addAtModule(code) {
+  ATMODULES.push(code);
+}
+
 // Add code to run soon after the Wasm module has been loaded. This is the first
 // injection point before all the other addAt<X> functions below. The code will
 // be executed after the runtime `onPreRuns` callbacks.
@@ -882,7 +890,7 @@ function makeModuleReceive(localName, moduleName) {
   if (expectToReceiveOnModule(moduleName)) {
     // Usually the local we use is the same as the Module property name,
     // but sometimes they must differ.
-    ret = `\nif (Module['${moduleName}']) ${localName} = Module['${moduleName}'];`;
+    ret = `if (Module['${moduleName}']) ${localName} = Module['${moduleName}'];`;
   }
   return ret;
 }
@@ -900,17 +908,12 @@ function makeModuleReceiveWithVar(localName, moduleName, defaultValue) {
   moduleName ||= localName;
   checkReceiving(moduleName);
   let ret = `var ${localName}`;
-  if (!expectToReceiveOnModule(moduleName)) {
-    if (defaultValue) {
-      ret += ` = ${defaultValue}`;
-    }
-    ret += ';';
-  } else {
-    if (defaultValue) {
-      ret += ` = Module['${moduleName}'] || ${defaultValue};`;
-    } else {
-      ret += ` = Module['${moduleName}'];`;
-    }
+  if (defaultValue) {
+    ret += ` = ${defaultValue}`;
+  }
+  ret += ';';
+  if (expectToReceiveOnModule(moduleName)) {
+    addAtModule(`if (Module['${moduleName}']) ${localName} = Module['${moduleName}'];`);
   }
   return ret;
 }
@@ -1119,6 +1122,7 @@ addToCompileTimeContext({
   ENVIRONMENT_IS_WORKER_THREAD,
   addAtExit,
   addAtPreRun,
+  addAtModule,
   addAtInit,
   addAtPostCtor,
   addAtPreMain,

src/postamble.js

@@ -24,8 +24,6 @@ if (ENVIRONMENT_IS_WORKER) {
 #include "deterministic.js"
 #endif
 
-{{{ exportJSSymbols() }}}
-
 #if ASSERTIONS
 var calledRun;
 #endif
@@ -199,7 +197,7 @@ function run() {
 #endif
 
 #if HAS_MAIN
-    {{{ makeModuleReceiveWithVar('noInitialRun', undefined, !INVOKE_RUN) }}}
+    var noInitialRun = {{{ makeModuleReceiveExpr('noInitialRun', !INVOKE_RUN) }}};
 #if MAIN_READS_PARAMS
     if (!noInitialRun) callMain(args);
 #else
@@ -287,26 +285,30 @@ function checkUnflushedContent() {
 #endif // EXIT_RUNTIME
 #endif // ASSERTIONS
 
+function preInit() {
 #if expectToReceiveOnModule('preInit')
-if (Module['preInit']) {
-  if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
-  while (Module['preInit'].length > 0) {
-    Module['preInit'].shift()();
+  if (Module['preInit']) {
+    if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+    while (Module['preInit'].length > 0) {
+      Module['preInit'].shift()();
+    }
   }
-}
 #if ASSERTIONS
-consumedModuleProp('preInit');
+  consumedModuleProp('preInit');
 #endif
 #endif
-
+}
 
 #if WASM_ESM_INTEGRATION
 export default function init(moduleArg = {}) {
-  // TODO(sbc): moduleArg processing
+  Module = moduleArg;
   updateMemoryViews();
+  processModuleArgs();
+  preInit();
   run();
 }
 #else
+preInit();
 run();
 #endif
 

src/postamble_minimal.js

@@ -5,8 +5,6 @@
  */
 
 // === Auto-generated postamble setup entry stuff ===
-{{{ exportJSSymbols() }}}
-
 #if HAS_MAIN // Only if user is exporting a C main(), we will generate a run() function that can be used to launch main.
 function run() {
 #if MEMORYPROFILER
@@ -136,6 +134,10 @@ WebAssembly.instantiateStreaming(fetch('{{{ TARGET_BASENAME }}}.wasm'), imports)
 if (!Module['wasm']) throw 'Must load WebAssembly Module in to variable Module.wasm before adding compiled output .js script to the DOM';
 #endif
 
+<<< ATMODULES >>>
+
+{{{ exportJSSymbols() }}}
+
 WebAssembly.instantiate(Module['wasm'], imports).then((output) => {
 #endif
 

src/postlibrary.js

@@ -0,0 +1,38 @@
+// This file is included after the automatically-generated JS library code
+// but before the wasm module is created.
+ 
+#if WASM_ESM_INTEGRATION
+function processModuleArgs() 
+#endif
+{
+  <<< ATMODULES >>>
+
+#if ASSERTIONS
+  checkIncomingModuleAPI();
+#endif
+
+  {{{ makeModuleReceive('arguments_', 'arguments') }}}
+  {{{ makeModuleReceive('thisProgram') }}}
+
+#if ASSERTIONS
+  // Assertions on removed incoming Module JS APIs.
+  assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');
+  assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');
+  assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');
+  assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');
+  assert(typeof Module['read'] == 'undefined', 'Module.read option was removed');
+  assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');
+  assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');
+  assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)');
+  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 !IMPORTED_MEMORY
+  // If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
+  assert(typeof Module['wasmMemory'] == 'undefined', 'Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally');
+  assert(typeof Module['INITIAL_MEMORY'] == 'undefined', 'Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically');
+#endif
+#endif // ASSERTIONS
+
+  {{{ exportJSSymbols() }}}
+}