@dmop/puru 0.1.5 → 0.1.11

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();
     }
   }
@@ -393,6 +397,12 @@ var ChannelImpl = class {
     this.capacity = capacity;
     channelRegistry.set(this._id, this);
   }
+  get len() {
+    return this.buffer.length;
+  }
+  get cap() {
+    return this.capacity;
+  }
   send(value) {
     if (this.closed) {
       return Promise.reject(new Error("send on closed channel"));
@@ -446,6 +456,40 @@ var ChannelImpl = class {
     }
     this.sendQueue = [];
   }
+  sendOnly() {
+    const send = (value) => this.send(value);
+    const close = () => this.close();
+    const getLen = () => this.len;
+    const getCap = () => this.cap;
+    return {
+      send,
+      close,
+      get len() {
+        return getLen();
+      },
+      get cap() {
+        return getCap();
+      }
+    };
+  }
+  recvOnly() {
+    const recv = () => this.recv();
+    const getLen = () => this.len;
+    const getCap = () => this.cap;
+    const getIter = () => this[Symbol.asyncIterator]();
+    return {
+      recv,
+      get len() {
+        return getLen();
+      },
+      get cap() {
+        return getCap();
+      },
+      [Symbol.asyncIterator]() {
+        return getIter();
+      }
+    };
+  }
   async *[Symbol.asyncIterator]() {
     while (true) {
       const value = await this.recv();
@@ -463,6 +507,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 +526,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 +563,6 @@ var InlineManagedWorker = class {
     }
   }
   buildChannelProxies(channels) {
-    const self = this;
     const proxies = {};
     for (const [name, channelId] of Object.entries(channels)) {
       proxies[name] = {
@@ -539,13 +584,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 +932,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 +989,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 +1050,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 +1058,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 +1078,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 +1172,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 = {
@@ -1161,6 +1198,18 @@ function spawn(fn, opts) {
       }
     }
   };
+  const ctx = opts?.ctx;
+  if (ctx) {
+    if (ctx.signal.aborted) {
+      settled = true;
+      rejectFn(ctx.err ?? new DOMException("Task was cancelled", "AbortError"));
+      return {
+        result,
+        cancel: () => {
+        }
+      };
+    }
+  }
   getPool().submit(task2);
   const cancel = () => {
     if (settled) return;
@@ -1168,6 +1217,14 @@ function spawn(fn, opts) {
     getPool().cancelTask(taskId);
     rejectFn(new DOMException("Task was cancelled", "AbortError"));
   };
+  if (ctx) {
+    const onAbort = () => cancel();
+    ctx.signal.addEventListener("abort", onAbort, { once: true });
+    result.then(
+      () => ctx.signal.removeEventListener("abort", onAbort),
+      () => ctx.signal.removeEventListener("abort", onAbort)
+    );
+  }
   return { result, cancel };
 }
 
@@ -1175,6 +1232,17 @@ function spawn(fn, opts) {
 var WaitGroup = class {
   tasks = [];
   controller = new AbortController();
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+    if (ctx) {
+      if (ctx.signal.aborted) {
+        this.controller.abort();
+      } else {
+        ctx.signal.addEventListener("abort", () => this.cancel(), { once: true });
+      }
+    }
+  }
   /**
    * An `AbortSignal` shared across all tasks in this group.
    * Pass it into spawned functions so they can stop early when `cancel()` is called.
@@ -1191,7 +1259,7 @@ var WaitGroup = class {
     if (this.controller.signal.aborted) {
       throw new Error("WaitGroup has been cancelled");
     }
-    const handle = spawn(fn, opts);
+    const handle = spawn(fn, { ...opts, ctx: this.ctx });
     this.tasks.push(handle);
   }
   /**
@@ -1224,28 +1292,77 @@ var WaitGroup = class {
 var ErrGroup = class {
   tasks = [];
   controller = new AbortController();
-  firstError = void 0;
+  firstError = null;
   hasError = false;
+  ctx;
+  limit = 0;
+  // 0 = unlimited
+  inFlight = 0;
+  waiting = [];
+  constructor(ctx) {
+    this.ctx = ctx;
+    if (ctx) {
+      if (ctx.signal.aborted) {
+        this.controller.abort();
+      } else {
+        ctx.signal.addEventListener("abort", () => this.cancel(), { once: true });
+      }
+    }
+  }
   get signal() {
     return this.controller.signal;
   }
+  /**
+   * Set the maximum number of tasks that can run concurrently.
+   * Like Go's `errgroup.SetLimit()`. Must be called before any `spawn()`.
+   * A value of 0 (default) means unlimited.
+   */
+  setLimit(n) {
+    if (this.tasks.length > 0) {
+      throw new Error("SetLimit must be called before any spawn()");
+    }
+    if (n < 0 || !Number.isInteger(n)) {
+      throw new RangeError("Limit must be a non-negative integer");
+    }
+    this.limit = n;
+  }
   spawn(fn, opts) {
     if (this.controller.signal.aborted) {
       throw new Error("ErrGroup has been cancelled");
     }
-    const handle = spawn(fn, opts);
-    handle.result.catch((err) => {
+    if (this.limit > 0 && this.inFlight >= this.limit) {
+      const result2 = new Promise((resolve) => {
+        this.waiting.push(resolve);
+      }).then(() => this.doSpawn(fn, opts));
+      this.tasks.push({ result: result2, cancel: () => {
+      } });
+      return;
+    }
+    const result = this.doSpawn(fn, opts);
+    this.tasks.push({ result, cancel: () => {
+    } });
+  }
+  doSpawn(fn, opts) {
+    this.inFlight++;
+    const handle = spawn(fn, { ...opts, ctx: this.ctx });
+    const onSettle = () => {
+      this.inFlight--;
+      const next = this.waiting.shift();
+      if (next) next();
+    };
+    handle.result.then(onSettle, (err) => {
+      onSettle();
       if (!this.hasError) {
         this.hasError = true;
         this.firstError = err;
         this.cancel();
       }
     });
-    this.tasks.push(handle);
+    return handle.result;
   }
   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) => {
@@ -1297,6 +1414,121 @@ var Mutex = class {
     return this.locked;
   }
 };
+var RWMutex = class {
+  readers = 0;
+  writing = false;
+  readQueue = [];
+  writeQueue = [];
+  async rLock() {
+    if (!this.writing && this.writeQueue.length === 0) {
+      this.readers++;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.readQueue.push(() => {
+        this.readers++;
+        resolve();
+      });
+    });
+  }
+  rUnlock() {
+    if (this.readers <= 0) {
+      throw new Error("Cannot rUnlock a RWMutex that is not read-locked");
+    }
+    this.readers--;
+    if (this.readers === 0) {
+      this.wakeWriter();
+    }
+  }
+  async lock() {
+    if (!this.writing && this.readers === 0) {
+      this.writing = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.writeQueue.push(() => {
+        this.writing = true;
+        resolve();
+      });
+    });
+  }
+  unlock() {
+    if (!this.writing) {
+      throw new Error("Cannot unlock a RWMutex that is not write-locked");
+    }
+    this.writing = false;
+    if (this.readQueue.length > 0) {
+      this.wakeReaders();
+    } else {
+      this.wakeWriter();
+    }
+  }
+  async withRLock(fn) {
+    await this.rLock();
+    try {
+      return await fn();
+    } finally {
+      this.rUnlock();
+    }
+  }
+  async withLock(fn) {
+    await this.lock();
+    try {
+      return await fn();
+    } finally {
+      this.unlock();
+    }
+  }
+  get isLocked() {
+    return this.writing || this.readers > 0;
+  }
+  wakeReaders() {
+    const queue = this.readQueue;
+    this.readQueue = [];
+    for (const wake of queue) {
+      wake();
+    }
+  }
+  wakeWriter() {
+    const next = this.writeQueue.shift();
+    if (next) next();
+  }
+};
+
+// src/cond.ts
+var Cond = class {
+  mu;
+  waiters = [];
+  constructor(mu) {
+    this.mu = mu;
+  }
+  /**
+   * Atomically releases the mutex, suspends the caller until `signal()` or `broadcast()`
+   * is called, then re-acquires the mutex before returning.
+   *
+   * Must be called while holding the mutex.
+   */
+  async wait() {
+    this.mu.unlock();
+    await new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+    await this.mu.lock();
+  }
+  /** Wake one waiting task (if any). */
+  signal() {
+    const next = this.waiters.shift();
+    if (next) next();
+  }
+  /** Wake all waiting tasks. */
+  broadcast() {
+    const queue = this.waiters;
+    this.waiters = [];
+    for (const wake of queue) {
+      wake();
+    }
+  }
+};
 
 // src/once.ts
 var Once = class {
@@ -1335,6 +1567,7 @@ function select(cases, opts) {
             if (settled) return;
             settled = true;
             try {
+              ;
               handler(value);
               resolve();
             } catch (err) {
@@ -1368,6 +1601,7 @@ function select(cases, opts) {
           if (settled) return;
           settled = true;
           try {
+            ;
             handler(value);
             resolve();
           } catch (err) {
@@ -1438,11 +1672,60 @@ function ticker(ms) {
   return new Ticker(ms);
 }
 
+// src/timer.ts
+var Timer = class {
+  timer = null;
+  _stopped = false;
+  /** Promise that resolves when the timer fires. Replaced on `reset()`. */
+  channel;
+  constructor(ms) {
+    this.channel = this.schedule(ms);
+  }
+  schedule(ms) {
+    return new Promise((resolve) => {
+      this.timer = setTimeout(() => {
+        this._stopped = true;
+        this.timer = null;
+        resolve();
+      }, ms);
+      if (typeof this.timer === "object" && "unref" in this.timer) {
+        this.timer.unref();
+      }
+    });
+  }
+  /**
+   * Stop the timer. Returns `true` if the timer was pending (stopped before firing),
+   * `false` if it had already fired or was already stopped.
+   *
+   * After stopping, the current `channel` promise will never resolve.
+   */
+  stop() {
+    if (this.timer === null) return false;
+    clearTimeout(this.timer);
+    this.timer = null;
+    this._stopped = true;
+    return true;
+  }
+  /**
+   * Reset the timer to fire after `ms` milliseconds.
+   * If the timer was pending, it is stopped first. Creates a new `channel` promise.
+   */
+  reset(ms) {
+    this.stop();
+    this._stopped = false;
+    this.channel = this.schedule(ms);
+  }
+  /** Whether the timer has fired or been stopped. */
+  get stopped() {
+    return this._stopped;
+  }
+};
+
 // src/registry.ts
 var taskCounter2 = 0;
 function task(fn) {
+  const fnStr = serializeFunction(fn);
   return (...args) => {
-    const fnStr = serializeFunction(fn);
     const serializedArgs = args.map((a) => {
       const json = JSON.stringify(a);
       if (json === void 0) {
@@ -1479,13 +1762,178 @@ function task(fn) {
     return result;
   };
 }
+
+// src/context.ts
+var CancelledError = class extends Error {
+  constructor(message = "context cancelled") {
+    super(message);
+    this.name = "CancelledError";
+  }
+};
+var DeadlineExceededError = class extends Error {
+  constructor() {
+    super("context deadline exceeded");
+    this.name = "DeadlineExceededError";
+  }
+};
+var BaseContext = class {
+  _err = null;
+  controller;
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+    this.controller = new AbortController();
+    if (parent) {
+      if (parent.signal.aborted) {
+        this._err = parent.err ?? new CancelledError();
+        this.controller.abort();
+      } else {
+        parent.signal.addEventListener(
+          "abort",
+          () => {
+            if (!this.controller.signal.aborted) {
+              this._err = parent.err ?? new CancelledError();
+              this.controller.abort();
+            }
+          },
+          { once: true }
+        );
+      }
+    }
+  }
+  get signal() {
+    return this.controller.signal;
+  }
+  get deadline() {
+    return this.parent?.deadline ?? null;
+  }
+  get err() {
+    return this._err;
+  }
+  value(_key) {
+    return this.parent?.value(_key);
+  }
+  done() {
+    if (this.controller.signal.aborted) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.controller.signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+  }
+};
+var BackgroundContext = class {
+  _signal = new AbortController().signal;
+  get signal() {
+    return this._signal;
+  }
+  get deadline() {
+    return null;
+  }
+  get err() {
+    return null;
+  }
+  value(_key) {
+    return void 0;
+  }
+  done() {
+    return new Promise(() => {
+    });
+  }
+};
+var bg = null;
+function background() {
+  if (!bg) bg = new BackgroundContext();
+  return bg;
+}
+var CancelContext = class extends BaseContext {
+  cancel(reason) {
+    if (!this.controller.signal.aborted) {
+      this._err = new CancelledError(reason ?? "context cancelled");
+      this.controller.abort();
+    }
+  }
+};
+function withCancel(parent) {
+  const ctx = new CancelContext(parent);
+  return [ctx, (reason) => ctx.cancel(reason)];
+}
+var DeadlineContext = class extends BaseContext {
+  _deadline;
+  timer = null;
+  constructor(parent, deadline) {
+    super(parent);
+    this._deadline = deadline;
+    if (parent.deadline && parent.deadline < deadline) {
+      this._deadline = parent.deadline;
+    }
+    if (this.controller.signal.aborted) {
+      return;
+    }
+    const ms = this._deadline.getTime() - Date.now();
+    if (ms <= 0) {
+      this._err = new DeadlineExceededError();
+      this.controller.abort();
+    } else {
+      this.timer = setTimeout(() => {
+        if (!this.controller.signal.aborted) {
+          this._err = new DeadlineExceededError();
+          this.controller.abort();
+        }
+      }, ms);
+      if (typeof this.timer === "object" && "unref" in this.timer) {
+        this.timer.unref();
+      }
+    }
+  }
+  get deadline() {
+    return this._deadline;
+  }
+  cancel(reason) {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (!this.controller.signal.aborted) {
+      this._err = new CancelledError(reason ?? "context cancelled");
+      this.controller.abort();
+    }
+  }
+};
+function withDeadline(parent, deadline) {
+  const ctx = new DeadlineContext(parent, deadline);
+  return [ctx, (reason) => ctx.cancel(reason)];
+}
+function withTimeout(parent, ms) {
+  return withDeadline(parent, new Date(Date.now() + ms));
+}
+var ValueContext = class extends BaseContext {
+  key;
+  val;
+  constructor(parent, key, val) {
+    super(parent);
+    this.key = key;
+    this.val = val;
+  }
+  value(key) {
+    if (key === this.key) return this.val;
+    return this.parent?.value(key);
+  }
+};
+function withValue(parent, key, value) {
+  return new ValueContext(parent, key, value);
+}
 export {
+  CancelledError,
+  Cond,
+  DeadlineExceededError,
   ErrGroup,
   Mutex,
   Once,
+  RWMutex,
   Ticker,
+  Timer,
   WaitGroup,
   after,
+  background,
   chan,
   configure,
   detectCapability,
@@ -1496,6 +1944,10 @@ export {
   spawn,
   stats,
   task,
-  ticker
+  ticker,
+  withCancel,
+  withDeadline,
+  withTimeout,
+  withValue
 };
 //# sourceMappingURL=index.js.map