@oxc-minify/binding-wasm32-wasi 0.151.0 → 0.153.0

package/minify.wasi.d.cts

@@ -341,6 +341,39 @@ export declare const enum Severity {
   Advice = 'Advice',
 }
 
+/** See <https://tc39.es/ecma426/#sec-source-map-format>. */
+export interface JSONSourceMap {
+  /** The version field, must be 3. */
+  version: number
+  /** An optional name of the generated code that this source map is associated with. */
+  file?: string
+  /** A string with the encoded mapping data. */
+  mappings: string
+  /**
+   * An optional source root, useful for relocating source files on a server or removing repeated values in the "sources" entry.
+   * This value is prepended to the individual entries in the "source" field.
+   */
+  sourceRoot?: string
+  /** A list of original sources used by the "mappings" entry. */
+  sources: Array<string>
+  /**
+   * An optional list of source content, useful when the "source" can't be hosted.
+   * The contents are listed in the same order as the sources in line 5. "null" may be used if some original sources should be retrieved by name.
+   */
+  sourcesContent?: Array<string | undefined | null>
+  /** A list of symbol names used by the "mappings" entry. */
+  names: Array<string>
+  /** An optional field containing the debugId for this sourcemap. */
+  debugId?: string
+  /**
+   * Identifies third-party sources (such as framework code or bundler-generated code), allowing developers to avoid code that they don't want to see or step through, without having to configure this beforehand.
+   * The `ignoreList` field refers to the `sources` array, and lists the indices of all the known third-party sources in that source map.
+   * When parsing the source map, developer tools can use this to determine sections of the code that the browser loads and runs that could be automatically ignore-listed.
+   * JSON input falls back to the deprecated `x_google_ignoreList` when `ignoreList` is missing or null.
+   */
+  ignoreList?: Array<number>
+}
+
 export interface SourceMap {
   file?: string
   mappings: string
@@ -349,5 +382,5 @@ export interface SourceMap {
   sources: Array<string>
   sourcesContent?: Array<string>
   version: number
-  x_google_ignoreList?: Array<number>
+  ignoreList?: Array<number>
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxc-minify/binding-wasm32-wasi",
-  "version": "0.151.0",
+  "version": "0.153.0",
   "main": "minify.wasi.cjs",
   "files": [
     "minify.wasm32-wasi.wasm",
@@ -40,7 +40,7 @@
   "browser": "minify.wasi-browser.js",
   "type": "module",
   "dependencies": {
-    "@napi-rs/wasm-runtime": "~1.2.4",
+    "@napi-rs/wasm-runtime": "~1.2.5",
     "@emnapi/core": "2.0.0-alpha.3",
     "@emnapi/runtime": "2.0.0-alpha.3"
   }

package/wasi-worker-browser.mjs

@@ -38,6 +38,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

@@ -2,80 +2,184 @@ import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import { parse } from 'node:path'
 import { WASI } from 'node:wasi'
-import { parentPort, Worker, workerData } from 'node:worker_threads'
+import { parentPort, threadId, Worker, workerData } from 'node:worker_threads'
 
 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) {
+      // 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)
+      }
+    },
   })
-}
 
-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 __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 __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)
+  handler = new MessageHandler({
+    onLoad({ wasmModule, wasmMemory }) {
+      const wasi = new WASI({
+        version: 'preview1',
+        env: process.env,
+        preopens: {
+          [__rootDir]: __hostRoot,
+          [__hostRoot]: __hostRoot,
+        },
+      })
 
-const 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,
+          }
+        },
+      })
+    },
+  })
+} catch (error) {
+  if (workerData && workerData.crashFlag instanceof Int32Array) {
+    __raiseWasiThreadCrashFlags(error)
+  }
+  throw error
+}
 
-    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,
+// 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)