@dmop/puru 0.1.11 → 0.1.13

package/dist/index.cjs

@@ -27,6 +27,7 @@ __export(index_exports, {
   Mutex: () => Mutex,
   Once: () => Once,
   RWMutex: () => RWMutex,
+  Semaphore: () => Semaphore,
   Ticker: () => Ticker,
   Timer: () => Timer,
   WaitGroup: () => WaitGroup,
@@ -54,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(
@@ -79,6 +83,7 @@ function serializeFunction(fn) {
       "Class methods cannot be serialized. Use an arrow function wrapper instead."
     );
   }
+  serializeCache.set(fn, str);
   return str;
 }
 
@@ -199,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 = `
@@ -233,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 });
           }
@@ -252,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({
@@ -293,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 });
           }
@@ -312,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({
@@ -399,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);
       });
     }
@@ -439,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;
@@ -480,6 +492,7 @@ var ChannelImpl = class {
         this.buffer.push(sender2.value);
         sender2.resolve();
       }
+      this.maybeUnregister();
       return Promise.resolve(value);
     }
     const sender = this.sendQueue.shift();
@@ -488,6 +501,7 @@ var ChannelImpl = class {
       return Promise.resolve(sender.value);
     }
     if (this.closed) {
+      this.maybeUnregister();
       return Promise.resolve(null);
     }
     return new Promise((resolve) => {
@@ -508,6 +522,11 @@ 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();
@@ -560,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
@@ -572,6 +593,7 @@ var InlineManagedWorker = class {
   exitHandlers = [];
   terminated = false;
   cancelledTasks = /* @__PURE__ */ new Set();
+  fnCache = /* @__PURE__ */ new Map();
   constructor() {
     this.id = ++inlineIdCounter;
     queueMicrotask(() => {
@@ -581,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") {
@@ -642,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)) {
@@ -650,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);
@@ -710,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;
@@ -747,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) {
@@ -772,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) {
@@ -809,6 +950,7 @@ var WorkerPool = class {
       type: "execute",
       taskId: task2.id,
       fnStr: task2.fnStr,
+      args: task2.args,
       concurrent: false,
       channels: task2.channels
     };
@@ -830,6 +972,7 @@ var WorkerPool = class {
       type: "execute",
       taskId: task2.id,
       fnStr: task2.fnStr,
+      args: task2.args,
       concurrent: true,
       channels: task2.channels
     };
@@ -876,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);
@@ -886,6 +1042,7 @@ var WorkerPool = class {
       this.dispatchConcurrent(worker, concurrentNext);
       return;
     }
+    this.cleanupDeque(worker);
     this.makeIdle(worker);
   }
   assignNextConcurrentOrIdle(worker) {
@@ -905,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);
       }
@@ -1000,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"));
@@ -1010,6 +1181,7 @@ var WorkerPool = class {
       this.exclusiveWorkers.delete(taskId);
       this.allWorkers.delete(exclusiveWorker);
       this.taskMap.delete(taskId);
+      this.flushDeque(exclusiveWorker);
       exclusiveWorker.terminate();
       return;
     }
@@ -1041,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);
     }
@@ -1068,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);
@@ -1131,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) {
@@ -1146,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,
@@ -1154,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,
@@ -1212,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;
@@ -1242,9 +1434,12 @@ 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);
       }
@@ -1383,16 +1578,26 @@ var ErrGroup = class {
       throw new Error("ErrGroup has been cancelled");
     }
     if (this.limit > 0 && this.inFlight >= this.limit) {
-      const result2 = new Promise((resolve) => {
+      let innerCancel = () => {
+      };
+      let cancelled = false;
+      const cancel = () => {
+        cancelled = true;
+        innerCancel();
+      };
+      const result = new Promise((resolve) => {
         this.waiting.push(resolve);
-      }).then(() => this.doSpawn(fn, opts));
-      this.tasks.push({ result: result2, cancel: () => {
-      } });
+      }).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 result = this.doSpawn(fn, opts);
-    this.tasks.push({ result, cancel: () => {
-    } });
+    const handle = this.doSpawn(fn, opts);
+    this.tasks.push(handle);
   }
   doSpawn(fn, opts) {
     this.inFlight++;
@@ -1410,7 +1615,7 @@ var ErrGroup = class {
         this.cancel();
       }
     });
-    return handle.result;
+    return handle;
   }
   async wait() {
     const settled = await Promise.allSettled(this.tasks.map((t) => t.result));
@@ -1547,6 +1752,97 @@ var RWMutex = class {
   }
 };
 
+// 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;
@@ -1619,7 +1915,6 @@ function select(cases, opts) {
             if (settled) return;
             settled = true;
             try {
-              ;
               handler(value);
               resolve();
             } catch (err) {
@@ -1653,7 +1948,6 @@ function select(cases, opts) {
           if (settled) return;
           settled = true;
           try {
-            ;
             handler(value);
             resolve();
           } catch (err) {
@@ -1778,18 +2072,15 @@ var taskCounter2 = 0;
 function task(fn) {
   const fnStr = serializeFunction(fn);
   return (...args) => {
-    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) => {
@@ -1798,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);
       }
@@ -1982,6 +2277,7 @@ function withValue(parent, key, value) {
   Mutex,
   Once,
   RWMutex,
+  Semaphore,
   Ticker,
   Timer,
   WaitGroup,