nuxt-ai-ready 2.5.1 → 2.5.3

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

@@ -0,0 +1,35 @@
+{
+  "name": "@emnapi/wasi-threads",
+  "version": "2.1.0",
+  "description": "WASI threads proposal implementation in JavaScript",
+  "type": "module",
+  "main": "./dist/wasi-threads.js",
+  "module": "./dist/wasi-threads.js",
+  "types": "./dist/wasi-threads.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/wasi-threads.js",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "tslib": "^2.4.0"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "build:test": "node ./test/build.js",
+    "test": "node ./test/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toyobayashi/emnapi.git"
+  },
+  "author": "toyobayashi",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/toyobayashi/emnapi/issues"
+  },
+  "homepage": "https://github.com/toyobayashi/emnapi#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/mdream/node_modules/@emnapi/core/node_modules/@emnapi/wasi-threads/rollup.config.js

@@ -0,0 +1,6 @@
+import { defineConfig } from '@emnapi/shared'
+
+export default defineConfig({
+  outputName: 'wasiThreads',
+  outputFile: 'wasi-threads'
+})

package/node_modules/mdream/node_modules/@emnapi/wasi-threads/dist/wasi-threads.d.ts

@@ -134,7 +134,10 @@ export declare class ThreadManager {
     returnWorkerToPool(worker: WorkerLike): void;
     loadWasmModuleToWorker(worker: WorkerLike, sab?: Int32Array): Promise<WorkerLike>;
     allocateUnusedWorker(): WorkerLike;
+    private allocatePoolWorker;
+    private dropFailedLoad;
     getNewWorker(sab?: Int32Array): WorkerLike | undefined;
+    private allocateAndLoadWorker;
     cleanThread(worker: WorkerLike, tid: number, force?: boolean): void;
     terminateWorker(worker: WorkerLike): void;
     terminateAllThreads(): void;
@@ -173,6 +176,7 @@ export declare class ThreadMessageHandler {
     private _load;
     private _start;
     protected _loaded(err: Error | null, source: WebAssembly.WebAssemblyInstantiatedSource | null, payload: LoadPayload): void;
+    private _failQueuedStarts;
     protected handleAfterLoad<E extends WorkerMessageEvent>(e: E, f: (e: E) => void): void;
     protected beforeReportError(_error: Error, _type: WorkerMessageType | 'async-worker-init', _tid?: number): void;
     protected reportError(value: unknown, type: WorkerMessageType | 'async-worker-init', tid?: number): void;

package/node_modules/mdream/node_modules/@emnapi/wasi-threads/dist/wasi-threads.js

@@ -231,11 +231,7 @@ class ThreadManager {
             if (this._reuseWorker.size) {
                 let pthreadPoolSize = this._reuseWorker.size;
                 while (pthreadPoolSize--) {
-                    const worker = this.allocateUnusedWorker();
-                    if (ENVIRONMENT_IS_NODE) {
-                        worker.once('message', () => { });
-                        worker.unref();
-                    }
+                    this.allocatePoolWorker();
                 }
             }
         }
@@ -338,8 +334,7 @@ class ThreadManager {
                 }
                 if (!worker.loaded) {
                     reject(error);
-                    _this.loadRejects.delete(worker);
-                    _this.terminateWorker(worker);
+                    _this.dropFailedLoad(worker);
                     return;
                 }
                 _this.fail(error, !ENVIRONMENT_IS_NODE);
@@ -374,8 +369,7 @@ class ThreadManager {
                         const error = deserializeError(threadError.error);
                         if (!worker.loaded && threadError.phase === 'load') {
                             reject(error);
-                            this.loadRejects.delete(worker);
-                            this.terminateWorker(worker);
+                            this.dropFailedLoad(worker);
                         }
                         else {
                             this.fail(error, true);
@@ -430,8 +424,7 @@ class ThreadManager {
                     error = memoryError;
                 }
                 reject(error);
-                this.loadRejects.delete(worker);
-                this.terminateWorker(worker);
+                this.dropFailedLoad(worker);
             }
         });
         return worker.whenLoaded;
@@ -447,6 +440,21 @@ class ThreadManager {
         this.unusedWorkers.push(worker);
         return worker;
     }
+    allocatePoolWorker() {
+        const worker = this.allocateUnusedWorker();
+        if (ENVIRONMENT_IS_NODE) {
+            worker.once('message', () => { });
+            worker.unref();
+        }
+        return worker;
+    }
+    dropFailedLoad(worker) {
+        const idle = this.unusedWorkers.indexOf(worker) !== -1;
+        this.loadRejects.delete(worker);
+        this.terminateWorker(worker);
+        if (idle && !this._fatalError)
+            this.allocatePoolWorker();
+    }
     getNewWorker(sab) {
         this.assertRunning();
         if (this._reuseWorker) {
@@ -459,14 +467,21 @@ class ThreadManager {
                         return;
                     }
                 }
-                const worker = this.allocateUnusedWorker();
+                return this.allocateAndLoadWorker(sab);
+            }
+            const worker = this.unusedWorkers.pop();
+            if (!worker.whenLoaded) {
                 this.loadWasmModuleToWorker(worker, sab);
             }
-            return this.unusedWorkers.pop();
+            return worker;
         }
+        return this.allocateAndLoadWorker(sab);
+    }
+    allocateAndLoadWorker(sab) {
         const worker = this.allocateUnusedWorker();
+        this.unusedWorkers.pop();
         this.loadWasmModuleToWorker(worker, sab);
-        return this.unusedWorkers.pop();
+        return this.expectedTerminations.has(worker) ? undefined : worker;
     }
     cleanThread(worker, tid, force) {
         if (!force && this._reuseWorker) {
@@ -482,14 +497,20 @@ class ThreadManager {
         const tid = worker.__emnapi_tid;
         this.expectedTerminations.add(worker);
         this.registeredWorkers.delete(worker);
+        const index = this.unusedWorkers.indexOf(worker);
+        if (index !== -1)
+            this.unusedWorkers.splice(index, 1);
         this.loadRejects.delete(worker);
         worker.terminate();
         this.messageEvents.get(worker)?.clear();
         this.messageEvents.delete(worker);
         worker.onmessage = (e) => {
             if (e.data.__emnapi__) {
+                const type = e.data.__emnapi__.type;
+                if (type === 'loaded')
+                    return;
                 const err = this.printErr;
-                err('received "' + e.data.__emnapi__.type + '" command from terminated worker: ' + tid);
+                err('received "' + type + '" command from terminated worker: ' + tid);
             }
         };
     }
@@ -793,7 +814,7 @@ class WASIThreads {
                 worker.whenLoaded.catch((err) => {
                     delete worker.whenLoaded;
                     PThread.cleanThread(worker, tid, true);
-                    throw err;
+                    PThread.printErr('failed to load the worker of thread ' + tid + ': ' + ((err && err.stack) || err));
                 });
             }
             if (isNewABI) {
@@ -1018,17 +1039,20 @@ class ThreadMessageHandler {
     _loaded(err, source, payload) {
         if (err) {
             notifyPthreadCreateResult(payload.sab, 2, err);
+            this._failQueuedStarts(err);
             throw err;
         }
         if (source == null) {
             const err = new TypeError('onLoad should return an object');
             notifyPthreadCreateResult(payload.sab, 2, err);
+            this._failQueuedStarts(err);
             throw err;
         }
         const instance = source.instance;
         if (!instance) {
             const err = new TypeError('onLoad should return an object which includes "instance"');
             notifyPthreadCreateResult(payload.sab, 2, err);
+            this._failQueuedStarts(err);
             throw err;
         }
         this.instance = instance;
@@ -1041,6 +1065,14 @@ class ThreadMessageHandler {
             this.handle({ data });
         }
     }
+    _failQueuedStarts(err) {
+        this.messagesBeforeLoad = this.messagesBeforeLoad.filter((data) => {
+            if (data?.__emnapi__?.type !== 'start')
+                return true;
+            notifyPthreadCreateResult(data.__emnapi__.payload.sab, 2, err);
+            return false;
+        });
+    }
     handleAfterLoad(e, f) {
         if (this.instance !== undefined) {
             f.call(this, e);

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

@@ -1,6 +1,6 @@
 {
   "name": "@emnapi/wasi-threads",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "WASI threads proposal implementation in JavaScript",
   "type": "module",
   "main": "./dist/wasi-threads.js",