@xylabs/threads 4.12.44 → 4.13.1

package/dist/neutral/master-DDdg1BKb.d.ts

@@ -0,0 +1,74 @@
+import { Observable } from 'observable-fns';
+import { ObservablePromise } from './observable-promise.js';
+
+declare const $errors: unique symbol;
+declare const $events: unique symbol;
+declare const $terminate: unique symbol;
+declare const $transferable: unique symbol;
+declare const $worker: unique symbol;
+
+interface TransferDescriptor<T = any> {
+    [$transferable]: true;
+    send: T;
+    transferables: Transferable[];
+}
+
+interface ObservableLikeSubscription {
+    unsubscribe(): any;
+}
+interface ObservableLike<T> {
+    subscribe(onNext: (value: T) => any, onError?: (error: any) => any, onComplete?: () => any): ObservableLikeSubscription;
+    subscribe(listeners: {
+        complete?(): any;
+        error?(error: any): any;
+        next?(value: T): any;
+    }): ObservableLikeSubscription;
+}
+type StripAsync<Type> = Type extends Promise<infer PromiseBaseType> ? PromiseBaseType : Type extends ObservableLike<infer ObservableBaseType> ? ObservableBaseType : Type;
+type StripTransfer<Type> = Type extends TransferDescriptor<infer BaseType> ? BaseType : Type;
+type ModuleMethods = {
+    [methodName: string]: (...args: any) => any;
+};
+type ProxyableArgs<Args extends any[]> = Args extends [arg0: infer Arg0, ...rest: infer RestArgs] ? [Arg0 extends Transferable ? Arg0 | TransferDescriptor<Arg0> : Arg0, ...RestArgs] : Args;
+type ProxyableFunction<Args extends any[], ReturnType> = Args extends [] ? () => ObservablePromise<StripTransfer<StripAsync<ReturnType>>> : (...args: ProxyableArgs<Args>) => ObservablePromise<StripTransfer<StripAsync<ReturnType>>>;
+type ModuleProxy<Methods extends ModuleMethods> = {
+    [method in keyof Methods]: ProxyableFunction<Parameters<Methods[method]>, ReturnType<Methods[method]>>;
+};
+interface PrivateThreadProps {
+    [$errors]: Observable<Error>;
+    [$events]: Observable<WorkerEvent>;
+    [$terminate]: () => Promise<void>;
+    [$worker]: Worker;
+}
+type FunctionThread<Args extends any[] = any[], ReturnType = any> = ProxyableFunction<Args, ReturnType> & PrivateThreadProps;
+type ModuleThread<Methods extends ModuleMethods = any> = ModuleProxy<Methods> & PrivateThreadProps;
+interface AnyFunctionThread extends PrivateThreadProps {
+    (...args: any[]): ObservablePromise<any>;
+}
+interface AnyModuleThread extends PrivateThreadProps {
+}
+type Thread = AnyFunctionThread | AnyModuleThread;
+type TransferList = Transferable[];
+interface Worker extends EventTarget {
+    postMessage(value: any, transferList?: TransferList): void;
+    terminate(callback?: (error?: Error, exitCode?: number) => void): void | Promise<number>;
+}
+declare enum WorkerEventType {
+    internalError = "internalError",
+    message = "message",
+    termination = "termination"
+}
+interface WorkerInternalErrorEvent {
+    error: Error;
+    type: WorkerEventType.internalError;
+}
+interface WorkerMessageEvent<Data> {
+    data: Data;
+    type: WorkerEventType.message;
+}
+interface WorkerTerminationEvent {
+    type: WorkerEventType.termination;
+}
+type WorkerEvent = WorkerInternalErrorEvent | WorkerMessageEvent<any> | WorkerTerminationEvent;
+
+export type { FunctionThread as F, ModuleThread as M, StripAsync as S, Thread as T, WorkerEvent as W, Worker as a };

package/dist/{types → neutral}/observable-promise.d.ts

@@ -1,24 +1,11 @@
-import type { ObservableLike, SubscriptionObserver } from 'observable-fns';
-import { Observable } from 'observable-fns';
+import { Observable, SubscriptionObserver, ObservableLike } from 'observable-fns';
+
 type Initializer<T> = (observer: SubscriptionObserver<T>) => UnsubscribeFn | void;
 type Thenable<T> = {
     then: (onFulfilled?: (value: T) => any, onRejected?: (error: any) => any) => any;
 };
 type UnsubscribeFn = () => void;
-/**
- * Creates a hybrid, combining the APIs of an Observable and a Promise.
- *
- * It is used to proxy async process states when we are initially not sure
- * if that async process will yield values once (-> Promise) or multiple
- * times (-> Observable).
- *
- * Note that the observable promise inherits some of the observable's characteristics:
- * The `init` function will be called *once for every time anyone subscribes to it*.
- *
- * If this is undesired, derive a hot observable from it using `makeHot()` and
- * subscribe to that.
- */
-export declare class ObservablePromise<T> extends Observable<T> implements Promise<T> {
+declare class ObservablePromise<T> extends Observable<T> implements Promise<T> {
     readonly [Symbol.toStringTag] = "[object ObservablePromise]";
     private initHasRun;
     private fulfillmentCallbacks;
@@ -36,5 +23,5 @@ export declare class ObservablePromise<T> extends Observable<T> implements Promi
     finally(onCompleted?: (() => void) | null | undefined): Promise<T>;
     static from<T>(thing: Observable<T> | ObservableLike<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T>;
 }
-export {};
-//# sourceMappingURL=observable-promise.d.ts.map
+
+export { ObservablePromise };

package/dist/neutral/observable-promise.mjs

@@ -1,16 +1,24 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/observable-promise.ts
 import { Observable } from "observable-fns";
-var doNothing = () => {
-};
-var returnInput = (input) => input;
-var runDeferred = (fn) => Promise.resolve().then(fn);
+var doNothing = /* @__PURE__ */ __name(() => {
+}, "doNothing");
+var returnInput = /* @__PURE__ */ __name((input) => input, "returnInput");
+var runDeferred = /* @__PURE__ */ __name((fn) => Promise.resolve().then(fn), "runDeferred");
 function fail(error) {
   throw error;
 }
+__name(fail, "fail");
 function isThenable(thing) {
   return thing && typeof thing.then === "function";
 }
+__name(isThenable, "isThenable");
 var ObservablePromise = class _ObservablePromise extends Observable {
+  static {
+    __name(this, "ObservablePromise");
+  }
   [Symbol.toStringTag] = "[object ObservablePromise]";
   initHasRun = false;
   fulfillmentCallbacks = [];
@@ -69,7 +77,7 @@ var ObservablePromise = class _ObservablePromise extends Observable {
     const onRejected = onRejectedRaw || fail;
     let onRejectedCalled = false;
     return new Promise((resolve, reject) => {
-      const rejectionCallback = (error) => {
+      const rejectionCallback = /* @__PURE__ */ __name((error) => {
         if (onRejectedCalled) return;
         onRejectedCalled = true;
         try {
@@ -77,17 +85,19 @@ var ObservablePromise = class _ObservablePromise extends Observable {
         } catch (anotherError) {
           reject(anotherError);
         }
-      };
-      const fulfillmentCallback = (value) => {
+      }, "rejectionCallback");
+      const fulfillmentCallback = /* @__PURE__ */ __name((value) => {
         try {
           resolve(onFulfilled(value));
         } catch (ex) {
           const error = ex;
           rejectionCallback(error);
         }
-      };
+      }, "fulfillmentCallback");
       if (!this.initHasRun) {
-        this.subscribe({ error: rejectionCallback });
+        this.subscribe({
+          error: rejectionCallback
+        });
       }
       if (this.state === "fulfilled") {
         return resolve(onFulfilled(this.firstValue));
@@ -105,23 +115,20 @@ var ObservablePromise = class _ObservablePromise extends Observable {
   }
   finally(onCompleted) {
     const handler = onCompleted || doNothing;
-    return this.then(
-      (value) => {
-        handler();
-        return value;
-      },
-      () => handler()
-    );
+    return this.then((value) => {
+      handler();
+      return value;
+    }, () => handler());
   }
   static from(thing) {
     return isThenable(thing) ? new _ObservablePromise((observer) => {
-      const onFulfilled = (value) => {
+      const onFulfilled = /* @__PURE__ */ __name((value) => {
         observer.next(value);
         observer.complete();
-      };
-      const onRejected = (error) => {
+      }, "onFulfilled");
+      const onRejected = /* @__PURE__ */ __name((error) => {
         observer.error(error);
-      };
+      }, "onRejected");
       thing.then(onFulfilled, onRejected);
     }) : super.from(thing);
   }

package/dist/neutral/observable-promise.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/observable-promise.ts"],"sourcesContent":["/* eslint-disable unicorn/no-thenable */\n/* eslint-disable @typescript-eslint/member-ordering */\n/* eslint-disable @typescript-eslint/no-floating-promises */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-this-alias */\n/* eslint-disable unicorn/no-this-assignment */\nimport type { ObservableLike, SubscriptionObserver } from 'observable-fns'\nimport { Observable } from 'observable-fns'\n\ntype OnFulfilled<T, Result = void> = (value: T) => Result\ntype OnRejected<Result = void> = (error: Error) => Result\n\ntype Initializer<T> = (observer: SubscriptionObserver<T>) => UnsubscribeFn | void\n\ntype Thenable<T> = { then: (onFulfilled?: (value: T) => any, onRejected?: (error: any) => any) => any }\n\ntype UnsubscribeFn = () => void\n\nconst doNothing = () => {}\nconst returnInput = <T>(input: T): T => input\nconst runDeferred = (fn: () => void) => Promise.resolve().then(fn)\n\nfunction fail(error: Error): never {\n  throw error\n}\n\nfunction isThenable(thing: any): thing is Thenable<any> {\n  return thing && typeof thing.then === 'function'\n}\n\n/**\n * Creates a hybrid, combining the APIs of an Observable and a Promise.\n *\n * It is used to proxy async process states when we are initially not sure\n * if that async process will yield values once (-> Promise) or multiple\n * times (-> Observable).\n *\n * Note that the observable promise inherits some of the observable's characteristics:\n * The `init` function will be called *once for every time anyone subscribes to it*.\n *\n * If this is undesired, derive a hot observable from it using `makeHot()` and\n * subscribe to that.\n */\nexport class ObservablePromise<T> extends Observable<T> implements Promise<T> {\n  readonly [Symbol.toStringTag] = '[object ObservablePromise]'\n  private initHasRun = false\n  private fulfillmentCallbacks: Array<OnFulfilled<T>> = []\n  private rejectionCallbacks: OnRejected[] = []\n\n  private firstValue: T | undefined\n  private firstValueSet = false\n  private rejection: Error | undefined\n  private state: 'fulfilled' | 'pending' | 'rejected' = 'pending'\n\n  constructor(init: Initializer<T>) {\n    super((originalObserver: SubscriptionObserver<T>) => {\n      // tslint:disable-next-line no-this-assignment\n      const self = this\n      const observer: SubscriptionObserver<T> = {\n        ...originalObserver,\n        complete() {\n          originalObserver.complete()\n          self.onCompletion()\n        },\n        error(error: Error) {\n          originalObserver.error(error)\n          self.onError(error)\n        },\n        next(value: T) {\n          originalObserver.next(value)\n          self.onNext(value)\n        },\n      }\n\n      try {\n        this.initHasRun = true\n        return init(observer)\n      } catch (error) {\n        observer.error(error)\n      }\n    })\n  }\n\n  private onNext(value: T) {\n    if (!this.firstValueSet) {\n      this.firstValue = value\n      this.firstValueSet = true\n    }\n  }\n\n  private onError(error: Error) {\n    this.state = 'rejected'\n    this.rejection = error\n\n    for (const onRejected of this.rejectionCallbacks) {\n      // Promisifying the call to turn errors into unhandled promise rejections\n      // instead of them failing sync and cancelling the iteration\n      runDeferred(() => onRejected(error))\n    }\n  }\n\n  private onCompletion() {\n    this.state = 'fulfilled'\n\n    for (const onFulfilled of this.fulfillmentCallbacks) {\n      // Promisifying the call to turn errors into unhandled promise rejections\n      // instead of them failing sync and cancelling the iteration\n      runDeferred(() => onFulfilled(this.firstValue as T))\n    }\n  }\n\n  then<TResult1 = T, TResult2 = never>(\n    onFulfilledRaw?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,\n    onRejectedRaw?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,\n  ): Promise<TResult1 | TResult2> {\n    const onFulfilled: OnFulfilled<T, TResult1> = onFulfilledRaw || (returnInput as any)\n    const onRejected = onRejectedRaw || fail\n    let onRejectedCalled = false\n\n    return new Promise<TResult1 | TResult2>((resolve, reject) => {\n      const rejectionCallback = (error: Error) => {\n        if (onRejectedCalled) return\n        onRejectedCalled = true\n\n        try {\n          resolve(onRejected(error))\n        } catch (anotherError) {\n          reject(anotherError)\n        }\n      }\n      const fulfillmentCallback = (value: T) => {\n        try {\n          resolve(onFulfilled(value))\n        } catch (ex) {\n          const error = ex as Error\n          rejectionCallback(error)\n        }\n      }\n      if (!this.initHasRun) {\n        this.subscribe({ error: rejectionCallback })\n      }\n      if (this.state === 'fulfilled') {\n        return resolve(onFulfilled(this.firstValue as T))\n      }\n      if (this.state === 'rejected') {\n        onRejectedCalled = true\n        return resolve(onRejected(this.rejection as Error))\n      }\n      this.fulfillmentCallbacks.push(fulfillmentCallback)\n      this.rejectionCallbacks.push(rejectionCallback)\n    })\n  }\n\n  catch<Result = never>(onRejected: ((error: Error) => Promise<Result> | Result) | null | undefined) {\n    return this.then(undefined, onRejected) as Promise<Result>\n  }\n\n  finally(onCompleted?: (() => void) | null | undefined) {\n    const handler = onCompleted || doNothing\n    return this.then(\n      (value: T) => {\n        handler()\n        return value\n      },\n      () => handler(),\n    ) as Promise<T>\n  }\n\n  static override from<T>(thing: Observable<T> | ObservableLike<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T> {\n    return isThenable(thing)\n      ? new ObservablePromise((observer) => {\n        const onFulfilled = (value: T) => {\n          observer.next(value)\n          observer.complete()\n        }\n        const onRejected = (error: any) => {\n          observer.error(error)\n        }\n        thing.then(onFulfilled, onRejected)\n      })\n      : (super.from(thing) as ObservablePromise<T>)\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/observable-promise.ts"],"sourcesContent":["/* eslint-disable unicorn/no-thenable */\n/* eslint-disable @typescript-eslint/member-ordering */\n/* eslint-disable @typescript-eslint/no-floating-promises */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-this-alias */\n/* eslint-disable unicorn/no-this-assignment */\nimport type { ObservableLike, SubscriptionObserver } from 'observable-fns'\nimport { Observable } from 'observable-fns'\n\ntype OnFulfilled<T, Result = void> = (value: T) => Result\ntype OnRejected<Result = void> = (error: Error) => Result\n\ntype Initializer<T> = (observer: SubscriptionObserver<T>) => UnsubscribeFn | void\n\ntype Thenable<T> = { then: (onFulfilled?: (value: T) => any, onRejected?: (error: any) => any) => any }\n\ntype UnsubscribeFn = () => void\n\nconst doNothing = () => {}\nconst returnInput = <T>(input: T): T => input\nconst runDeferred = (fn: () => void) => Promise.resolve().then(fn)\n\nfunction fail(error: Error): never {\n  throw error\n}\n\nfunction isThenable(thing: any): thing is Thenable<any> {\n  return thing && typeof thing.then === 'function'\n}\n\n/**\n * Creates a hybrid, combining the APIs of an Observable and a Promise.\n *\n * It is used to proxy async process states when we are initially not sure\n * if that async process will yield values once (-> Promise) or multiple\n * times (-> Observable).\n *\n * Note that the observable promise inherits some of the observable's characteristics:\n * The `init` function will be called *once for every time anyone subscribes to it*.\n *\n * If this is undesired, derive a hot observable from it using `makeHot()` and\n * subscribe to that.\n */\nexport class ObservablePromise<T> extends Observable<T> implements Promise<T> {\n  readonly [Symbol.toStringTag] = '[object ObservablePromise]'\n  private initHasRun = false\n  private fulfillmentCallbacks: Array<OnFulfilled<T>> = []\n  private rejectionCallbacks: OnRejected[] = []\n\n  private firstValue: T | undefined\n  private firstValueSet = false\n  private rejection: Error | undefined\n  private state: 'fulfilled' | 'pending' | 'rejected' = 'pending'\n\n  constructor(init: Initializer<T>) {\n    super((originalObserver: SubscriptionObserver<T>) => {\n      // tslint:disable-next-line no-this-assignment\n      const self = this\n      const observer: SubscriptionObserver<T> = {\n        ...originalObserver,\n        complete() {\n          originalObserver.complete()\n          self.onCompletion()\n        },\n        error(error: Error) {\n          originalObserver.error(error)\n          self.onError(error)\n        },\n        next(value: T) {\n          originalObserver.next(value)\n          self.onNext(value)\n        },\n      }\n\n      try {\n        this.initHasRun = true\n        return init(observer)\n      } catch (error) {\n        observer.error(error)\n      }\n    })\n  }\n\n  private onNext(value: T) {\n    if (!this.firstValueSet) {\n      this.firstValue = value\n      this.firstValueSet = true\n    }\n  }\n\n  private onError(error: Error) {\n    this.state = 'rejected'\n    this.rejection = error\n\n    for (const onRejected of this.rejectionCallbacks) {\n      // Promisifying the call to turn errors into unhandled promise rejections\n      // instead of them failing sync and cancelling the iteration\n      runDeferred(() => onRejected(error))\n    }\n  }\n\n  private onCompletion() {\n    this.state = 'fulfilled'\n\n    for (const onFulfilled of this.fulfillmentCallbacks) {\n      // Promisifying the call to turn errors into unhandled promise rejections\n      // instead of them failing sync and cancelling the iteration\n      runDeferred(() => onFulfilled(this.firstValue as T))\n    }\n  }\n\n  then<TResult1 = T, TResult2 = never>(\n    onFulfilledRaw?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,\n    onRejectedRaw?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,\n  ): Promise<TResult1 | TResult2> {\n    const onFulfilled: OnFulfilled<T, TResult1> = onFulfilledRaw || (returnInput as any)\n    const onRejected = onRejectedRaw || fail\n    let onRejectedCalled = false\n\n    return new Promise<TResult1 | TResult2>((resolve, reject) => {\n      const rejectionCallback = (error: Error) => {\n        if (onRejectedCalled) return\n        onRejectedCalled = true\n\n        try {\n          resolve(onRejected(error))\n        } catch (anotherError) {\n          reject(anotherError)\n        }\n      }\n      const fulfillmentCallback = (value: T) => {\n        try {\n          resolve(onFulfilled(value))\n        } catch (ex) {\n          const error = ex as Error\n          rejectionCallback(error)\n        }\n      }\n      if (!this.initHasRun) {\n        this.subscribe({ error: rejectionCallback })\n      }\n      if (this.state === 'fulfilled') {\n        return resolve(onFulfilled(this.firstValue as T))\n      }\n      if (this.state === 'rejected') {\n        onRejectedCalled = true\n        return resolve(onRejected(this.rejection as Error))\n      }\n      this.fulfillmentCallbacks.push(fulfillmentCallback)\n      this.rejectionCallbacks.push(rejectionCallback)\n    })\n  }\n\n  catch<Result = never>(onRejected: ((error: Error) => Promise<Result> | Result) | null | undefined) {\n    return this.then(undefined, onRejected) as Promise<Result>\n  }\n\n  finally(onCompleted?: (() => void) | null | undefined) {\n    const handler = onCompleted || doNothing\n    return this.then(\n      (value: T) => {\n        handler()\n        return value\n      },\n      () => handler(),\n    ) as Promise<T>\n  }\n\n  static override from<T>(thing: Observable<T> | ObservableLike<T> | ArrayLike<T> | Thenable<T>): ObservablePromise<T> {\n    return isThenable(thing)\n      ? new ObservablePromise((observer) => {\n        const onFulfilled = (value: T) => {\n          observer.next(value)\n          observer.complete()\n        }\n        const onRejected = (error: any) => {\n          observer.error(error)\n        }\n        thing.then(onFulfilled, onRejected)\n      })\n      : (super.from(thing) as ObservablePromise<T>)\n  }\n}\n"],"mappings":"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","names":["Observable","doNothing","returnInput","input","runDeferred","fn","Promise","resolve","then","fail","error","isThenable","thing","ObservablePromise","Observable","Symbol","toStringTag","initHasRun","fulfillmentCallbacks","rejectionCallbacks","firstValue","firstValueSet","rejection","state","init","originalObserver","self","observer","complete","onCompletion","onError","next","value","onNext","onRejected","onFulfilled","onFulfilledRaw","onRejectedRaw","onRejectedCalled","reject","rejectionCallback","anotherError","fulfillmentCallback","ex","subscribe","push","catch","undefined","finally","onCompleted","handler","from"]}

package/dist/neutral/observable.d.ts

@@ -0,0 +1,13 @@
+import { Observable, ObservableLike } from 'observable-fns';
+export { Observable } from 'observable-fns';
+
+declare const $observers: unique symbol;
+declare class Subject<T> extends Observable<T> implements ObservableLike<T> {
+    private [$observers];
+    constructor();
+    complete(): void;
+    error(error: any): void;
+    next(value: T): void;
+}
+
+export { Subject };

package/dist/neutral/observable.mjs

@@ -1,15 +1,24 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/observable.ts
 import { Observable } from "observable-fns";
 import { Observable as Observable2 } from "observable-fns";
 var $observers = Symbol("observers");
 var Subject = class extends Observable {
+  static {
+    __name(this, "Subject");
+  }
   [$observers];
   constructor() {
     super((observer) => {
-      this[$observers] = [...this[$observers] || [], observer];
-      const unsubscribe = () => {
+      this[$observers] = [
+        ...this[$observers] || [],
+        observer
+      ];
+      const unsubscribe = /* @__PURE__ */ __name(() => {
         this[$observers] = this[$observers].filter((someObserver) => someObserver !== observer);
-      };
+      }, "unsubscribe");
       return unsubscribe;
     });
     this[$observers] = [];

package/dist/neutral/observable.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/observable.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { ObservableLike, SubscriptionObserver } from 'observable-fns'\nimport { Observable } from 'observable-fns'\n\nconst $observers = Symbol('observers')\n\n/**\n * Observable subject. Implements the Observable interface, but also exposes\n * the `next()`, `error()`, `complete()` methods to initiate observable\n * updates \"from the outside\".\n *\n * Use `Observable.from(subject)` to derive an observable that proxies all\n * values, errors and the completion raised on this subject, but does not\n * expose the `next()`, `error()`, `complete()` methods.\n */\nexport class Subject<T> extends Observable<T> implements ObservableLike<T> {\n  private [$observers]: Array<SubscriptionObserver<T>>\n\n  constructor() {\n    super((observer) => {\n      this[$observers] = [...(this[$observers] || []), observer]\n      const unsubscribe = () => {\n        this[$observers] = this[$observers].filter(someObserver => someObserver !== observer)\n      }\n      return unsubscribe\n    })\n\n    this[$observers] = []\n  }\n\n  complete() {\n    for (const observer of this[$observers]) observer.complete()\n  }\n\n  error(error: any) {\n    for (const observer of this[$observers]) observer.error(error)\n  }\n\n  next(value: T) {\n    for (const observer of this[$observers]) observer.next(value)\n  }\n}\n\nexport { Observable } from 'observable-fns'\n"],"mappings":";AAEA,SAAS,kBAAkB;AAyC3B,SAAS,cAAAA,mBAAkB;AAvC3B,IAAM,aAAa,OAAO,WAAW;AAW9B,IAAM,UAAN,cAAyB,WAA2C;AAAA,EACzE,CAAS,UAAU;AAAA,EAEnB,cAAc;AACZ,UAAM,CAAC,aAAa;AAClB,WAAK,UAAU,IAAI,CAAC,GAAI,KAAK,UAAU,KAAK,CAAC,GAAI,QAAQ;AACzD,YAAM,cAAc,MAAM;AACxB,aAAK,UAAU,IAAI,KAAK,UAAU,EAAE,OAAO,kBAAgB,iBAAiB,QAAQ;AAAA,MACtF;AACA,aAAO;AAAA,IACT,CAAC;AAED,SAAK,UAAU,IAAI,CAAC;AAAA,EACtB;AAAA,EAEA,WAAW;AACT,eAAW,YAAY,KAAK,UAAU,EAAG,UAAS,SAAS;AAAA,EAC7D;AAAA,EAEA,MAAM,OAAY;AAChB,eAAW,YAAY,KAAK,UAAU,EAAG,UAAS,MAAM,KAAK;AAAA,EAC/D;AAAA,EAEA,KAAK,OAAU;AACb,eAAW,YAAY,KAAK,UAAU,EAAG,UAAS,KAAK,KAAK;AAAA,EAC9D;AACF;","names":["Observable"]}
+{"version":3,"sources":["../../src/observable.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { ObservableLike, SubscriptionObserver } from 'observable-fns'\nimport { Observable } from 'observable-fns'\n\nconst $observers = Symbol('observers')\n\n/**\n * Observable subject. Implements the Observable interface, but also exposes\n * the `next()`, `error()`, `complete()` methods to initiate observable\n * updates \"from the outside\".\n *\n * Use `Observable.from(subject)` to derive an observable that proxies all\n * values, errors and the completion raised on this subject, but does not\n * expose the `next()`, `error()`, `complete()` methods.\n */\nexport class Subject<T> extends Observable<T> implements ObservableLike<T> {\n  private [$observers]: Array<SubscriptionObserver<T>>\n\n  constructor() {\n    super((observer) => {\n      this[$observers] = [...(this[$observers] || []), observer]\n      const unsubscribe = () => {\n        this[$observers] = this[$observers].filter(someObserver => someObserver !== observer)\n      }\n      return unsubscribe\n    })\n\n    this[$observers] = []\n  }\n\n  complete() {\n    for (const observer of this[$observers]) observer.complete()\n  }\n\n  error(error: any) {\n    for (const observer of this[$observers]) observer.error(error)\n  }\n\n  next(value: T) {\n    for (const observer of this[$observers]) observer.next(value)\n  }\n}\n\nexport { Observable } from 'observable-fns'\n"],"mappings":";;;;AAEA,SAASA,kBAAkB;AAyC3B,SAASA,cAAAA,mBAAkB;AAvC3B,IAAMC,aAAaC,OAAO,WAAA;AAWnB,IAAMC,UAAN,cAAyBC,WAAAA;EAfhC,OAegCA;;;EACtB,CAACH,UAAAA;EAET,cAAc;AACZ,UAAM,CAACI,aAAAA;AACL,WAAKJ,UAAAA,IAAc;WAAK,KAAKA,UAAAA,KAAe,CAAA;QAAKI;;AACjD,YAAMC,cAAc,6BAAA;AAClB,aAAKL,UAAAA,IAAc,KAAKA,UAAAA,EAAYM,OAAOC,CAAAA,iBAAgBA,iBAAiBH,QAAAA;MAC9E,GAFoB;AAGpB,aAAOC;IACT,CAAA;AAEA,SAAKL,UAAAA,IAAc,CAAA;EACrB;EAEAQ,WAAW;AACT,eAAWJ,YAAY,KAAKJ,UAAAA,EAAaI,UAASI,SAAQ;EAC5D;EAEAC,MAAMA,OAAY;AAChB,eAAWL,YAAY,KAAKJ,UAAAA,EAAaI,UAASK,MAAMA,KAAAA;EAC1D;EAEAC,KAAKC,OAAU;AACb,eAAWP,YAAY,KAAKJ,UAAAA,EAAaI,UAASM,KAAKC,KAAAA;EACzD;AACF;","names":["Observable","$observers","Symbol","Subject","Observable","observer","unsubscribe","filter","someObserver","complete","error","next","value"]}

package/dist/{types → neutral}/types/messages.d.ts

@@ -1,31 +1,31 @@
-export interface SerializedError {
+interface SerializedError {
     __error_marker: '$$error';
     message: string;
     name: string;
     stack?: string;
 }
-export declare enum MasterMessageType {
+declare enum MasterMessageType {
     cancel = "cancel",
     run = "run"
 }
-export type MasterJobCancelMessage = {
+type MasterJobCancelMessage = {
     type: MasterMessageType.cancel;
     uid: number;
 };
-export type MasterJobRunMessage = {
+type MasterJobRunMessage = {
     type: MasterMessageType.run;
     uid: number;
     method?: string;
     args: any[];
 };
-export declare enum WorkerMessageType {
+declare enum WorkerMessageType {
     error = "error",
     init = "init",
     result = "result",
     running = "running",
     uncaughtError = "uncaughtError"
 }
-export type WorkerUncaughtErrorMessage = {
+type WorkerUncaughtErrorMessage = {
     type: WorkerMessageType.uncaughtError;
     error: {
         message: string;
@@ -33,7 +33,7 @@ export type WorkerUncaughtErrorMessage = {
         stack?: string;
     };
 };
-export type WorkerInitMessage = {
+type WorkerInitMessage = {
     type: WorkerMessageType.init;
     exposed: {
         type: 'function';
@@ -42,20 +42,21 @@ export type WorkerInitMessage = {
         methods: string[];
     };
 };
-export type WorkerJobErrorMessage = {
+type WorkerJobErrorMessage = {
     type: WorkerMessageType.error;
     uid: number;
     error: SerializedError;
 };
-export type WorkerJobResultMessage = {
+type WorkerJobResultMessage = {
     type: WorkerMessageType.result;
     uid: number;
     complete?: true;
     payload?: any;
 };
-export type WorkerJobStartMessage = {
+type WorkerJobStartMessage = {
     type: WorkerMessageType.running;
     uid: number;
     resultType: 'observable' | 'promise';
 };
-//# sourceMappingURL=messages.d.ts.map
+
+export { type MasterJobCancelMessage, type MasterJobRunMessage, MasterMessageType, type SerializedError, type WorkerInitMessage, type WorkerJobErrorMessage, type WorkerJobResultMessage, type WorkerJobStartMessage, WorkerMessageType, type WorkerUncaughtErrorMessage };

package/dist/neutral/types/messages.mjs

@@ -0,0 +1,19 @@
+// src/types/messages.ts
+var MasterMessageType = /* @__PURE__ */ function(MasterMessageType2) {
+  MasterMessageType2["cancel"] = "cancel";
+  MasterMessageType2["run"] = "run";
+  return MasterMessageType2;
+}({});
+var WorkerMessageType = /* @__PURE__ */ function(WorkerMessageType2) {
+  WorkerMessageType2["error"] = "error";
+  WorkerMessageType2["init"] = "init";
+  WorkerMessageType2["result"] = "result";
+  WorkerMessageType2["running"] = "running";
+  WorkerMessageType2["uncaughtError"] = "uncaughtError";
+  return WorkerMessageType2;
+}({});
+export {
+  MasterMessageType,
+  WorkerMessageType
+};
+//# sourceMappingURL=messages.mjs.map

package/dist/neutral/types/messages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/types/messages.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/member-ordering */\nexport interface SerializedError {\n  __error_marker: '$$error'\n  message: string\n  name: string\n  stack?: string\n}\n\n/////////////////////////////\n// Messages sent by master:\n\nexport enum MasterMessageType {\n  cancel = 'cancel',\n  run = 'run',\n}\n\nexport type MasterJobCancelMessage = {\n  type: MasterMessageType.cancel\n  uid: number\n}\n\nexport type MasterJobRunMessage = {\n  type: MasterMessageType.run\n  uid: number\n  method?: string\n  args: any[]\n}\n\n////////////////////////////\n// Messages sent by worker:\n\nexport enum WorkerMessageType {\n  error = 'error',\n  init = 'init',\n  result = 'result',\n  running = 'running',\n  uncaughtError = 'uncaughtError',\n}\n\nexport type WorkerUncaughtErrorMessage = {\n  type: WorkerMessageType.uncaughtError\n  error: {\n    message: string\n    name: string\n    stack?: string\n  }\n}\n\nexport type WorkerInitMessage = {\n  type: WorkerMessageType.init\n  exposed: { type: 'function' } | { type: 'module'; methods: string[] }\n}\n\nexport type WorkerJobErrorMessage = {\n  type: WorkerMessageType.error\n  uid: number\n  error: SerializedError\n}\n\nexport type WorkerJobResultMessage = {\n  type: WorkerMessageType.result\n  uid: number\n  complete?: true\n  payload?: any\n}\n\nexport type WorkerJobStartMessage = {\n  type: WorkerMessageType.running\n  uid: number\n  resultType: 'observable' | 'promise'\n}\n"],"mappings":";AAYO,IAAKA,oBAAAA,yBAAAA,oBAAAA;;;SAAAA;;AAoBL,IAAKC,oBAAAA,yBAAAA,oBAAAA;;;;;;SAAAA;;","names":["MasterMessageType","WorkerMessageType"]}

package/dist/node/common-Cuiya5FG.d.ts

@@ -0,0 +1,21 @@
+interface Serializer<Msg = JsonSerializable, Input = any> {
+    deserialize(message: Msg): Input;
+    serialize(input: Input): Msg;
+}
+interface SerializerImplementation<Msg = JsonSerializable, Input = any> {
+    deserialize(message: Msg, defaultDeserialize: (msg: Msg) => Input): Input;
+    serialize(input: Input, defaultSerialize: (inp: Input) => Msg): Msg;
+}
+type JsonSerializablePrimitive = string | number | boolean | null;
+type JsonSerializableObject = {
+    [key: string]: JsonSerializablePrimitive | JsonSerializablePrimitive[] | JsonSerializableObject | JsonSerializableObject[] | undefined;
+};
+type JsonSerializable = JsonSerializablePrimitive | JsonSerializablePrimitive[] | JsonSerializableObject | JsonSerializableObject[];
+declare const DefaultSerializer: Serializer<JsonSerializable>;
+
+declare global {
+    var registeredSerializer: Serializer<JsonSerializable>;
+}
+declare function registerSerializer(serializer: SerializerImplementation<JsonSerializable>): void;
+
+export { DefaultSerializer as D, type JsonSerializable as J, type Serializer as S, type SerializerImplementation as a, registerSerializer as r };

package/dist/node/index-node-DB1sNl0d.d.ts

@@ -0,0 +1,66 @@
+import { F as FunctionThread, M as ModuleThread, S as StripAsync, a as Worker$1, B as BlobWorker$1, b as WorkerImplementation } from './master-BjjSaJAj.js';
+import { Observable } from 'observable-fns';
+import { T as Thread, P as PoolEvent, a as PoolEventType, b as TaskRunFunction, Q as QueuedTask } from './pool-types-Bzei07Nj.js';
+import { W as WorkerFunction, a as WorkerModule } from './worker-04t9iwDh.js';
+import './master/implementation.node.js';
+
+interface PoolOptions {
+    concurrency?: number;
+    maxQueuedJobs?: number;
+    name?: string;
+    size?: number;
+}
+declare class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
+    static EventType: typeof PoolEventType;
+    private readonly debug;
+    private readonly eventObservable;
+    private readonly options;
+    private readonly workers;
+    private readonly eventSubject;
+    private initErrors;
+    private isClosing;
+    private nextTaskID;
+    private taskQueue;
+    constructor(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions);
+    private findIdlingWorker;
+    private runPoolTask;
+    private run;
+    private scheduleWork;
+    private taskCompletion;
+    settled(allowResolvingImmediately?: boolean): Promise<Error[]>;
+    completed(allowResolvingImmediately?: boolean): Promise<void>;
+    events(): Observable<PoolEvent<ThreadType>>;
+    queue(taskFunction: TaskRunFunction<ThreadType, any>): QueuedTask<ThreadType, any>;
+    terminate(force?: boolean): Promise<void>;
+}
+declare function PoolConstructor<ThreadType extends Thread>(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions): WorkerPool<ThreadType>;
+declare namespace Pool {
+    type Event<ThreadType extends Thread = any> = PoolEvent<ThreadType>;
+    type EventType = PoolEventType;
+}
+interface Pool<ThreadType extends Thread> {
+    completed(allowResolvingImmediately?: boolean): Promise<any>;
+    settled(allowResolvingImmediately?: boolean): Promise<Error[]>;
+    events(): Observable<PoolEvent<ThreadType>>;
+    queue<Return>(task: TaskRunFunction<ThreadType, Return>): QueuedTask<ThreadType, Return>;
+    terminate(force?: boolean): Promise<void>;
+}
+declare const Pool: typeof PoolConstructor & {
+    EventType: typeof PoolEventType;
+};
+
+type ArbitraryWorkerInterface = WorkerFunction & WorkerModule<string> & {
+    somekeythatisneverusedinproductioncode123: 'magicmarker123';
+};
+type ArbitraryThreadType = FunctionThread<any, any> & ModuleThread<any>;
+type ExposedToThreadType<Exposed extends WorkerFunction | WorkerModule<any>> = Exposed extends ArbitraryWorkerInterface ? ArbitraryThreadType : Exposed extends WorkerFunction ? FunctionThread<Parameters<Exposed>, StripAsync<ReturnType<Exposed>>> : Exposed extends WorkerModule<any> ? ModuleThread<Exposed> : never;
+declare function spawn<Exposed extends WorkerFunction | WorkerModule<any> = ArbitraryWorkerInterface>(worker: Worker$1, options?: {
+    timeout?: number;
+}): Promise<ExposedToThreadType<Exposed>>;
+
+type BlobWorker = typeof BlobWorker$1;
+declare const BlobWorker: typeof BlobWorker$1;
+type Worker = Worker$1;
+declare const Worker: typeof WorkerImplementation;
+
+export { BlobWorker as B, type ExposedToThreadType as E, Pool as P, Worker as W, spawn as s };

package/dist/node/index-node.d.ts

@@ -0,0 +1,8 @@
+export { D as DefaultSerializer, J as JsonSerializable, S as Serializer, a as SerializerImplementation, r as registerSerializer } from './common-Cuiya5FG.js';
+export { B as BlobWorker, E as ExposedAs, P as Pool, W as Worker, s as spawn } from './index-node-DB1sNl0d.js';
+export { Q as QueuedTask, T as Thread } from './pool-types-Bzei07Nj.js';
+export { a as Transfer, T as TransferDescriptor } from './transferable-Cv9t618f.js';
+export { F as FunctionThread, M as ModuleThread } from './master-BjjSaJAj.js';
+export { isWorkerRuntime } from './master/implementation.node.js';
+import 'observable-fns';
+import './worker-04t9iwDh.js';