@dmop/puru 0.1.12 → 0.1.14

package/README.md

@@ -58,7 +58,11 @@ const { result } = spawn(() => {
   return fibonacci(40)
 })
 
-console.log(await result)
+try {
+  console.log(await result)
+} catch (err) {
+  console.error(err)
+}
 ```
 
 </td>

package/dist/index.cjs

@@ -56,6 +56,10 @@ 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();
+var functionRefCache = /* @__PURE__ */ new WeakMap();
+var functionIdCache = /* @__PURE__ */ new Map();
+var FUNCTION_ID_CACHE_MAX = 512;
+var functionIdCounter = 0;
 function serializeFunction(fn) {
   if (typeof fn !== "function") {
     throw new TypeError("Expected a function");
@@ -86,6 +90,25 @@ function serializeFunction(fn) {
   serializeCache.set(fn, str);
   return str;
 }
+function getSerializedFunctionRef(fn) {
+  const cached = functionRefCache.get(fn);
+  if (cached) return cached;
+  const fnStr = serializeFunction(fn);
+  let fnId = functionIdCache.get(fnStr);
+  if (fnId) {
+    functionIdCache.delete(fnStr);
+  } else {
+    fnId = `fn_${++functionIdCounter}`;
+  }
+  functionIdCache.set(fnStr, fnId);
+  if (functionIdCache.size > FUNCTION_ID_CACHE_MAX) {
+    const oldestFnStr = functionIdCache.keys().next().value;
+    if (oldestFnStr !== void 0) functionIdCache.delete(oldestFnStr);
+  }
+  const ref = { fnId, fnStr };
+  functionRefCache.set(fn, ref);
+  return ref;
+}
 
 // src/configure.ts
 var import_node_os = require("os");
@@ -207,12 +230,15 @@ function __buildChannelProxies(channels) {
 const __fnCache = new Map();
 const __FN_CACHE_MAX = 1000;
 
-function __execFn(fnStr, channels, args) {
-  let parsedFn = __fnCache.get(fnStr);
+function __execFn(fnId, fnStr, channels, args) {
+  let parsedFn = __fnCache.get(fnId);
   if (!parsedFn) {
+    if (!fnStr) {
+      throw new Error('Worker function was not registered on this worker');
+    }
     parsedFn = (new Function('return (' + fnStr + ')'))();
     if (__fnCache.size >= __FN_CACHE_MAX) __fnCache.delete(__fnCache.keys().next().value);
-    __fnCache.set(fnStr, parsedFn);
+    __fnCache.set(fnId, parsedFn);
   }
   if (args) {
     return parsedFn(...args);
@@ -246,7 +272,7 @@ parentPort.on('message', async (msg) => {
           return;
         }
         try {
-          const result = await __execFn(msg.fnStr, msg.channels, msg.args);
+          const result = await __execFn(msg.fnId, msg.fnStr, msg.channels, msg.args);
           if (!cancelledTasks.has(msg.taskId)) {
             parentPort.postMessage({ type: 'result', taskId: msg.taskId, value: result });
           }
@@ -265,7 +291,7 @@ parentPort.on('message', async (msg) => {
       })();
     } else {
       try {
-        const result = await __execFn(msg.fnStr, msg.channels, msg.args);
+        const result = await __execFn(msg.fnId, msg.fnStr, msg.channels, msg.args);
         parentPort.postMessage({ type: 'result', taskId: msg.taskId, value: result });
       } catch (error) {
         parentPort.postMessage({
@@ -306,7 +332,7 @@ self.onmessage = async (event) => {
           return;
         }
         try {
-          const result = await __execFn(msg.fnStr, msg.channels, msg.args);
+          const result = await __execFn(msg.fnId, msg.fnStr, msg.channels, msg.args);
           if (!cancelledTasks.has(msg.taskId)) {
             self.postMessage({ type: 'result', taskId: msg.taskId, value: result });
           }
@@ -325,7 +351,7 @@ self.onmessage = async (event) => {
       })();
     } else {
       try {
-        const result = await __execFn(msg.fnStr, msg.channels, msg.args);
+        const result = await __execFn(msg.fnId, msg.fnStr, msg.channels, msg.args);
         self.postMessage({ type: 'result', taskId: msg.taskId, value: result });
       } catch (error) {
         self.postMessage({
@@ -441,8 +467,80 @@ var BunWorkerAdapter = class {
   }
 };
 
+// src/queue.ts
+var RingBuffer = class {
+  items;
+  head = 0;
+  tail = 0;
+  size = 0;
+  cap;
+  constructor(capacity) {
+    this.cap = capacity;
+    this.items = new Array(capacity);
+  }
+  get length() {
+    return this.size;
+  }
+  push(value) {
+    this.items[this.tail] = value;
+    this.tail = (this.tail + 1) % this.cap;
+    this.size++;
+  }
+  shift() {
+    if (this.size === 0) return void 0;
+    const value = this.items[this.head];
+    this.items[this.head] = void 0;
+    this.head = (this.head + 1) % this.cap;
+    this.size--;
+    return value;
+  }
+};
+var FifoQueue = class {
+  head = null;
+  tail = null;
+  size = 0;
+  get length() {
+    return this.size;
+  }
+  push(value) {
+    const node = { value, next: null };
+    if (this.tail) {
+      this.tail.next = node;
+    } else {
+      this.head = node;
+    }
+    this.tail = node;
+    this.size++;
+  }
+  shift() {
+    if (!this.head) return void 0;
+    const node = this.head;
+    this.head = node.next;
+    if (!this.head) this.tail = null;
+    this.size--;
+    const value = node.value;
+    node.value = void 0;
+    node.next = null;
+    return value;
+  }
+  clear() {
+    this.head = null;
+    this.tail = null;
+    this.size = 0;
+  }
+  *[Symbol.iterator]() {
+    let current = this.head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+
 // src/channel.ts
 var CLOSED = /* @__PURE__ */ Symbol("puru.channel.closed");
+var RESOLVED_VOID = Promise.resolve();
+var RESOLVED_NULL = Promise.resolve(null);
 var channelIdCounter = 0;
 var channelRegistry = /* @__PURE__ */ new Map();
 var ChannelImpl = class {
@@ -451,14 +549,15 @@ var ChannelImpl = class {
   _id;
   /** @internal — true once the channel ID has been sent to a worker */
   _shared = false;
-  buffer = [];
+  buffer;
   capacity;
   closed = false;
-  recvQueue = [];
-  sendQueue = [];
+  recvQueue = new FifoQueue();
+  sendQueue = new FifoQueue();
   constructor(capacity) {
     this._id = `__ch_${++channelIdCounter}`;
     this.capacity = capacity;
+    this.buffer = new RingBuffer(capacity);
     channelRegistry.set(this._id, this);
   }
   get len() {
@@ -474,11 +573,11 @@ var ChannelImpl = class {
     const receiver = this.recvQueue.shift();
     if (receiver) {
       receiver.resolve(value);
-      return Promise.resolve();
+      return RESOLVED_VOID;
     }
     if (this.buffer.length < this.capacity) {
       this.buffer.push(value);
-      return Promise.resolve();
+      return RESOLVED_VOID;
     }
     return new Promise((resolve, reject) => {
       this.sendQueue.push({ value, resolve, reject });
@@ -502,7 +601,7 @@ var ChannelImpl = class {
     }
     if (this.closed) {
       this.maybeUnregister();
-      return Promise.resolve(null);
+      return RESOLVED_NULL;
     }
     return new Promise((resolve) => {
       this.recvQueue.push({
@@ -516,11 +615,11 @@ var ChannelImpl = class {
     for (const receiver of this.recvQueue) {
       receiver.resolve(CLOSED);
     }
-    this.recvQueue = [];
+    this.recvQueue.clear();
     for (const sender of this.sendQueue) {
       sender.reject(new Error("send on closed channel"));
     }
-    this.sendQueue = [];
+    this.sendQueue.clear();
   }
   maybeUnregister() {
     if (!this._shared && this.closed && this.buffer.length === 0 && this.recvQueue.length === 0) {
@@ -603,7 +702,7 @@ var InlineManagedWorker = class {
   postMessage(msg) {
     if (this.terminated) return;
     if (msg.type === "execute") {
-      this.executeTask(msg.taskId, msg.fnStr, msg.concurrent, msg.channels, msg.args);
+      this.executeTask(msg.taskId, msg.fnId, msg.fnStr, msg.concurrent, msg.channels, msg.args);
     } else if (msg.type === "cancel") {
       this.cancelledTasks.add(msg.taskId);
     } else if (msg.type === "channel-result") {
@@ -664,7 +763,7 @@ var InlineManagedWorker = class {
     }
     return proxies;
   }
-  executeTask(taskId, fnStr, concurrent, channels, args) {
+  executeTask(taskId, fnId, fnStr, concurrent, channels, args) {
     queueMicrotask(async () => {
       if (this.terminated) return;
       if (concurrent && this.cancelledTasks.has(taskId)) {
@@ -672,11 +771,14 @@ var InlineManagedWorker = class {
         return;
       }
       try {
-        let parsedFn = this.fnCache.get(fnStr);
+        let parsedFn = this.fnCache.get(fnId);
         if (!parsedFn) {
+          if (!fnStr) {
+            throw new Error("Worker function was not registered on this worker");
+          }
           parsedFn = new Function("return (" + fnStr + ")")();
           if (this.fnCache.size >= 1e3) this.fnCache.clear();
-          this.fnCache.set(fnStr, parsedFn);
+          this.fnCache.set(fnId, parsedFn);
         }
         let result;
         if (args) {
@@ -738,6 +840,7 @@ var WorkerPool = class {
   totalCompleted = 0;
   totalFailed = 0;
   taskMap = /* @__PURE__ */ new Map();
+  workerFunctionIds = /* @__PURE__ */ new Map();
   // Per-worker deques for work-stealing strategy
   workerDeques = /* @__PURE__ */ new Map();
   constructor(config, adapter) {
@@ -949,7 +1052,8 @@ var WorkerPool = class {
     const msg = {
       type: "execute",
       taskId: task2.id,
-      fnStr: task2.fnStr,
+      fnId: task2.fnId,
+      fnStr: this.getWorkerFunctionString(worker, task2),
       args: task2.args,
       concurrent: false,
       channels: task2.channels
@@ -971,13 +1075,24 @@ var WorkerPool = class {
     const msg = {
       type: "execute",
       taskId: task2.id,
-      fnStr: task2.fnStr,
+      fnId: task2.fnId,
+      fnStr: this.getWorkerFunctionString(worker, task2),
       args: task2.args,
       concurrent: true,
       channels: task2.channels
     };
     worker.postMessage(msg);
   }
+  getWorkerFunctionString(worker, task2) {
+    let knownFunctions = this.workerFunctionIds.get(worker);
+    if (!knownFunctions) {
+      knownFunctions = /* @__PURE__ */ new Set();
+      this.workerFunctionIds.set(worker, knownFunctions);
+    }
+    if (knownFunctions.has(task2.fnId)) return void 0;
+    knownFunctions.add(task2.fnId);
+    return task2.fnStr;
+  }
   // --- Task completion ---
   handleWorkerMessage(worker, response) {
     if (response.type === "channel-op") {
@@ -1242,6 +1357,7 @@ var WorkerPool = class {
     this.sharedWorkers.clear();
     this.allWorkers.clear();
     this.idleTimers.clear();
+    this.workerFunctionIds.clear();
   }
   resize(maxThreads) {
     this.config = { ...this.config, maxThreads };
@@ -1301,6 +1417,7 @@ var WorkerPool = class {
     });
     worker.on("exit", (_code) => {
       this.allWorkers.delete(worker);
+      this.workerFunctionIds.delete(worker);
       const timer = this.idleTimers.get(worker);
       if (timer) {
         clearTimeout(timer);
@@ -1402,7 +1519,7 @@ async function shutdown() {
 // src/spawn.ts
 var taskCounter = 0;
 function spawn(fn, opts) {
-  const fnStr = serializeFunction(fn);
+  const { fnId, fnStr } = getSerializedFunctionRef(fn);
   const taskId = String(++taskCounter);
   const spawnError = new Error();
   let resolveFn;
@@ -1421,6 +1538,7 @@ function spawn(fn, opts) {
   }
   const task2 = {
     id: taskId,
+    fnId,
     fnStr,
     priority: opts?.priority ?? "normal",
     concurrent: opts?.concurrent ?? false,
@@ -2070,7 +2188,7 @@ var Timer = class {
 // src/registry.ts
 var taskCounter2 = 0;
 function task(fn) {
-  const fnStr = serializeFunction(fn);
+  const { fnId, fnStr } = getSerializedFunctionRef(fn);
   return (...args) => {
     for (const a of args) {
       if (JSON.stringify(a) === void 0) {
@@ -2089,6 +2207,7 @@ function task(fn) {
     });
     const taskObj = {
       id: taskId,
+      fnId,
       fnStr,
       args,
       priority: "normal",