@napi-rs/snappy-wasm32-wasi 7.4.2 → 7.4.4

package/snappy.wasi.d.cts

@@ -1,10 +1,57 @@
 /* auto-generated by NAPI-RS */
 /* eslint-disable */
-export declare function compress(
-  input: string | Uint8Array,
-  options?: EncOptions | undefined | null,
-  signal?: AbortSignal | undefined | null,
-): Promise<Buffer>
+
+/** The WASI flavor this loader instantiates. */
+export declare const __napiBindingTarget: 'wasm32-wasi'
+
+/**
+ * Incremental Snappy **frame-format** compressor.
+ *
+ * Feed plaintext with [`update`](Compressor::update); call
+ * [`finish`](Compressor::finish) for the trailing framed bytes. The valid
+ * stream is the concatenation of every `update()` output plus the `finish()`
+ * tail. This is **not** the same format as one-shot [`crate::compress`].
+ */
+export declare class Compressor {
+  /** Create a streaming framed-Snappy compressor. */
+  constructor()
+  /**
+   * Feed one chunk. A `string` is UTF-8 encoded (matching the one-shot
+   * `compress` convention); a `Uint8Array` is fed verbatim. Returns the
+   * framed bytes produced so far (possibly empty). Never flushes the encoder
+   * (byte-identity invariant across chunkings).
+   */
+  update(chunk: string | Uint8Array): Buffer
+  /**
+   * Flush remaining buffered plaintext into frames off the JS thread.
+   * Resolves to the tail bytes. Idempotency-guarded: a second call rejects.
+   */
+  finish(): Promise<Buffer>
+}
+
+/**
+ * Incremental Snappy **frame-format** decompressor.
+ *
+ * Feed framed compressed chunks with [`update`](Decompressor::update); call
+ * [`finish`](Decompressor::finish) for the decoded tail. Not compatible with
+ * one-shot raw [`crate::compress`] output.
+ */
+export declare class Decompressor {
+  /** Create a streaming framed-Snappy decompressor and start its worker thread. */
+  constructor()
+  /**
+   * Feed one compressed chunk; returns the bytes decoded so far (possibly
+   * empty). Deadlock-free under backpressure.
+   */
+  update(chunk: Uint8Array): Buffer
+  /**
+   * Signal EOF and resolve to the decoded tail off the JS thread.
+   * Idempotency-guarded: a second call rejects cleanly.
+   */
+  finish(): Promise<Buffer>
+}
+
+export declare function compress(input: string | Uint8Array, options?: EncOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<Buffer>
 
 export declare function compressSync(input: string | Uint8Array, options?: EncOptions | undefined | null): Buffer
 
@@ -29,13 +76,6 @@ export interface EncOptions {
   copyOutputData?: boolean
 }
 
-export declare function uncompress(
-  input: string | Uint8Array,
-  options?: DecOptions | undefined | null,
-  signal?: AbortSignal | undefined | null,
-): Promise<string | Buffer>
+export declare function uncompress(input: string | Uint8Array, options?: DecOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<string | Buffer>
 
-export declare function uncompressSync(
-  input: string | Uint8Array,
-  options?: DecOptions | undefined | null,
-): string | Buffer
+export declare function uncompressSync(input: string | Uint8Array, options?: DecOptions | undefined | null): string | Buffer

package/wasi-worker-browser.mjs

@@ -13,10 +13,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)
-        
       },
     })
     return instantiateNapiModuleSync(wasmModule, {
@@ -37,9 +36,32 @@ 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)
+}