@dmop/puru 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1515 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ErrGroup: () => ErrGroup,
+  Mutex: () => Mutex,
+  Once: () => Once,
+  Ticker: () => Ticker,
+  WaitGroup: () => WaitGroup,
+  after: () => after,
+  chan: () => chan,
+  configure: () => configure,
+  detectCapability: () => detectCapability,
+  detectRuntime: () => detectRuntime,
+  register: () => register,
+  resize: () => resize,
+  run: () => run,
+  select: () => select,
+  spawn: () => spawn,
+  stats: () => stats,
+  ticker: () => ticker
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/serialize.ts
+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_$])/;
+function serializeFunction(fn) {
+  if (typeof fn !== "function") {
+    throw new TypeError("Expected a function");
+  }
+  const str = fn.toString();
+  if (typeof str !== "string" || str.length === 0) {
+    throw new TypeError(
+      "Function serialization returned an invalid result. This may indicate Function.prototype.toString has been tampered with."
+    );
+  }
+  if (NATIVE_CODE_RE.test(str)) {
+    throw new TypeError(
+      "Native functions cannot be serialized. Use an arrow function wrapper instead."
+    );
+  }
+  if (!VALID_FN_START_RE.test(str)) {
+    throw new TypeError(
+      "Function serialization produced unexpected output. Only arrow functions, function expressions, and async functions are supported."
+    );
+  }
+  if (METHOD_RE.test(str) && !str.startsWith("function") && !str.startsWith("async function") && !str.startsWith("async (") && !str.startsWith("async=") && !str.startsWith("(") && !str.includes("=>")) {
+    throw new TypeError(
+      "Class methods cannot be serialized. Use an arrow function wrapper instead."
+    );
+  }
+  return str;
+}
+
+// src/configure.ts
+var import_node_os = require("os");
+var DEFAULT_CONFIG = {
+  maxThreads: (0, import_node_os.availableParallelism)?.() ?? 4,
+  strategy: "fifo",
+  idleTimeout: 3e4,
+  adapter: "auto",
+  concurrency: 64
+};
+var currentConfig = { ...DEFAULT_CONFIG };
+var configLocked = false;
+function configure(opts) {
+  if (configLocked) {
+    throw new Error(
+      "configure() must be called before the first spawn(). The worker pool has already been initialized."
+    );
+  }
+  currentConfig = { ...currentConfig, ...opts };
+}
+function getConfig() {
+  configLocked = true;
+  return { ...currentConfig };
+}
+
+// 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";
+  return "browser";
+}
+function detectCapability() {
+  const runtime = detectRuntime();
+  if (runtime === "node" || runtime === "bun") return "full-threads";
+  if (typeof globalThis.Worker !== "undefined") return "full-threads";
+  return "single-thread";
+}
+
+// src/adapters/node.ts
+var import_node_worker_threads = require("worker_threads");
+
+// src/bootstrap.ts
+var CHANNEL_PROXY_CODE = `
+const __chCallbacks = new Map();
+let __chRpcId = 0;
+
+class __ChannelProxy {
+  constructor(id) {
+    this._id = id;
+  }
+
+  _rpc(op, value) {
+    const correlationId = ++__chRpcId;
+    return new Promise((resolve, reject) => {
+      __chCallbacks.set(correlationId, { resolve, reject });
+      __postMsg({
+        type: 'channel-op',
+        channelId: this._id,
+        op,
+        correlationId,
+        value
+      });
+    });
+  }
+
+  send(value) {
+    return this._rpc('send', value);
+  }
+
+  recv() {
+    return this._rpc('recv', undefined);
+  }
+
+  close() {
+    __postMsg({
+      type: 'channel-op',
+      channelId: this._id,
+      op: 'close',
+      correlationId: ++__chRpcId
+    });
+  }
+
+  [Symbol.asyncIterator]() {
+    const proxy = this;
+    return {
+      async next() {
+        const value = await proxy.recv();
+        if (value === null) return { done: true, value: undefined };
+        return { done: false, value };
+      }
+    };
+  }
+}
+
+function __handleChannelResult(msg) {
+  if (msg.type === 'channel-result') {
+    const cb = __chCallbacks.get(msg.correlationId);
+    if (cb) {
+      __chCallbacks.delete(msg.correlationId);
+      if (msg.error) {
+        cb.reject(new Error(msg.error));
+      } else {
+        cb.resolve(msg.value);
+      }
+    }
+  }
+}
+
+function __buildChannelProxies(channels) {
+  if (!channels) return undefined;
+  const proxies = {};
+  for (const name of Object.keys(channels)) {
+    proxies[name] = new __ChannelProxy(channels[name]);
+  }
+  return proxies;
+}
+
+function __execFn(fnStr, channels) {
+  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();
+  }
+}
+`;
+var NODE_BOOTSTRAP_CODE = `
+'use strict';
+const { parentPort } = require('worker_threads');
+
+const __postMsg = (d) => parentPort.postMessage(d);
+
+${CHANNEL_PROXY_CODE}
+
+const cancelledTasks = new Set();
+
+parentPort.on('message', (msg) => {
+  __handleChannelResult(msg);
+});
+
+parentPort.on('message', async (msg) => {
+  if (msg.type === 'execute') {
+    if (msg.concurrent) {
+      (async () => {
+        if (cancelledTasks.has(msg.taskId)) {
+          cancelledTasks.delete(msg.taskId);
+          return;
+        }
+        try {
+          const result = await __execFn(msg.fnStr, msg.channels);
+          if (!cancelledTasks.has(msg.taskId)) {
+            parentPort.postMessage({ type: 'result', taskId: msg.taskId, value: result });
+          }
+        } catch (error) {
+          if (!cancelledTasks.has(msg.taskId)) {
+            parentPort.postMessage({
+              type: 'error',
+              taskId: msg.taskId,
+              message: error instanceof Error ? error.message : String(error),
+              stack: error instanceof Error ? error.stack : undefined,
+            });
+          }
+        } finally {
+          cancelledTasks.delete(msg.taskId);
+        }
+      })();
+    } else {
+      try {
+        const result = await __execFn(msg.fnStr, msg.channels);
+        parentPort.postMessage({ type: 'result', taskId: msg.taskId, value: result });
+      } catch (error) {
+        parentPort.postMessage({
+          type: 'error',
+          taskId: msg.taskId,
+          message: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        });
+      }
+    }
+  } else if (msg.type === 'cancel') {
+    cancelledTasks.add(msg.taskId);
+  } else if (msg.type === 'shutdown') {
+    process.exit(0);
+  }
+});
+
+parentPort.postMessage({ type: 'ready' });
+`;
+var WEB_BOOTSTRAP_CODE = `
+const __postMsg = (d) => self.postMessage(d);
+
+${CHANNEL_PROXY_CODE}
+
+const cancelledTasks = new Set();
+
+self.addEventListener('message', (event) => {
+  __handleChannelResult(event.data);
+});
+
+self.onmessage = async (event) => {
+  const msg = event.data;
+  if (msg.type === 'execute') {
+    if (msg.concurrent) {
+      (async () => {
+        if (cancelledTasks.has(msg.taskId)) {
+          cancelledTasks.delete(msg.taskId);
+          return;
+        }
+        try {
+          const result = await __execFn(msg.fnStr, msg.channels);
+          if (!cancelledTasks.has(msg.taskId)) {
+            self.postMessage({ type: 'result', taskId: msg.taskId, value: result });
+          }
+        } catch (error) {
+          if (!cancelledTasks.has(msg.taskId)) {
+            self.postMessage({
+              type: 'error',
+              taskId: msg.taskId,
+              message: error instanceof Error ? error.message : String(error),
+              stack: error instanceof Error ? error.stack : undefined,
+            });
+          }
+        } finally {
+          cancelledTasks.delete(msg.taskId);
+        }
+      })();
+    } else {
+      try {
+        const result = await __execFn(msg.fnStr, msg.channels);
+        self.postMessage({ type: 'result', taskId: msg.taskId, value: result });
+      } catch (error) {
+        self.postMessage({
+          type: 'error',
+          taskId: msg.taskId,
+          message: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        });
+      }
+    }
+  } else if (msg.type === 'cancel') {
+    cancelledTasks.add(msg.taskId);
+  } else if (msg.type === 'shutdown') {
+    self.close();
+  }
+};
+
+self.postMessage({ type: 'ready' });
+`;
+
+// src/adapters/node.ts
+var NodeManagedWorker = class {
+  worker;
+  constructor() {
+    this.worker = new import_node_worker_threads.Worker(NODE_BOOTSTRAP_CODE, { eval: true });
+  }
+  get id() {
+    return this.worker.threadId;
+  }
+  postMessage(data) {
+    this.worker.postMessage(data);
+  }
+  terminate() {
+    return this.worker.terminate();
+  }
+  on(event, handler) {
+    this.worker.on(event, handler);
+  }
+  unref() {
+    this.worker.unref();
+  }
+  ref() {
+    this.worker.ref();
+  }
+};
+var NodeWorkerAdapter = class {
+  createWorker() {
+    return new NodeManagedWorker();
+  }
+};
+
+// src/adapters/bun.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os2 = require("os");
+var workerIdCounter = 0;
+var bootstrapFile = null;
+function getBootstrapFile() {
+  if (!bootstrapFile) {
+    const dir = (0, import_node_fs.mkdtempSync)((0, import_node_path.join)((0, import_node_os2.tmpdir)(), "puru-"));
+    bootstrapFile = (0, import_node_path.join)(dir, "worker.js");
+    (0, import_node_fs.writeFileSync)(bootstrapFile, WEB_BOOTSTRAP_CODE);
+  }
+  return bootstrapFile;
+}
+var BunManagedWorker = class {
+  worker;
+  id;
+  constructor() {
+    this.id = ++workerIdCounter;
+    this.worker = new Worker(getBootstrapFile());
+  }
+  postMessage(data) {
+    this.worker.postMessage(data);
+  }
+  terminate() {
+    this.worker.terminate();
+    return Promise.resolve(0);
+  }
+  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();
+    }
+  }
+};
+var BunWorkerAdapter = class {
+  createWorker() {
+    return new BunManagedWorker();
+  }
+};
+
+// src/channel.ts
+var channelIdCounter = 0;
+var channelRegistry = /* @__PURE__ */ new Map();
+var ChannelImpl = class {
+  /** @internal */
+  _id;
+  buffer = [];
+  capacity;
+  closed = false;
+  recvQueue = [];
+  sendQueue = [];
+  constructor(capacity) {
+    this._id = `__ch_${++channelIdCounter}`;
+    this.capacity = capacity;
+    channelRegistry.set(this._id, this);
+  }
+  send(value) {
+    if (this.closed) {
+      return Promise.reject(new Error("send on closed channel"));
+    }
+    const receiver = this.recvQueue.shift();
+    if (receiver) {
+      receiver.resolve(value);
+      return Promise.resolve();
+    }
+    if (this.buffer.length < this.capacity) {
+      this.buffer.push(value);
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      this.sendQueue.push({ value, resolve, reject });
+    });
+  }
+  recv() {
+    if (this.buffer.length > 0) {
+      const value = this.buffer.shift();
+      const sender2 = this.sendQueue.shift();
+      if (sender2) {
+        this.buffer.push(sender2.value);
+        sender2.resolve();
+      }
+      return Promise.resolve(value);
+    }
+    const sender = this.sendQueue.shift();
+    if (sender) {
+      sender.resolve();
+      return Promise.resolve(sender.value);
+    }
+    if (this.closed) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+      this.recvQueue.push({ resolve });
+    });
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const receiver of this.recvQueue) {
+      receiver.resolve(null);
+    }
+    this.recvQueue = [];
+    for (const sender of this.sendQueue) {
+      sender.reject(new Error("send on closed channel"));
+    }
+    this.sendQueue = [];
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      const value = await this.recv();
+      if (value === null) return;
+      yield value;
+    }
+  }
+};
+function chan(capacity = 0) {
+  if (capacity < 0 || !Number.isInteger(capacity)) {
+    throw new RangeError("Channel capacity must be a non-negative integer");
+  }
+  return new ChannelImpl(capacity);
+}
+function getChannelById(id) {
+  return channelRegistry.get(id);
+}
+
+// src/adapters/inline.ts
+var inlineIdCounter = 0;
+var InlineManagedWorker = class {
+  id;
+  messageHandlers = [];
+  errorHandlers = [];
+  exitHandlers = [];
+  terminated = false;
+  cancelledTasks = /* @__PURE__ */ new Set();
+  constructor() {
+    this.id = ++inlineIdCounter;
+    queueMicrotask(() => {
+      this.emit("message", { type: "ready" });
+    });
+  }
+  postMessage(data) {
+    if (this.terminated) return;
+    const msg = data;
+    if (msg.type === "execute") {
+      this.executeTask(msg.taskId, msg.fnStr, msg.concurrent ?? false, msg.channels);
+    } else if (msg.type === "cancel") {
+      this.cancelledTasks.add(msg.taskId);
+    } else if (msg.type === "channel-result") {
+      this.emit("message", msg);
+    } else if (msg.type === "shutdown") {
+      this.terminated = true;
+      this.emit("exit", 0);
+    }
+  }
+  terminate() {
+    this.terminated = true;
+    this.emit("exit", 1);
+    return Promise.resolve(1);
+  }
+  on(event, handler) {
+    if (event === "message") this.messageHandlers.push(handler);
+    else if (event === "error") this.errorHandlers.push(handler);
+    else if (event === "exit") this.exitHandlers.push(handler);
+  }
+  unref() {
+  }
+  ref() {
+  }
+  emit(event, value) {
+    if (event === "message") {
+      for (const h of this.messageHandlers) h(value);
+    } else if (event === "error") {
+      for (const h of this.errorHandlers) h(value);
+    } else if (event === "exit") {
+      for (const h of this.exitHandlers) h(value);
+    }
+  }
+  buildChannelProxies(channels) {
+    const self = this;
+    const proxies = {};
+    for (const [name, channelId] of Object.entries(channels)) {
+      proxies[name] = {
+        _id: channelId,
+        async send(value) {
+          const ch = getChannelById(channelId);
+          if (!ch) throw new Error(`Channel ${channelId} not found`);
+          await ch.send(value);
+        },
+        async recv() {
+          const ch = getChannelById(channelId);
+          if (!ch) throw new Error(`Channel ${channelId} not found`);
+          return ch.recv();
+        },
+        close() {
+          const ch = getChannelById(channelId);
+          if (ch) ch.close();
+        },
+        [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 proxies;
+  }
+  executeTask(taskId, fnStr, concurrent, channels) {
+    queueMicrotask(async () => {
+      if (this.terminated) return;
+      if (concurrent && this.cancelledTasks.has(taskId)) {
+        this.cancelledTasks.delete(taskId);
+        return;
+      }
+      try {
+        let result;
+        if (channels) {
+          const proxies = this.buildChannelProxies(channels);
+          const fn = new Function("__ch", "return (" + fnStr + ")(__ch)");
+          result = await fn(proxies);
+        } else {
+          const fn = new Function("return (" + fnStr + ")()");
+          result = await fn();
+        }
+        if (concurrent && this.cancelledTasks.has(taskId)) {
+          this.cancelledTasks.delete(taskId);
+          return;
+        }
+        this.emit("message", { type: "result", taskId, value: result });
+      } catch (error) {
+        if (concurrent && this.cancelledTasks.has(taskId)) {
+          this.cancelledTasks.delete(taskId);
+          return;
+        }
+        this.emit("message", {
+          type: "error",
+          taskId,
+          message: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    });
+  }
+};
+var InlineAdapter = class {
+  createWorker() {
+    return new InlineManagedWorker();
+  }
+};
+
+// src/pool.ts
+var WorkerPool = class {
+  config;
+  adapter;
+  idleWorkers = [];
+  exclusiveWorkers = /* @__PURE__ */ new Map();
+  sharedWorkers = /* @__PURE__ */ new Map();
+  queues = {
+    high: [],
+    normal: [],
+    low: []
+  };
+  concurrentQueues = {
+    high: [],
+    normal: [],
+    low: []
+  };
+  allWorkers = /* @__PURE__ */ new Set();
+  idleTimers = /* @__PURE__ */ new Map();
+  pendingWorkerCount = 0;
+  pendingTasksForWorkers = [];
+  draining = false;
+  totalCompleted = 0;
+  totalFailed = 0;
+  taskMap = /* @__PURE__ */ new Map();
+  constructor(config, adapter) {
+    this.config = config;
+    this.adapter = adapter;
+  }
+  // --- Queue helpers ---
+  enqueue(task) {
+    this.queues[task.priority].push(task);
+  }
+  dequeue() {
+    return this.queues.high.shift() ?? this.queues.normal.shift() ?? this.queues.low.shift();
+  }
+  enqueueConcurrent(task) {
+    this.concurrentQueues[task.priority].push(task);
+  }
+  dequeueConcurrent() {
+    return this.concurrentQueues.high.shift() ?? this.concurrentQueues.normal.shift() ?? this.concurrentQueues.low.shift();
+  }
+  removeFromQueue(taskId) {
+    for (const priority of ["high", "normal", "low"]) {
+      const queue = this.queues[priority];
+      const idx = queue.findIndex((t) => t.id === taskId);
+      if (idx !== -1) {
+        return queue.splice(idx, 1)[0];
+      }
+    }
+    return void 0;
+  }
+  removeFromConcurrentQueue(taskId) {
+    for (const priority of ["high", "normal", "low"]) {
+      const queue = this.concurrentQueues[priority];
+      const idx = queue.findIndex((t) => t.id === taskId);
+      if (idx !== -1) {
+        return queue.splice(idx, 1)[0];
+      }
+    }
+    return void 0;
+  }
+  // --- Submit ---
+  submit(task) {
+    if (this.draining) {
+      task.reject(new Error("Pool is shutting down"));
+      return;
+    }
+    if (task.concurrent) {
+      this.submitConcurrent(task);
+    } else {
+      this.submitExclusive(task);
+    }
+  }
+  submitExclusive(task) {
+    const worker = this.idleWorkers.pop();
+    if (worker) {
+      this.dispatch(worker, task);
+      return;
+    }
+    const totalWorkers = this.allWorkers.size + this.pendingWorkerCount;
+    if (totalWorkers < this.config.maxThreads) {
+      this.pendingWorkerCount++;
+      this.pendingTasksForWorkers.push(task);
+      this.createAndReadyWorker();
+      return;
+    }
+    this.enqueue(task);
+  }
+  submitConcurrent(task) {
+    for (const [worker, tasks] of this.sharedWorkers) {
+      if (tasks.size < this.config.concurrency) {
+        this.dispatchConcurrent(worker, task);
+        return;
+      }
+    }
+    const idleWorker = this.idleWorkers.pop();
+    if (idleWorker) {
+      this.dispatchConcurrent(idleWorker, task);
+      return;
+    }
+    const totalWorkers = this.allWorkers.size + this.pendingWorkerCount;
+    if (totalWorkers < this.config.maxThreads) {
+      this.pendingWorkerCount++;
+      this.pendingTasksForWorkers.push(task);
+      this.createAndReadyWorker();
+      return;
+    }
+    this.enqueueConcurrent(task);
+  }
+  // --- Dispatch ---
+  dispatch(worker, task) {
+    const timer = this.idleTimers.get(worker);
+    if (timer) {
+      clearTimeout(timer);
+      this.idleTimers.delete(worker);
+    }
+    worker.ref();
+    this.exclusiveWorkers.set(task.id, worker);
+    this.taskMap.set(task.id, task);
+    const msg = {
+      type: "execute",
+      taskId: task.id,
+      fnStr: task.fnStr,
+      concurrent: false,
+      channels: task.channels
+    };
+    worker.postMessage(msg);
+  }
+  dispatchConcurrent(worker, task) {
+    const timer = this.idleTimers.get(worker);
+    if (timer) {
+      clearTimeout(timer);
+      this.idleTimers.delete(worker);
+    }
+    worker.ref();
+    if (!this.sharedWorkers.has(worker)) {
+      this.sharedWorkers.set(worker, /* @__PURE__ */ new Set());
+    }
+    this.sharedWorkers.get(worker).add(task.id);
+    this.taskMap.set(task.id, task);
+    const msg = {
+      type: "execute",
+      taskId: task.id,
+      fnStr: task.fnStr,
+      concurrent: true,
+      channels: task.channels
+    };
+    worker.postMessage(msg);
+  }
+  // --- Task completion ---
+  handleWorkerMessage(worker, response) {
+    if (response.type === "channel-op") {
+      this.handleChannelOp(worker, response);
+      return;
+    }
+    if (response.type === "result") {
+      const taskId = response.taskId;
+      this.resolveTask(taskId, response.value);
+      if (this.exclusiveWorkers.has(taskId)) {
+        this.exclusiveWorkers.delete(taskId);
+        this.assignNextOrIdle(worker);
+      } else {
+        const taskSet = this.sharedWorkers.get(worker);
+        if (taskSet) {
+          taskSet.delete(taskId);
+          this.assignNextConcurrentOrIdle(worker);
+        }
+      }
+    } else if (response.type === "error") {
+      const taskId = response.taskId;
+      const err = new Error(response.message);
+      if (response.stack) err.stack = response.stack;
+      this.rejectTask(taskId, err);
+      if (this.exclusiveWorkers.has(taskId)) {
+        this.exclusiveWorkers.delete(taskId);
+        this.assignNextOrIdle(worker);
+      } else {
+        const taskSet = this.sharedWorkers.get(worker);
+        if (taskSet) {
+          taskSet.delete(taskId);
+          this.assignNextConcurrentOrIdle(worker);
+        }
+      }
+    }
+  }
+  assignNextOrIdle(worker) {
+    if (!this.allWorkers.has(worker)) return;
+    const next = this.dequeue();
+    if (next) {
+      this.dispatch(worker, next);
+      return;
+    }
+    const concurrentNext = this.dequeueConcurrent();
+    if (concurrentNext) {
+      this.dispatchConcurrent(worker, concurrentNext);
+      return;
+    }
+    this.makeIdle(worker);
+  }
+  assignNextConcurrentOrIdle(worker) {
+    if (!this.allWorkers.has(worker)) return;
+    const taskSet = this.sharedWorkers.get(worker);
+    const currentCount = taskSet?.size ?? 0;
+    let filled = currentCount;
+    while (filled < this.config.concurrency) {
+      const next = this.dequeueConcurrent();
+      if (!next) break;
+      this.dispatchConcurrent(worker, next);
+      filled++;
+    }
+    const updatedSet = this.sharedWorkers.get(worker);
+    if (!updatedSet || updatedSet.size === 0) {
+      this.sharedWorkers.delete(worker);
+      const exclusiveTask = this.dequeue();
+      if (exclusiveTask) {
+        this.dispatch(worker, exclusiveTask);
+      } else {
+        this.makeIdle(worker);
+      }
+    }
+  }
+  makeIdle(worker) {
+    worker.unref();
+    this.idleWorkers.push(worker);
+    if (this.config.idleTimeout > 0) {
+      const timer = setTimeout(() => {
+        this.idleTimers.delete(worker);
+        const idx = this.idleWorkers.indexOf(worker);
+        if (idx !== -1) {
+          this.idleWorkers.splice(idx, 1);
+        }
+        this.allWorkers.delete(worker);
+        worker.terminate();
+      }, this.config.idleTimeout);
+      if (timer.unref) timer.unref();
+      this.idleTimers.set(worker, timer);
+    }
+  }
+  // --- Channel RPC ---
+  async handleChannelOp(worker, msg) {
+    const channel = getChannelById(msg.channelId);
+    if (!channel) {
+      worker.postMessage({
+        type: "channel-result",
+        correlationId: msg.correlationId,
+        error: `Channel ${msg.channelId} not found`
+      });
+      return;
+    }
+    try {
+      if (msg.op === "send") {
+        await channel.send(msg.value);
+        worker.postMessage({
+          type: "channel-result",
+          correlationId: msg.correlationId
+        });
+      } else if (msg.op === "recv") {
+        const value = await channel.recv();
+        worker.postMessage({
+          type: "channel-result",
+          correlationId: msg.correlationId,
+          value
+        });
+      } else if (msg.op === "close") {
+        channel.close();
+        worker.postMessage({
+          type: "channel-result",
+          correlationId: msg.correlationId
+        });
+      }
+    } catch (err) {
+      worker.postMessage({
+        type: "channel-result",
+        correlationId: msg.correlationId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  // --- Task resolution ---
+  resolveTask(taskId, value) {
+    const task = this.taskMap.get(taskId);
+    if (task) {
+      this.taskMap.delete(taskId);
+      this.totalCompleted++;
+      task.resolve(value);
+    }
+  }
+  rejectTask(taskId, reason) {
+    const task = this.taskMap.get(taskId);
+    if (task) {
+      this.taskMap.delete(taskId);
+      this.totalFailed++;
+      task.reject(reason);
+    }
+  }
+  // --- Cancellation ---
+  cancelTask(taskId) {
+    const removed = this.removeFromQueue(taskId);
+    if (removed) {
+      removed.reject(new DOMException("Task was cancelled", "AbortError"));
+      return;
+    }
+    const removedConcurrent = this.removeFromConcurrentQueue(taskId);
+    if (removedConcurrent) {
+      removedConcurrent.reject(new DOMException("Task was cancelled", "AbortError"));
+      return;
+    }
+    const exclusiveWorker = this.exclusiveWorkers.get(taskId);
+    if (exclusiveWorker) {
+      this.exclusiveWorkers.delete(taskId);
+      this.allWorkers.delete(exclusiveWorker);
+      this.taskMap.delete(taskId);
+      exclusiveWorker.terminate();
+      return;
+    }
+    for (const [worker, taskSet] of this.sharedWorkers) {
+      if (taskSet.has(taskId)) {
+        taskSet.delete(taskId);
+        this.taskMap.delete(taskId);
+        worker.postMessage({ type: "cancel", taskId });
+        if (taskSet.size === 0) {
+          this.sharedWorkers.delete(worker);
+          this.assignNextConcurrentOrIdle(worker);
+        }
+        return;
+      }
+    }
+  }
+  // --- Lifecycle ---
+  async drain() {
+    this.draining = true;
+    for (const priority of ["high", "normal", "low"]) {
+      for (const task of this.queues[priority]) {
+        task.reject(new Error("Pool is shutting down"));
+      }
+      this.queues[priority] = [];
+    }
+    for (const priority of ["high", "normal", "low"]) {
+      for (const task of this.concurrentQueues[priority]) {
+        task.reject(new Error("Pool is shutting down"));
+      }
+      this.concurrentQueues[priority] = [];
+    }
+    for (const [, taskSet] of this.sharedWorkers) {
+      for (const taskId of taskSet) {
+        this.taskMap.delete(taskId);
+      }
+    }
+    const terminatePromises = [];
+    for (const worker of this.allWorkers) {
+      const timer = this.idleTimers.get(worker);
+      if (timer) clearTimeout(timer);
+      terminatePromises.push(worker.terminate());
+    }
+    await Promise.all(terminatePromises);
+    this.idleWorkers = [];
+    this.exclusiveWorkers.clear();
+    this.sharedWorkers.clear();
+    this.allWorkers.clear();
+    this.idleTimers.clear();
+  }
+  resize(maxThreads) {
+    this.config = { ...this.config, maxThreads };
+    while (true) {
+      const totalWorkers = this.allWorkers.size + this.pendingWorkerCount;
+      if (totalWorkers >= maxThreads) break;
+      const task = this.dequeue() ?? this.dequeueConcurrent();
+      if (!task) break;
+      this.pendingWorkerCount++;
+      this.pendingTasksForWorkers.push(task);
+      this.createAndReadyWorker();
+    }
+    while (this.allWorkers.size > maxThreads && this.idleWorkers.length > 0) {
+      const worker = this.idleWorkers.pop();
+      const timer = this.idleTimers.get(worker);
+      if (timer) {
+        clearTimeout(timer);
+        this.idleTimers.delete(worker);
+      }
+      this.allWorkers.delete(worker);
+      worker.terminate();
+    }
+  }
+  // --- Worker creation ---
+  createAndReadyWorker() {
+    const worker = this.adapter.createWorker();
+    const onReady = () => {
+      this.pendingWorkerCount--;
+      this.allWorkers.add(worker);
+      const task = this.pendingTasksForWorkers.shift();
+      if (task) {
+        if (task.concurrent) {
+          this.dispatchConcurrent(worker, task);
+        } else {
+          this.dispatch(worker, task);
+        }
+      } else {
+        this.makeIdle(worker);
+      }
+    };
+    worker.on("message", (msg) => {
+      const response = msg;
+      if (response.type === "ready") {
+        onReady();
+        return;
+      }
+      this.handleWorkerMessage(worker, response);
+    });
+    worker.on("error", (err) => {
+      for (const [taskId, w] of this.exclusiveWorkers) {
+        if (w === worker) {
+          this.exclusiveWorkers.delete(taskId);
+          break;
+        }
+      }
+      const taskSet = this.sharedWorkers.get(worker);
+      if (taskSet) {
+        for (const taskId of taskSet) {
+          this.rejectTask(taskId, err);
+        }
+        this.sharedWorkers.delete(worker);
+      }
+    });
+    worker.on("exit", (_code) => {
+      this.allWorkers.delete(worker);
+      const timer = this.idleTimers.get(worker);
+      if (timer) {
+        clearTimeout(timer);
+        this.idleTimers.delete(worker);
+      }
+      const idleIdx = this.idleWorkers.indexOf(worker);
+      if (idleIdx !== -1) {
+        this.idleWorkers.splice(idleIdx, 1);
+      }
+      for (const [taskId, w] of this.exclusiveWorkers) {
+        if (w === worker) {
+          this.exclusiveWorkers.delete(taskId);
+          break;
+        }
+      }
+      const taskSet = this.sharedWorkers.get(worker);
+      if (taskSet) {
+        for (const taskId of taskSet) {
+          this.rejectTask(taskId, new Error("Worker exited unexpectedly"));
+        }
+        this.sharedWorkers.delete(worker);
+      }
+    });
+  }
+  // --- Stats ---
+  stats() {
+    let concurrentTasks = 0;
+    for (const taskSet of this.sharedWorkers.values()) {
+      concurrentTasks += taskSet.size;
+    }
+    return {
+      totalWorkers: this.allWorkers.size,
+      idleWorkers: this.idleWorkers.length,
+      busyWorkers: this.exclusiveWorkers.size,
+      sharedWorkers: this.sharedWorkers.size,
+      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
+      },
+      queuedConcurrentTasks: {
+        high: this.concurrentQueues.high.length,
+        normal: this.concurrentQueues.normal.length,
+        low: this.concurrentQueues.low.length,
+        total: this.concurrentQueues.high.length + this.concurrentQueues.normal.length + this.concurrentQueues.low.length
+      },
+      totalCompleted: this.totalCompleted,
+      totalFailed: this.totalFailed,
+      maxThreads: this.config.maxThreads,
+      concurrency: this.config.concurrency
+    };
+  }
+};
+var poolInstance = null;
+function createAdapter(adapterConfig) {
+  if (adapterConfig === "inline") return new InlineAdapter();
+  if (adapterConfig === "node") return new NodeWorkerAdapter();
+  if (adapterConfig === "bun") return new BunWorkerAdapter();
+  const capability = detectCapability();
+  if (capability === "single-thread") {
+    throw new Error(
+      "puru requires a runtime with thread support (Node.js or Bun). Current runtime does not support worker threads."
+    );
+  }
+  const runtime = detectRuntime();
+  if (runtime === "bun") return new BunWorkerAdapter();
+  return new NodeWorkerAdapter();
+}
+function getPool() {
+  if (!poolInstance) {
+    const config = getConfig();
+    poolInstance = new WorkerPool(config, createAdapter(config.adapter));
+  }
+  return poolInstance;
+}
+function stats() {
+  return getPool().stats();
+}
+function resize(maxThreads) {
+  getPool().resize(maxThreads);
+}
+
+// src/spawn.ts
+var taskCounter = 0;
+function spawn(fn, opts) {
+  const fnStr = serializeFunction(fn);
+  const taskId = String(++taskCounter);
+  const spawnStack = new Error().stack;
+  let resolveFn;
+  let rejectFn;
+  let settled = false;
+  const result = new Promise((resolve, reject) => {
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+  let channelMap;
+  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;
+    }
+  }
+  const task = {
+    id: taskId,
+    fnStr,
+    priority: opts?.priority ?? "normal",
+    concurrent: opts?.concurrent ?? false,
+    channels: channelMap,
+    resolve: (value) => {
+      if (!settled) {
+        settled = true;
+        resolveFn(value);
+      }
+    },
+    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;
+        }
+        rejectFn(reason);
+      }
+    }
+  };
+  getPool().submit(task);
+  const cancel = () => {
+    if (settled) return;
+    settled = true;
+    getPool().cancelTask(taskId);
+    rejectFn(new DOMException("Task was cancelled", "AbortError"));
+  };
+  return { result, cancel };
+}
+
+// src/waitgroup.ts
+var WaitGroup = class {
+  tasks = [];
+  controller = new AbortController();
+  get signal() {
+    return this.controller.signal;
+  }
+  spawn(fn, opts) {
+    if (this.controller.signal.aborted) {
+      throw new Error("WaitGroup has been cancelled");
+    }
+    const handle = spawn(fn, opts);
+    this.tasks.push(handle);
+  }
+  async wait() {
+    return Promise.all(this.tasks.map((t) => t.result));
+  }
+  async waitSettled() {
+    return Promise.allSettled(this.tasks.map((t) => t.result));
+  }
+  cancel() {
+    this.controller.abort();
+    for (const task of this.tasks) {
+      task.cancel();
+    }
+  }
+};
+
+// src/errgroup.ts
+var ErrGroup = class {
+  tasks = [];
+  controller = new AbortController();
+  firstError = void 0;
+  hasError = false;
+  get signal() {
+    return this.controller.signal;
+  }
+  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.hasError) {
+        this.hasError = true;
+        this.firstError = err;
+        this.cancel();
+      }
+    });
+    this.tasks.push(handle);
+  }
+  async wait() {
+    const settled = await Promise.allSettled(this.tasks.map((t) => t.result));
+    if (this.hasError) {
+      throw this.firstError;
+    }
+    return settled.map((r) => {
+      if (r.status === "fulfilled") return r.value;
+      throw r.reason;
+    });
+  }
+  cancel() {
+    this.controller.abort();
+    for (const task of this.tasks) {
+      task.cancel();
+    }
+  }
+};
+
+// src/mutex.ts
+var Mutex = class {
+  queue = [];
+  locked = false;
+  async lock() {
+    if (!this.locked) {
+      this.locked = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  unlock() {
+    if (!this.locked) {
+      throw new Error("Cannot unlock a mutex that is not locked");
+    }
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+  async withLock(fn) {
+    await this.lock();
+    try {
+      return await fn();
+    } finally {
+      this.unlock();
+    }
+  }
+  get isLocked() {
+    return this.locked;
+  }
+};
+
+// src/once.ts
+var Once = class {
+  promise = null;
+  called = false;
+  async do(fn) {
+    if (!this.called) {
+      this.called = true;
+      this.promise = Promise.resolve(fn());
+    }
+    return this.promise;
+  }
+  get done() {
+    return this.called;
+  }
+  reset() {
+    this.called = false;
+    this.promise = null;
+  }
+};
+
+// src/select.ts
+function select(cases, opts) {
+  if (cases.length === 0) {
+    if (opts?.default) {
+      opts.default();
+    }
+    return Promise.resolve();
+  }
+  if (opts?.default) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      for (const [promise, handler] of cases) {
+        Promise.resolve(promise).then(
+          (value) => {
+            if (settled) return;
+            settled = true;
+            try {
+              handler(value);
+              resolve();
+            } catch (err) {
+              reject(err);
+            }
+          },
+          (err) => {
+            if (settled) return;
+            settled = true;
+            reject(err);
+          }
+        );
+      }
+      queueMicrotask(() => {
+        if (settled) return;
+        settled = true;
+        try {
+          opts.default();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    cases.forEach(([promise, handler]) => {
+      promise.then(
+        (value) => {
+          if (settled) return;
+          settled = true;
+          try {
+            handler(value);
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        },
+        (err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        }
+      );
+    });
+  });
+}
+
+// src/after.ts
+function after(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/ticker.ts
+var Ticker = class {
+  interval = null;
+  resolve = null;
+  stopped = false;
+  ms;
+  constructor(ms) {
+    this.ms = ms;
+    this.interval = setInterval(() => {
+      if (this.resolve) {
+        const r = this.resolve;
+        this.resolve = null;
+        r();
+      }
+    }, ms);
+    if (this.interval.unref) this.interval.unref();
+  }
+  async tick() {
+    if (this.stopped) return false;
+    return new Promise((resolve) => {
+      this.resolve = () => resolve(true);
+    });
+  }
+  stop() {
+    this.stopped = true;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (this.resolve) {
+      const r = this.resolve;
+      this.resolve = null;
+      r();
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    while (await this.tick()) {
+      yield;
+    }
+  }
+};
+function ticker(ms) {
+  return new Ticker(ms);
+}
+
+// src/registry.ts
+var registry = /* @__PURE__ */ new Map();
+var taskCounter2 = 0;
+function register(name, fn) {
+  if (registry.has(name)) {
+    throw new Error(`Task "${name}" is already registered`);
+  }
+  registry.set(name, fn);
+}
+function run(name, ...args) {
+  const fn = registry.get(name);
+  if (!fn) {
+    throw new Error(`Task "${name}" is not registered. Call register() first.`);
+  }
+  const fnStr = serializeFunction(fn);
+  const serializedArgs = args.map((a) => {
+    const json = JSON.stringify(a);
+    if (json === void 0) {
+      throw new TypeError(
+        `Argument of type ${typeof a} is not JSON-serializable. run() args must be JSON-serializable (no undefined, functions, symbols, or BigInt).`
+      );
+    }
+    return json;
+  });
+  const wrapperStr = `() => (${fnStr})(${serializedArgs.join(", ")})`;
+  const taskId = `reg_${++taskCounter2}`;
+  const spawnStack = new Error().stack;
+  let resolveFn;
+  let rejectFn;
+  const result = new Promise((resolve, reject) => {
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+  const task = {
+    id: taskId,
+    fnStr: wrapperStr,
+    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;
+      }
+      rejectFn(reason);
+    }
+  };
+  getPool().submit(task);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrGroup,
+  Mutex,
+  Once,
+  Ticker,
+  WaitGroup,
+  after,
+  chan,
+  configure,
+  detectCapability,
+  detectRuntime,
+  register,
+  resize,
+  run,
+  select,
+  spawn,
+  stats,
+  ticker
+});
+//# sourceMappingURL=index.cjs.map