@xylabs/threads/dist/neutral/master/spawn.mjs

Web workers & worker threads as simple as a function call

// 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 = /* @__PURE__ */ Symbol("thread.errors");
var $events = /* @__PURE__ */ Symbol("thread.events");
var $terminate = /* @__PURE__ */ Symbol("thread.terminate");
var $transferable = /* @__PURE__ */ Symbol("thread.transferable");
var $worker = /* @__PURE__ */ 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