@tstdl/base 0.90.19 → 0.90.21

package/api/server/gateway.js

@@ -111,7 +111,7 @@ let ApiGateway = class ApiGateway {
                     };
                     this.apis.set(resource, resourceApis);
                 }
-                const endpointImplementation = implementation[name]?.bind(implementation) ?? deferThrow(new NotImplementedError(`Endpoint ${name} for resource ${resource} not implemented.`));
+                const endpointImplementation = implementation[name]?.bind(implementation) ?? deferThrow(() => new NotImplementedError(`Endpoint ${name} for resource ${resource} not implemented.`));
                 for (const method of methods) {
                     resourceApis.endpoints.set(method, { definition: endpointDefinition, implementation: endpointImplementation });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.19",
+  "version": "0.90.21",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -109,7 +109,7 @@
     "luxon": "^3.4",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
-    "type-fest": "^4.5"
+    "type-fest": "^4.6"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -120,13 +120,13 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "6.8",
-    "@typescript-eslint/parser": "6.8",
+    "@typescript-eslint/eslint-plugin": "6.9",
+    "@typescript-eslint/parser": "6.9",
     "concurrently": "8.2",
     "esbuild": "0.19",
     "eslint": "8.52",
     "eslint-import-resolver-typescript": "3.6",
-    "eslint-plugin-import": "2.28",
+    "eslint-plugin-import": "2.29",
     "tsc-alias": "1.8",
     "typedoc": "0.25",
     "typedoc-plugin-missing-exports": "2.1",

package/rpc/adapters/index.d.ts

@@ -0,0 +1 @@
+export * from './readable-stream.adapter.js';

package/rpc/adapters/index.js

@@ -0,0 +1 @@
+export * from './readable-stream.adapter.js';

package/rpc/adapters/readable-stream.adapter.d.ts

@@ -0,0 +1,25 @@
+import type { AdaptSourceResult, RpcAdapter } from '../rpc.adapter.js';
+import type { RpcChannel } from '../rpc.endpoint.js';
+type Request = {
+    type: 'pull';
+} | {
+    type: 'cancel';
+    reason?: any;
+};
+type Response<T> = {
+    type: 'values';
+    values: T[];
+} | {
+    type: 'done';
+} | {
+    type: 'void';
+};
+export declare class ReadableStreamRpcAdapter<T> implements RpcAdapter<ReadableStream<T>, void, void, Request, Response<T>> {
+    readonly name = "ReadableStream";
+    readonly maxChunkSize: number;
+    constructor(maxChunkSize?: number);
+    adaptSource(stream: ReadableStream<T>, channel: RpcChannel<void, Request, Response<T>>): AdaptSourceResult<void>;
+    adaptTarget(_data: void, channel: RpcChannel<void, Request, Response<T>>): ReadableStream<T>;
+}
+export declare const defaultReadableStreamRpcAdapter: ReadableStreamRpcAdapter<unknown>;
+export {};

package/rpc/adapters/readable-stream.adapter.js

@@ -0,0 +1,67 @@
+import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { Timer } from '../../utils/timer.js';
+export class ReadableStreamRpcAdapter {
+    name = 'ReadableStream';
+    maxChunkSize;
+    constructor(maxChunkSize = 1000) {
+        this.maxChunkSize = maxChunkSize;
+    }
+    adaptSource(stream, channel) {
+        const reader = stream.getReader();
+        channel.request$.subscribe(async ({ id, data }) => {
+            switch (data.type) {
+                case 'pull': {
+                    const values = [];
+                    const timer = Timer.startNew();
+                    while ((timer.milliseconds < 3) && (values.length < this.maxChunkSize)) {
+                        const result = await reader.read();
+                        if (result.done) {
+                            break;
+                        }
+                        values.push(result.value);
+                    }
+                    const response = (values.length > 0)
+                        ? { type: 'values', values }
+                        : { type: 'done' };
+                    await channel.respond(id, response);
+                    break;
+                }
+                case 'cancel': {
+                    await reader.cancel(data.reason);
+                    await channel.respond(id, { type: 'void' });
+                    channel.close();
+                    break;
+                }
+                default:
+                    throw new NotSupportedError(`Type ${data.type} is not supported.`);
+            }
+        });
+    }
+    adaptTarget(_data, channel) {
+        return new ReadableStream({
+            async pull(controller) {
+                const response = await channel.request({ type: 'pull' });
+                switch (response.type) {
+                    case 'values': {
+                        for (const value of response.values) {
+                            controller.enqueue(value);
+                        }
+                        break;
+                    }
+                    case 'done': {
+                        controller.close();
+                        break;
+                    }
+                    default: {
+                        throw new NotSupportedError(`Type ${response.type} is not supported.`);
+                    }
+                }
+            },
+            async cancel(reason) {
+                await channel.request({ type: 'cancel', reason });
+                channel.close();
+            }
+        });
+    }
+}
+export const defaultReadableStreamRpcAdapter = new ReadableStreamRpcAdapter();

package/rpc/endpoints/message-port.rpc-endpoint.d.ts

@@ -1,19 +1,51 @@
 /// <reference types="node" resolution-mode="require"/>
 import type * as NodeWorkerThreads from 'node:worker_threads';
 import type { Observable } from 'rxjs';
-import type { RpcMessage } from '../model.js';
-import { RpcEndpoint } from '../rpc-endpoint.js';
-type BrowserSource = Worker | MessagePort | Window | SharedWorker;
-type NodeSource = NodeWorkerThreads.MessagePort | NodeWorkerThreads.Worker;
-export type MessagePortRpcEndpointSource = BrowserSource | NodeSource;
-export declare class MessagePortRpcEndpoint extends RpcEndpoint {
-    private readonly source;
+import type { RpcChannelMessage } from '../rpc.endpoint.js';
+import { RpcChannel, RpcEndpoint } from '../rpc.endpoint.js';
+type BrowserTransport = Worker | MessagePort | Window | SharedWorker;
+type NodeTransport = NodeWorkerThreads.MessagePort | NodeWorkerThreads.Worker;
+export type MessagePortRpcTransport = BrowserTransport | NodeTransport;
+type MessagePortMessageBase<Type extends string> = {
+    seq: number;
+    type: Type;
+};
+type MessagePortOpenChannelMessage = MessagePortMessageBase<'open-channel'> & {
+    id: string;
+    port: MessagePort | NodeWorkerThreads.MessagePort;
+};
+type MessagePortCloseChannelMessage = MessagePortMessageBase<'close-channel'>;
+type MessagePortDataMessage<T> = MessagePortMessageBase<'data'> & {
+    data: T;
+};
+type MessagePortMessage<T> = MessagePortOpenChannelMessage | MessagePortCloseChannelMessage | MessagePortDataMessage<T>;
+export declare class MessagePortRpcChannel<Data = any, Req = any, Res = any> extends RpcChannel<Data, Req, Res> {
+    #private;
     private readonly _postMessage;
-    readonly supportsTransfers: boolean;
-    readonly message$: Observable<RpcMessage>;
-    constructor(source: MessagePortRpcEndpointSource);
-    start(): void;
+    private transport;
+    readonly messagePortMessage$: Observable<MessagePortMessage<RpcChannelMessage<Data, Req, Res>>>;
+    channelMessages$: Observable<RpcChannelMessage<Data, Req, Res>>;
+    readonly supportsTransfers = true;
+    readonly endpoint: MessagePortRpcEndpoint;
+    sequence: number;
+    lastSequence: number;
+    constructor(id: string, transport: MessagePortRpcTransport | undefined, endpoint: MessagePortRpcEndpoint);
+    setTransport(transport: MessagePortRpcTransport): void;
+    postPortMessage(message: MessagePortMessage<RpcChannelMessage<Data, Req, Res>>, transfer?: any[]): void;
+    close(): void;
+    postMessage(message: RpcChannelMessage<Data, Req, Res>, transfer?: any[] | undefined): void | Promise<void>;
+}
+export declare class MessagePortRpcEndpoint extends RpcEndpoint {
+    #private;
+    private readonly transport;
+    private readonly mainChannel;
+    constructor(source: MessagePortRpcTransport);
+    static from(transport: MessagePortRpcTransport): MessagePortRpcEndpoint;
+    openChannel<Data, Req, Res>(id?: string): MessagePortRpcChannel<Data, Req, Res>;
+    getChannel<Data, Req, Res>(id: string): MessagePortRpcChannel<Data, Req, Res>;
+    getOrOpenChannel<Data, Req, Res>(id: string): RpcChannel<Data, Req, Res>;
     close(): void;
-    postMessage(data: any, transfer?: any[] | undefined): void;
+    forgetChannel(id: string): void;
+    private handleOpenChannelMessage;
 }
 export {};

package/rpc/endpoints/message-port.rpc-endpoint.js

@@ -1,32 +1,115 @@
-import { fromEvent, map } from 'rxjs';
+import { ReplaySubject, Subject, filter, fromEvent, map, shareReplay, startWith, switchMap, takeUntil } from 'rxjs';
 import { isBrowser } from '../../environment.js';
-import { RpcEndpoint } from '../rpc-endpoint.js';
-export class MessagePortRpcEndpoint extends RpcEndpoint {
-    source;
+import { deferThrow } from '../../utils/throw.js';
+import { isDefined, isUndefined } from '../../utils/type-guards.js';
+import { RpcChannel, RpcEndpoint } from '../rpc.endpoint.js';
+export class MessagePortRpcChannel extends RpcChannel {
+    #transportSubject = new ReplaySubject(1);
+    #closeSubject = new Subject();
     _postMessage;
+    transport = { postMessage: deferThrow(() => new Error('Rpc transport not yet initialized.')) };
+    messagePortMessage$;
+    channelMessages$;
     supportsTransfers = true;
-    message$;
+    endpoint;
+    sequence = 1;
+    lastSequence = 0;
+    constructor(id, transport, endpoint) {
+        super(id);
+        this.endpoint = endpoint;
+        if (isDefined(transport)) {
+            this.setTransport(transport);
+        }
+        this.messagePortMessage$ = this.#transportSubject.pipe(startWith(transport), filter(isDefined), switchMap((newTransport) => fromEvent(newTransport, 'message')), takeUntil(this.#closeSubject), map((message) => ((message instanceof MessageEvent) ? message.data : message)), shareReplay({ bufferSize: 0, refCount: true }));
+        this.channelMessages$ = this.messagePortMessage$.pipe(filter((message) => message.type == 'data'), map((message) => message.data));
+        this._postMessage = isBrowser
+            ? (data, transfer) => this.transport.postMessage(data, { transfer })
+            : (data, transfer) => this.transport.postMessage(data, transfer);
+        if (transport instanceof MessagePort) {
+            transport.start();
+        }
+        this.messagePortMessage$.subscribe((message) => {
+            if (message.type == 'close-channel') {
+                this.close();
+            }
+        });
+    }
+    setTransport(transport) {
+        this.transport = transport;
+        this.#transportSubject.next(transport);
+        this.#transportSubject.complete();
+    }
+    postPortMessage(message, transfer) {
+        this._postMessage(message, transfer);
+    }
+    close() {
+        this.postPortMessage({ seq: this.sequence++, type: 'close-channel' });
+        if (this.transport instanceof MessagePort) {
+            this.transport.close();
+        }
+        this.#closeSubject.next();
+        this.endpoint.forgetChannel(this.id);
+    }
+    postMessage(message, transfer) {
+        this.postPortMessage({ seq: this.sequence++, type: 'data', data: message }, transfer);
+    }
+}
+export class MessagePortRpcEndpoint extends RpcEndpoint {
+    #closeSubject = new Subject();
+    #channels = new Map();
+    transport;
+    mainChannel;
     constructor(source) {
         super();
-        this.source = (isBrowser && ((typeof SharedWorker == 'function') && (source instanceof SharedWorker)))
+        this.transport = (isBrowser && ((typeof SharedWorker == 'function') && (source instanceof SharedWorker)))
             ? source.port
             : source;
-        this.message$ = fromEvent(this.source, 'message').pipe(map((message) => ((message instanceof MessageEvent) ? { ...message.data, metadata: { source: message } } : message)));
-        this._postMessage = isBrowser
-            ? (data, transfer) => this.source.postMessage(data, { transfer })
-            : (data, transfer) => this.source.postMessage(data, transfer);
+        this.mainChannel = new MessagePortRpcChannel('main', this.transport, this);
+        this.mainChannel.messagePortMessage$.subscribe((message) => {
+            if (message.type == 'open-channel') {
+                this.handleOpenChannelMessage(message);
+            }
+        });
+    }
+    static from(transport) {
+        return new MessagePortRpcEndpoint(transport);
     }
-    start() {
-        if (this.source instanceof MessagePort) {
-            this.source.start();
+    openChannel(id = crypto.randomUUID()) {
+        const { port1, port2 } = new MessageChannel();
+        const openChannelMessage = { seq: this.mainChannel.sequence++, type: 'open-channel', id, port: port2 };
+        this.mainChannel.postPortMessage(openChannelMessage, [port2]);
+        const channel = new MessagePortRpcChannel(id, port1, this);
+        this.#channels.set(id, channel);
+        return channel;
+    }
+    getChannel(id) {
+        const channel = this.#channels.get(id);
+        if (isUndefined(channel)) {
+            const newChannel = new MessagePortRpcChannel(id, undefined, this);
+            this.#channels.set(id, newChannel);
+            return newChannel;
         }
+        return channel;
+    }
+    getOrOpenChannel(id) {
+        return this.#channels.get(id) ?? this.openChannel(id);
     }
     close() {
-        if (this.source instanceof MessagePort) {
-            this.source.close();
+        if (this.transport instanceof MessagePort) {
+            this.transport.close();
         }
+        this.#closeSubject.next();
     }
-    postMessage(data, transfer) {
-        this._postMessage(data, transfer);
+    forgetChannel(id) {
+        this.#channels.delete(id);
+    }
+    handleOpenChannelMessage(message) {
+        const { id, port } = message;
+        if (this.#channels.has(id)) {
+            this.#channels.get(id).setTransport(port);
+            return;
+        }
+        const channel = new MessagePortRpcChannel(id, port, this);
+        this.#channels.set(id, channel);
     }
 }

package/rpc/index.d.ts

@@ -1,4 +1,6 @@
+export * from './adapters/index.js';
 export * from './model.js';
+export * from './rpc.adapter.js';
+export * from './rpc.endpoint.js';
+export * from './rpc.error.js';
 export * from './rpc.js';
-export * from './rpc-endpoint.js';
-export * from './rpc-error.js';

package/rpc/index.js

@@ -1,4 +1,6 @@
+export * from './adapters/index.js';
 export * from './model.js';
+export * from './rpc.adapter.js';
+export * from './rpc.endpoint.js';
+export * from './rpc.error.js';
 export * from './rpc.js';
-export * from './rpc-endpoint.js';
-export * from './rpc-error.js';

package/rpc/model.d.ts

@@ -9,35 +9,27 @@ export type RpcRemoteInput = ((...args: any) => any) | Record;
 export type RpcRemote<T extends RpcRemoteInput = RpcRemoteInput> = T extends Constructor ? RpcConstructor<T> : T extends (...args: any) => any ? RpcFunction<T> : RpcObject<T>;
 export type RpcMessageBase<Type extends string = string> = {
     type: Type;
-    id: string;
-    metadata?: any;
-};
-export type RpcMessageWithProxyIdBase<Type extends string = string> = RpcMessageBase<Type> & {
-    proxyId: string;
 };
 export type RpcConnectMessage = RpcMessageBase<'connect'> & {
     name: string;
 };
-export type RpcApplyMessage = RpcMessageWithProxyIdBase<'apply'> & {
+export type RpcControlRequestMessage = RpcConnectMessage;
+export type RpcProxyApplyMessage = RpcMessageBase<'apply'> & {
     path: PropertyKey[];
-    args: RpcMessageValue[];
+    args: RpcValue[];
 };
-export type RpcConstructMessage = RpcMessageWithProxyIdBase<'construct'> & {
+export type RpcProxyConstructMessage = RpcMessageBase<'construct'> & {
     path: PropertyKey[];
-    args: RpcMessageValue[];
+    args: RpcValue[];
 };
-export type RpcGetMessage = RpcMessageWithProxyIdBase<'get'> & {
+export type RpcProxyGetMessage = RpcMessageBase<'get'> & {
     path: PropertyKey[];
 };
-export type RpcSetMessage = RpcMessageWithProxyIdBase<'set'> & {
+export type RpcProxySetMessage = RpcMessageBase<'set'> & {
     path: PropertyKey[];
-    value: RpcMessageValue;
-};
-export type RpcReleaseProxyMessage = RpcMessageWithProxyIdBase<'release-proxy'>;
-export type RpcResponseMessage = RpcMessageBase<'response'> & {
-    value: RpcMessageValue;
+    value: RpcValue;
 };
-export type RpcMessage = RpcConnectMessage | RpcApplyMessage | RpcConstructMessage | RpcGetMessage | RpcSetMessage | RpcReleaseProxyMessage | RpcResponseMessage;
+export type RpcProxyRequestMessage = RpcProxyApplyMessage | RpcProxyConstructMessage | RpcProxyGetMessage | RpcProxySetMessage;
 export type RpcMessageRawValue = {
     type: 'raw';
     value: any;
@@ -49,24 +41,24 @@ export type RpcMessageSerializedValue = {
 };
 export type RpcMessageProxyValue = {
     type: 'proxy';
-    id: string;
-    port?: MessagePort;
+    channel: string;
+};
+export type RpcMessageAdapterValue = {
+    type: 'adapter';
+    adapter: string;
+    channel: string;
+    data: any;
 };
 export type RpcMessageThrowValue = {
     type: 'throw';
     error: unknown;
 };
-export type RpcMessageValue = RpcMessageRawValue | RpcMessageSerializedValue | RpcMessageProxyValue | RpcMessageThrowValue;
+export type RpcValue = RpcMessageRawValue | RpcMessageSerializedValue | RpcMessageProxyValue | RpcMessageAdapterValue | RpcMessageThrowValue;
 export type RpcPostMessageArrayData = {
-    value: RpcMessageValue[];
+    value: RpcValue[];
     transfer?: any[];
 };
 export type RpcPostMessageData = {
-    value: RpcMessageValue;
+    value: RpcValue;
     transfer?: any[];
 };
-export declare function createRpcMessage<Type extends RpcMessage['type']>(type: Type, message: Omit<Extract<RpcMessage, {
-    type: Type;
-}>, 'id' | 'type'>): Extract<RpcMessage, {
-    type: Type;
-}>;

package/rpc/model.js

@@ -1,8 +1 @@
-import { getRandomString } from '../utils/random.js';
-export function createRpcMessage(type, message) {
-    return {
-        id: getRandomString(24),
-        type,
-        ...message
-    };
-}
+export {};

package/rpc/rpc.adapter.d.ts

@@ -0,0 +1,19 @@
+import type { NonPrimitive } from '../serializer/types.js';
+import type { RpcChannel } from './rpc.endpoint.js';
+export type AdaptSourceResult<Data> = Data extends void ? (void | {
+    data?: undefined;
+    transfer?: any[];
+}) : {
+    data: Data;
+    transfer?: any[];
+};
+export type RpcAdapterNonPrimitive = NonPrimitive<string, RpcAdapterNonPrimitiveData>;
+export type RpcAdapterNonPrimitiveData = {
+    channel: string;
+    data: any;
+};
+export interface RpcAdapter<T extends object = any, Data = any, ChannelData = any, Req = any, Res = any> {
+    name: string;
+    adaptSource(value: T, channel: RpcChannel<ChannelData, Req, Res>): AdaptSourceResult<Data>;
+    adaptTarget(data: Data, channel: RpcChannel<ChannelData, Req, Res>): T;
+}

package/rpc/rpc.adapter.js

@@ -0,0 +1 @@
+export {};

package/rpc/rpc.d.ts

@@ -1,19 +1,21 @@
 import type { SerializationOptions } from '../serializer/index.js';
-import type { MessagePortRpcEndpointSource } from './endpoints/message-port.rpc-endpoint.js';
 import type { RpcRemote, RpcRemoteInput } from './model.js';
-import { RpcEndpoint } from './rpc-endpoint.js';
-export type RpcEndpointSource = RpcEndpoint | MessagePortRpcEndpointSource;
+import type { RpcAdapter } from './rpc.adapter.js';
+import type { RpcEndpoint } from './rpc.endpoint.js';
 export declare const Rpc: {
-    connect<T extends RpcRemoteInput>(endpointOrSource: RpcEndpointSource, name?: string): Promise<RpcRemote<T>>;
-    expose(object: RpcRemoteInput, endpointOrSource: RpcEndpointSource, name?: string): void;
+    listen(endpoint: RpcEndpoint): void;
+    connect<T extends RpcRemoteInput>(endpoint: RpcEndpoint, name?: string): Promise<RpcRemote<T>>;
+    expose(object: RpcRemoteInput, name?: string): void;
+    registerAdapter<T_1 extends object, Data>(adapter: RpcAdapter<T_1, Data, any, any, any>): void;
     /**
      * mark object for proxy forward
      * @param object object to forward as proxy
      * @param root if object is a child of the actual passed value (to function calls, returns or whatever), this must be set to to mark the parent for serialization (required for children proxies)
      * @returns
      */
-    proxy<T_1 extends object>(object: T_1, root?: object): T_1;
-    transfer<T_2 extends object>(object: T_2, transfer: any[]): T_2;
-    serialize<T_3 extends object>(object: T_3, options?: SerializationOptions): T_3;
+    proxy<T_2 extends object>(object: T_2, root?: object): T_2;
+    transfer<T_3 extends object>(object: T_3, transfer: any[]): T_3;
+    serialize<T_4 extends object>(object: T_4, options?: SerializationOptions): T_4;
+    adapt<T_5 extends object>(object: T_5, adapter: RpcAdapter<T_5, any, any, any, any>, root?: object): T_5;
     isProxied(object: object): boolean;
 };

package/rpc/rpc.endpoint.d.ts

@@ -0,0 +1,45 @@
+import { type Observable } from 'rxjs';
+export type RpcChannelDataMessage<T> = {
+    type: 'data';
+    data: T;
+};
+export type RpcChannelRequestMessage<T> = {
+    type: 'request';
+    id: string;
+    data: T;
+};
+export type RpcChannelResponseMessage<T> = {
+    type: 'response';
+    id: string;
+    data: T;
+};
+export type RpcChannelMessage<Data, Req, Res> = RpcChannelDataMessage<Data> | RpcChannelRequestMessage<Req> | RpcChannelResponseMessage<Res>;
+export type RpcChannelRequest<T> = {
+    id: string;
+    data: T;
+};
+export declare abstract class RpcEndpoint {
+    abstract openChannel<Data, Req, Res>(id?: string): RpcChannel<Data, Req, Res>;
+    abstract getChannel<Data, Req, Res>(id: string): RpcChannel<Data, Req, Res>;
+    abstract getOrOpenChannel<Data, Req, Res>(id: string): RpcChannel<Data, Req, Res>;
+    abstract close(): void;
+}
+/**
+ * @template Data - type of data-messages
+ * @template Req - type of request-messages
+ * @template Res - type of response-messages
+ */
+export declare abstract class RpcChannel<Data = unknown, Req = unknown, Res = unknown> {
+    readonly id: string;
+    readonly message$: Observable<Data>;
+    readonly request$: Observable<RpcChannelRequest<Req>>;
+    protected abstract readonly channelMessages$: Observable<RpcChannelMessage<Data, Req, Res>>;
+    abstract readonly supportsTransfers: boolean;
+    abstract readonly endpoint: RpcEndpoint;
+    constructor(id: string);
+    request<U extends Res>(data: Req, transfer?: any[]): Promise<U>;
+    respond(id: string, data: Res, transfer?: any[]): Promise<void>;
+    send(data: Data, transfer?: any[]): Promise<void>;
+    abstract close(): void;
+    protected abstract postMessage(message: RpcChannelMessage<Data, Req, Res>, transfer?: any[]): void | Promise<void>;
+}

package/rpc/rpc.endpoint.js

@@ -0,0 +1,46 @@
+import { defer, filter, map } from 'rxjs';
+export class RpcEndpoint {
+}
+/**
+ * @template Data - type of data-messages
+ * @template Req - type of request-messages
+ * @template Res - type of response-messages
+ */
+export class RpcChannel {
+    id;
+    message$;
+    request$;
+    constructor(id) {
+        this.id = id;
+        this.message$ = defer(() => this.channelMessages$.pipe(filter((message) => message.type == 'data'), map((message) => message.data)));
+        this.request$ = defer(() => this.channelMessages$.pipe(filter((message) => message.type == 'request'), map((message) => message)));
+    }
+    async request(data, transfer) {
+        const id = crypto.randomUUID();
+        const $response = getResponsePromise(this.channelMessages$, id);
+        await this.postMessage({ type: 'request', id, data }, transfer);
+        const response = await $response;
+        return response;
+    }
+    async respond(id, data, transfer) {
+        await this.postMessage({ type: 'response', id, data }, transfer);
+    }
+    async send(data, transfer) {
+        await this.postMessage({ type: 'data', data }, transfer);
+    }
+}
+async function getResponsePromise(channelMessage$, requestId) {
+    return new Promise((resolve, reject) => {
+        const subscription = channelMessage$.subscribe({
+            next(message) {
+                if ((message.type == 'response') && (message.id == requestId)) {
+                    resolve(message.data);
+                    subscription.unsubscribe();
+                }
+            },
+            complete() {
+                reject(new Error('RpcEndpoint was closed while waiting for response.'));
+            }
+        });
+    });
+}

package/rpc/rpc.js

@@ -1,38 +1,66 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { filter, Subject, takeUntil } from 'rxjs';
+import { NotFoundError } from '../errors/not-found.error.js';
 import { NotImplementedError } from '../errors/not-implemented.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { deserialize, registerSerializer, serialize } from '../serializer/index.js';
+import { valueOfType } from '../utils/helpers.js';
 import { hasOwnProperty } from '../utils/object/object.js';
 import { reflectMethods } from '../utils/proxy.js';
-import { getRandomString } from '../utils/random.js';
-import { _throw } from '../utils/throw.js';
-import { assert, isDefined } from '../utils/type-guards.js';
-import { MessagePortRpcEndpoint } from './endpoints/message-port.rpc-endpoint.js';
-import { createRpcMessage } from './model.js';
-import { RpcEndpoint } from './rpc-endpoint.js';
-import { RpcError, RpcRemoteError } from './rpc-error.js';
+import { _throw, deferThrow } from '../utils/throw.js';
+import { assert, isDefined, isUndefined } from '../utils/type-guards.js';
+import { RpcError, RpcRemoteError } from './rpc.error.js';
 const markedTransfers = new WeakMap();
 const serializationTargets = new WeakMap();
+const adapters = new Map();
+const adapterTargets = new WeakMap();
 const proxyTargets = new WeakSet();
-const proxyFinalizationRegistry = new FinalizationRegistry(async (data) => {
-    const message = createRpcMessage('release-proxy', { proxyId: data.id });
-    await data.endpoint.postMessage(message);
-});
+const exposings = new Map();
+const channelFinalizationRegistry = new FinalizationRegistry((data) => data.channel.close());
+class RpcProxy {
+}
 // eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
 export const Rpc = {
-    async connect(endpointOrSource, name = 'default') {
-        const endpoint = (endpointOrSource instanceof RpcEndpoint) ? endpointOrSource : new MessagePortRpcEndpoint(endpointOrSource);
-        endpoint.start();
-        const connectMessage = createRpcMessage('connect', { name });
-        const response = await endpoint.request(connectMessage);
-        assert(response.type == 'proxy', 'Rpc connect must result in proxy.');
+    listen(endpoint) {
+        const controlChannel = endpoint.getChannel('control');
+        controlChannel.request$.subscribe(async ({ id: messageId, data: message }) => {
+            switch (message.type) {
+                case 'connect': {
+                    try {
+                        const exposing = exposings.get(message.name);
+                        if (isUndefined(exposing)) {
+                            throw new NotFoundError(`Could not connect to "${message.name}" as nothing with that name is exposed.`);
+                        }
+                        const value = getAdapterOrProxy(exposing, endpoint);
+                        await controlChannel.respond(messageId, value);
+                    }
+                    catch (error) {
+                        await controlChannel.respond(messageId, { type: 'throw', error });
+                    }
+                    break;
+                }
+                default:
+                    throw new NotSupportedError(`Message type ${message.type} not supported in listen.`);
+            }
+        });
+    },
+    async connect(endpoint, name = 'default') {
+        const channel = endpoint.getOrOpenChannel('control');
+        const response = await channel.request({ type: 'connect', name });
+        assert((response.type == 'proxy') || (response.type == 'adapter') || (response.type == 'throw'), 'Rpc connect must result in proxy, adapter or throw.');
         return parseRpcMessageValue(response, endpoint);
     },
-    expose(object, endpointOrSource, name = 'default') {
-        const endpoint = (endpointOrSource instanceof RpcEndpoint) ? endpointOrSource : new MessagePortRpcEndpoint(endpointOrSource);
-        endpoint.start();
-        exposeConnectable(object, endpoint, name);
+    expose(object, name = 'default') {
+        exposings.set(name, object);
+    },
+    registerAdapter(adapter) {
+        const adapterName = `RpcAdapter:${adapter.name}`;
+        adapters.set(adapterName, adapter);
+        const klass = {
+            [adapterName]: class {
+            }
+        }[adapterName];
+        registerSerializer(klass, klass.name, () => _throw(new NotSupportedError('Serialization not supported for rpc adapter.')), ({ channel, data }, _, { rpcEndpoint }) => adapter.adaptTarget(data, rpcEndpoint.getChannel(channel)));
     },
     /**
      * mark object for proxy forward
@@ -48,48 +76,57 @@ export const Rpc = {
         return object;
     },
     transfer(object, transfer) {
-        markedTransfers.set(object, transfer);
+        const existingTransfers = markedTransfers.get(object);
+        markedTransfers.set(object, isDefined(existingTransfers) ? [...existingTransfers, ...transfer] : transfer);
         return object;
     },
     serialize(object, options) {
         serializationTargets.set(object, options);
         return object;
     },
+    adapt(object, adapter, root) {
+        adapterTargets.set(object, adapter);
+        if (isDefined(root)) {
+            Rpc.serialize(root);
+        }
+        return object;
+    },
     isProxied(object) {
         return proxyTargets.has(object);
     }
 };
-function createProxy(endpoint, id, path = []) {
-    class RpcProxy {
-    }
+function createProxy(channel, path = []) {
     // eslint-disable-next-line prefer-const
     let proxy;
+    const { endpoint } = channel;
     const handlers = {
         apply(_target, _this, args) {
             const postMessageData = getPostMessageDataFromArray(args, endpoint);
-            const message = createRpcMessage('apply', { proxyId: id, path, args: postMessageData.value });
-            return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+            return channel
+                .request({ type: 'apply', path, args: postMessageData.value }, postMessageData.transfer)
+                .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
         },
         construct(_target, args) {
             const postMessageData = getPostMessageDataFromArray(args, endpoint);
-            const message = createRpcMessage('construct', { proxyId: id, path, args: postMessageData.value });
-            return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+            return channel
+                .request({ type: 'construct', path, args: postMessageData.value }, postMessageData.transfer)
+                .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
         },
         get(_target, property) {
             if (property == 'then') {
                 if (path.length == 0) {
                     return { then: () => proxy };
                 }
-                const message = createRpcMessage('get', { proxyId: id, path });
-                const resultValue = endpoint.request(message).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+                const resultValue = channel.request({ type: 'get', path }).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
                 return resultValue.then.bind(resultValue);
             }
-            return createProxy(endpoint, id, [...path, property]);
+            return createProxy(channel, [...path, property]);
         },
         set(_target, property, value) {
             const postMessageData = getPostMessageData(value, endpoint);
-            const message = createRpcMessage('set', { proxyId: id, path: [...path, property], value: postMessageData.value });
-            return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+            return channel
+                .request({ type: 'set', path: [...path, property], value: postMessageData.value }, postMessageData.transfer)
+                .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
         },
         getPrototypeOf() {
             return null;
@@ -97,115 +134,97 @@ function createProxy(endpoint, id, path = []) {
     };
     for (const method of reflectMethods) {
         if (!hasOwnProperty(handlers, method)) {
-            handlers[method] = () => {
-                throw new Error(`${method} not supported on rpc proxies.`);
-            };
+            handlers[method] = deferThrow(() => new NotSupportedError(`${method} not supported on rpc proxies.`));
         }
     }
-    proxy = new Proxy(RpcProxy, handlers);
-    proxyFinalizationRegistry.register(proxy, { id, endpoint });
-    return proxy;
-}
-function exposeConnectable(object, endpoint, name) {
-    endpoint.message$
-        .pipe(filter((message) => message.type == 'connect'), filter((message) => message.name == name))
-        .subscribe(async (message) => {
-        try {
-            const [proxy, transfer] = createProxyValue(object, endpoint);
-            await endpoint.respond(message.id, proxy, transfer);
-        }
-        catch (error) {
-            await endpoint.respond(message.id, { type: 'throw', error });
-        }
-    });
+    return new Proxy(RpcProxy, handlers);
 }
-function exposeObject(object, endpoint, proxyId) {
-    const abortSubject = new Subject();
-    endpoint.message$
-        .pipe(takeUntil(abortSubject), filter((message) => (message.proxyId == proxyId)))
-        .subscribe(async (message) => {
+function exposeObject(object, channel) {
+    const { endpoint } = channel;
+    channel.request$.subscribe(async ({ id: messageId, data: message }) => {
         try {
             switch (message.type) {
                 case 'get': {
                     const { value } = deref(object, message.path);
                     const postMessageData = getPostMessageData(await value, endpoint);
-                    await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
+                    await channel.respond(messageId, postMessageData.value, postMessageData.transfer);
                     break;
                 }
                 case 'set': {
                     const { value } = deref(object, message.path, true);
-                    const result = Reflect.set(value, message.path[message.path.length - 1], parseRpcMessageValue(message.value, endpoint));
+                    const result = Reflect.set(value, message.path[message.path.length - 1], parseRpcMessageValue(message.value, channel.endpoint));
                     const postMessageData = getPostMessageData(result, endpoint);
-                    await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
+                    await channel.respond(messageId, postMessageData.value, postMessageData.transfer);
                     break;
                 }
                 case 'apply': {
                     const { parent, value } = deref(object, message.path);
-                    const result = await Reflect.apply(value, parent, parseRpcMessageValues(message.args, endpoint));
+                    const result = await Reflect.apply(value, parent, parseRpcMessageValues(message.args, channel.endpoint));
                     const postMessageData = getPostMessageData(result, endpoint);
-                    await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
+                    await channel.respond(messageId, postMessageData.value, postMessageData.transfer);
                     break;
                 }
                 case 'construct': {
                     const { value } = deref(object, message.path);
-                    const result = Reflect.construct(value, parseRpcMessageValues(message.args, endpoint));
-                    const [proxy, transfer] = createProxyValue(result, endpoint);
-                    await endpoint.respond(message.id, proxy, transfer);
-                    break;
-                }
-                case 'release-proxy': {
-                    abortSubject.next();
+                    const result = Reflect.construct(value, parseRpcMessageValues(message.args, channel.endpoint));
+                    const postMessageData = getPostMessageData(Rpc.proxy(result), endpoint);
+                    await channel.respond(messageId, postMessageData.value, postMessageData.transfer);
                     break;
                 }
-                case 'response':
-                case 'connect':
-                    // we do not handle these here
-                    break;
                 default:
-                    throw new NotImplementedError(`Unsupported message type ${message.type}`);
+                    throw new NotImplementedError(`Unsupported message type ${message.type}.`);
             }
         }
         catch (error) {
-            await endpoint.respond(message.id, { type: 'throw', error });
+            await channel.respond(messageId, { type: 'throw', error });
         }
     });
 }
 function getPostMessageDataFromArray(values, endpoint) {
-    const mappedValues = values.map((value) => getRpcMessageValue(value, endpoint));
+    const messageValues = values.map((value) => getRpcMessageValue(value, endpoint));
     const transfer = values.flatMap((value) => markedTransfers.get(value) ?? []);
-    const messageValues = mappedValues.map((mappedValue) => mappedValue[0]);
-    const additionalTransfers = mappedValues.flatMap((mappedValue) => mappedValue[1]);
-    return { value: messageValues, transfer: [...transfer, ...additionalTransfers] };
+    return { value: messageValues, transfer };
 }
 function getPostMessageData(value, endpoint) {
-    const [messageValue, additionalTransfers] = getRpcMessageValue(value, endpoint);
-    const transfer = markedTransfers.get(value) ?? [];
-    return { value: messageValue, transfer: [...transfer, ...additionalTransfers] };
+    const messageValue = getRpcMessageValue(value, endpoint);
+    const transfer = markedTransfers.get(value);
+    return { value: messageValue, transfer };
+}
+function getAdapterOrProxy(exposing, endpoint) {
+    return adapterTargets.has(exposing)
+        ? createAdapterValue(exposing, adapterTargets.get(exposing), endpoint)
+        : createProxyValue(exposing, endpoint);
 }
 function getRpcMessageValue(value, endpoint) {
+    const adapter = adapterTargets.get(value);
+    if (isDefined(adapter)) {
+        return createAdapterValue(value, adapter, endpoint);
+    }
     if (proxyTargets.has(value)) {
         return createProxyValue(value, endpoint);
     }
     if (serializationTargets.has(value)) {
         const options = serializationTargets.get(value);
-        const transfer = [];
-        const replacer = getRpcProxySerializationReplacer(endpoint, transfer);
-        const serialized = serialize(value, { ...options, replacers: [replacer, ...options?.replacers ?? []] });
-        return [{ type: 'serialized', value: serialized, options }, transfer];
+        const proxyReplacer = getRpcProxySerializationReplacer(endpoint);
+        const serialized = serialize(value, { ...options, replacers: [proxyReplacer, rpcAdapterReplacer, ...options?.replacers ?? []], data: { ...options?.data, rpcEndpoint: endpoint } });
+        return { type: 'serialized', value: serialized, options };
     }
-    return [{ type: 'raw', value }, []];
+    return { type: 'raw', value };
 }
 function createProxyValue(value, endpoint) {
-    const id = getRandomString(24);
-    if (endpoint.supportsTransfers) {
-        const { port1, port2 } = new MessageChannel();
-        const newEndpoint = new MessagePortRpcEndpoint(port1);
-        newEndpoint.start();
-        exposeObject(value, newEndpoint, id);
-        return [{ type: 'proxy', id, port: port2 }, [port2]];
+    const channel = endpoint.openChannel();
+    exposeObject(value, channel);
+    return { type: 'proxy', channel: channel.id };
+}
+function createAdapterValue(value, adapter, endpoint) {
+    const channel = endpoint.openChannel();
+    const { data, transfer } = adapter.adaptSource(value, channel) ?? {}; // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+    if (isDefined(transfer)) {
+        for (const transferValue of transfer) {
+            Rpc.transfer(value, transferValue);
+        }
     }
-    exposeObject(value, endpoint, id);
-    return [{ type: 'proxy', id }, []];
+    return { type: 'adapter', adapter: `RpcAdapter:${adapter.name}`, channel: channel.id, data };
 }
 function parseRpcMessageValues(values, endpoint) {
     return values.map((value) => parseRpcMessageValue(value, endpoint));
@@ -220,12 +239,23 @@ function parseRpcMessageValue(value, endpoint) {
         }
         case 'throw': {
             const remoteError = new RpcRemoteError(value.error);
-            throw new RpcError('Received error from remote.', remoteError);
+            throw new RpcError(`Received error from remote: ${remoteError.message}`, remoteError);
         }
         case 'proxy': {
-            const proxyEndpoint = (isDefined(value.port)) ? new MessagePortRpcEndpoint(value.port) : endpoint;
-            proxyEndpoint.start();
-            return createProxy(proxyEndpoint, value.id);
+            const channel = endpoint.getChannel(value.channel);
+            const proxy = createProxy(channel);
+            channelFinalizationRegistry.register(proxy, { channel });
+            return proxy;
+        }
+        case 'adapter': {
+            const channel = endpoint.getChannel(value.channel);
+            const adapter = adapters.get(value.adapter);
+            if (isUndefined(adapter)) {
+                throw new NotSupportedError(`No adapter registration for "${value.adapter}" found.`);
+            }
+            const adaptedValue = adapter.adaptTarget(value.data, channel);
+            channelFinalizationRegistry.register(adaptedValue, { channel });
+            return adaptedValue;
         }
         default:
             throw new Error(`Type ${value.type} not supported`);
@@ -243,17 +273,31 @@ function deref(object, path, skipLast = false) {
     }
     return { parent, value };
 }
-class RpcProxy {
-}
-registerSerializer(RpcProxy, 'RpcProxy', () => _throw(new Error('Not supported.')), (data, _, { rpcEndpoint }) => parseRpcMessageValue({ type: 'proxy', ...data }, rpcEndpoint));
-function getRpcProxySerializationReplacer(endpoint, transfer) {
+registerSerializer(RpcProxy, 'RpcProxy', () => _throw(new NotSupportedError('Serialization not supported for rpc proxy.')), (data, _, { rpcEndpoint }) => parseRpcMessageValue({ type: 'proxy', ...data }, rpcEndpoint));
+function getRpcProxySerializationReplacer(endpoint) {
     function rpcProxySerializationReplacer(value) {
         if (!proxyTargets.has(value)) {
             return value;
         }
-        const [proxy, proxyTransfer] = createProxyValue(value, endpoint);
-        transfer.push(...proxyTransfer);
-        return { '<RpcProxy>': { id: proxy.id, port: proxy.port } };
+        const proxy = createProxyValue(value, endpoint);
+        return { '<RpcProxy>': valueOfType({ channel: proxy.channel }) };
     }
     return rpcProxySerializationReplacer;
 }
+function rpcAdapterReplacer(value, serializationData) {
+    const adapter = adapterTargets.get(value);
+    if (isUndefined(adapter)) {
+        return value;
+    }
+    const channel = serializationData.rpcEndpoint.openChannel();
+    const { data, transfer } = adapter.adaptSource(value, channel) ?? {}; // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+    if (isDefined(transfer)) {
+        if (isDefined(serializationData.transfer)) {
+            serializationData.transfer.push(...transfer);
+        }
+        else {
+            serializationData.transfer = transfer;
+        }
+    }
+    return { [`<RpcAdapter:${adapter.name}>`]: valueOfType({ channel: channel.id, data }) };
+}

package/serializer/serializable.d.ts

@@ -6,8 +6,8 @@ export declare const Serializable: {
 export type DereferenceCallback = (dereferenced: unknown) => void;
 export type TryDereference = (value: unknown, callback: DereferenceCallback) => boolean;
 export interface Serializable<T, Data> {
-    [Serializable.serialize](instance: T, context: Record): Data;
-    [Serializable.deserialize](data: Data, tryDereference: TryDereference, context: Record): T;
+    [Serializable.serialize](instance: T, context: Record | undefined): Data;
+    [Serializable.deserialize](data: Data, tryDereference: TryDereference, context: Record | undefined): T;
 }
 export type SerializableType<T, Data> = Type<Serializable<T, Data>>;
 export type SerializeFunction<T, Data> = Serializable<T, Data>[typeof Serializable.serialize];

package/serializer/serializer.js

@@ -19,7 +19,7 @@ export function serialize(_value, options = {}, references = new Map(), queue =
     let value = _value;
     if (isDefined(options.replacers)) {
         for (const replacer of options.replacers) {
-            value = replacer(value);
+            value = replacer(value, options.data);
         }
     }
     const type = typeof value;
@@ -31,7 +31,7 @@ export function serialize(_value, options = {}, references = new Map(), queue =
     }
     if ((path == '$') && isDefined(options.context)) {
         for (const entry of objectEntries(options.context)) {
-            references.set(entry[1], `$['__context__']['${entry[0]}']`);
+            references.set(entry[1], `$['__context__']['${String(entry[0])}']`);
         }
     }
     const reference = references.get(value);
@@ -97,7 +97,7 @@ export function serialize(_value, options = {}, references = new Map(), queue =
             const typeString = getTypeString(serializableType);
             const nonPrimitive = { [typeString]: null };
             queue.add(() => {
-                const data = registration.serializer.call(value, value, options.data ?? {});
+                const data = registration.serializer.call(value, value, options.data);
                 (nonPrimitive[typeString] = (registration.serializeData != false) ? serialize(data, options, references, queue, `${path}['${typeString}']`) : data);
             });
             result = nonPrimitive;
@@ -130,7 +130,7 @@ function _deserialize(serialized, context, path, depth) {
     if (type == 'object') {
         if ((depth == 0) && isDefined(context.options.context)) {
             for (const entry of objectEntries(context.options.context)) {
-                context.references.set(`$['__context__']['${entry[0]}']`, entry[1]);
+                context.references.set(`$['__context__']['${String(entry[0])}']`, entry[1]);
             }
         }
         const entries = objectEntries(serialized);
@@ -180,7 +180,7 @@ function _deserialize(serialized, context, path, depth) {
                     context.addToDeserializeQueue(() => {
                         const deserializedData = _deserialize(nonPrimitiveData, context, `${path}['<${nonPrimitiveType}>']`, depth + 1);
                         context.addToDeserializeQueue(() => {
-                            const deserialized = registration.deserializer(deserializedData, context.tryAddToDerefQueue, context.options.data ?? {});
+                            const deserialized = registration.deserializer(deserializedData, context.tryAddToDerefQueue, context.options.data);
                             ForwardRef.setRef(forwardRef, deserialized);
                         }, depth);
                     }, depth);

package/serializer/types.d.ts

@@ -1,8 +1,8 @@
-import type { AbstractConstructor, JsonPrimitive, Nested, Record, StringMap } from '../types.js';
+import type { AbstractConstructor, JsonPrimitive, Nested, Record } from '../types.js';
 declare const serializedSymbol: unique symbol;
 declare const stringSerializedSymbol: unique symbol;
 declare const decycledSymbol: unique symbol;
-export type SerializationReplacer = (value: any) => any;
+export type SerializationReplacer = (value: any, data?: Record) => any;
 export type TypeField<T extends string> = `<${T}>`;
 export type NonPrimitive<TypeName extends string = string, Data = unknown> = Record<TypeField<TypeName>, Data>;
 export type RawNonPrimitive = NonPrimitive<typeof rawNonPrimitiveType, any>;
@@ -45,14 +45,14 @@ export type SerializationOptions = {
      *
      * Only first level of object is referenced. For example for `{ foo: { bar: 'baz' } }` there will be one context entry having { bar: 'baz' }
      */
-    context?: StringMap<object | Function | string | symbol | bigint>;
+    context?: Record;
     /**
      * Disables dereferencing of ForwardRefs. Only useful for debugging (when implementing custom serializers) and curiosity
      * @default false
      */
     doNotDereferenceForwardRefs?: boolean;
     /**
-     * Data to be used on de/serialization handlers
+     * Data to be used on de/serialization handlers and replacers
      */
     data?: Record;
 };

package/threading/thread-pool.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
+import type * as NodeWorkerThreads from 'node:worker_threads';
+import type { LiteralUnion } from 'type-fest';
 import type { AsyncDisposable } from '../disposable/index.js';
 import { disposeAsync } from '../disposable/index.js';
 import type { Logger } from '../logger/index.js';
-import type * as NodeWorkerThreads from 'node:worker_threads';
 import type { ThreadWorker } from './thread-worker.js';
 export type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
     threadCount?: number;
@@ -15,6 +16,6 @@ export declare class ThreadPool implements AsyncDisposable {
     dispose(): Promise<void>;
     [disposeAsync](): Promise<void>;
     getProcessor<T extends ThreadWorker>(name?: string): (...args: Parameters<T>) => Promise<ReturnType<T>>;
-    process<T extends ThreadWorker>(name: string, ...args: Parameters<T>): Promise<ReturnType<T>>;
+    process<T extends ThreadWorker>(name: LiteralUnion<'default', string>, ...args: Parameters<T>): Promise<ReturnType<T>>;
     private spawn;
 }

package/threading/thread-pool.js

@@ -2,6 +2,7 @@ import { disposeAsync } from '../disposable/index.js';
 import { isNode } from '../environment.js';
 import { dynamicImport } from '../import.js';
 import { Pool } from '../pool/index.js';
+import { MessagePortRpcEndpoint } from '../rpc/endpoints/message-port.rpc-endpoint.js';
 import { Rpc } from '../rpc/index.js';
 let spawnWorker;
 if (isNode) {
@@ -35,12 +36,12 @@ export class ThreadPool {
     }
     async process(name, ...args) {
         return this.pool.use(async (entry) => {
-            const hasRemote = entry.remotes.has(name);
-            const remote = hasRemote ? entry.remotes.get(name) : await Rpc.connect(entry.worker, `thread-worker:${name}`);
-            if (!hasRemote) {
+            if (!entry.remotes.has(name)) {
+                const rpcEndpoint = MessagePortRpcEndpoint.from(entry.worker);
+                const remote = await Rpc.connect(rpcEndpoint, `thread-worker:${name}`);
                 entry.remotes.set(name, remote);
             }
-            return remote(...args);
+            return entry.remotes.get(name)(...args);
         });
     }
     async spawn() {

package/threading/thread-worker.d.ts

@@ -1,3 +1,2 @@
-import type { RpcEndpointSource } from '../rpc/index.js';
 export type ThreadWorker = (...args: any[]) => any | Promise<any>;
-export declare function exposeThreadWorker<T extends ThreadWorker>(worker: T, endpointOrSource: RpcEndpointSource, name?: string): void;
+export declare function exposeThreadWorker<T extends ThreadWorker>(worker: T, name?: string): void;

package/threading/thread-worker.js

@@ -1,4 +1,4 @@
 import { Rpc } from '../rpc/index.js';
-export function exposeThreadWorker(worker, endpointOrSource, name = 'default') {
-    Rpc.expose(worker, endpointOrSource, `thread-worker:${name}`);
+export function exposeThreadWorker(worker, name = 'default') {
+    Rpc.expose(worker, `thread-worker:${name}`);
 }

package/utils/throw.d.ts

@@ -1,2 +1,2 @@
 export declare function _throw(value: any): never;
-export declare function deferThrow(value: any): () => never;
+export declare function deferThrow(valueProvider: () => any): () => never;

package/utils/throw.js

@@ -1,9 +1,8 @@
 export function _throw(value) {
     throw value;
 }
-export function deferThrow(value) {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
+export function deferThrow(valueProvider) {
     return function deferThrow() {
-        throw value;
+        throw valueProvider();
     };
 }

package/utils/timer.d.ts

@@ -2,6 +2,7 @@ export declare class Timer {
     private elapsedNanoseconds;
     private begin?;
     constructor(start?: boolean);
+    static startNew(): Timer;
     static measure(func: () => any): number;
     static measureAsync(func: () => Promise<any>): Promise<number>;
     start(): void;

package/utils/timer.js

@@ -20,14 +20,16 @@ else {
     getDuration = (begin) => (Date.now() - begin) * nsPerMs;
 }
 export class Timer {
-    elapsedNanoseconds;
+    elapsedNanoseconds = 0;
     begin;
     constructor(start = false) {
-        this.elapsedNanoseconds = 0;
         if (start) {
             this.start();
         }
     }
+    static startNew() {
+        return new Timer(true);
+    }
     static measure(func) {
         const timer = new Timer(true);
         func();

package/rpc/rpc-endpoint.d.ts

@@ -1,11 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { RpcMessage, RpcMessageValue } from './model.js';
-export declare abstract class RpcEndpoint {
-    abstract readonly supportsTransfers: boolean;
-    abstract readonly message$: Observable<RpcMessage>;
-    request(message: RpcMessage, transfer?: any[]): Promise<RpcMessageValue>;
-    respond(id: string, value: RpcMessageValue, transfer?: any[]): Promise<void>;
-    abstract start(): void;
-    abstract close(): void;
-    abstract postMessage(data: any, transfer?: any[]): void | Promise<void>;
-}

package/rpc/rpc-endpoint.js

@@ -1,18 +0,0 @@
-import { filter, firstValueFrom } from 'rxjs';
-export class RpcEndpoint {
-    async request(message, transfer) {
-        const response$ = this.message$.pipe(filter((incomingMessage) => (incomingMessage.type == 'response') && (incomingMessage.id == message.id)));
-        const $response = firstValueFrom(response$);
-        await this.postMessage(message, transfer);
-        const response = await $response;
-        return response.value;
-    }
-    async respond(id, value, transfer) {
-        const message = {
-            id,
-            type: 'response',
-            value
-        };
-        await this.postMessage(message, transfer);
-    }
-}