@xylabs/threads 4.12.44 → 4.13.1

package/dist/node/master/pool-node.mjs

@@ -1,17 +1,170 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// ../../node_modules/.store/tiny-worker-npm-2.3.0-38c7100e1d/package/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.store/tiny-worker-npm-2.3.0-38c7100e1d/package/lib/index.js"(exports, module) {
+    "use strict";
+    var _createClass = /* @__PURE__ */ function() {
+      function defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+        }
+      }
+      __name(defineProperties, "defineProperties");
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    var path2 = __require("path");
+    var fork = __require("child_process").fork;
+    var worker = path2.join(__dirname, "worker.js");
+    var events = /^(error|message)$/;
+    var defaultPorts = {
+      inspect: 9229,
+      debug: 5858
+    };
+    var range = {
+      min: 1,
+      max: 300
+    };
+    var Worker = function() {
+      function Worker2(arg) {
+        var _this = this;
+        var args = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+          cwd: process.cwd()
+        };
+        _classCallCheck(this, Worker2);
+        var isfn = typeof arg === "function", input = isfn ? arg.toString() : arg;
+        if (!options.cwd) {
+          options.cwd = process.cwd();
+        }
+        var debugVars = process.execArgv.filter(function(execArg) {
+          return /(debug|inspect)/.test(execArg);
+        });
+        if (debugVars.length > 0 && !options.noDebugRedirection) {
+          if (!options.execArgv) {
+            debugVars = Array.from(process.execArgv);
+            options.execArgv = [];
+          }
+          var inspectIndex = debugVars.findIndex(function(debugArg) {
+            return /^--inspect(-brk)?(=\d+)?$/.test(debugArg);
+          });
+          var debugIndex = debugVars.findIndex(function(debugArg) {
+            return /^--debug(-brk)?(=\d+)?$/.test(debugArg);
+          });
+          var portIndex = inspectIndex >= 0 ? inspectIndex : debugIndex;
+          if (portIndex >= 0) {
+            var match = /^--(debug|inspect)(?:-brk)?(?:=(\d+))?$/.exec(debugVars[portIndex]);
+            var port = defaultPorts[match[1]];
+            if (match[2]) {
+              port = parseInt(match[2]);
+            }
+            debugVars[portIndex] = "--" + match[1] + "=" + (port + range.min + Math.floor(Math.random() * (range.max - range.min)));
+            if (debugIndex >= 0 && debugIndex !== portIndex) {
+              match = /^(--debug)(?:-brk)?(.*)/.exec(debugVars[debugIndex]);
+              debugVars[debugIndex] = match[1] + (match[2] ? match[2] : "");
+            }
+          }
+          options.execArgv = options.execArgv.concat(debugVars);
+        }
+        delete options.noDebugRedirection;
+        this.child = fork(worker, args, options);
+        this.onerror = void 0;
+        this.onmessage = void 0;
+        this.child.on("error", function(e) {
+          if (_this.onerror) {
+            _this.onerror.call(_this, e);
+          }
+        });
+        this.child.on("message", function(msg) {
+          var message = JSON.parse(msg);
+          var error = void 0;
+          if (!message.error && _this.onmessage) {
+            _this.onmessage.call(_this, message);
+          }
+          if (message.error && _this.onerror) {
+            error = new Error(message.error);
+            error.stack = message.stack;
+            _this.onerror.call(_this, error);
+          }
+        });
+        this.child.send({
+          input,
+          isfn,
+          cwd: options.cwd,
+          esm: options.esm
+        });
+      }
+      __name(Worker2, "Worker");
+      _createClass(Worker2, [
+        {
+          key: "addEventListener",
+          value: /* @__PURE__ */ __name(function addEventListener(event, fn) {
+            if (events.test(event)) {
+              this["on" + event] = fn;
+            }
+          }, "addEventListener")
+        },
+        {
+          key: "postMessage",
+          value: /* @__PURE__ */ __name(function postMessage(msg) {
+            this.child.send(JSON.stringify({
+              data: msg
+            }, null, 0));
+          }, "postMessage")
+        },
+        {
+          key: "terminate",
+          value: /* @__PURE__ */ __name(function terminate() {
+            this.child.kill("SIGINT");
+          }, "terminate")
+        }
+      ], [
+        {
+          key: "setRange",
+          value: /* @__PURE__ */ __name(function setRange(min, max) {
+            if (min >= max) {
+              return false;
+            }
+            range.min = min;
+            range.max = max;
+            return true;
+          }, "setRange")
+        }
+      ]);
+      return Worker2;
+    }();
+    module.exports = Worker;
+  }
+});
 
 // src/master/pool-node.ts
 import DebugLogger from "debug";
-import {
-  multicast,
-  Observable,
-  Subject
-} from "observable-fns";
+import { multicast, Observable, Subject } from "observable-fns";
 
 // src/master/implementation.node.ts
 import { EventEmitter } from "events";
@@ -21,15 +174,19 @@ import { cwd } from "process";
 import { Worker as NativeWorker } from "worker_threads";
 var defaultPoolSize = cpus().length;
 function resolveScriptPath(scriptPath, baseURL) {
-  const makeAbsolute = (filePath) => {
+  const makeAbsolute = /* @__PURE__ */ __name((filePath) => {
     return path.isAbsolute(filePath) ? filePath : path.join(baseURL ?? cwd(), filePath);
-  };
+  }, "makeAbsolute");
   const absolutePath = makeAbsolute(scriptPath);
   return absolutePath;
 }
+__name(resolveScriptPath, "resolveScriptPath");
 function initWorkerThreadsWorker() {
   let allWorkers = [];
-  class Worker extends NativeWorker {
+  let Worker = class Worker extends NativeWorker {
+    static {
+      __name(this, "Worker");
+    }
     mappedEventListeners;
     constructor(scriptPath, options) {
       const resolvedScriptPath = options && options.fromSource ? null : resolveScriptPath(scriptPath, (options ?? {})._baseURL);
@@ -37,15 +194,20 @@ function initWorkerThreadsWorker() {
         super(resolvedScriptPath, options);
       } else {
         const sourceCode = scriptPath;
-        super(sourceCode, { ...options, eval: true });
+        super(sourceCode, {
+          ...options,
+          eval: true
+        });
       }
       this.mappedEventListeners = /* @__PURE__ */ new WeakMap();
       allWorkers.push(this);
     }
     addEventListener(eventName, rawListener) {
-      const listener = (message) => {
-        rawListener({ data: message });
-      };
+      const listener = /* @__PURE__ */ __name((message) => {
+        rawListener({
+          data: message
+        });
+      }, "listener");
       this.mappedEventListeners.set(rawListener, listener);
       this.on(eventName, listener);
     }
@@ -53,41 +215,55 @@ function initWorkerThreadsWorker() {
       const listener = this.mappedEventListeners.get(rawListener) || rawListener;
       this.off(eventName, listener);
     }
-  }
-  const terminateWorkersAndMaster = () => {
-    Promise.all(allWorkers.map((worker) => worker.terminate())).then(
-      () => process.exit(0),
-      () => process.exit(1)
-    );
-    allWorkers = [];
   };
+  const terminateWorkersAndMaster = /* @__PURE__ */ __name(() => {
+    Promise.all(allWorkers.map((worker) => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+    allWorkers = [];
+  }, "terminateWorkersAndMaster");
   process.on("SIGINT", () => terminateWorkersAndMaster());
   process.on("SIGTERM", () => terminateWorkersAndMaster());
-  class BlobWorker extends Worker {
+  let BlobWorker = class BlobWorker extends Worker {
+    static {
+      __name(this, "BlobWorker");
+    }
     constructor(blob, options) {
-      super(Buffer.from(blob).toString("utf-8"), { ...options, fromSource: true });
+      super(Buffer.from(blob).toString("utf-8"), {
+        ...options,
+        fromSource: true
+      });
     }
     static fromText(source, options) {
-      return new Worker(source, { ...options, fromSource: true });
+      return new Worker(source, {
+        ...options,
+        fromSource: true
+      });
     }
-  }
+  };
   return {
     blob: BlobWorker,
     default: Worker
   };
 }
+__name(initWorkerThreadsWorker, "initWorkerThreadsWorker");
 function initTinyWorker() {
-  const TinyWorker = __require("tiny-worker");
+  const TinyWorker = require_lib();
   let allWorkers = [];
-  class Worker extends TinyWorker {
+  let Worker = class Worker extends TinyWorker {
+    static {
+      __name(this, "Worker");
+    }
     emitter;
     constructor(scriptPath, options) {
       const resolvedScriptPath = options && options.fromSource ? null : process.platform === "win32" ? `file:///${resolveScriptPath(scriptPath).replaceAll("\\", "/")}` : resolveScriptPath(scriptPath);
       if (resolvedScriptPath) {
-        super(resolvedScriptPath, [], { esm: true });
+        super(resolvedScriptPath, [], {
+          esm: true
+        });
       } else {
         const sourceCode = scriptPath;
-        super(new Function(sourceCode), [], { esm: true });
+        super(new Function(sourceCode), [], {
+          esm: true
+        });
       }
       allWorkers.push(this);
       this.emitter = new EventEmitter();
@@ -104,29 +280,36 @@ function initTinyWorker() {
       allWorkers = allWorkers.filter((worker) => worker !== this);
       return super.terminate();
     }
-  }
-  const terminateWorkersAndMaster = () => {
-    Promise.all(allWorkers.map((worker) => worker.terminate())).then(
-      () => process.exit(0),
-      () => process.exit(1)
-    );
-    allWorkers = [];
   };
+  const terminateWorkersAndMaster = /* @__PURE__ */ __name(() => {
+    Promise.all(allWorkers.map((worker) => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+    allWorkers = [];
+  }, "terminateWorkersAndMaster");
   process.on("SIGINT", () => terminateWorkersAndMaster());
   process.on("SIGTERM", () => terminateWorkersAndMaster());
-  class BlobWorker extends Worker {
+  let BlobWorker = class BlobWorker extends Worker {
+    static {
+      __name(this, "BlobWorker");
+    }
     constructor(blob, options) {
-      super(Buffer.from(blob).toString("utf-8"), { ...options, fromSource: true });
+      super(Buffer.from(blob).toString("utf-8"), {
+        ...options,
+        fromSource: true
+      });
     }
     static fromText(source, options) {
-      return new Worker(source, { ...options, fromSource: true });
+      return new Worker(source, {
+        ...options,
+        fromSource: true
+      });
     }
-  }
+  };
   return {
     blob: BlobWorker,
     default: Worker
   };
 }
+__name(initTinyWorker, "initTinyWorker");
 var implementation;
 var isTinyWorker;
 function selectWorkerImplementation() {
@@ -140,12 +323,14 @@ function selectWorkerImplementation() {
     return initTinyWorker();
   }
 }
+__name(selectWorkerImplementation, "selectWorkerImplementation");
 function getWorkerImplementation() {
   if (!implementation) {
     implementation = selectWorkerImplementation();
   }
   return implementation;
 }
+__name(getWorkerImplementation, "getWorkerImplementation");
 function isWorkerRuntime() {
   if (isTinyWorker) {
     return globalThis !== void 0 && self["postMessage"] ? true : false;
@@ -154,9 +339,10 @@ function isWorkerRuntime() {
     return !isMainThread;
   }
 }
+__name(isWorkerRuntime, "isWorkerRuntime");
 
 // src/master/pool-types.ts
-var PoolEventType = /* @__PURE__ */ ((PoolEventType2) => {
+var PoolEventType = /* @__PURE__ */ function(PoolEventType2) {
   PoolEventType2["initialized"] = "initialized";
   PoolEventType2["taskCanceled"] = "taskCanceled";
   PoolEventType2["taskCompleted"] = "taskCompleted";
@@ -166,7 +352,7 @@ var PoolEventType = /* @__PURE__ */ ((PoolEventType2) => {
   PoolEventType2["taskStart"] = "taskStart";
   PoolEventType2["terminated"] = "terminated";
   return PoolEventType2;
-})(PoolEventType || {});
+}({});
 
 // src/symbols.ts
 var $errors = Symbol("thread.errors");
@@ -179,6 +365,7 @@ var $worker = Symbol("thread.worker");
 function fail(message) {
   throw new Error(message);
 }
+__name(fail, "fail");
 var Thread = {
   /** Return an observable that can be used to subscribe to all errors happening in the thread. */
   errors(thread) {
@@ -203,24 +390,33 @@ function createArray(size) {
   }
   return array;
 }
+__name(createArray, "createArray");
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+__name(delay, "delay");
 function flatMap(array, mapper) {
-  return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
+  return array.reduce((flattened, element) => [
+    ...flattened,
+    ...mapper(element)
+  ], []);
 }
+__name(flatMap, "flatMap");
 function slugify(text) {
   return text.replaceAll(/\W/g, " ").trim().replaceAll(/\s+/g, "-");
 }
+__name(slugify, "slugify");
 function spawnWorkers(spawnWorker, count) {
-  return createArray(count).map(
-    () => ({
-      init: spawnWorker(),
-      runningTasks: []
-    })
-  );
+  return createArray(count).map(() => ({
+    init: spawnWorker(),
+    runningTasks: []
+  }));
 }
-var WorkerPool = class {
+__name(spawnWorkers, "spawnWorkers");
+var WorkerPool = class WorkerPool2 {
+  static {
+    __name(this, "WorkerPool");
+  }
   static EventType = PoolEventType;
   debug;
   eventObservable;
@@ -232,23 +428,22 @@ var WorkerPool = class {
   nextTaskID = 1;
   taskQueue = [];
   constructor(spawnWorker, optionsOrSize) {
-    const options = typeof optionsOrSize === "number" ? { size: optionsOrSize } : optionsOrSize || {};
+    const options = typeof optionsOrSize === "number" ? {
+      size: optionsOrSize
+    } : optionsOrSize || {};
     const { size = defaultPoolSize } = options;
     this.debug = DebugLogger(`threads:pool:${slugify(options.name || String(nextPoolID++))}`);
     this.options = options;
     this.workers = spawnWorkers(spawnWorker, size);
     this.eventObservable = multicast(Observable.from(this.eventSubject));
-    Promise.all(this.workers.map((worker) => worker.init)).then(
-      () => this.eventSubject.next({
-        size: this.workers.length,
-        type: "initialized" /* initialized */
-      }),
-      (error) => {
-        this.debug("Error while initializing pool worker:", error);
-        this.eventSubject.error(error);
-        this.initErrors.push(error);
-      }
-    );
+    Promise.all(this.workers.map((worker) => worker.init)).then(() => this.eventSubject.next({
+      size: this.workers.length,
+      type: PoolEventType.initialized
+    }), (error) => {
+      this.debug("Error while initializing pool worker:", error);
+      this.eventSubject.error(error);
+      this.initErrors.push(error);
+    });
   }
   findIdlingWorker() {
     const { concurrency = 1 } = this.options;
@@ -259,7 +454,7 @@ var WorkerPool = class {
     this.debug(`Running task #${task.id} on worker #${workerID}...`);
     this.eventSubject.next({
       taskID: task.id,
-      type: "taskStart" /* taskStart */,
+      type: PoolEventType.taskStart,
       workerID
     });
     try {
@@ -268,7 +463,7 @@ var WorkerPool = class {
       this.eventSubject.next({
         returnValue,
         taskID: task.id,
-        type: "taskCompleted" /* taskCompleted */,
+        type: PoolEventType.taskCompleted,
         workerID
       });
     } catch (ex) {
@@ -277,16 +472,16 @@ var WorkerPool = class {
       this.eventSubject.next({
         error,
         taskID: task.id,
-        type: "taskFailed" /* taskFailed */,
+        type: PoolEventType.taskFailed,
         workerID
       });
     }
   }
   run(worker, task) {
     const runPromise = (async () => {
-      const removeTaskFromWorkersRunningTasks = () => {
+      const removeTaskFromWorkersRunningTasks = /* @__PURE__ */ __name(() => {
         worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise);
-      };
+      }, "removeTaskFromWorkersRunningTasks");
       await delay(0);
       try {
         await this.runPoolTask(worker, task);
@@ -306,7 +501,9 @@ var WorkerPool = class {
     const nextTask = this.taskQueue.shift();
     if (!nextTask) {
       this.debug("Task queue is empty");
-      this.eventSubject.next({ type: "taskQueueDrained" /* taskQueueDrained */ });
+      this.eventSubject.next({
+        type: PoolEventType.taskQueueDrained
+      });
       return;
     }
     this.run(availableWorker, nextTask);
@@ -314,13 +511,13 @@ var WorkerPool = class {
   taskCompletion(taskID) {
     return new Promise((resolve, reject) => {
       const eventSubscription = this.events().subscribe((event) => {
-        if (event.type === "taskCompleted" /* taskCompleted */ && event.taskID === taskID) {
+        if (event.type === PoolEventType.taskCompleted && event.taskID === taskID) {
           eventSubscription.unsubscribe();
           resolve(event.returnValue);
-        } else if (event.type === "taskFailed" /* taskFailed */ && event.taskID === taskID) {
+        } else if (event.type === PoolEventType.taskFailed && event.taskID === taskID) {
           eventSubscription.unsubscribe();
           reject(event.error);
-        } else if (event.type === "terminated" /* terminated */) {
+        } else if (event.type === PoolEventType.terminated) {
           eventSubscription.unsubscribe();
           reject(new Error("Pool has been terminated before task was run."));
         }
@@ -328,10 +525,10 @@ var WorkerPool = class {
     });
   }
   async settled(allowResolvingImmediately = false) {
-    const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
+    const getCurrentlyRunningTasks = /* @__PURE__ */ __name(() => flatMap(this.workers, (worker) => worker.runningTasks), "getCurrentlyRunningTasks");
     const taskFailures = [];
     const failureSubscription = this.eventObservable.subscribe((event) => {
-      if (event.type === "taskFailed" /* taskFailed */) {
+      if (event.type === PoolEventType.taskFailed) {
         taskFailures.push(event.error);
       }
     });
@@ -346,12 +543,11 @@ var WorkerPool = class {
       const subscription = this.eventObservable.subscribe({
         error: reject,
         next(event) {
-          if (event.type === "taskQueueDrained" /* taskQueueDrained */) {
+          if (event.type === PoolEventType.taskQueueDrained) {
             subscription.unsubscribe();
             resolve(void 0);
           }
         }
-        // make a pool-wide error reject the completed() result promise
       });
     });
     await Promise.allSettled(getCurrentlyRunningTasks());
@@ -364,18 +560,20 @@ var WorkerPool = class {
       const subscription = this.eventObservable.subscribe({
         error: reject,
         next(event) {
-          if (event.type === "taskQueueDrained" /* taskQueueDrained */) {
+          if (event.type === PoolEventType.taskQueueDrained) {
             subscription.unsubscribe();
             resolve(settlementPromise);
-          } else if (event.type === "taskFailed" /* taskFailed */) {
+          } else if (event.type === PoolEventType.taskFailed) {
             subscription.unsubscribe();
             reject(event.error);
           }
         }
-        // make a pool-wide error reject the completed() result promise
       });
     });
-    const errors = await Promise.race([settlementPromise, earlyExitPromise]);
+    const errors = await Promise.race([
+      settlementPromise,
+      earlyExitPromise
+    ]);
     if (errors.length > 0) {
       throw errors[0];
     }
@@ -397,28 +595,26 @@ var WorkerPool = class {
       this.debug(`Task #${taskID} errored:`, error);
     });
     const task = {
-      cancel: () => {
+      cancel: /* @__PURE__ */ __name(() => {
         if (!this.taskQueue.includes(task)) return;
         this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
         this.eventSubject.next({
           taskID: task.id,
-          type: "taskCanceled" /* taskCanceled */
+          type: PoolEventType.taskCanceled
         });
-      },
+      }, "cancel"),
       id: taskID,
       run: taskFunction,
       then: taskCompletion.then.bind(taskCompletion)
     };
     if (this.taskQueue.length >= maxQueuedJobs) {
-      throw new Error(
-        "Maximum number of pool tasks queued. Refusing to queue another one.\nThis usually happens for one of two reasons: We are either at peak workload right now or some tasks just won't finish, thus blocking the pool."
-      );
+      throw new Error("Maximum number of pool tasks queued. Refusing to queue another one.\nThis usually happens for one of two reasons: We are either at peak workload right now or some tasks just won't finish, thus blocking the pool.");
     }
     this.debug(`Queueing task #${task.id}...`);
     this.taskQueue.push(task);
     this.eventSubject.next({
       taskID: task.id,
-      type: "taskQueued" /* taskQueued */
+      type: PoolEventType.taskQueued
     });
     this.scheduleWork();
     return task;
@@ -429,8 +625,10 @@ var WorkerPool = class {
       await this.completed(true);
     }
     this.eventSubject.next({
-      remainingQueue: [...this.taskQueue],
-      type: "terminated" /* terminated */
+      remainingQueue: [
+        ...this.taskQueue
+      ],
+      type: PoolEventType.terminated
     });
     this.eventSubject.complete();
     await Promise.all(this.workers.map(async (worker) => Thread.terminate(await worker.init)));
@@ -439,6 +637,7 @@ var WorkerPool = class {
 function PoolConstructor(spawnWorker, optionsOrSize) {
   return new WorkerPool(spawnWorker, optionsOrSize);
 }
+__name(PoolConstructor, "PoolConstructor");
 PoolConstructor.EventType = PoolEventType;
 var Pool = PoolConstructor;
 export {