feat: module mode

.github/workflows/main.yml

@@ -379,8 +379,8 @@ jobs:
       env:
         FASTLY_API_TOKEN: ${{ secrets.FASTLY_API_TOKEN }}
 
-    - name: Run TLA Tests
-      run: SUFFIX_STRING=${{matrix.profile}} node integration-tests/js-compute/test.js --tla ${{ matrix.platform == 'viceroy' && '--local' || '' }} ${{ matrix.profile == 'weval' && '--aot' || '' }}
+    - name: Run Module Mode Tests
+      run: SUFFIX_STRING=${{matrix.profile}} node integration-tests/js-compute/test.js --module-mode ${{ matrix.platform == 'viceroy' && '--local' || '' }} ${{ matrix.profile == 'weval' && '--aot' || '' }}
       env:
         FASTLY_API_TOKEN: ${{ secrets.FASTLY_API_TOKEN }}  
 
@@ -442,7 +442,7 @@ jobs:
       env:
         FASTLY_API_TOKEN: ${{ secrets.FASTLY_API_TOKEN }}
 
-    - name: Run TLA Tests
-      run: SUFFIX_STRING=debug node integration-tests/js-compute/test.js --tla --debug-build ${{ matrix.platform == 'viceroy' && '--local' || '' }}
+    - name: Run Module Mode Tests
+      run: SUFFIX_STRING=debug node integration-tests/js-compute/test.js --module-mode --debug-build ${{ matrix.platform == 'viceroy' && '--local' || '' }}
       env:
         FASTLY_API_TOKEN: ${{ secrets.FASTLY_API_TOKEN }}  

integration-tests/cli/help.test.js

@@ -30,6 +30,8 @@ test('--help should return help on stdout and zero exit code', async function (t
     '-V, --version                                           Prints version information',
     'OPTIONS:',
     '--engine-wasm <engine-wasm>                             The JS engine Wasm file path',
+    '--module-mode                            [experimental] Run all sources as native modules,',
+    'with full error stack support.',
     '--enable-experimental-aot                               Enable experimental AOT compilation for performance',
     '--enable-experimental-high-resolution-time-methods      Enable experimental high-resolution fastly.now() method',
     '--enable-experimental-top-level-await                   Enable experimental top level await',
@@ -57,6 +59,8 @@ test('-h should return help on stdout and zero exit code', async function (t) {
     '-V, --version                                           Prints version information',
     'OPTIONS:',
     '--engine-wasm <engine-wasm>                             The JS engine Wasm file path',
+    '--module-mode                            [experimental] Run all sources as native modules,',
+    'with full error stack support.',
     '--enable-experimental-aot                               Enable experimental AOT compilation for performance',
     '--enable-experimental-high-resolution-time-methods      Enable experimental high-resolution fastly.now() method',
     '--enable-experimental-top-level-await                   Enable experimental top level await',

integration-tests/js-compute/test.js

@@ -36,7 +36,7 @@ let args = argv.slice(2);
 
 const local = args.includes('--local');
 const verbose = args.includes('--verbose');
-const tla = args.includes('--tla');
+const moduleMode = args.includes('--module-mode');
 const aot = args.includes('--aot');
 const debugBuild = args.includes('--debug-build');
 const filter = args.filter((arg) => !arg.startsWith('--'));
@@ -68,7 +68,7 @@ const branchName = (await zx`git branch --show-current`).stdout
   .trim()
   .replace(/[^a-zA-Z0-9_-]/g, '_');
 
-const fixture = tla ? 'tla' : 'app';
+const fixture = moduleMode ? 'module-mode' : 'app';
 const serviceName = `${fixture}--${branchName}${aot ? '--aot' : ''}${process.env.SUFFIX_STRING || ''}`;
 let domain;
 const fixturePath = join(__dirname, 'fixtures', fixture);

js-compute-runtime-cli.js

@@ -9,7 +9,8 @@ const {
   enableAOT,
   aotCache,
   enableExperimentalHighResolutionTimeMethods,
-  enableExperimentalTopLevelAwait,
+  moduleMode,
+  bundle,
   wasmEngine,
   input,
   output,
@@ -36,9 +37,10 @@ if (version) {
     output,
     wasmEngine,
     enableExperimentalHighResolutionTimeMethods,
-    enableExperimentalTopLevelAwait,
     enableAOT,
     aotCache,
+    moduleMode,
+    bundle,
   );
   await addSdkMetadataField(output, enableAOT);
 }

src/bundle.js

@@ -115,13 +115,13 @@ export const TransactionCacheEntry = globalThis.TransactionCacheEntry;
   },
 };
 
-export async function bundle(input, enableExperimentalTopLevelAwait = false) {
+export async function bundle(input, moduleMode = false) {
   return await build({
     conditions: ['fastly'],
     entryPoints: [input],
     bundle: true,
     write: false,
-    format: enableExperimentalTopLevelAwait ? 'esm' : 'iife',
+    format: moduleMode ? 'esm' : 'iife',
     tsconfig: undefined,
     plugins: [fastlyPlugin],
   });

src/compileApplicationToWasm.js

@@ -26,9 +26,10 @@ export async function compileApplicationToWasm(
   output,
   wasmEngine,
   enableExperimentalHighResolutionTimeMethods = false,
-  enableExperimentalTopLevelAwait = false,
   enableAOT = false,
   aotCache = '',
+  moduleMode = false,
+  doBundle = false,
 ) {
   try {
     if (!(await isFile(input))) {
@@ -94,86 +95,132 @@ export async function compileApplicationToWasm(
     process.exit(1);
   }
 
-  let contents;
-  try {
-    contents = await bundle(input, enableExperimentalTopLevelAwait);
-  } catch (error) {
-    console.error(`Error:`, error.message);
-    process.exit(1);
-  }
+  let tmpDir;
+  if (doBundle) {
+    let contents;
+    try {
+      contents = await bundle(input, moduleMode);
+    } catch (error) {
+      console.error(`Error:`, error.message);
+      process.exit(1);
+    }
 
-  let wizerInput = precompile(
-    contents.outputFiles[0].text,
-    undefined,
-    enableExperimentalTopLevelAwait,
-  );
+    const precompiled = precompile(
+      contents.outputFiles[0].text,
+      undefined,
+      moduleMode,
+    );
 
-  // for StarlingMonkey, we need to write to a tmpdir pending streaming source hooks or similar
-  const tmpDir = await getTmpDir();
-  const outPath = resolve(tmpDir, 'input.js');
-  await writeFile(outPath, wizerInput);
-  wizerInput = outPath;
+    tmpDir = await getTmpDir();
+    const outPath = resolve(tmpDir, 'input.js');
+    await writeFile(outPath, precompiled);
 
-  try {
-    if (enableAOT) {
-      const wevalBin = await weval();
+    // the bundled output is now the Wizer input
+    input = outPath;
+  }
 
-      let wevalProcess = spawnSync(
-        `"${wevalBin}"`,
-        [
-          'weval',
-          ...(aotCache ? [`--cache-ro ${aotCache}`] : []),
-          '--dir .',
-          `--dir ${maybeWindowsPath(dirname(wizerInput))}`,
-          '-w',
-          `-i "${wasmEngine}"`,
-          `-o "${output}"`,
-        ],
-        {
-          stdio: [null, process.stdout, process.stderr],
-          input: `${maybeWindowsPath(wizerInput)}${enableExperimentalTopLevelAwait ? '' : ' --legacy-script'}`,
-          shell: true,
-          encoding: 'utf-8',
-          env: {
-            ...process.env,
-            ENABLE_EXPERIMENTAL_HIGH_RESOLUTION_TIME_METHODS:
-              enableExperimentalHighResolutionTimeMethods ? '1' : '0',
-          },
+  try {
+    if (!doBundle) {
+      // assert(moduleMode);
+      const spawnOpts = {
+        stdio: [null, process.stdout, process.stderr],
+        input: maybeWindowsPath(input),
+        shell: true,
+        encoding: 'utf-8',
+        env: {
+          ENABLE_EXPERIMENTAL_HIGH_RESOLUTION_TIME_METHODS:
+            enableExperimentalHighResolutionTimeMethods ? '1' : '0',
         },
-      );
-      if (wevalProcess.status !== 0) {
-        throw new Error(`Weval initialization failure`);
+      };
+      if (enableAOT) {
+        const wevalBin = await weval();
+
+        let wevalProcess = spawnSync(
+          `"${wevalBin}"`,
+          [
+            'weval',
+            ...(aotCache ? [`--cache-ro ${aotCache}`] : []),
+            `--dir="${maybeWindowsPath(process.cwd())}"`,
+            '-w',
+            `-i "${wasmEngine}"`,
+            `-o "${output}"`,
+          ],
+          spawnOpts,
+        );
+        if (wevalProcess.status !== 0) {
+          throw new Error(`Weval initialization failure`);
+        }
+        process.exitCode = wevalProcess.status;
+      } else {
+        let wizerProcess = spawnSync(
+          `"${wizer}"`,
+          [
+            '--allow-wasi',
+            `--wasm-bulk-memory=true`,
+            `--dir="${maybeWindowsPath(process.cwd())}"`,
+            '-r _start=wizer.resume',
+            `-o="${output}"`,
+            `"${wasmEngine}"`,
+          ],
+          spawnOpts,
+        );
+        if (wizerProcess.status !== 0) {
+          throw new Error(`Wizer initialization failure`);
+        }
+        process.exitCode = wizerProcess.status;
       }
-      process.exitCode = wevalProcess.status;
     } else {
-      let wizerProcess = spawnSync(
-        `"${wizer}"`,
-        [
-          '--inherit-env=true',
-          '--allow-wasi',
-          '--dir=.',
-          `--dir=${maybeWindowsPath(dirname(wizerInput))}`,
-          `--wasm-bulk-memory=true`,
-          '-r _start=wizer.resume',
-          `-o="${output}"`,
-          `"${wasmEngine}"`,
-        ],
-        {
-          stdio: [null, process.stdout, process.stderr],
-          input: `${maybeWindowsPath(wizerInput)}${enableExperimentalTopLevelAwait ? '' : ' --legacy-script'}`,
-          shell: true,
-          encoding: 'utf-8',
-          env: {
-            ...process.env,
-            ENABLE_EXPERIMENTAL_HIGH_RESOLUTION_TIME_METHODS:
-              enableExperimentalHighResolutionTimeMethods ? '1' : '0',
-          },
+      const spawnOpts = {
+        stdio: [null, process.stdout, process.stderr],
+        input: `${maybeWindowsPath(input)}${moduleMode ? '' : ' --legacy-script'}`,
+        shell: true,
+        encoding: 'utf-8',
+        env: {
+          ...process.env,
+          ENABLE_EXPERIMENTAL_HIGH_RESOLUTION_TIME_METHODS:
+            enableExperimentalHighResolutionTimeMethods ? '1' : '0',
         },
-      );
-      if (wizerProcess.status !== 0) {
-        throw new Error(`Wizer initialization failure`);
+      };
+      if (enableAOT) {
+        const wevalBin = await weval();
+
+        let wevalProcess = spawnSync(
+          `"${wevalBin}"`,
+          [
+            'weval',
+            ...(aotCache ? [`--cache-ro ${aotCache}`] : []),
+            '--dir .',
+            `--dir ${maybeWindowsPath(dirname(input))}`,
+            '-w',
+            `-i "${wasmEngine}"`,
+            `-o "${output}"`,
+          ],
+          spawnOpts,
+        );
+        if (wevalProcess.status !== 0) {
+          throw new Error(`Weval initialization failure`);
+        }
+        process.exitCode = wevalProcess.status;
+      } else {
+        let wizerProcess = spawnSync(
+          `"${wizer}"`,
+          [
+            '--inherit-env=true',
+            '--allow-wasi',
+            '--dir=.',
+            `--dir=${maybeWindowsPath(dirname(input))}`,
+            '-r _start=wizer.resume',
+            `--wasm-bulk-memory=true`,
+            `-o="${output}"`,
+            `"${wasmEngine}"`,
+          ],
+          spawnOpts,
+        );
+        if (wizerProcess.status !== 0) {
+          throw new Error(`Wizer initialization failure`);
+        }
+        process.exitCode = wizerProcess.status;
       }
-      process.exitCode = wizerProcess.status;
     }
   } catch (error) {
     console.error(
@@ -182,6 +229,8 @@ export async function compileApplicationToWasm(
     );
     process.exit(1);
   } finally {
-    rmSync(tmpDir, { recursive: true });
+    if (doBundle) {
+      rmSync(tmpDir, { recursive: true });
+    }
   }
 }

src/parseInputs.js

@@ -7,9 +7,10 @@ export async function parseInputs(cliInputs) {
   const __dirname = dirname(fileURLToPath(import.meta.url));
 
   let enableExperimentalHighResolutionTimeMethods = false;
-  let enableExperimentalTopLevelAwait = false;
   let enableAOT = false;
   let customEngineSet = false;
+  let moduleMode = false;
+  let bundle = true;
   let wasmEngine = join(__dirname, '../fastly.wasm');
   let aotCache = join(__dirname, '../fastly-ics.wevalcache');
   let customInputSet = false;
@@ -28,8 +29,14 @@ export async function parseInputs(cliInputs) {
         enableExperimentalHighResolutionTimeMethods = true;
         break;
       }
+      case '--module-mode': {
+        moduleMode = true;
+        bundle = false;
+        break;
+      }
       case '--enable-experimental-top-level-await': {
-        enableExperimentalTopLevelAwait = true;
+        moduleMode = true;
+        bundle = true;
         break;
       }
       case '--enable-experimental-aot': {
@@ -128,7 +135,8 @@ export async function parseInputs(cliInputs) {
 
   return {
     enableExperimentalHighResolutionTimeMethods,
-    enableExperimentalTopLevelAwait,
+    moduleMode,
+    bundle,
     enableAOT,
     aotCache,
     input,

src/precompile.js

@@ -12,18 +12,14 @@ const POSTAMBLE = '}';
 /// will intern regular expressions, duplicating them at the top level and testing them with both
 /// an ascii and utf8 string should ensure that they won't be re-compiled when run in the fetch
 /// handler.
-export function precompile(
-  source,
-  filename = '<input>',
-  enableExperimentalTopLevelAwait = false,
-) {
+export function precompile(source, filename = '<input>', moduleMode = false) {
   const magicString = new MagicString(source, {
     filename,
   });
 
   const ast = parse(source, {
     ecmaVersion: 'latest',
-    sourceType: enableExperimentalTopLevelAwait ? 'module' : 'script',
+    sourceType: moduleMode ? 'module' : 'script',
   });
 
   const precompileCalls = [];

src/printHelp.js

@@ -14,6 +14,8 @@ FLAGS:
 
 OPTIONS:
     --engine-wasm <engine-wasm>                             The JS engine Wasm file path
+    --module-mode                            [experimental] Run all sources as native modules,
+                                                            with full error stack support.
     --enable-experimental-aot                               Enable experimental AOT compilation for performance
     --enable-experimental-high-resolution-time-methods      Enable experimental high-resolution fastly.now() method
     --enable-experimental-top-level-await                   Enable experimental top level await