@dmop/puru 0.1.5 → 0.1.10

package/dist/index.cjs

@@ -98,16 +98,15 @@ function getConfig() {
 
 // src/runtime.ts
 function detectRuntime() {
-  if (typeof globalThis.Bun !== "undefined") return "bun";
-  if (typeof globalThis.Deno !== "undefined") return "deno";
-  if (typeof globalThis.process !== "undefined" && globalThis.process.versions?.node)
-    return "node";
+  if ("Bun" in globalThis) return "bun";
+  if ("Deno" in globalThis) return "deno";
+  if (typeof globalThis.process !== "undefined" && globalThis.process.versions?.node) return "node";
   return "browser";
 }
 function detectCapability() {
   const runtime = detectRuntime();
   if (runtime === "node" || runtime === "bun") return "full-threads";
-  if (typeof globalThis.Worker !== "undefined") return "full-threads";
+  if ("Worker" in globalThis) return "full-threads";
   return "single-thread";
 }
 
@@ -374,7 +373,11 @@ var BunManagedWorker = class {
   id;
   constructor() {
     this.id = ++workerIdCounter;
-    this.worker = new Worker(getBootstrapFile());
+    const WorkerConstructor = globalThis.Worker;
+    if (!WorkerConstructor) {
+      throw new Error("Bun Worker constructor is not available in this runtime");
+    }
+    this.worker = new WorkerConstructor(getBootstrapFile());
   }
   postMessage(data) {
     this.worker.postMessage(data);
@@ -386,27 +389,28 @@ var BunManagedWorker = class {
   on(event, handler) {
     if (event === "message") {
       this.worker.addEventListener("message", (e) => {
+        ;
         handler(e.data);
       });
     } else if (event === "error") {
       this.worker.addEventListener("error", (e) => {
+        ;
         handler(e.error ?? new Error(e.message));
       });
     } else if (event === "exit") {
       this.worker.addEventListener("close", (e) => {
+        ;
         handler(e.code ?? 0);
       });
     }
   }
   unref() {
     if ("unref" in this.worker && typeof this.worker.unref === "function") {
-      ;
       this.worker.unref();
     }
   }
   ref() {
     if ("ref" in this.worker && typeof this.worker.ref === "function") {
-      ;
       this.worker.ref();
     }
   }
@@ -505,6 +509,9 @@ function chan(capacity = 0) {
 function getChannelById(id) {
   return channelRegistry.get(id);
 }
+function getChannelId(channel) {
+  return channel._id;
+}
 
 // src/adapters/inline.ts
 var inlineIdCounter = 0;
@@ -521,15 +528,14 @@ var InlineManagedWorker = class {
       this.emit("message", { type: "ready" });
     });
   }
-  postMessage(data) {
+  postMessage(msg) {
     if (this.terminated) return;
-    const msg = data;
     if (msg.type === "execute") {
-      this.executeTask(msg.taskId, msg.fnStr, msg.concurrent ?? false, msg.channels);
+      this.executeTask(msg.taskId, msg.fnStr, msg.concurrent, msg.channels);
     } else if (msg.type === "cancel") {
       this.cancelledTasks.add(msg.taskId);
     } else if (msg.type === "channel-result") {
-      this.emit("message", msg);
+      return;
     } else if (msg.type === "shutdown") {
       this.terminated = true;
       this.emit("exit", 0);
@@ -559,7 +565,6 @@ var InlineManagedWorker = class {
     }
   }
   buildChannelProxies(channels) {
-    const self = this;
     const proxies = {};
     for (const [name, channelId] of Object.entries(channels)) {
       proxies[name] = {
@@ -581,13 +586,7 @@ var InlineManagedWorker = class {
         [Symbol.asyncIterator]() {
           const ch = getChannelById(channelId);
           if (!ch) throw new Error(`Channel ${channelId} not found`);
-          return {
-            async next() {
-              const value = await ch.recv();
-              if (value === null) return { done: true, value: void 0 };
-              return { done: false, value };
-            }
-          };
+          return ch[Symbol.asyncIterator]();
         }
       };
     }
@@ -935,6 +934,15 @@ var WorkerPool = class {
       task2.reject(reason);
     }
   }
+  rejectExclusiveTaskForWorker(worker, reason) {
+    for (const [taskId, assignedWorker] of this.exclusiveWorkers) {
+      if (assignedWorker === worker) {
+        this.exclusiveWorkers.delete(taskId);
+        this.rejectTask(taskId, reason);
+        break;
+      }
+    }
+  }
   // --- Cancellation ---
   cancelTask(taskId) {
     const removed = this.removeFromQueue(taskId);
@@ -983,6 +991,10 @@ var WorkerPool = class {
       }
       this.concurrentQueues[priority] = [];
     }
+    for (const [taskId] of this.exclusiveWorkers) {
+      this.taskMap.delete(taskId);
+    }
+    this.exclusiveWorkers.clear();
     for (const [, taskSet] of this.sharedWorkers) {
       for (const taskId of taskSet) {
         this.taskMap.delete(taskId);
@@ -1040,8 +1052,7 @@ var WorkerPool = class {
         this.makeIdle(worker);
       }
     };
-    worker.on("message", (msg) => {
-      const response = msg;
+    worker.on("message", (response) => {
       if (response.type === "ready") {
         onReady();
         return;
@@ -1049,12 +1060,7 @@ var WorkerPool = class {
       this.handleWorkerMessage(worker, response);
     });
     worker.on("error", (err) => {
-      for (const [taskId, w] of this.exclusiveWorkers) {
-        if (w === worker) {
-          this.exclusiveWorkers.delete(taskId);
-          break;
-        }
-      }
+      this.rejectExclusiveTaskForWorker(worker, err);
       const taskSet = this.sharedWorkers.get(worker);
       if (taskSet) {
         for (const taskId of taskSet) {
@@ -1074,12 +1080,7 @@ var WorkerPool = class {
       if (idleIdx !== -1) {
         this.idleWorkers.splice(idleIdx, 1);
       }
-      for (const [taskId, w] of this.exclusiveWorkers) {
-        if (w === worker) {
-          this.exclusiveWorkers.delete(taskId);
-          break;
-        }
-      }
+      this.rejectExclusiveTaskForWorker(worker, new Error("Worker exited unexpectedly"));
       const taskSet = this.sharedWorkers.get(worker);
       if (taskSet) {
         for (const taskId of taskSet) {
@@ -1173,11 +1174,7 @@ function spawn(fn, opts) {
   if (opts?.channels) {
     channelMap = {};
     for (const [name, ch] of Object.entries(opts.channels)) {
-      const impl = ch;
-      if (!impl._id) {
-        throw new Error(`Channel "${name}" is not a valid puru channel`);
-      }
-      channelMap[name] = impl._id;
+      channelMap[name] = getChannelId(ch);
     }
   }
   const task2 = {
@@ -1266,7 +1263,7 @@ var WaitGroup = class {
 var ErrGroup = class {
   tasks = [];
   controller = new AbortController();
-  firstError = void 0;
+  firstError = null;
   hasError = false;
   get signal() {
     return this.controller.signal;
@@ -1287,7 +1284,7 @@ var ErrGroup = class {
   }
   async wait() {
     const settled = await Promise.allSettled(this.tasks.map((t) => t.result));
-    if (this.hasError) {
+    if (this.hasError && this.firstError) {
       throw this.firstError;
     }
     return settled.map((r) => {