@tailwindcss/oxide-wasm32-wasi 0.0.0-insiders.bd30a71 → 0.0.0-insiders.bdcd708

package/node_modules/@emnapi/wasi-threads/dist/wasi-threads.mjs

@@ -123,7 +123,6 @@ class ThreadManager {
     constructor(options) {
         var _a;
         this.unusedWorkers = [];
-        this.runningWorkers = [];
         this.pthreads = Object.create(null);
         this.wasmModule = null;
         this.wasmMemory = null;
@@ -148,6 +147,7 @@ class ThreadManager {
             this._beforeLoad = options.beforeLoad;
         }
         this.printErr = (_a = options.printErr) !== null && _a !== void 0 ? _a : console.error.bind(console);
+        this.threadSpawn = options.threadSpawn;
     }
     init() {
         if (!this._childThread) {
@@ -220,7 +220,6 @@ class ThreadManager {
             delete this.pthreads[tid];
         }
         this.unusedWorkers.push(worker);
-        this.runningWorkers.splice(this.runningWorkers.indexOf(worker), 1);
         delete worker.__emnapi_tid;
         if (ENVIRONMENT_IS_NODE) {
             worker.unref();
@@ -269,6 +268,12 @@ class ThreadManager {
                             this.cleanThread(worker, payload.tid);
                         }
                     }
+                    else if (type === 'spawn-thread') {
+                        this.threadSpawn(payload.startArg, payload.errorOrTid);
+                    }
+                    else if (type === 'terminate-all-threads') {
+                        this.terminateAllThreads();
+                    }
                 }
             };
             worker.onmessage = (e) => {
@@ -341,10 +346,6 @@ class ThreadManager {
         }
         else {
             delete this.pthreads[tid];
-            const index = this.runningWorkers.indexOf(worker);
-            if (index !== -1) {
-                this.runningWorkers.splice(index, 1);
-            }
             this.terminateWorker(worker);
             delete worker.__emnapi_tid;
         }
@@ -363,14 +364,14 @@ class ThreadManager {
         };
     }
     terminateAllThreads() {
-        for (let i = 0; i < this.runningWorkers.length; ++i) {
-            this.terminateWorker(this.runningWorkers[i]);
+        const runningWorkers = Object.values(this.pthreads);
+        for (let i = 0; i < runningWorkers.length; ++i) {
+            this.terminateWorker(runningWorkers[i]);
         }
         for (let i = 0; i < this.unusedWorkers.length; ++i) {
             this.terminateWorker(this.unusedWorkers[i]);
         }
         this.unusedWorkers = [];
-        this.runningWorkers = [];
         this.pthreads = Object.create(null);
         this.preparePool();
     }
@@ -512,18 +513,6 @@ class WASIThreads {
         }
         this.postMessage = postMessage;
         const wasm64 = Boolean(options.wasm64);
-        const onMessage = (e) => {
-            if (e.data.__emnapi__) {
-                const type = e.data.__emnapi__.type;
-                const payload = e.data.__emnapi__.payload;
-                if (type === 'spawn-thread') {
-                    threadSpawn(payload.startArg, payload.errorOrTid);
-                }
-                else if (type === 'terminate-all-threads') {
-                    this.terminateAllThreads();
-                }
-            }
-        };
         const threadSpawn = (startArg, errorOrTid) => {
             var _a;
             const EAGAIN = 6;
@@ -546,7 +535,7 @@ class WASIThreads {
             }
             if (!isNewABI) {
                 const malloc = this.wasmInstance.exports.malloc;
-                errorOrTid = wasm64 ? Number(malloc(BigInt(8))) : malloc(8);
+                errorOrTid = wasm64 ? Number(malloc(BigInt(8))) : (malloc(8) >>> 0);
                 if (!errorOrTid) {
                     return -48;
                 }
@@ -584,10 +573,9 @@ class WASIThreads {
                 if (!worker) {
                     throw new Error('failed to get new worker');
                 }
-                PThread.addMessageEventListener(worker, onMessage);
                 tid = PThread.markId(worker);
                 if (ENVIRONMENT_IS_NODE) {
-                    worker.ref();
+                    worker.unref();
                 }
                 worker.postMessage(createMessage('start', {
                     tid,
@@ -598,10 +586,6 @@ class WASIThreads {
                     if (typeof waitThreadStart === 'number') {
                         const waitResult = Atomics.wait(sab, 0, 0, waitThreadStart);
                         if (waitResult === 'timed-out') {
-                            try {
-                                PThread.cleanThread(worker, tid, true);
-                            }
-                            catch (_) { }
                             throw new Error('Spawning thread timed out. Please check if the worker is created successfully and if message is handled properly in the worker.');
                         }
                     }
@@ -610,15 +594,17 @@ class WASIThreads {
                     }
                     const r = Atomics.load(sab, 0);
                     if (r > 1) {
-                        try {
-                            PThread.cleanThread(worker, tid, true);
-                        }
-                        catch (_) { }
                         throw deserizeErrorFromBuffer(sab.buffer);
                     }
                 }
             }
             catch (e) {
+                if (worker !== undefined && tid !== undefined) {
+                    try {
+                        PThread.cleanThread(worker, tid, true);
+                    }
+                    catch (_) { }
+                }
                 Atomics.store(struct, 0, 1);
                 Atomics.store(struct, 1, EAGAIN);
                 Atomics.notify(struct, 1);
@@ -632,7 +618,6 @@ class WASIThreads {
             Atomics.store(struct, 0, 0);
             Atomics.store(struct, 1, tid);
             Atomics.notify(struct, 1);
-            PThread.runningWorkers.push(worker);
             if (!shouldWait) {
                 worker.whenLoaded.catch((err) => {
                     delete worker.whenLoaded;
@@ -647,6 +632,9 @@ class WASIThreads {
             return tid;
         };
         this.threadSpawn = threadSpawn;
+        if (this.PThread) {
+            this.PThread.threadSpawn = threadSpawn;
+        }
     }
     getImportObject() {
         return {

package/node_modules/@emnapi/wasi-threads/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emnapi/wasi-threads",
-  "version": "1.1.0",
+  "version": "1.2.2",
   "description": "WASI threads proposal implementation in JavaScript",
   "main": "index.js",
   "module": "./dist/wasi-threads.esm-bundler.js",

package/node_modules/@napi-rs/wasm-runtime/dist/fs-proxy.cjs

@@ -17,6 +17,21 @@ const getType = (value) => {
   return -1
 };
 
+const RESPONSE_HEADER_SIZE = 16;
+const RESPONSE_PAYLOAD_SIZE = 10240;
+const RESPONSE_BUFFER_SIZE = RESPONSE_HEADER_SIZE + RESPONSE_PAYLOAD_SIZE;
+
+/**
+ * @param {Int32Array} sab
+ * @param {Uint8Array} payload
+ */
+const writeResponsePayload = (sab, payload) => {
+  if (payload.length > RESPONSE_PAYLOAD_SIZE) {
+    throw new RangeError('payload overflow')
+  }
+  new Uint8Array(sab.buffer).set(payload, RESPONSE_HEADER_SIZE);
+};
+
 /**
  * @param {import('memfs').IFs} memfs
  * @param {any} value
@@ -91,9 +106,7 @@ const encodeValue = (memfs, value, type) => {
       return view
     }
     case 9: {
-      const view = new BigInt64Array(1);
-      view[0] = value;
-      return new Uint8Array(view.buffer)
+      return new TextEncoder().encode(String(value))
     }
     case -1:
     default:
@@ -178,8 +191,9 @@ const decodeValue = (memfs, payload, type) => {
     }
     return obj
   }
-  if (type === 9)
-    return new BigInt64Array(payload.buffer, payload.byteOffset, 1)[0]
+  if (type === 9) {
+    return BigInt(new TextDecoder().decode(payload.slice()))
+  }
   throw new Error('unsupported data')
 };
 
@@ -194,7 +208,7 @@ const createOnMessage = (fs) =>
       /**
        * 0..4                    status(int32_t):        21(waiting) 0(success) 1(error)
        * 5..8                    type(napi_valuetype):   0(undefined) 1(null) 2(boolean) 3(number) 4(string) 6(jsonstring) 9(bigint) -1(unsupported)
-       * 9..16                   payload_size(uint32_t)  <= 1024
+       * 9..16                   payload_size(uint32_t)  <= 10240
        * 16..16 + payload_size   payload_content
        */
       const { sab, type, payload } = e.data.__fs__;
@@ -205,14 +219,35 @@ const createOnMessage = (fs) =>
         Atomics.store(sab, 1, t);
         const v = encodeValue(fs, ret, t);
         Atomics.store(sab, 2, v.length);
-        new Uint8Array(sab.buffer).set(v, 16);
+        writeResponsePayload(sab, v);
         Atomics.store(sab, 0, 0); // success
       } catch (/** @type {any} */ err) {
-        const t = getType(err);
+        let t = getType(err);
+        let v;
+        try {
+          if (t === -1) {
+            throw new Error('unsupported data')
+          }
+          v = encodeValue(fs, err, t);
+        } catch {
+          const fallback = (() => {
+            try {
+              return String(err)
+            } catch {
+              return 'Unserializable thrown value'
+            }
+          })();
+          t = getType(fallback);
+          v = encodeValue(fs, fallback, t);
+        }
+        if (v.length > RESPONSE_PAYLOAD_SIZE) {
+          const overflowErr = new RangeError('payload overflow');
+          t = getType(overflowErr);
+          v = encodeValue(fs, overflowErr, t);
+        }
         Atomics.store(sab, 1, t);
-        const v = encodeValue(fs, err, t);
         Atomics.store(sab, 2, v.length);
-        new Uint8Array(sab.buffer).set(v, 16);
+        writeResponsePayload(sab, v);
         Atomics.store(sab, 0, 1); // error
       } finally {
         Atomics.notify(sab, 0);
@@ -232,7 +267,7 @@ const createFsProxy = (memfs) =>
          * @param {any[]} args
          */
         return function (...args) {
-          const sab = new SharedArrayBuffer(16 + 10240);
+          const sab = new SharedArrayBuffer(RESPONSE_BUFFER_SIZE);
           const i32arr = new Int32Array(sab);
           Atomics.store(i32arr, 0, 21);
 
@@ -249,7 +284,7 @@ const createFsProxy = (memfs) =>
           const status = Atomics.load(i32arr, 0);
           const type = Atomics.load(i32arr, 1);
           const size = Atomics.load(i32arr, 2);
-          const content = new Uint8Array(sab, 16, size);
+          const content = new Uint8Array(sab, RESPONSE_HEADER_SIZE, size);
           const value = decodeValue(memfs, content, type);
           if (status === 1) {
             throw value