@dmop/puru 0.1.5 → 0.1.10

package/dist/index.d.ts

@@ -1,3 +1,12 @@
+interface JsonObject {
+    [key: string]: JsonValue;
+}
+type JsonValue = null | string | number | boolean | JsonValue[] | JsonObject;
+interface StructuredCloneObject {
+    [key: string]: StructuredCloneValue;
+}
+type StructuredCloneValue = void | null | undefined | string | number | boolean | bigint | Date | RegExp | Error | ArrayBuffer | ArrayBufferView | StructuredCloneValue[] | Map<StructuredCloneValue, StructuredCloneValue> | Set<StructuredCloneValue> | StructuredCloneObject;
+type ChannelValue = Exclude<StructuredCloneValue, null>;
 interface PuruConfig {
     maxThreads: number;
     strategy: 'fifo' | 'work-stealing';
@@ -30,7 +39,7 @@ interface SpawnResult<T> {
  *   process(item)
  * }
  */
-interface Channel<T> {
+interface Channel<T extends ChannelValue> {
     send(value: T): Promise<void>;
     /** Resolves with the next value, or `null` if the channel is closed. */
     recv(): Promise<T | null>;
@@ -65,7 +74,7 @@ interface Channel<T> {
  *   }, { channels: { input, output } })
  * }
  */
-declare function chan<T extends NonNullable<unknown>>(capacity?: number): Channel<T>;
+declare function chan<T extends ChannelValue>(capacity?: number): Channel<T>;
 
 /**
  * Run a function in a worker thread. Returns a handle with the result promise and a cancel function.
@@ -108,12 +117,13 @@ declare function chan<T extends NonNullable<unknown>>(capacity?: number): Channe
  *   ch.close()
  * }, { channels: { ch } })
  */
-declare function spawn<T>(fn: (() => T | Promise<T>) | ((channels: Record<string, Channel<unknown>>) => T | Promise<T>), opts?: {
+declare function spawn<T extends StructuredCloneValue, TChannels extends Record<string, Channel<ChannelValue>> = Record<never, never>>(fn: (() => T | Promise<T>) | ((channels: TChannels) => T | Promise<T>), opts?: {
     priority?: 'low' | 'normal' | 'high';
     concurrent?: boolean;
-    channels?: Record<string, Channel<unknown>>;
+    channels?: TChannels;
 }): SpawnResult<T>;
 
+type SpawnChannels$1 = Record<string, Channel<ChannelValue>>;
 /**
  * Structured concurrency: spawn multiple tasks and wait for all to complete.
  *
@@ -144,7 +154,7 @@ declare function spawn<T>(fn: (() => T | Promise<T>) | ((channels: Record<string
  *   else console.error(r.reason)
  * }
  */
-declare class WaitGroup {
+declare class WaitGroup<T extends StructuredCloneValue = StructuredCloneValue> {
     private tasks;
     private controller;
     /**
@@ -157,20 +167,20 @@ declare class WaitGroup {
      *
      * @throws If the group has already been cancelled.
      */
-    spawn(fn: (() => unknown) | ((channels: Record<string, Channel<unknown>>) => unknown), opts?: {
+    spawn<TChannels extends SpawnChannels$1 = Record<never, never>>(fn: (() => T | Promise<T>) | ((channels: TChannels) => T | Promise<T>), opts?: {
         concurrent?: boolean;
-        channels?: Record<string, Channel<unknown>>;
+        channels?: TChannels;
     }): void;
     /**
      * Waits for all tasks to complete successfully.
      * Rejects as soon as any task throws.
      */
-    wait(): Promise<unknown[]>;
+    wait(): Promise<T[]>;
     /**
      * Waits for all tasks to settle (fulfilled or rejected) and returns each outcome.
      * Never rejects — inspect each `PromiseSettledResult` to handle failures individually.
      */
-    waitSettled(): Promise<PromiseSettledResult<unknown>[]>;
+    waitSettled(): Promise<PromiseSettledResult<T>[]>;
     /**
      * Cancels all tasks in the group and signals the shared `AbortSignal`.
      * Already-settled tasks are unaffected.
@@ -178,6 +188,7 @@ declare class WaitGroup {
     cancel(): void;
 }
 
+type SpawnChannels = Record<string, Channel<ChannelValue>>;
 /**
  * Like `WaitGroup`, but cancels all remaining tasks on the first error.
  *
@@ -207,17 +218,17 @@ declare class WaitGroup {
  *   // use task() with register() and check a channel or AbortSignal instead
  * })
  */
-declare class ErrGroup {
+declare class ErrGroup<T extends StructuredCloneValue = StructuredCloneValue> {
     private tasks;
     private controller;
     private firstError;
     private hasError;
     get signal(): AbortSignal;
-    spawn(fn: (() => unknown) | ((channels: Record<string, Channel<unknown>>) => unknown), opts?: {
+    spawn<TChannels extends SpawnChannels = Record<never, never>>(fn: (() => T | Promise<T>) | ((channels: TChannels) => T | Promise<T>), opts?: {
         concurrent?: boolean;
-        channels?: Record<string, Channel<unknown>>;
+        channels?: TChannels;
     }): void;
-    wait(): Promise<unknown[]>;
+    wait(): Promise<T[]>;
     cancel(): void;
 }
 
@@ -291,7 +302,7 @@ declare class Once<T = void> {
     reset(): void;
 }
 
-type SelectCase<T = unknown> = [Promise<T>, (value: T) => void];
+type SelectCase<T = StructuredCloneValue> = [Promise<T>, (value: T) => void];
 /**
  * Options for `select()`.
  *
@@ -427,7 +438,7 @@ declare function ticker(ms: number): Ticker;
  * const result = await resizeImage('photo.jpg', 800, 600)
  * const [a, b] = await Promise.all([resizeImage('a.jpg', 400, 300), resizeImage('b.jpg', 800, 600)])
  */
-declare function task<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn | Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+declare function task<TArgs extends JsonValue[], TReturn extends StructuredCloneValue>(fn: (...args: TArgs) => TReturn | Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
 
 /**
  * Configure the global thread pool. **Must be called before the first `spawn()`.**

package/dist/index.js

@@ -56,21 +56,20 @@ 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";
 }
 
 // src/adapters/node.ts
-import { Worker as Worker2 } from "worker_threads";
+import { Worker } from "worker_threads";
 
 // src/bootstrap.ts
 var CHANNEL_PROXY_CODE = `
@@ -286,7 +285,7 @@ self.postMessage({ type: 'ready' });
 var NodeManagedWorker = class {
   worker;
   constructor() {
-    this.worker = new Worker2(NODE_BOOTSTRAP_CODE, { eval: true });
+    this.worker = new Worker(NODE_BOOTSTRAP_CODE, { eval: true });
   }
   get id() {
     return this.worker.threadId;
@@ -332,7 +331,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);
@@ -344,27 +347,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();
     }
   }
@@ -463,6 +467,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;
@@ -479,15 +486,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);
@@ -517,7 +523,6 @@ var InlineManagedWorker = class {
     }
   }
   buildChannelProxies(channels) {
-    const self = this;
     const proxies = {};
     for (const [name, channelId] of Object.entries(channels)) {
       proxies[name] = {
@@ -539,13 +544,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]();
         }
       };
     }
@@ -893,6 +892,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);
@@ -941,6 +949,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);
@@ -998,8 +1010,7 @@ var WorkerPool = class {
         this.makeIdle(worker);
       }
     };
-    worker.on("message", (msg) => {
-      const response = msg;
+    worker.on("message", (response) => {
       if (response.type === "ready") {
         onReady();
         return;
@@ -1007,12 +1018,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) {
@@ -1032,12 +1038,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) {
@@ -1131,11 +1132,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 = {
@@ -1224,7 +1221,7 @@ var WaitGroup = class {
 var ErrGroup = class {
   tasks = [];
   controller = new AbortController();
-  firstError = void 0;
+  firstError = null;
   hasError = false;
   get signal() {
     return this.controller.signal;
@@ -1245,7 +1242,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) => {