@xylabs/threads 4.7.1 → 4.7.3

package/dist/neutral/master/register.mjs

@@ -0,0 +1,162 @@
+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');
+});
+
+// src/master/implementation.node.ts
+import { EventEmitter } from "node:events";
+import { cpus } from "node:os";
+import path from "node:path";
+import { cwd } from "node:process";
+import { Worker as NativeWorker } from "node:worker_threads";
+var defaultPoolSize = cpus().length;
+function resolveScriptPath(scriptPath, baseURL) {
+  const makeAbsolute = (filePath) => {
+    return path.isAbsolute(filePath) ? filePath : path.join(baseURL ?? cwd(), filePath);
+  };
+  const absolutePath = makeAbsolute(scriptPath);
+  return absolutePath;
+}
+function initWorkerThreadsWorker() {
+  let allWorkers = [];
+  class Worker2 extends NativeWorker {
+    mappedEventListeners;
+    constructor(scriptPath, options) {
+      const resolvedScriptPath = options && options.fromSource ? null : resolveScriptPath(scriptPath, (options ?? {})._baseURL);
+      if (resolvedScriptPath) {
+        super(resolvedScriptPath, options);
+      } else {
+        const sourceCode = scriptPath;
+        super(sourceCode, { ...options, eval: true });
+      }
+      this.mappedEventListeners = /* @__PURE__ */ new WeakMap();
+      allWorkers.push(this);
+    }
+    addEventListener(eventName, rawListener) {
+      const listener = (message) => {
+        rawListener({ data: message });
+      };
+      this.mappedEventListeners.set(rawListener, listener);
+      this.on(eventName, listener);
+    }
+    removeEventListener(eventName, rawListener) {
+      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 = [];
+  };
+  process.on("SIGINT", () => terminateWorkersAndMaster());
+  process.on("SIGTERM", () => terminateWorkersAndMaster());
+  class BlobWorker2 extends Worker2 {
+    constructor(blob, options) {
+      super(Buffer.from(blob).toString("utf-8"), { ...options, fromSource: true });
+    }
+    static fromText(source, options) {
+      return new Worker2(source, { ...options, fromSource: true });
+    }
+  }
+  return {
+    blob: BlobWorker2,
+    default: Worker2
+  };
+}
+function initTinyWorker() {
+  const TinyWorker = __require("tiny-worker");
+  let allWorkers = [];
+  class Worker2 extends TinyWorker {
+    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 });
+      } else {
+        const sourceCode = scriptPath;
+        super(new Function(sourceCode), [], { esm: true });
+      }
+      allWorkers.push(this);
+      this.emitter = new EventEmitter();
+      this.onerror = (error) => this.emitter.emit("error", error);
+      this.onmessage = (message) => this.emitter.emit("message", message);
+    }
+    addEventListener(eventName, listener) {
+      this.emitter.addListener(eventName, listener);
+    }
+    removeEventListener(eventName, listener) {
+      this.emitter.removeListener(eventName, listener);
+    }
+    terminate() {
+      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 = [];
+  };
+  process.on("SIGINT", () => terminateWorkersAndMaster());
+  process.on("SIGTERM", () => terminateWorkersAndMaster());
+  class BlobWorker2 extends Worker2 {
+    constructor(blob, options) {
+      super(Buffer.from(blob).toString("utf-8"), { ...options, fromSource: true });
+    }
+    static fromText(source, options) {
+      return new Worker2(source, { ...options, fromSource: true });
+    }
+  }
+  return {
+    blob: BlobWorker2,
+    default: Worker2
+  };
+}
+var implementation;
+var isTinyWorker;
+function selectWorkerImplementation() {
+  try {
+    isTinyWorker = false;
+    return initWorkerThreadsWorker();
+  } catch (ex) {
+    console.error(ex);
+    console.debug("Node worker_threads not available. Trying to fall back to tiny-worker polyfill...");
+    isTinyWorker = true;
+    return initTinyWorker();
+  }
+}
+function getWorkerImplementation() {
+  if (!implementation) {
+    implementation = selectWorkerImplementation();
+  }
+  return implementation;
+}
+function isWorkerRuntime() {
+  if (isTinyWorker) {
+    return globalThis !== void 0 && self["postMessage"] ? true : false;
+  } else {
+    const isMainThread = typeof __non_webpack_require__ === "function" ? __non_webpack_require__("worker_threads").isMainThread : eval("require")("worker_threads").isMainThread;
+    return !isMainThread;
+  }
+}
+
+// src/master/index-node.ts
+var BlobWorker = getWorkerImplementation().blob;
+var Worker = getWorkerImplementation().default;
+
+// src/master/register.ts
+if (typeof globalThis !== "undefined") {
+  ;
+  globalThis.Worker = Worker;
+} else if (window !== void 0) {
+  ;
+  window.Worker = Worker;
+}
+//# sourceMappingURL=register.mjs.map

package/dist/neutral/master/register.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/master/implementation.node.ts","../../../src/master/index-node.ts","../../../src/master/register.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-require-imports */\n\n/* eslint-disable unicorn/prefer-add-event-listener */\n/* eslint-disable unicorn/prefer-event-target */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable unicorn/text-encoding-identifier-case */\n\nimport { EventEmitter } from 'node:events'\nimport { cpus } from 'node:os'\nimport path from 'node:path'\nimport { cwd } from 'node:process'\nimport { Worker as NativeWorker } from 'node:worker_threads'\n\nimport type {\n  ImplementationExport, ThreadsWorkerOptions, WorkerImplementation,\n// eslint-disable-next-line import-x/no-internal-modules\n} from '../types/master.ts'\n\ndeclare const __non_webpack_require__: typeof require\n\ntype WorkerEventName = 'error' | 'message'\n\nexport const defaultPoolSize = cpus().length\n\nfunction resolveScriptPath(scriptPath: string, baseURL?: string | undefined) {\n  const makeAbsolute = (filePath: string) => {\n    return path.isAbsolute(filePath) ? filePath : path.join(baseURL ?? cwd(), filePath)\n  }\n\n  const absolutePath = makeAbsolute(scriptPath)\n  return absolutePath\n}\n\nfunction initWorkerThreadsWorker(): ImplementationExport {\n  let allWorkers: Array<NativeWorker> = []\n\n  class Worker extends NativeWorker {\n    private mappedEventListeners: WeakMap<EventListener, EventListener>\n\n    constructor(scriptPath: string, options?: ThreadsWorkerOptions & { fromSource: boolean }) {\n      const resolvedScriptPath = options && options.fromSource ? null : resolveScriptPath(scriptPath, (options ?? {})._baseURL)\n      if (resolvedScriptPath) {\n        super(resolvedScriptPath, options)\n      } else {\n        // `options.fromSource` is true\n        const sourceCode = scriptPath\n        super(sourceCode, { ...options, eval: true })\n      }\n\n      this.mappedEventListeners = new WeakMap()\n      allWorkers.push(this)\n    }\n\n    addEventListener(eventName: string, rawListener: EventListener) {\n      const listener = (message: any) => {\n        rawListener({ data: message } as any)\n      }\n      this.mappedEventListeners.set(rawListener, listener)\n      this.on(eventName, listener)\n    }\n\n    removeEventListener(eventName: string, rawListener: EventListener) {\n      const listener = this.mappedEventListeners.get(rawListener) || rawListener\n      this.off(eventName, listener)\n    }\n  }\n\n  const terminateWorkersAndMaster = () => {\n    // we should terminate all workers and then gracefully shutdown self process\n    Promise.all(allWorkers.map(worker => worker.terminate())).then(\n      () => process.exit(0),\n      () => process.exit(1),\n    )\n    allWorkers = []\n  }\n\n  // Take care to not leave orphaned processes behind. See #147.\n  process.on('SIGINT', () => terminateWorkersAndMaster())\n  process.on('SIGTERM', () => terminateWorkersAndMaster())\n\n  class BlobWorker extends Worker {\n    constructor(blob: Uint8Array, options?: ThreadsWorkerOptions) {\n      super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true })\n    }\n\n    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation {\n      return new Worker(source, { ...options, fromSource: true }) as any\n    }\n  }\n\n  return {\n    blob: BlobWorker as any,\n    default: Worker as any,\n  }\n}\n\nfunction initTinyWorker(): ImplementationExport {\n  const TinyWorker = require('tiny-worker')\n\n  let allWorkers: Array<typeof TinyWorker> = []\n\n  class Worker extends TinyWorker {\n    private emitter: EventEmitter\n\n    constructor(scriptPath: string, options?: ThreadsWorkerOptions & { fromSource?: boolean }) {\n      // Need to apply a work-around for Windows or it will choke upon the absolute path\n      // (`Error [ERR_INVALID_PROTOCOL]: Protocol 'c:' not supported`)\n      const resolvedScriptPath\n        = options && options.fromSource\n          ? null\n          : process.platform === 'win32'\n            ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\\\', '/')}`\n            : resolveScriptPath(scriptPath)\n\n      if (resolvedScriptPath) {\n        super(resolvedScriptPath, [], { esm: true })\n      } else {\n        // `options.fromSource` is true\n        const sourceCode = scriptPath\n        super(new Function(sourceCode), [], { esm: true })\n      }\n\n      allWorkers.push(this)\n\n      this.emitter = new EventEmitter()\n      this.onerror = (error: Error) => this.emitter.emit('error', error)\n      this.onmessage = (message: MessageEvent) => this.emitter.emit('message', message)\n    }\n\n    addEventListener(eventName: WorkerEventName, listener: EventListener) {\n      this.emitter.addListener(eventName, listener)\n    }\n\n    removeEventListener(eventName: WorkerEventName, listener: EventListener) {\n      this.emitter.removeListener(eventName, listener)\n    }\n\n    terminate() {\n      allWorkers = allWorkers.filter(worker => worker !== this)\n      return super.terminate()\n    }\n  }\n\n  const terminateWorkersAndMaster = () => {\n    // we should terminate all workers and then gracefully shutdown self process\n    Promise.all(allWorkers.map(worker => worker.terminate())).then(\n      () => process.exit(0),\n      () => process.exit(1),\n    )\n    allWorkers = []\n  }\n\n  // Take care to not leave orphaned processes behind\n  // See <https://github.com/avoidwork/tiny-worker#faq>\n  process.on('SIGINT', () => terminateWorkersAndMaster())\n  process.on('SIGTERM', () => terminateWorkersAndMaster())\n\n  class BlobWorker extends Worker {\n    constructor(blob: Uint8Array, options?: ThreadsWorkerOptions) {\n      super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true })\n    }\n\n    static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation {\n      return new Worker(source, { ...options, fromSource: true }) as any\n    }\n  }\n\n  return {\n    blob: BlobWorker as any,\n    default: Worker as any,\n  }\n}\n\nlet implementation: ImplementationExport\nlet isTinyWorker: boolean\n\nfunction selectWorkerImplementation(): ImplementationExport {\n  try {\n    isTinyWorker = false\n    return initWorkerThreadsWorker()\n  } catch (ex) {\n    console.error(ex)\n    // tslint:disable-next-line no-console\n    console.debug('Node worker_threads not available. Trying to fall back to tiny-worker polyfill...')\n    isTinyWorker = true\n    return initTinyWorker()\n  }\n}\n\nexport function getWorkerImplementation(): ImplementationExport {\n  if (!implementation) {\n    implementation = selectWorkerImplementation()\n  }\n  return implementation\n}\n\nexport function isWorkerRuntime() {\n  if (isTinyWorker) {\n    return globalThis !== undefined && self['postMessage'] ? true : false\n  } else {\n    // Webpack hack\n    const isMainThread\n      = typeof __non_webpack_require__ === 'function'\n        ? __non_webpack_require__('worker_threads').isMainThread\n        : eval('require')('worker_threads').isMainThread\n    return !isMainThread\n  }\n}\n","/* eslint-disable import-x/no-internal-modules */\nimport type { BlobWorker as BlobWorkerClass, Worker as WorkerType } from '../types/master.ts'\nimport * as NodeImplementation from './implementation.node.ts'\n\nexport type { FunctionThread, ModuleThread } from '../types/master.ts'\nexport { Pool } from './pool.ts'\nexport { spawn } from './spawn.ts'\nexport { Thread } from './thread.ts'\n\nexport type BlobWorker = typeof BlobWorkerClass\nexport type Worker = WorkerType\n\n/** Separate class to spawn workers from source code blobs or strings. */\nexport const BlobWorker = NodeImplementation.getWorkerImplementation().blob\n\n/** Worker implementation. Either web worker or a node.js Worker class. */\nexport const Worker = NodeImplementation.getWorkerImplementation().default\n\nexport { isWorkerRuntime } from './implementation.ts'\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { Worker as WorkerImplementation } from './index-node.ts'\n\ndeclare const window: any\n\nif (typeof globalThis !== 'undefined') {\n  ;(globalThis as any).Worker = WorkerImplementation\n} else if (window !== undefined) {\n  ;(window as any).Worker = WorkerImplementation\n}\n"],"mappings":"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","names":["Worker","BlobWorker"]}

package/dist/neutral/master/spawn.mjs

@@ -0,0 +1,412 @@
+// src/master/spawn.ts
+import DebugLogger2 from "debug";
+import { Observable as Observable3 } from "observable-fns";
+
+// src/serializers.ts
+var DefaultErrorSerializer = {
+  deserialize(message) {
+    return Object.assign(new Error(message.message), {
+      name: message.name,
+      stack: message.stack
+    });
+  },
+  serialize(error) {
+    return {
+      __error_marker: "$$error",
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+  }
+};
+var isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+var DefaultSerializer = {
+  deserialize(message) {
+    return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
+  },
+  serialize(input) {
+    return input instanceof Error ? DefaultErrorSerializer.serialize(input) : input;
+  }
+};
+
+// src/common.ts
+globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
+function deserialize(message) {
+  return globalThis.registeredSerializer.deserialize(message);
+}
+function serialize(input) {
+  return globalThis.registeredSerializer.serialize(input);
+}
+
+// src/promise.ts
+var doNothing = () => void 0;
+function createPromiseWithResolver() {
+  let alreadyResolved = false;
+  let resolvedTo;
+  let resolver = doNothing;
+  const promise = new Promise((resolve) => {
+    if (alreadyResolved) {
+      resolve(resolvedTo);
+    } else {
+      resolver = resolve;
+    }
+  });
+  const exposedResolver = (value) => {
+    alreadyResolved = true;
+    resolvedTo = value;
+    resolver(resolvedTo);
+  };
+  return [promise, exposedResolver];
+}
+
+// src/symbols.ts
+var $errors = Symbol("thread.errors");
+var $events = Symbol("thread.events");
+var $terminate = Symbol("thread.terminate");
+var $transferable = Symbol("thread.transferable");
+var $worker = Symbol("thread.worker");
+
+// src/master/invocation-proxy.ts
+import DebugLogger from "debug";
+import { multicast, Observable as Observable2 } from "observable-fns";
+
+// src/observable-promise.ts
+import { Observable } from "observable-fns";
+var doNothing2 = () => {
+};
+var returnInput = (input) => input;
+var runDeferred = (fn) => Promise.resolve().then(fn);
+function fail(error) {
+  throw error;
+}
+function isThenable(thing) {
+  return thing && typeof thing.then === "function";
+}
+var ObservablePromise = class _ObservablePromise extends Observable {
+  [Symbol.toStringTag] = "[object ObservablePromise]";
+  initHasRun = false;
+  fulfillmentCallbacks = [];
+  rejectionCallbacks = [];
+  firstValue;
+  firstValueSet = false;
+  rejection;
+  state = "pending";
+  constructor(init) {
+    super((originalObserver) => {
+      const self = this;
+      const observer = {
+        ...originalObserver,
+        complete() {
+          originalObserver.complete();
+          self.onCompletion();
+        },
+        error(error) {
+          originalObserver.error(error);
+          self.onError(error);
+        },
+        next(value) {
+          originalObserver.next(value);
+          self.onNext(value);
+        }
+      };
+      try {
+        this.initHasRun = true;
+        return init(observer);
+      } catch (error) {
+        observer.error(error);
+      }
+    });
+  }
+  onNext(value) {
+    if (!this.firstValueSet) {
+      this.firstValue = value;
+      this.firstValueSet = true;
+    }
+  }
+  onError(error) {
+    this.state = "rejected";
+    this.rejection = error;
+    for (const onRejected of this.rejectionCallbacks) {
+      runDeferred(() => onRejected(error));
+    }
+  }
+  onCompletion() {
+    this.state = "fulfilled";
+    for (const onFulfilled of this.fulfillmentCallbacks) {
+      runDeferred(() => onFulfilled(this.firstValue));
+    }
+  }
+  then(onFulfilledRaw, onRejectedRaw) {
+    const onFulfilled = onFulfilledRaw || returnInput;
+    const onRejected = onRejectedRaw || fail;
+    let onRejectedCalled = false;
+    return new Promise((resolve, reject) => {
+      const rejectionCallback = (error) => {
+        if (onRejectedCalled) return;
+        onRejectedCalled = true;
+        try {
+          resolve(onRejected(error));
+        } catch (anotherError) {
+          reject(anotherError);
+        }
+      };
+      const fulfillmentCallback = (value) => {
+        try {
+          resolve(onFulfilled(value));
+        } catch (ex) {
+          const error = ex;
+          rejectionCallback(error);
+        }
+      };
+      if (!this.initHasRun) {
+        this.subscribe({ error: rejectionCallback });
+      }
+      if (this.state === "fulfilled") {
+        return resolve(onFulfilled(this.firstValue));
+      }
+      if (this.state === "rejected") {
+        onRejectedCalled = true;
+        return resolve(onRejected(this.rejection));
+      }
+      this.fulfillmentCallbacks.push(fulfillmentCallback);
+      this.rejectionCallbacks.push(rejectionCallback);
+    });
+  }
+  catch(onRejected) {
+    return this.then(void 0, onRejected);
+  }
+  finally(onCompleted) {
+    const handler = onCompleted || doNothing2;
+    return this.then(
+      (value) => {
+        handler();
+        return value;
+      },
+      () => handler()
+    );
+  }
+  static from(thing) {
+    return isThenable(thing) ? new _ObservablePromise((observer) => {
+      const onFulfilled = (value) => {
+        observer.next(value);
+        observer.complete();
+      };
+      const onRejected = (error) => {
+        observer.error(error);
+      };
+      thing.then(onFulfilled, onRejected);
+    }) : super.from(thing);
+  }
+};
+
+// src/transferable.ts
+function isTransferDescriptor(thing) {
+  return thing && typeof thing === "object" && thing[$transferable];
+}
+
+// src/master/invocation-proxy.ts
+var debugMessages = DebugLogger("threads:master:messages");
+var nextJobUID = 1;
+var dedupe = (array) => [...new Set(array)];
+var isJobErrorMessage = (data) => data && data.type === "error" /* error */;
+var isJobResultMessage = (data) => data && data.type === "result" /* result */;
+var isJobStartMessage = (data) => data && data.type === "running" /* running */;
+function createObservableForJob(worker, jobUID) {
+  return new Observable2((observer) => {
+    let asyncType;
+    const messageHandler = (event) => {
+      debugMessages("Message from worker:", event.data);
+      if (!event.data || event.data.uid !== jobUID) return;
+      if (isJobStartMessage(event.data)) {
+        asyncType = event.data.resultType;
+      } else if (isJobResultMessage(event.data)) {
+        if (asyncType === "promise") {
+          if (event.data.payload !== void 0) {
+            observer.next(deserialize(event.data.payload));
+          }
+          observer.complete();
+          worker.removeEventListener("message", messageHandler);
+        } else {
+          if (event.data.payload) {
+            observer.next(deserialize(event.data.payload));
+          }
+          if (event.data.complete) {
+            observer.complete();
+            worker.removeEventListener("message", messageHandler);
+          }
+        }
+      } else if (isJobErrorMessage(event.data)) {
+        const error = deserialize(event.data.error);
+        if (asyncType === "promise" || !asyncType) {
+          observer.error(error);
+        } else {
+          observer.error(error);
+        }
+        worker.removeEventListener("message", messageHandler);
+      }
+    };
+    worker.addEventListener("message", messageHandler);
+    return () => {
+      if (asyncType === "observable" || !asyncType) {
+        const cancelMessage = {
+          type: "cancel" /* cancel */,
+          uid: jobUID
+        };
+        worker.postMessage(cancelMessage);
+      }
+      worker.removeEventListener("message", messageHandler);
+    };
+  });
+}
+function prepareArguments(rawArgs) {
+  if (rawArgs.length === 0) {
+    return {
+      args: [],
+      transferables: []
+    };
+  }
+  const args = [];
+  const transferables = [];
+  for (const arg of rawArgs) {
+    if (isTransferDescriptor(arg)) {
+      args.push(serialize(arg.send));
+      transferables.push(...arg.transferables);
+    } else {
+      args.push(serialize(arg));
+    }
+  }
+  return {
+    args,
+    transferables: transferables.length === 0 ? transferables : dedupe(transferables)
+  };
+}
+function createProxyFunction(worker, method) {
+  return (...rawArgs) => {
+    const uid = nextJobUID++;
+    const { args, transferables } = prepareArguments(rawArgs);
+    const runMessage = {
+      args,
+      method,
+      type: "run" /* run */,
+      uid
+    };
+    debugMessages("Sending command to run function to worker:", runMessage);
+    try {
+      worker.postMessage(runMessage, transferables);
+    } catch (error) {
+      return ObservablePromise.from(Promise.reject(error));
+    }
+    return ObservablePromise.from(multicast(createObservableForJob(worker, uid)));
+  };
+}
+function createProxyModule(worker, methodNames) {
+  const proxy = {};
+  for (const methodName of methodNames) {
+    proxy[methodName] = createProxyFunction(worker, methodName);
+  }
+  return proxy;
+}
+
+// src/master/spawn.ts
+var debugMessages2 = DebugLogger2("threads:master:messages");
+var debugSpawn = DebugLogger2("threads:master:spawn");
+var debugThreadUtils = DebugLogger2("threads:master:thread-utils");
+var isInitMessage = (data) => data && data.type === "init";
+var isUncaughtErrorMessage = (data) => data && data.type === "uncaughtError";
+var initMessageTimeout = typeof process !== "undefined" && process.env !== void 0 && process.env.THREADS_WORKER_INIT_TIMEOUT ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10) : 1e4;
+async function withTimeout(promise, timeoutInMs, errorMessage) {
+  let timeoutHandle;
+  const timeout = new Promise((resolve, reject) => {
+    timeoutHandle = setTimeout(() => reject(new Error(errorMessage)), timeoutInMs);
+  });
+  const result = await Promise.race([promise, timeout]);
+  clearTimeout(timeoutHandle);
+  return result;
+}
+function receiveInitMessage(worker) {
+  return new Promise((resolve, reject) => {
+    const messageHandler = (event) => {
+      debugMessages2("Message from worker before finishing initialization:", event.data);
+      if (isInitMessage(event.data)) {
+        worker.removeEventListener("message", messageHandler);
+        resolve(event.data);
+      } else if (isUncaughtErrorMessage(event.data)) {
+        worker.removeEventListener("message", messageHandler);
+        reject(deserialize(event.data.error));
+      }
+    };
+    worker.addEventListener("message", messageHandler);
+  });
+}
+function createEventObservable(worker, workerTermination) {
+  return new Observable3((observer) => {
+    const messageHandler = (messageEvent) => {
+      const workerEvent = {
+        data: messageEvent.data,
+        type: "message" /* message */
+      };
+      observer.next(workerEvent);
+    };
+    const rejectionHandler = (errorEvent) => {
+      debugThreadUtils("Unhandled promise rejection event in thread:", errorEvent);
+      const workerEvent = {
+        error: new Error(errorEvent.reason),
+        type: "internalError" /* internalError */
+      };
+      observer.next(workerEvent);
+    };
+    worker.addEventListener("message", messageHandler);
+    worker.addEventListener("unhandledrejection", rejectionHandler);
+    workerTermination.then(() => {
+      const terminationEvent = { type: "termination" /* termination */ };
+      worker.removeEventListener("message", messageHandler);
+      worker.removeEventListener("unhandledrejection", rejectionHandler);
+      observer.next(terminationEvent);
+      observer.complete();
+    });
+  });
+}
+function createTerminator(worker) {
+  const [termination, resolver] = createPromiseWithResolver();
+  const terminate = async () => {
+    debugThreadUtils("Terminating worker");
+    await worker.terminate();
+    resolver();
+  };
+  return { terminate, termination };
+}
+function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
+  const workerErrors = workerEvents.filter((event) => event.type === "internalError" /* internalError */).map((errorEvent) => errorEvent.error);
+  return Object.assign(raw, {
+    [$errors]: workerErrors,
+    [$events]: workerEvents,
+    [$terminate]: terminate,
+    [$worker]: worker
+  });
+}
+async function spawn(worker, options) {
+  debugSpawn("Initializing new thread");
+  const timeout = options && options.timeout ? options.timeout : initMessageTimeout;
+  const initMessage = await withTimeout(
+    receiveInitMessage(worker),
+    timeout,
+    `Timeout: Did not receive an init message from worker after ${timeout}ms. Make sure the worker calls expose().`
+  );
+  const exposed = initMessage.exposed;
+  const { termination, terminate } = createTerminator(worker);
+  const events = createEventObservable(worker, termination);
+  if (exposed.type === "function") {
+    const proxy = createProxyFunction(worker);
+    return setPrivateThreadProps(proxy, worker, events, terminate);
+  } else if (exposed.type === "module") {
+    const proxy = createProxyModule(worker, exposed.methods);
+    return setPrivateThreadProps(proxy, worker, events, terminate);
+  } else {
+    const type = exposed.type;
+    throw new Error(`Worker init message states unexpected type of expose(): ${type}`);
+  }
+}
+export {
+  spawn
+};
+//# sourceMappingURL=spawn.mjs.map