@solidjs/compiler-wasm32-wasi 2.0.0-rc.11 → 2.0.0-rc.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/compiler-wasm32-wasi",
-  "version": "2.0.0-rc.11",
+  "version": "2.0.0-rc.14",
   "main": "compiler.wasi.cjs",
   "files": [
     "compiler.wasm32-wasi.wasm",
@@ -26,4 +26,4 @@
     "@emnapi/core": "1.11.3",
     "@emnapi/runtime": "1.11.3"
   }
-}
+}

package/wasi-worker-browser.mjs

@@ -15,10 +15,9 @@ const handler = new MessageHandler({
         // eslint-disable-next-line no-console
         console.log.apply(console, arguments)
       },
-      printErr: function() {
+      printErr: function () {
         // eslint-disable-next-line no-console
         console.error.apply(console, arguments)
-        
         errorOutputs.push([...arguments])
       },
     })
@@ -46,6 +45,30 @@ const handler = new MessageHandler({
   }
 })
 
+// When this wasm thread dies, raise the addon's crash flag before emnapi reports
+// it. The loader thread may be inside wasm, in a cleanup call that waits on this
+// thread; the flag is what those waits check between short slices, and once it
+// is up they trap instead of waiting for good. It is a word in the shared wasm
+// memory, and the loader posts a view of it (see
+// napi_wasm_thread_crash_flag_address) after it instantiated the wasm, or right
+// after it created this worker. No view, no flag: an addon built with an older
+// napi, or a failure before the view arrived.
+let __addonCrashFlag
+const __beforeReportError = handler.beforeReportError
+handler.beforeReportError = function (...args) {
+  if (__addonCrashFlag !== undefined) {
+    try {
+      Atomics.store(__addonCrashFlag, 0, 1)
+    } catch {}
+  }
+  return __beforeReportError.apply(this, args)
+}
+
 globalThis.onmessage = function (e) {
+  const data = e && e.data
+  if (data && data.__napiRsAddonCrashFlag instanceof Int32Array) {
+    __addonCrashFlag = data.__napiRsAddonCrashFlag
+    return
+  }
   handler.handle(e)
 }

package/wasi-worker.mjs

@@ -1,74 +1,186 @@
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import { parse } from "node:path";
-import { WASI } from "node:wasi";
-import { parentPort, Worker } from "node:worker_threads";
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import { parse } from 'node:path'
+import { WASI } from 'node:wasi'
+import { parentPort, threadId, Worker, workerData } from 'node:worker_threads'
 
-const require = createRequire(import.meta.url);
+const require = createRequire(import.meta.url)
 
-const {
-  instantiateNapiModuleSync,
-  MessageHandler,
-  getDefaultContext,
-  emnapiAsyncWorkPlugin,
-  emnapiTSFNPlugin,
-} = require("@napi-rs/wasm-runtime");
+// The thread spawn that created this worker has already returned, so the loader
+// thread may be waiting on this thread. A failure before the crash hook below is
+// in place (a missing '@napi-rs/wasm-runtime', say) has to raise the crash flags
+// too, then fail the worker as before.
+let handler
+try {
+  const {
+    instantiateNapiModuleSync,
+    MessageHandler,
+    getDefaultContext,
+    emnapiAsyncWorkPlugin,
+    emnapiTSFNPlugin,
+  } = require('@napi-rs/wasm-runtime')
 
-if (parentPort) {
-  parentPort.on("message", (data) => {
-    globalThis.onmessage({ data });
-  });
-}
+  if (parentPort) {
+    parentPort.on('message', (data) => {
+      globalThis.onmessage({ data })
+    })
+  }
 
-Object.assign(globalThis, {
-  self: globalThis,
-  require,
-  Worker,
-  importScripts: function (f) {
-    ;(0, eval)(fs.readFileSync(f, "utf8") + "//# sourceURL=" + f);
-  },
-  postMessage: function (msg) {
-    if (parentPort) {
-      parentPort.postMessage(msg);
-    }
-  },
-});
+  Object.assign(globalThis, {
+    self: globalThis,
+    require,
+    Worker,
+    importScripts: function (f) {
+      // oxlint-disable-next-line no-eval -- WASI importScripts polyfill
+      ;(0, eval)(fs.readFileSync(f, 'utf8') + '//# sourceURL=' + f)
+    },
+    postMessage: function (msg) {
+      if (parentPort) {
+        parentPort.postMessage(msg)
+      }
+    },
+  })
 
-const emnapiContext = getDefaultContext();
+  const emnapiContext = getDefaultContext()
 
-const __rootDir = parse(process.cwd()).root;
+  const __cwd = process.cwd()
+  const __rootDir =
+    (workerData && typeof workerData.rootDir === 'string' && workerData.rootDir) ||
+    parse(__cwd).root
+  const __hostRoot =
+    (workerData && typeof workerData.hostRoot === 'string' && workerData.hostRoot) ||
+    (process.platform === 'android' ? __cwd : __rootDir)
 
-const handler = new MessageHandler({
-  onLoad({ wasmModule, wasmMemory }) {
-    const wasi = new WASI({
-      version: 'preview1',
-      env: process.env,
-      preopens: {
-        [__rootDir]: __rootDir,
-      },
-    });
+  handler = new MessageHandler({
+    onLoad({ wasmModule, wasmMemory }) {
+      const wasi = new WASI({
+        version: 'preview1',
+        env: process.env,
+        preopens: {
+          [__rootDir]: __hostRoot,
+          [__hostRoot]: __hostRoot,
+        },
+      })
 
-    return instantiateNapiModuleSync(wasmModule, {
-      childThread: true,
-      wasi,
-      context: emnapiContext,
-      // The wasm links a "basic" emnapi archive (no C async-work /
-      // threadsafe-function implementations), so every thread that
-      // instantiates it must provide the JavaScript implementations
-      // through the emnapi plugins.
-      plugins: [emnapiAsyncWorkPlugin, emnapiTSFNPlugin],
-      overwriteImports(importObject) {
-        importObject.env = {
-          ...importObject.env,
-          ...importObject.napi,
-          ...importObject.emnapi,
-          memory: wasmMemory
-        };
-      },
-    });
-  },
-});
+      return instantiateNapiModuleSync(wasmModule, {
+        childThread: true,
+        wasi,
+        context: emnapiContext,
+        // The wasm links a "basic" emnapi archive (no C async-work /
+        // threadsafe-function implementations), so every thread that
+        // instantiates it must provide the JavaScript implementations
+        // through the emnapi plugins.
+        plugins: [emnapiAsyncWorkPlugin, emnapiTSFNPlugin],
+        overwriteImports(importObject) {
+          importObject.env = {
+            ...importObject.env,
+            ...importObject.napi,
+            ...importObject.emnapi,
+            memory: wasmMemory,
+          }
+        },
+      })
+    },
+  })
+} catch (error) {
+  if (workerData && workerData.crashFlag instanceof Int32Array) {
+    __raiseWasiThreadCrashFlags(error)
+  }
+  throw error
+}
+
+// Tell the loader thread synchronously that this wasm thread died, so its 'exit'
+// teardown does not re-enter wasm and wait on this thread forever. emnapi calls
+// beforeReportError (which runs emnapi_thread_crashed, so the main thread may
+// throw 'unwind' and start exiting) before the 'error' event is even posted.
+// A loader that predates the flag passes none.
+if (workerData && workerData.crashFlag instanceof Int32Array) {
+  const __beforeReportError = handler.beforeReportError
+  handler.beforeReportError = function (...args) {
+    if (!__raiseWasiThreadCrashFlags(args[0])) {
+      // No view (the thread was spawned before the loader read the address,
+      // say): the export stores into the same word, but only a worker that
+      // loaded has an instance to call it on.
+      try {
+        const __napiThreadCrashed = this.instance?.exports?.napi_wasm_thread_crashed
+        if (typeof __napiThreadCrashed === 'function') {
+          __napiThreadCrashed()
+        }
+      } catch {}
+    }
+    return __beforeReportError.apply(this, args)
+  }
+}
+
+// The error goes into the shared crash report first. The 'error' event that
+// would carry it is dropped when the loader terminates this worker before the
+// event is sent, so the report is the only copy the loader can count on.
+// Layout: three Int32 words — state (0 empty, 1 writing, 2 written), byte
+// length, threadId — then the UTF-8 JSON of { name, message, stack }. Only the
+// first worker to crash writes it, and it is complete before the flag is raised.
+//
+// Then the loader's flag, then the addon's. The loader thread may already be
+// inside wasm, in a cleanup call that waits on this thread; the addon's flag is
+// what those waits check between short slices. It is a word in the shared wasm
+// memory (the loader passes a view of it, see napi_wasm_thread_crash_flag_address),
+// so no instance is needed: a worker that failed while loading raises it too.
+// Once it is up the waits trap, and the loader, whose flag is already up, turns
+// the throw into its crash rejection. Returns whether the addon's flag was raised.
+function __raiseWasiThreadCrashFlags(error) {
+  try {
+    __writeCrashReport(workerData.crashReport, error)
+  } catch {}
+  try {
+    Atomics.store(workerData.crashFlag, 0, 1)
+  } catch {}
+  const addonCrashFlag = workerData.addonCrashFlag
+  if (!(addonCrashFlag instanceof Int32Array)) {
+    return false
+  }
+  try {
+    Atomics.store(addonCrashFlag, 0, 1)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function __writeCrashReport(report, error) {
+  if (!(report instanceof SharedArrayBuffer) || report.byteLength <= 12) {
+    return
+  }
+  const header = new Int32Array(report, 0, 3)
+  if (Atomics.compareExchange(header, 0, 0, 1) !== 0) {
+    return
+  }
+  let length = 0
+  try {
+    const body = new Uint8Array(report, 12)
+    const isObject =
+      error !== null && (typeof error === 'object' || typeof error === 'function')
+    const name = isObject && typeof error.name === 'string' ? error.name : 'Error'
+    const message = isObject && typeof error.message === 'string'
+      ? error.message
+      : String(error)
+    const stack = isObject && typeof error.stack === 'string' ? error.stack : undefined
+    const encoder = new TextEncoder()
+    let bytes = encoder.encode(JSON.stringify({ name, message, stack }))
+    if (bytes.length > body.length) {
+      bytes = encoder.encode(
+        JSON.stringify({ name, message: message.slice(0, body.length >> 3) }),
+      )
+    }
+    if (bytes.length <= body.length) {
+      body.set(bytes)
+      length = bytes.length
+    }
+    Atomics.store(header, 2, threadId)
+  } finally {
+    Atomics.store(header, 1, length)
+    Atomics.store(header, 0, 2)
+  }
+}
 
 globalThis.onmessage = function (e) {
-  handler.handle(e);
-};
+  handler.handle(e)
+}