@xylabs/threads 4.7.0-rc.1 → 4.7.1

package/dist/promise.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromiseWithResolver = createPromiseWithResolver;
+const doNothing = () => undefined;
+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];
+}

package/dist/{types/serializers.d.ts → serializers.d.ts}

@@ -14,4 +14,3 @@ type JsonSerializableObject = {
 export type JsonSerializable = JsonSerializablePrimitive | JsonSerializablePrimitive[] | JsonSerializableObject | JsonSerializableObject[];
 export declare const DefaultSerializer: Serializer<JsonSerializable>;
 export {};
-//# sourceMappingURL=serializers.d.ts.map

package/dist/serializers.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSerializer = void 0;
+exports.extendSerializer = extendSerializer;
+function extendSerializer(extend, implementation) {
+    const fallbackDeserializer = extend.deserialize.bind(extend);
+    const fallbackSerializer = extend.serialize.bind(extend);
+    return {
+        deserialize(message) {
+            return implementation.deserialize(message, fallbackDeserializer);
+        },
+        serialize(input) {
+            return implementation.serialize(input, fallbackSerializer);
+        },
+    };
+}
+const 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,
+        };
+    },
+};
+const isSerializedError = (thing) => thing && typeof thing === 'object' && '__error_marker' in thing && thing.__error_marker === '$$error';
+exports.DefaultSerializer = {
+    deserialize(message) {
+        return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
+    },
+    serialize(input) {
+        return input instanceof Error ? DefaultErrorSerializer.serialize(input) : input;
+    },
+};

package/dist/{types/symbols.d.ts → symbols.d.ts}

@@ -3,4 +3,3 @@ export declare const $events: unique symbol;
 export declare const $terminate: unique symbol;
 export declare const $transferable: unique symbol;
 export declare const $worker: unique symbol;
-//# sourceMappingURL=symbols.d.ts.map

package/dist/symbols.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$worker = exports.$transferable = exports.$terminate = exports.$events = exports.$errors = void 0;
+exports.$errors = Symbol('thread.errors');
+exports.$events = Symbol('thread.events');
+exports.$terminate = Symbol('thread.terminate');
+exports.$transferable = Symbol('thread.transferable');
+exports.$worker = Symbol('thread.worker');

package/dist/transferable.d.ts

@@ -0,0 +1,9 @@
+import { $transferable } from './symbols';
+export interface TransferDescriptor<T = any> {
+    [$transferable]: true;
+    send: T;
+    transferables: Transferable[];
+}
+export declare function isTransferDescriptor(thing: any): thing is TransferDescriptor;
+export declare function Transfer(transferable: Transferable): TransferDescriptor;
+export declare function Transfer<T>(payload: T, transferables: Transferable[]): TransferDescriptor;

package/dist/transferable.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTransferDescriptor = isTransferDescriptor;
+exports.Transfer = Transfer;
+const symbols_1 = require("./symbols");
+function isTransferable(thing) {
+    if (!thing || typeof thing !== 'object')
+        return false;
+    return true;
+}
+function isTransferDescriptor(thing) {
+    return thing && typeof thing === 'object' && thing[symbols_1.$transferable];
+}
+function Transfer(payload, transferables) {
+    if (!transferables) {
+        if (!isTransferable(payload))
+            throw new Error('Not transferable');
+        transferables = [payload];
+    }
+    return {
+        [symbols_1.$transferable]: true,
+        send: payload,
+        transferables,
+    };
+}

package/dist/types/{types/master.d.ts → master.d.ts}

@@ -1,7 +1,7 @@
 import type { Observable } from 'observable-fns';
-import type { ObservablePromise } from '../observable-promise.ts';
-import type { $errors, $events, $terminate, $worker } from '../symbols.ts';
-import type { TransferDescriptor } from '../transferable.ts';
+import type { ObservablePromise } from '../observable-promise';
+import type { $errors, $events, $terminate, $worker } from '../symbols';
+import type { TransferDescriptor } from '../transferable';
 interface ObservableLikeSubscription {
     unsubscribe(): any;
 }
@@ -36,39 +36,27 @@ interface AnyFunctionThread extends PrivateThreadProps {
 }
 interface AnyModuleThread extends PrivateThreadProps {
 }
-/** Worker thread. Either a `FunctionThread` or a `ModuleThread`. */
 export type Thread = AnyFunctionThread | AnyModuleThread;
 export type TransferList = Transferable[];
-/** Worker instance. Either a web worker or a node.js Worker provided by `worker_threads` or `tiny-worker`. */
 export interface Worker extends EventTarget {
     postMessage(value: any, transferList?: TransferList): void;
-    /** In nodejs 10+ return type is Promise while with tiny-worker and in browser return type is void */
     terminate(callback?: (error?: Error, exitCode?: number) => void): void | Promise<number>;
 }
 export interface ThreadsWorkerOptions extends WorkerOptions {
-    /** Whether to apply CORS protection workaround. Defaults to true. */
     CORSWorkaround?: boolean;
-    /** Prefix for the path passed to the Worker constructor. Web worker only. */
     _baseURL?: string;
-    /** Resource limits passed on to Node worker_threads */
     resourceLimits?: {
-        /** The size of a pre-allocated memory range used for generated code. */
         codeRangeSizeMb?: number;
-        /** The maximum size of the main heap in MB. */
         maxOldGenerationSizeMb?: number;
-        /** The maximum size of a heap space for recently created objects. */
         maxYoungGenerationSizeMb?: number;
     };
-    /** Data passed on to node.js worker_threads. */
     workerData?: any;
 }
-/** Worker implementation. Either web worker or a node.js Worker class. */
 export declare class WorkerImplementation extends EventTarget implements Worker {
     constructor(path: string, options?: ThreadsWorkerOptions);
     postMessage(value: any, transferList?: TransferList): void;
     terminate(): void | Promise<number>;
 }
-/** Class to spawn workers from a blob or source string. */
 export declare class BlobWorker extends WorkerImplementation {
     constructor(blob: Blob, options?: ThreadsWorkerOptions);
     static fromText(source: string, options?: ThreadsWorkerOptions): WorkerImplementation;
@@ -77,7 +65,6 @@ export interface ImplementationExport {
     blob: typeof BlobWorker;
     default: typeof WorkerImplementation;
 }
-/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
 export declare enum WorkerEventType {
     internalError = "internalError",
     message = "message",
@@ -96,4 +83,3 @@ export interface WorkerTerminationEvent {
 }
 export type WorkerEvent = WorkerInternalErrorEvent | WorkerMessageEvent<any> | WorkerTerminationEvent;
 export {};
-//# sourceMappingURL=master.d.ts.map

package/dist/types/master.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerEventType = void 0;
+var WorkerEventType;
+(function (WorkerEventType) {
+    WorkerEventType["internalError"] = "internalError";
+    WorkerEventType["message"] = "message";
+    WorkerEventType["termination"] = "termination";
+})(WorkerEventType || (exports.WorkerEventType = WorkerEventType = {}));

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

@@ -58,4 +58,3 @@ export type WorkerJobStartMessage = {
     uid: number;
     resultType: 'observable' | 'promise';
 };
-//# sourceMappingURL=messages.d.ts.map

package/dist/types/messages.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerMessageType = exports.MasterMessageType = void 0;
+var MasterMessageType;
+(function (MasterMessageType) {
+    MasterMessageType["cancel"] = "cancel";
+    MasterMessageType["run"] = "run";
+})(MasterMessageType || (exports.MasterMessageType = MasterMessageType = {}));
+var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType["error"] = "error";
+    WorkerMessageType["init"] = "init";
+    WorkerMessageType["result"] = "result";
+    WorkerMessageType["running"] = "running";
+    WorkerMessageType["uncaughtError"] = "uncaughtError";
+})(WorkerMessageType || (exports.WorkerMessageType = WorkerMessageType = {}));

package/dist/types/{types/worker.d.ts → worker.d.ts}

@@ -9,4 +9,3 @@ export type WorkerModule<Keys extends string> = {
     [key in Keys]: WorkerFunction;
 };
 export {};
-//# sourceMappingURL=worker.d.ts.map

package/dist/types/worker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/worker/bundle-entry.d.ts

@@ -0,0 +1 @@
+export * from './index';

package/dist/worker/bundle-entry.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+__exportStar(require("./index"), exports);
+if (typeof globalThis !== 'undefined') {
+    ;
+    globalThis.expose = index_1.expose;
+}
+if (typeof globalThis !== 'undefined') {
+    ;
+    globalThis.expose = index_1.expose;
+}

package/dist/worker/implementation.browser.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    isWorkerRuntime: () => boolean;
+    postMessageToMaster: (message: any, transferList?: Transferable[]) => void;
+    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+};
+export default _default;

package/dist/worker/implementation.browser.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isWorkerRuntime = function isWorkerRuntime() {
+    const isWindowContext = self !== undefined && typeof Window !== 'undefined' && self instanceof Window;
+    return self !== undefined && self['postMessage'] && !isWindowContext ? true : false;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    self.postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const messageHandler = (messageEvent) => {
+        onMessage(messageEvent.data);
+    };
+    const unsubscribe = () => {
+        self.removeEventListener('message', messageHandler);
+    };
+    self.addEventListener('message', messageHandler);
+    return unsubscribe;
+};
+exports.default = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+};

package/dist/worker/implementation.d.ts

@@ -0,0 +1,3 @@
+import type { AbstractedWorkerAPI } from '../types/worker';
+declare const _default: AbstractedWorkerAPI;
+export default _default;

package/dist/worker/implementation.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const implementation_browser_1 = __importDefault(require("./implementation.browser"));
+const implementation_tiny_worker_1 = __importDefault(require("./implementation.tiny-worker"));
+const implementation_worker_threads_1 = __importDefault(require("./implementation.worker_threads"));
+const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
+function selectNodeImplementation() {
+    try {
+        implementation_worker_threads_1.default.testImplementation();
+        return implementation_worker_threads_1.default;
+    }
+    catch {
+        return implementation_tiny_worker_1.default;
+    }
+}
+exports.default = runningInNode ? selectNodeImplementation() : implementation_browser_1.default;

package/dist/worker/implementation.tiny-worker.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    isWorkerRuntime: () => boolean;
+    postMessageToMaster: (message: any, transferList?: Transferable[]) => void;
+    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+};
+export default _default;

package/dist/worker/implementation.tiny-worker.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+try {
+    if (self === undefined) {
+        ;
+        globalThis.self = globalThis;
+    }
+}
+catch {
+    ;
+    globalThis.self = globalThis;
+}
+const isWorkerRuntime = function isWorkerRuntime() {
+    return self !== undefined && self['postMessage'] ? true : false;
+};
+const postMessageToMaster = function postMessageToMaster(data) {
+    self.postMessage(data);
+};
+let muxingHandlerSetUp = false;
+const messageHandlers = new Set();
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    if (!muxingHandlerSetUp) {
+        self.addEventListener('message', ((event) => {
+            for (const handler of messageHandlers)
+                handler(event.data);
+        }));
+        muxingHandlerSetUp = true;
+    }
+    messageHandlers.add(onMessage);
+    const unsubscribe = () => messageHandlers.delete(onMessage);
+    return unsubscribe;
+};
+exports.default = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+};

package/dist/worker/implementation.worker_threads.d.ts

@@ -0,0 +1,8 @@
+declare function testImplementation(): void;
+declare const _default: {
+    isWorkerRuntime: () => boolean;
+    postMessageToMaster: (message: any, transferList?: Transferable[]) => void;
+    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+    testImplementation: typeof testImplementation;
+};
+export default _default;

package/dist/worker/implementation.worker_threads.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = __importDefault(require("../worker_threads"));
+function assertMessagePort(port) {
+    if (!port) {
+        throw new Error('Invariant violation: MessagePort to parent is not available.');
+    }
+    return port;
+}
+const isWorkerRuntime = function isWorkerRuntime() {
+    return !(0, worker_threads_1.default)().isMainThread;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    assertMessagePort((0, worker_threads_1.default)().parentPort).postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const parentPort = (0, worker_threads_1.default)().parentPort;
+    if (!parentPort) {
+        throw new Error('Invariant violation: MessagePort to parent is not available.');
+    }
+    const messageHandler = (message) => {
+        onMessage(message);
+    };
+    const unsubscribe = () => {
+        assertMessagePort(parentPort).off('message', messageHandler);
+    };
+    assertMessagePort(parentPort).on('message', messageHandler);
+    return unsubscribe;
+};
+function testImplementation() {
+    (0, worker_threads_1.default)();
+}
+exports.default = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+    testImplementation,
+};

package/dist/worker/index.d.ts

@@ -0,0 +1,5 @@
+import type { WorkerFunction, WorkerModule } from '../types/worker';
+export { registerSerializer } from '../common';
+export { Transfer } from '../transferable';
+export declare const isWorkerRuntime: () => boolean;
+export declare function expose(exposed: WorkerFunction | WorkerModule<any>): void;

package/dist/worker/index.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.Transfer = exports.registerSerializer = void 0;
+exports.expose = expose;
+const is_observable_2_1_0_1 = __importDefault(require("is-observable-2-1-0"));
+const common_1 = require("../common");
+const transferable_1 = require("../transferable");
+const messages_1 = require("../types/messages");
+const implementation_1 = __importDefault(require("./implementation"));
+var common_2 = require("../common");
+Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_2.registerSerializer; } });
+var transferable_2 = require("../transferable");
+Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_2.Transfer; } });
+exports.isWorkerRuntime = implementation_1.default.isWorkerRuntime;
+let exposeCalled = false;
+const activeSubscriptions = new Map();
+const isMasterJobCancelMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.cancel;
+const isMasterJobRunMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.run;
+const isObservable = (thing) => (0, is_observable_2_1_0_1.default)(thing) || isZenObservable(thing);
+function isZenObservable(thing) {
+    return thing && typeof thing === 'object' && typeof thing.subscribe === 'function';
+}
+function deconstructTransfer(thing) {
+    return (0, transferable_1.isTransferDescriptor)(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: undefined };
+}
+function postFunctionInitMessage() {
+    const initMessage = {
+        exposed: { type: 'function' },
+        type: messages_1.WorkerMessageType.init,
+    };
+    implementation_1.default.postMessageToMaster(initMessage);
+}
+function postModuleInitMessage(methodNames) {
+    const initMessage = {
+        exposed: {
+            methods: methodNames,
+            type: 'module',
+        },
+        type: messages_1.WorkerMessageType.init,
+    };
+    implementation_1.default.postMessageToMaster(initMessage);
+}
+function postJobErrorMessage(uid, rawError) {
+    const { payload: error, transferables } = deconstructTransfer(rawError);
+    const errorMessage = {
+        error: (0, common_1.serialize)(error),
+        type: messages_1.WorkerMessageType.error,
+        uid,
+    };
+    implementation_1.default.postMessageToMaster(errorMessage, transferables);
+}
+function postJobResultMessage(uid, completed, resultValue) {
+    const { payload, transferables } = deconstructTransfer(resultValue);
+    const resultMessage = {
+        complete: completed ? true : undefined,
+        payload,
+        type: messages_1.WorkerMessageType.result,
+        uid,
+    };
+    implementation_1.default.postMessageToMaster(resultMessage, transferables);
+}
+function postJobStartMessage(uid, resultType) {
+    const startMessage = {
+        resultType,
+        type: messages_1.WorkerMessageType.running,
+        uid,
+    };
+    implementation_1.default.postMessageToMaster(startMessage);
+}
+function postUncaughtErrorMessage(error) {
+    try {
+        const errorMessage = {
+            error: (0, common_1.serialize)(error),
+            type: messages_1.WorkerMessageType.uncaughtError,
+        };
+        implementation_1.default.postMessageToMaster(errorMessage);
+    }
+    catch (subError) {
+        console.error('Not reporting uncaught error back to master thread as it ' + 'occured while reporting an uncaught error already.' + '\nLatest error:', subError, '\nOriginal error:', error);
+    }
+}
+async function runFunction(jobUID, fn, args) {
+    let syncResult;
+    try {
+        syncResult = fn(...args);
+    }
+    catch (error) {
+        return postJobErrorMessage(jobUID, error);
+    }
+    const resultType = isObservable(syncResult) ? 'observable' : 'promise';
+    postJobStartMessage(jobUID, resultType);
+    if (isObservable(syncResult)) {
+        const subscription = syncResult.subscribe(value => postJobResultMessage(jobUID, false, (0, common_1.serialize)(value)), (error) => {
+            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
+            activeSubscriptions.delete(jobUID);
+        }, () => {
+            postJobResultMessage(jobUID, true);
+            activeSubscriptions.delete(jobUID);
+        });
+        activeSubscriptions.set(jobUID, subscription);
+    }
+    else {
+        try {
+            const result = await syncResult;
+            postJobResultMessage(jobUID, true, (0, common_1.serialize)(result));
+        }
+        catch (error) {
+            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
+        }
+    }
+}
+function expose(exposed) {
+    if (!implementation_1.default.isWorkerRuntime()) {
+        throw new Error('expose() called in the master thread.');
+    }
+    if (exposeCalled) {
+        throw new Error('expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.');
+    }
+    exposeCalled = true;
+    if (typeof exposed === 'function') {
+        implementation_1.default.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && !messageData.method) {
+                runFunction(messageData.uid, exposed, messageData.args.map(common_1.deserialize));
+            }
+        });
+        postFunctionInitMessage();
+    }
+    else if (typeof exposed === 'object' && exposed) {
+        implementation_1.default.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && messageData.method) {
+                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
+            }
+        });
+        const methodNames = Object.keys(exposed).filter(key => typeof exposed[key] === 'function');
+        postModuleInitMessage(methodNames);
+    }
+    else {
+        throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+    }
+    implementation_1.default.subscribeToMasterMessages((messageData) => {
+        if (isMasterJobCancelMessage(messageData)) {
+            const jobUID = messageData.uid;
+            const subscription = activeSubscriptions.get(jobUID);
+            if (subscription) {
+                subscription.unsubscribe();
+                activeSubscriptions.delete(jobUID);
+            }
+        }
+    });
+}
+if (typeof globalThis !== 'undefined' && typeof self.addEventListener === 'function' && implementation_1.default.isWorkerRuntime()) {
+    self.addEventListener('error', (event) => {
+        setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
+    });
+    self.addEventListener('unhandledrejection', (event) => {
+        const error = event.reason;
+        if (error && typeof error.message === 'string') {
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}
+if (typeof process !== 'undefined' && typeof process.on === 'function' && implementation_1.default.isWorkerRuntime()) {
+    process.on('uncaughtException', (error) => {
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+    });
+    process.on('unhandledRejection', (error) => {
+        if (error && typeof error.message === 'string') {
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}

package/dist/worker_threads.d.ts

@@ -0,0 +1,8 @@
+type MessagePort = any;
+interface WorkerThreadsModule {
+    MessagePort: typeof MessagePort;
+    isMainThread: boolean;
+    parentPort: MessagePort;
+}
+export default function getImplementation(): WorkerThreadsModule;
+export {};

package/dist/worker_threads.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getImplementation;
+let implementation;
+function selectImplementation() {
+    return typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads') : eval('require')('worker_threads');
+}
+function getImplementation() {
+    if (!implementation) {
+        implementation = selectImplementation();
+    }
+    return implementation;
+}

package/eslint.config.mjs

@@ -0,0 +1,35 @@
+import {
+  typescriptConfig,
+  unicornConfig,
+  workspacesConfig,
+  rulesConfig,
+  importConfig,
+} from '@xylabs/eslint-config-flat'
+
+export default [
+  { ignores: ['.yarn', 'dist', '**/dist/**',
+    'build', '**/build/**', 'node_modules/**', 'public', 'storybook-static', 'eslint.config.mjs',
+    'rollup.config.js', 'test-tooling', 'test', 'types', 'worker.*', '*.mjs', '*.d.ts', '*.js'] },
+  unicornConfig,
+  workspacesConfig,
+  rulesConfig,
+  typescriptConfig,
+  importConfig,
+  {
+    rules: {
+      'no-restricted-syntax': ['off'],
+      'no-restricted-imports': [
+        'warn',
+        {
+          paths: [
+            ...rulesConfig.rules['no-restricted-imports'][1].paths,
+            '@xyo-network/*',
+            'lodash',
+            'lodash-es',
+            '@xylabs/lodash',
+          ],
+        },
+      ],
+    },
+  },
+]