@dmop/puru 0.1.10 → 0.1.12

package/dist/index.cjs

@@ -20,12 +20,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CancelledError: () => CancelledError,
+  Cond: () => Cond,
+  DeadlineExceededError: () => DeadlineExceededError,
   ErrGroup: () => ErrGroup,
   Mutex: () => Mutex,
   Once: () => Once,
+  RWMutex: () => RWMutex,
+  Semaphore: () => Semaphore,
   Ticker: () => Ticker,
+  Timer: () => Timer,
   WaitGroup: () => WaitGroup,
   after: () => after,
+  background: () => background,
   chan: () => chan,
   configure: () => configure,
   detectCapability: () => detectCapability,
@@ -36,7 +43,11 @@ __export(index_exports, {
   spawn: () => spawn,
   stats: () => stats,
   task: () => task,
-  ticker: () => ticker
+  ticker: () => ticker,
+  withCancel: () => withCancel,
+  withDeadline: () => withDeadline,
+  withTimeout: () => withTimeout,
+  withValue: () => withValue
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -44,10 +55,13 @@ module.exports = __toCommonJS(index_exports);
 var NATIVE_CODE_RE = /\[native code\]/;
 var METHOD_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/;
 var VALID_FN_START_RE = /^(?:function\b|async\s+function\b|async\s*\(|\(|[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>|async\s+[a-zA-Z_$])/;
+var serializeCache = /* @__PURE__ */ new WeakMap();
 function serializeFunction(fn) {
   if (typeof fn !== "function") {
     throw new TypeError("Expected a function");
   }
+  const cached = serializeCache.get(fn);
+  if (cached) return cached;
   const str = fn.toString();
   if (typeof str !== "string" || str.length === 0) {
     throw new TypeError(
@@ -69,6 +83,7 @@ function serializeFunction(fn) {
       "Class methods cannot be serialized. Use an arrow function wrapper instead."
     );
   }
+  serializeCache.set(fn, str);
   return str;
 }
 
@@ -189,15 +204,23 @@ function __buildChannelProxies(channels) {
   return proxies;
 }
 
-function __execFn(fnStr, channels) {
+const __fnCache = new Map();
+const __FN_CACHE_MAX = 1000;
+
+function __execFn(fnStr, channels, args) {
+  let parsedFn = __fnCache.get(fnStr);
+  if (!parsedFn) {
+    parsedFn = (new Function('return (' + fnStr + ')'))();
+    if (__fnCache.size >= __FN_CACHE_MAX) __fnCache.delete(__fnCache.keys().next().value);
+    __fnCache.set(fnStr, parsedFn);
+  }
+  if (args) {
+    return parsedFn(...args);
+  }
   if (channels) {
-    const __ch = __buildChannelProxies(channels);
-    const fn = new Function('__ch', 'return (' + fnStr + ')(__ch)');
-    return fn(__ch);
-  } else {
-    const fn = new Function('return (' + fnStr + ')()');
-    return fn();
+    return parsedFn(__buildChannelProxies(channels));
   }
+  return parsedFn();
 }
 `;
 var NODE_BOOTSTRAP_CODE = `
@@ -223,7 +246,7 @@ parentPort.on('message', async (msg) => {
           return;
         }
         try {
-          const result = await __execFn(msg.fnStr, msg.channels);
+          const result = await __execFn(msg.fnStr, msg.channels, msg.args);
           if (!cancelledTasks.has(msg.taskId)) {
             parentPort.postMessage({ type: 'result', taskId: msg.taskId, value: result });
           }
@@ -242,7 +265,7 @@ parentPort.on('message', async (msg) => {
       })();
     } else {
       try {
-        const result = await __execFn(msg.fnStr, msg.channels);
+        const result = await __execFn(msg.fnStr, msg.channels, msg.args);
         parentPort.postMessage({ type: 'result', taskId: msg.taskId, value: result });
       } catch (error) {
         parentPort.postMessage({
@@ -283,7 +306,7 @@ self.onmessage = async (event) => {
           return;
         }
         try {
-          const result = await __execFn(msg.fnStr, msg.channels);
+          const result = await __execFn(msg.fnStr, msg.channels, msg.args);
           if (!cancelledTasks.has(msg.taskId)) {
             self.postMessage({ type: 'result', taskId: msg.taskId, value: result });
           }
@@ -302,7 +325,7 @@ self.onmessage = async (event) => {
       })();
     } else {
       try {
-        const result = await __execFn(msg.fnStr, msg.channels);
+        const result = await __execFn(msg.fnStr, msg.channels, msg.args);
         self.postMessage({ type: 'result', taskId: msg.taskId, value: result });
       } catch (error) {
         self.postMessage({
@@ -389,17 +412,14 @@ 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);
       });
     }
@@ -429,6 +449,8 @@ var ChannelImpl = class {
   // constraint: can't create channels of nullable type
   /** @internal */
   _id;
+  /** @internal — true once the channel ID has been sent to a worker */
+  _shared = false;
   buffer = [];
   capacity;
   closed = false;
@@ -439,6 +461,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"));
@@ -464,6 +492,7 @@ var ChannelImpl = class {
         this.buffer.push(sender2.value);
         sender2.resolve();
       }
+      this.maybeUnregister();
       return Promise.resolve(value);
     }
     const sender = this.sendQueue.shift();
@@ -472,6 +501,7 @@ var ChannelImpl = class {
       return Promise.resolve(sender.value);
     }
     if (this.closed) {
+      this.maybeUnregister();
       return Promise.resolve(null);
     }
     return new Promise((resolve) => {
@@ -492,6 +522,45 @@ var ChannelImpl = class {
     }
     this.sendQueue = [];
   }
+  maybeUnregister() {
+    if (!this._shared && this.closed && this.buffer.length === 0 && this.recvQueue.length === 0) {
+      channelRegistry.delete(this._id);
+    }
+  }
+  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();
@@ -510,7 +579,9 @@ function getChannelById(id) {
   return channelRegistry.get(id);
 }
 function getChannelId(channel) {
-  return channel._id;
+  const impl = channel;
+  impl._shared = true;
+  return impl._id;
 }
 
 // src/adapters/inline.ts
@@ -522,6 +593,7 @@ var InlineManagedWorker = class {
   exitHandlers = [];
   terminated = false;
   cancelledTasks = /* @__PURE__ */ new Set();
+  fnCache = /* @__PURE__ */ new Map();
   constructor() {
     this.id = ++inlineIdCounter;
     queueMicrotask(() => {
@@ -531,7 +603,7 @@ var InlineManagedWorker = class {
   postMessage(msg) {
     if (this.terminated) return;
     if (msg.type === "execute") {
-      this.executeTask(msg.taskId, msg.fnStr, msg.concurrent, msg.channels);
+      this.executeTask(msg.taskId, msg.fnStr, msg.concurrent, msg.channels, msg.args);
     } else if (msg.type === "cancel") {
       this.cancelledTasks.add(msg.taskId);
     } else if (msg.type === "channel-result") {
@@ -592,7 +664,7 @@ var InlineManagedWorker = class {
     }
     return proxies;
   }
-  executeTask(taskId, fnStr, concurrent, channels) {
+  executeTask(taskId, fnStr, concurrent, channels, args) {
     queueMicrotask(async () => {
       if (this.terminated) return;
       if (concurrent && this.cancelledTasks.has(taskId)) {
@@ -600,14 +672,20 @@ var InlineManagedWorker = class {
         return;
       }
       try {
+        let parsedFn = this.fnCache.get(fnStr);
+        if (!parsedFn) {
+          parsedFn = new Function("return (" + fnStr + ")")();
+          if (this.fnCache.size >= 1e3) this.fnCache.clear();
+          this.fnCache.set(fnStr, parsedFn);
+        }
         let result;
-        if (channels) {
+        if (args) {
+          result = await parsedFn(...args);
+        } else if (channels) {
           const proxies = this.buildChannelProxies(channels);
-          const fn = new Function("__ch", "return (" + fnStr + ")(__ch)");
-          result = await fn(proxies);
+          result = await parsedFn(proxies);
         } else {
-          const fn = new Function("return (" + fnStr + ")()");
-          result = await fn();
+          result = await parsedFn();
         }
         if (concurrent && this.cancelledTasks.has(taskId)) {
           this.cancelledTasks.delete(taskId);
@@ -660,6 +738,8 @@ var WorkerPool = class {
   totalCompleted = 0;
   totalFailed = 0;
   taskMap = /* @__PURE__ */ new Map();
+  // Per-worker deques for work-stealing strategy
+  workerDeques = /* @__PURE__ */ new Map();
   constructor(config, adapter) {
     this.config = config;
     this.adapter = adapter;
@@ -697,6 +777,110 @@ var WorkerPool = class {
     }
     return void 0;
   }
+  // --- Work-stealing helpers ---
+  getOrCreateDeque(worker) {
+    let deque = this.workerDeques.get(worker);
+    if (!deque) {
+      deque = { high: [], normal: [], low: [] };
+      this.workerDeques.set(worker, deque);
+    }
+    return deque;
+  }
+  dequeSize(worker) {
+    const deque = this.workerDeques.get(worker);
+    if (!deque) return 0;
+    return deque.high.length + deque.normal.length + deque.low.length;
+  }
+  enqueueToWorker(worker, task2) {
+    this.getOrCreateDeque(worker)[task2.priority].push(task2);
+  }
+  /** Pop from own deque — FIFO within each priority level. */
+  dequeueFromOwn(worker) {
+    const deque = this.workerDeques.get(worker);
+    if (!deque) return void 0;
+    return deque.high.shift() ?? deque.normal.shift() ?? deque.low.shift();
+  }
+  /** Steal from a victim's deque — takes lowest-priority work from the back. */
+  stealFrom(victim) {
+    const deque = this.workerDeques.get(victim);
+    if (!deque) return void 0;
+    return deque.low.pop() ?? deque.normal.pop() ?? deque.high.pop();
+  }
+  /** Find the exclusive worker with the shortest deque to push a new task to. */
+  findShortestDequeWorker() {
+    let best;
+    let bestSize = Infinity;
+    const seen = /* @__PURE__ */ new Set();
+    for (const worker of this.exclusiveWorkers.values()) {
+      if (seen.has(worker)) continue;
+      seen.add(worker);
+      const size = this.dequeSize(worker);
+      if (size < bestSize) {
+        bestSize = size;
+        best = worker;
+      }
+    }
+    return best;
+  }
+  /** Steal a task from the busiest worker's deque, excluding the thief. */
+  stealFromBusiest(thief) {
+    let victim;
+    let maxSize = 0;
+    for (const [worker, deque] of this.workerDeques) {
+      if (worker === thief) continue;
+      const size = deque.high.length + deque.normal.length + deque.low.length;
+      if (size > maxSize) {
+        maxSize = size;
+        victim = worker;
+      }
+    }
+    if (!victim || maxSize === 0) return void 0;
+    return this.stealFrom(victim);
+  }
+  /** Steal from any deque (no thief exclusion — used by resize). */
+  stealFromAny() {
+    let victim;
+    let maxSize = 0;
+    for (const [worker, deque] of this.workerDeques) {
+      const size = deque.high.length + deque.normal.length + deque.low.length;
+      if (size > maxSize) {
+        maxSize = size;
+        victim = worker;
+      }
+    }
+    if (!victim || maxSize === 0) return void 0;
+    return this.stealFrom(victim);
+  }
+  /** Remove a task by ID from any worker's deque. */
+  removeFromDeques(taskId) {
+    for (const [, deque] of this.workerDeques) {
+      for (const priority of ["high", "normal", "low"]) {
+        const queue = deque[priority];
+        const idx = queue.findIndex((t) => t.id === taskId);
+        if (idx !== -1) {
+          return queue.splice(idx, 1)[0];
+        }
+      }
+    }
+    return void 0;
+  }
+  /** Flush a worker's deque back to the global queue (for redistribution). */
+  flushDeque(worker) {
+    const deque = this.workerDeques.get(worker);
+    if (!deque) return;
+    for (const priority of ["high", "normal", "low"]) {
+      for (const task2 of deque[priority]) {
+        this.queues[priority].push(task2);
+      }
+    }
+    this.workerDeques.delete(worker);
+  }
+  /** Clean up a deque if it's empty. */
+  cleanupDeque(worker) {
+    if (this.dequeSize(worker) === 0) {
+      this.workerDeques.delete(worker);
+    }
+  }
   // --- Submit ---
   submit(task2) {
     if (this.draining) {
@@ -722,6 +906,13 @@ var WorkerPool = class {
       this.createAndReadyWorker();
       return;
     }
+    if (this.config.strategy === "work-stealing") {
+      const target = this.findShortestDequeWorker();
+      if (target) {
+        this.enqueueToWorker(target, task2);
+        return;
+      }
+    }
     this.enqueue(task2);
   }
   submitConcurrent(task2) {
@@ -759,6 +950,7 @@ var WorkerPool = class {
       type: "execute",
       taskId: task2.id,
       fnStr: task2.fnStr,
+      args: task2.args,
       concurrent: false,
       channels: task2.channels
     };
@@ -780,6 +972,7 @@ var WorkerPool = class {
       type: "execute",
       taskId: task2.id,
       fnStr: task2.fnStr,
+      args: task2.args,
       concurrent: true,
       channels: task2.channels
     };
@@ -826,6 +1019,19 @@ var WorkerPool = class {
   }
   assignNextOrIdle(worker) {
     if (!this.allWorkers.has(worker)) return;
+    if (this.config.strategy === "work-stealing") {
+      const own = this.dequeueFromOwn(worker);
+      if (own) {
+        this.cleanupDeque(worker);
+        this.dispatch(worker, own);
+        return;
+      }
+      const stolen = this.stealFromBusiest(worker);
+      if (stolen) {
+        this.dispatch(worker, stolen);
+        return;
+      }
+    }
     const next = this.dequeue();
     if (next) {
       this.dispatch(worker, next);
@@ -836,6 +1042,7 @@ var WorkerPool = class {
       this.dispatchConcurrent(worker, concurrentNext);
       return;
     }
+    this.cleanupDeque(worker);
     this.makeIdle(worker);
   }
   assignNextConcurrentOrIdle(worker) {
@@ -855,6 +1062,13 @@ var WorkerPool = class {
       const exclusiveTask = this.dequeue();
       if (exclusiveTask) {
         this.dispatch(worker, exclusiveTask);
+      } else if (this.config.strategy === "work-stealing") {
+        const stolen = this.stealFromBusiest(worker);
+        if (stolen) {
+          this.dispatch(worker, stolen);
+        } else {
+          this.makeIdle(worker);
+        }
       } else {
         this.makeIdle(worker);
       }
@@ -950,6 +1164,13 @@ var WorkerPool = class {
       removed.reject(new DOMException("Task was cancelled", "AbortError"));
       return;
     }
+    if (this.config.strategy === "work-stealing") {
+      const removedFromDeque = this.removeFromDeques(taskId);
+      if (removedFromDeque) {
+        removedFromDeque.reject(new DOMException("Task was cancelled", "AbortError"));
+        return;
+      }
+    }
     const removedConcurrent = this.removeFromConcurrentQueue(taskId);
     if (removedConcurrent) {
       removedConcurrent.reject(new DOMException("Task was cancelled", "AbortError"));
@@ -960,6 +1181,7 @@ var WorkerPool = class {
       this.exclusiveWorkers.delete(taskId);
       this.allWorkers.delete(exclusiveWorker);
       this.taskMap.delete(taskId);
+      this.flushDeque(exclusiveWorker);
       exclusiveWorker.terminate();
       return;
     }
@@ -991,6 +1213,14 @@ var WorkerPool = class {
       }
       this.concurrentQueues[priority] = [];
     }
+    for (const [, deque] of this.workerDeques) {
+      for (const priority of ["high", "normal", "low"]) {
+        for (const task2 of deque[priority]) {
+          task2.reject(new Error("Pool is shutting down"));
+        }
+      }
+    }
+    this.workerDeques.clear();
     for (const [taskId] of this.exclusiveWorkers) {
       this.taskMap.delete(taskId);
     }
@@ -1018,7 +1248,7 @@ var WorkerPool = class {
     while (true) {
       const totalWorkers = this.allWorkers.size + this.pendingWorkerCount;
       if (totalWorkers >= maxThreads) break;
-      const task2 = this.dequeue() ?? this.dequeueConcurrent();
+      const task2 = this.dequeue() ?? (this.config.strategy === "work-stealing" ? this.stealFromAny() : void 0) ?? this.dequeueConcurrent();
       if (!task2) break;
       this.pendingWorkerCount++;
       this.pendingTasksForWorkers.push(task2);
@@ -1081,6 +1311,7 @@ var WorkerPool = class {
         this.idleWorkers.splice(idleIdx, 1);
       }
       this.rejectExclusiveTaskForWorker(worker, new Error("Worker exited unexpectedly"));
+      this.flushDeque(worker);
       const taskSet = this.sharedWorkers.get(worker);
       if (taskSet) {
         for (const taskId of taskSet) {
@@ -1096,6 +1327,17 @@ var WorkerPool = class {
     for (const taskSet of this.sharedWorkers.values()) {
       concurrentTasks += taskSet.size;
     }
+    let dequeHigh = 0;
+    let dequeNormal = 0;
+    let dequeLow = 0;
+    for (const deque of this.workerDeques.values()) {
+      dequeHigh += deque.high.length;
+      dequeNormal += deque.normal.length;
+      dequeLow += deque.low.length;
+    }
+    const queuedHigh = this.queues.high.length + dequeHigh;
+    const queuedNormal = this.queues.normal.length + dequeNormal;
+    const queuedLow = this.queues.low.length + dequeLow;
     return {
       totalWorkers: this.allWorkers.size,
       idleWorkers: this.idleWorkers.length,
@@ -1104,10 +1346,10 @@ var WorkerPool = class {
       concurrentTasks,
       pendingWorkers: this.pendingWorkerCount,
       queuedTasks: {
-        high: this.queues.high.length,
-        normal: this.queues.normal.length,
-        low: this.queues.low.length,
-        total: this.queues.high.length + this.queues.normal.length + this.queues.low.length
+        high: queuedHigh,
+        normal: queuedNormal,
+        low: queuedLow,
+        total: queuedHigh + queuedNormal + queuedLow
       },
       queuedConcurrentTasks: {
         high: this.concurrentQueues.high.length,
@@ -1162,7 +1404,7 @@ var taskCounter = 0;
 function spawn(fn, opts) {
   const fnStr = serializeFunction(fn);
   const taskId = String(++taskCounter);
-  const spawnStack = new Error().stack;
+  const spawnError = new Error();
   let resolveFn;
   let rejectFn;
   let settled = false;
@@ -1192,14 +1434,29 @@ function spawn(fn, opts) {
     reject: (reason) => {
       if (!settled) {
         settled = true;
-        if (reason instanceof Error && spawnStack) {
-          const callerLine = spawnStack.split("\n").slice(2).join("\n");
-          reason.stack = (reason.stack ?? reason.message) + "\n    --- spawned at ---\n" + callerLine;
+        if (reason instanceof Error) {
+          const spawnStack = spawnError.stack;
+          if (spawnStack) {
+            const callerLine = spawnStack.split("\n").slice(2).join("\n");
+            reason.stack = (reason.stack ?? reason.message) + "\n    --- spawned at ---\n" + callerLine;
+          }
         }
         rejectFn(reason);
       }
     }
   };
+  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;
@@ -1207,6 +1464,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 };
 }
 
@@ -1214,6 +1479,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.
@@ -1230,7 +1506,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);
   }
   /**
@@ -1265,22 +1541,81 @@ var ErrGroup = class {
   controller = new AbortController();
   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) {
+      let innerCancel = () => {
+      };
+      let cancelled = false;
+      const cancel = () => {
+        cancelled = true;
+        innerCancel();
+      };
+      const result = new Promise((resolve) => {
+        this.waiting.push(resolve);
+      }).then(() => {
+        if (cancelled) throw new DOMException("Task was cancelled", "AbortError");
+        const handle2 = this.doSpawn(fn, opts);
+        innerCancel = handle2.cancel;
+        return handle2.result;
+      });
+      this.tasks.push({ result, cancel });
+      return;
+    }
+    const handle = this.doSpawn(fn, opts);
+    this.tasks.push(handle);
+  }
+  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;
   }
   async wait() {
     const settled = await Promise.allSettled(this.tasks.map((t) => t.result));
@@ -1336,6 +1671,212 @@ 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/semaphore.ts
+var Semaphore = class {
+  max;
+  cur;
+  queue = [];
+  constructor(n) {
+    if (n <= 0 || !Number.isInteger(n)) {
+      throw new Error("Semaphore capacity must be a positive integer");
+    }
+    this.max = n;
+    this.cur = 0;
+  }
+  /**
+   * Acquire `n` permits, waiting if necessary until they are available.
+   * Acquires are served in FIFO order.
+   */
+  async acquire(n = 1) {
+    if (n <= 0 || !Number.isInteger(n)) {
+      throw new Error("Acquire count must be a positive integer");
+    }
+    if (n > this.max) {
+      throw new Error(`Acquire count ${n} exceeds semaphore capacity ${this.max}`);
+    }
+    if (this.cur + n <= this.max && this.queue.length === 0) {
+      this.cur += n;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.queue.push({ n, resolve });
+    });
+  }
+  /**
+   * Try to acquire `n` permits without blocking.
+   * Returns `true` if successful, `false` if not enough permits are available.
+   */
+  tryAcquire(n = 1) {
+    if (n <= 0 || !Number.isInteger(n)) {
+      throw new Error("Acquire count must be a positive integer");
+    }
+    if (n > this.max) {
+      throw new Error(`Acquire count ${n} exceeds semaphore capacity ${this.max}`);
+    }
+    if (this.cur + n <= this.max && this.queue.length === 0) {
+      this.cur += n;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Release `n` permits, potentially waking queued acquirers.
+   */
+  release(n = 1) {
+    if (n <= 0 || !Number.isInteger(n)) {
+      throw new Error("Release count must be a positive integer");
+    }
+    if (this.cur - n < 0) {
+      throw new Error("Released more permits than acquired");
+    }
+    this.cur -= n;
+    this.wake();
+  }
+  /**
+   * Acquire `n` permits, run `fn`, then release automatically — even if `fn` throws.
+   */
+  async withAcquire(fn, n = 1) {
+    await this.acquire(n);
+    try {
+      return await fn();
+    } finally {
+      this.release(n);
+    }
+  }
+  /** Number of permits currently available. */
+  get available() {
+    return this.max - this.cur;
+  }
+  /** Total capacity of the semaphore. */
+  get capacity() {
+    return this.max;
+  }
+  wake() {
+    while (this.queue.length > 0) {
+      const head = this.queue[0];
+      if (this.cur + head.n > this.max) break;
+      this.queue.shift();
+      this.cur += head.n;
+      head.resolve();
+    }
+  }
+};
+
+// 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 {
@@ -1477,23 +2018,69 @@ 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) {
+    for (const a of args) {
+      if (JSON.stringify(a) === void 0) {
         throw new TypeError(
           `Argument of type ${typeof a} is not JSON-serializable. task() args must be JSON-serializable (no undefined, functions, symbols, or BigInt).`
         );
       }
-      return json;
-    });
-    const wrapperStr = `() => (${fnStr})(${serializedArgs.join(", ")})`;
+    }
     const taskId = `task_${++taskCounter2}`;
-    const spawnStack = new Error().stack;
+    const spawnError = new Error();
     let resolveFn;
     let rejectFn;
     const result = new Promise((resolve, reject) => {
@@ -1502,14 +2089,18 @@ function task(fn) {
     });
     const taskObj = {
       id: taskId,
-      fnStr: wrapperStr,
+      fnStr,
+      args,
       priority: "normal",
       concurrent: false,
       resolve: (value) => resolveFn(value),
       reject: (reason) => {
-        if (reason instanceof Error && spawnStack) {
-          const callerLine = spawnStack.split("\n").slice(2).join("\n");
-          reason.stack = (reason.stack ?? reason.message) + "\n    --- spawned at ---\n" + callerLine;
+        if (reason instanceof Error) {
+          const spawnStack = spawnError.stack;
+          if (spawnStack) {
+            const callerLine = spawnStack.split("\n").slice(2).join("\n");
+            reason.stack = (reason.stack ?? reason.message) + "\n    --- spawned at ---\n" + callerLine;
+          }
         }
         rejectFn(reason);
       }
@@ -1518,14 +2109,180 @@ 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);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CancelledError,
+  Cond,
+  DeadlineExceededError,
   ErrGroup,
   Mutex,
   Once,
+  RWMutex,
+  Semaphore,
   Ticker,
+  Timer,
   WaitGroup,
   after,
+  background,
   chan,
   configure,
   detectCapability,
@@ -1536,6 +2293,10 @@ function task(fn) {
   spawn,
   stats,
   task,
-  ticker
+  ticker,
+  withCancel,
+  withDeadline,
+  withTimeout,
+  withValue
 });
 //# sourceMappingURL=index.cjs.map