@vampgg/utils 1.0.0-beta.1

package/dist/worker-channel.d.mts

@@ -0,0 +1,99 @@
+import { BebopRecord } from "bebop";
+import { BebopContentType, Credential, Deadline, TempoError } from "@tempojs/common";
+import { BaseChannel, CallCredential, CallOptions, ClientContext, MethodInfo, RetryPolicy, TempoChannelOptions } from "@tempojs/client";
+
+//#region src/worker-channel.d.ts
+/**
+ * Represents a Tempo channel for communication with a worker thread.
+ */
+declare class TempoWorkerChannel extends BaseChannel {
+  static readonly defaultMaxRetryAttempts: number;
+  static readonly defaultCredential: CallCredential;
+  static readonly defaultContentType: BebopContentType;
+  private readonly _worker;
+  private readonly events;
+  private readonly userAgent;
+  private _open;
+  private _ready;
+  private _resolveReady?;
+  private _rejectReady?;
+  readonly pending: Map<string, (e: unknown) => void>;
+  private closed;
+  get worker(): Bun.Worker;
+  get ready(): Promise<void>;
+  /**
+   * Constructs a new TempoChannel instance.
+   *
+   * @param {URL} target - The target URL for the channel.
+   * @param {TempoChannelOptions} options - The configuration options for the channel.
+   * @protected
+   */
+  constructor(url: string, options?: TempoChannelOptions);
+  /**
+   * Tear down the channel: reject every in-flight call and a pending `ready`,
+   * remove all listeners, and terminate the owned worker. Idempotent.
+   */
+  close(reason?: TempoError): void;
+  removeCredential(): Promise<void>;
+  getCredential(): Promise<Credential | undefined>;
+  /**
+   * Executes a function with retries according to the provided retry policy.
+   * The function will be retried if it fails with a TempoError and its status code is included in the retryableStatusCodes of the retry policy.
+   * If a deadline is provided, the deadline for each attempt will be managed by the provided deadline, but the deadline will not be reset upon each retry.
+   *
+   * @template T - The type of the result returned by the function.
+   * @param {((retryAttempt: number) => Promise<T>)} func - A function that returns a Promise with a result. The function will receive a number indicating the current retry attempt.
+   * @param {RetryPolicy} retryPolicy - An object defining the retry policy, including maxAttempts, initialBackoff, maxBackoff, backoffMultiplier, and retryableStatusCodes.
+   * @param {Deadline} [deadline] - An optional deadline object that manages the timeout for each attempt.
+   * @param {AbortController} [abortController] - An optional AbortController instance to cancel the function execution.
+   * @returns {Promise<T>} - A Promise that resolves with the result of the function if it completes within the deadline and retry policy constraints.
+   * @throws {Error} - If the function execution fails and the error does not match the retry policy, or if the maximum number of attempts is reached without a successful result.
+   */
+  executeWithRetry<T>(func: (retryAttempt: number) => Promise<T>, retryPolicy: RetryPolicy, deadline?: Deadline, abortController?: AbortController): Promise<T>;
+  private fetchUnary;
+  private fetchClientStream;
+  private fetchServerStream;
+  private fetchDuplexStream;
+  /**
+   * Creates a `RequestInit` object for a given payload, context, method and optional call options.
+   * This object can be used to make an HTTP request using the Fetch API.
+   *
+   * @private
+   * @param {Uint8Array} payload - The payload to be sent in the request.
+   * @param {ClientContext} context - The context of the client making the request.
+   * @param {MethodInfo<BebopRecord, BebopRecord>} method - Information about the method being called.
+   * @param {CallOptions | undefined} options - Optional configuration for the call.
+   * @returns {Promise<RequestInit>} A Promise resolving to the created `RequestInit` object.
+   * @throws {TempoError} Throws an error if there's a problem while getting the credential header.
+   */
+  private createRequest;
+  /**
+   * Processes the headers of the response from the server, validating their integrity and correctness.
+   * Also sets the incoming metadata from the response headers to the provided context.
+   *
+   * @private
+   * @param {Response} response - The response received from the server.
+   * @param {ClientContext} context - The context of the client making the request.
+   * @param {MethodType} methodType - The type of method being called.
+   * @throws {TempoError} Throws an error if any validation checks fail or if there's a problem parsing or storing credentials.
+   */
+  private processResponseHeaders;
+  /**
+   * {@inheritDoc BaseChannel.startUnary}
+   */
+  startUnary<TRequest extends BebopRecord, TResponse extends BebopRecord>(request: TRequest, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<TResponse>;
+  /**
+   * {@inheritDoc BaseChannel.startClientStream}
+   */
+  startClientStream<TRequest extends BebopRecord, TResponse extends BebopRecord>(generator: () => AsyncGenerator<TRequest, void, undefined>, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<TResponse>;
+  /**
+   * {@inheritDoc BaseChannel.startServerStream}
+   */
+  startServerStream<TRequest extends BebopRecord, TResponse extends BebopRecord>(request: TRequest, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<AsyncGenerator<TResponse, void, undefined>>;
+  /**
+   * {@inheritDoc BaseChannel.startDuplexStream}
+   */
+  startDuplexStream<TRequest extends BebopRecord, TResponse extends BebopRecord>(generator: () => AsyncGenerator<TRequest, void, undefined>, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<AsyncGenerator<TResponse, void, undefined>>;
+}
+//#endregion
+export { TempoWorkerChannel };

package/dist/worker-channel.mjs

@@ -0,0 +1,419 @@
+import { Message } from "./bebop.mjs";
+import { createEventIterator } from "./create-event-iterator.mjs";
+import { createDuplexIterator } from "./create-duplex-iterator.mjs";
+import { ConsoleLogger, ExecutionEnvironment, Metadata, TempoError, TempoStatusCode, TempoUtil, TempoVersion } from "@tempojs/common";
+import { BaseChannel, InsecureChannelCredential } from "@tempojs/client";
+import { EventEmitter } from "tseep";
+//#region src/worker-channel.ts
+/**
+* Represents a Tempo channel for communication with a worker thread.
+*/
+var TempoWorkerChannel = class TempoWorkerChannel extends BaseChannel {
+	static defaultMaxRetryAttempts = 5;
+	static defaultCredential = InsecureChannelCredential.create();
+	static defaultContentType = "bebop";
+	_worker;
+	events = new EventEmitter();
+	userAgent;
+	_open = false;
+	_ready;
+	_resolveReady;
+	_rejectReady;
+	pending = /* @__PURE__ */ new Map();
+	closed = false;
+	get worker() {
+		return this._worker;
+	}
+	get ready() {
+		return this._ready;
+	}
+	/**
+	* Constructs a new TempoChannel instance.
+	*
+	* @param {URL} target - The target URL for the channel.
+	* @param {TempoChannelOptions} options - The configuration options for the channel.
+	* @protected
+	*/
+	constructor(url, options = {}) {
+		super(new URL(url, "worker://"), options.logger ?? new ConsoleLogger("TempoWorkerChannel"), options.contentType ?? TempoWorkerChannel.defaultContentType);
+		this.logger.trace("creating new TempoWorkerChannel");
+		this.userAgent = TempoUtil.buildUserAgent("javascript", TempoVersion, void 0, { runtime: TempoUtil.getEnvironmentName() });
+		this._ready = new Promise((resolve, reject) => {
+			this._resolveReady = resolve;
+			this._rejectReady = reject;
+		});
+		this._ready.catch(() => {});
+		const worker = this._worker = new Worker(url);
+		worker.addEventListener("message", (ev) => {
+			const resolveReadyOnce = () => {
+				if (!this._open) {
+					this._open = true;
+					this._resolveReady?.();
+				}
+			};
+			if (!ev.data.length) {
+				resolveReadyOnce();
+				return;
+			}
+			const message = Message.decode(ev.data);
+			if (message.messageId === "__ready__") {
+				resolveReadyOnce();
+				return;
+			}
+			resolveReadyOnce();
+			if (!message.methodId) {
+				this.logger.trace("ignoring control frame without methodId");
+				return;
+			}
+			const messageId = message.messageId;
+			this.logger.trace(`received new message ${messageId}`);
+			this.events.emit(messageId, message);
+		});
+		worker.addEventListener("open", (e) => {
+			this.logger.trace(`opened TempoWorkerChannel for ${url} / ${this.userAgent}`, { event: e });
+		});
+		worker.addEventListener("close", (e) => {
+			this.logger.trace(`closed TempoWorkerChannel for ${url} / ${this.userAgent}`, { event: e });
+			this.close(new TempoError(TempoStatusCode.UNAVAILABLE, "channel closed"));
+		});
+		worker.addEventListener("error", () => {
+			this.close(new TempoError(TempoStatusCode.UNAVAILABLE, "channel transport error"));
+		});
+		this.logger.debug(`created new TempoWorkerChannel`);
+	}
+	/**
+	* Tear down the channel: reject every in-flight call and a pending `ready`,
+	* remove all listeners, and terminate the owned worker. Idempotent.
+	*/
+	close(reason) {
+		if (this.closed) return;
+		this.closed = true;
+		const err = reason ?? new TempoError(TempoStatusCode.CANCELLED, "channel disposed");
+		this._rejectReady?.(err);
+		for (const reject of this.pending.values()) reject(err);
+		this.pending.clear();
+		this.events.removeAllListeners();
+		try {
+			this._worker.terminate();
+		} catch {}
+	}
+	async removeCredential() {}
+	async getCredential() {}
+	/**
+	* Executes a function with retries according to the provided retry policy.
+	* The function will be retried if it fails with a TempoError and its status code is included in the retryableStatusCodes of the retry policy.
+	* If a deadline is provided, the deadline for each attempt will be managed by the provided deadline, but the deadline will not be reset upon each retry.
+	*
+	* @template T - The type of the result returned by the function.
+	* @param {((retryAttempt: number) => Promise<T>)} func - A function that returns a Promise with a result. The function will receive a number indicating the current retry attempt.
+	* @param {RetryPolicy} retryPolicy - An object defining the retry policy, including maxAttempts, initialBackoff, maxBackoff, backoffMultiplier, and retryableStatusCodes.
+	* @param {Deadline} [deadline] - An optional deadline object that manages the timeout for each attempt.
+	* @param {AbortController} [abortController] - An optional AbortController instance to cancel the function execution.
+	* @returns {Promise<T>} - A Promise that resolves with the result of the function if it completes within the deadline and retry policy constraints.
+	* @throws {Error} - If the function execution fails and the error does not match the retry policy, or if the maximum number of attempts is reached without a successful result.
+	*/
+	async executeWithRetry(func, retryPolicy, deadline, abortController) {
+		let attempt = 0;
+		let lastError;
+		const execute = deadline ? (retryAttempt) => deadline.executeWithinDeadline(async () => await func(retryAttempt), abortController) : (retryAttempt) => func(retryAttempt);
+		while (attempt < retryPolicy.maxAttempts) try {
+			return await execute(attempt);
+		} catch (error) {
+			if (!(error instanceof Error)) throw new TempoError(TempoStatusCode.UNKNOWN, `unexpected error`, { data: error });
+			lastError = error;
+			if (!(error instanceof TempoError) || !retryPolicy.retryableStatusCodes.includes(error.status)) throw error;
+			const backoffWithJitter = Math.min(retryPolicy.initialBackoff.multiply(Math.pow(retryPolicy.backoffMultiplier, attempt)).totalMilliseconds, retryPolicy.maxBackoff.totalMilliseconds) * (Math.random() * .5 + .75);
+			await new Promise((resolve) => setTimeout(resolve, backoffWithJitter));
+			attempt++;
+		}
+		if (abortController && lastError !== void 0 && !(lastError instanceof Error && lastError.name === "AbortError") && !(lastError instanceof TempoError && lastError.status === TempoStatusCode.ABORTED)) abortController.abort();
+		return Promise.reject(lastError || new TempoError(TempoStatusCode.DEADLINE_EXCEEDED, "Failed to execute function with retry policy"));
+	}
+	async fetchUnary(init, options) {
+		const messageId = init.messageId;
+		let listener;
+		let onAbort;
+		const cleanup = () => {
+			this.events.off(messageId, listener);
+			if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+			this.pending.delete(messageId);
+		};
+		return await new Promise((resolve, reject) => {
+			listener = (message) => resolve(message);
+			this.pending.set(messageId, reject);
+			if (options?.controller) {
+				onAbort = () => reject(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
+				options.controller.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			this.events.on(messageId, listener);
+			const frame = Message.encode(init).slice();
+			this.worker.postMessage(frame, [frame.buffer]);
+		}).finally(cleanup);
+	}
+	async fetchClientStream(init, method, generator, options) {
+		const messageId = init.messageId;
+		let listener;
+		let onAbort;
+		const cleanup = () => {
+			this.events.off(messageId, listener);
+			if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+			this.pending.delete(messageId);
+		};
+		return await new Promise((resolve, reject) => {
+			listener = (message) => resolve(message);
+			this.pending.set(messageId, reject);
+			if (options?.controller) {
+				onAbort = () => reject(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
+				options.controller.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			this.events.on(messageId, listener);
+			runGenerator.call(this).catch(reject);
+			async function runGenerator() {
+				for await (const value of generator()) {
+					const frame = Message.encode(Message({
+						...init,
+						data: new Uint8Array(value.encode())
+					})).slice();
+					this.worker.postMessage(frame, [frame.buffer]);
+				}
+				const frame = Message.encode(Message({
+					...init,
+					status: TempoStatusCode.CANCELLED,
+					data: new Uint8Array()
+				})).slice();
+				this.worker.postMessage(frame, [frame.buffer]);
+			}
+		}).finally(cleanup);
+	}
+	fetchServerStream(init, context, method, options) {
+		const messageId = init.messageId;
+		return createEventIterator(({ emit, cancel, error }) => {
+			let terminated = false;
+			let onAbort;
+			const eventHandler = async (message) => {
+				try {
+					if (message.status === TempoStatusCode.CANCELLED) {
+						terminated = true;
+						cancel();
+						return;
+					}
+					this.processResponseHeaders(message, context, method.type);
+					const requestData = message.data;
+					const record = method.deserialize(requestData);
+					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+					emit(record);
+				} catch (e) {
+					error(e);
+				}
+			};
+			if (options?.controller) {
+				onAbort = () => error(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
+				options.controller.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			this.events.on(messageId, eventHandler);
+			const frame = Message.encode(init).slice();
+			this.worker.postMessage(frame, [frame.buffer]);
+			return () => {
+				this.events.off(messageId, eventHandler);
+				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+				if (terminated || this.closed) return;
+				const cancelMessage = {
+					messageId,
+					methodId: init.methodId,
+					status: TempoStatusCode.CANCELLED,
+					data: new Uint8Array(),
+					timestamp: /* @__PURE__ */ new Date()
+				};
+				const cancelFrame = Message.encode(cancelMessage).slice();
+				this.worker.postMessage(cancelFrame, [cancelFrame.buffer]);
+			};
+		});
+	}
+	fetchDuplexStream(init, context, method, generator, options) {
+		const messageId = init.messageId;
+		return createDuplexIterator(generator(), (value) => {
+			const frame = Message.encode(Message({
+				...init,
+				data: new Uint8Array(method.serialize(value))
+			})).slice();
+			this.worker.postMessage(frame, [frame.buffer]);
+		}, ({ emit, cancel, error }) => {
+			let onAbort;
+			const eventHandler = async (message) => {
+				try {
+					if (message.status === TempoStatusCode.CANCELLED) {
+						cancel();
+						return;
+					}
+					this.processResponseHeaders(message, context, method.type);
+					const requestData = message.data;
+					const record = method.deserialize(requestData);
+					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+					emit(record);
+				} catch (e) {
+					error(e);
+				}
+			};
+			if (options?.controller) {
+				onAbort = () => error(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
+				options.controller.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			this.events.on(messageId, eventHandler);
+			return () => {
+				this.events.off(messageId, eventHandler);
+				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+			};
+		});
+	}
+	/**
+	* Creates a `RequestInit` object for a given payload, context, method and optional call options.
+	* This object can be used to make an HTTP request using the Fetch API.
+	*
+	* @private
+	* @param {Uint8Array} payload - The payload to be sent in the request.
+	* @param {ClientContext} context - The context of the client making the request.
+	* @param {MethodInfo<BebopRecord, BebopRecord>} method - Information about the method being called.
+	* @param {CallOptions | undefined} options - Optional configuration for the call.
+	* @returns {Promise<RequestInit>} A Promise resolving to the created `RequestInit` object.
+	* @throws {TempoError} Throws an error if there's a problem while getting the credential header.
+	*/
+	createRequest(payload, _context, method, options) {
+		const customMetadata = new Metadata();
+		customMetadata.set("path", `/${method.service}/${method.name}`);
+		customMetadata.set("service-name", method.service);
+		if (ExecutionEnvironment.isBrowser || ExecutionEnvironment.isWebWorker) customMetadata.set("x-user-agent", this.userAgent);
+		else customMetadata.set("user-agent", this.userAgent);
+		const requestInit = {
+			messageId: Bun.randomUUIDv7(),
+			methodId: method.id,
+			data: new Uint8Array(payload),
+			timestamp: /* @__PURE__ */ new Date()
+		};
+		if (options?.deadline) requestInit.deadline = new Date(options.deadline.toUnixTimestamp());
+		return requestInit;
+	}
+	/**
+	* Processes the headers of the response from the server, validating their integrity and correctness.
+	* Also sets the incoming metadata from the response headers to the provided context.
+	*
+	* @private
+	* @param {Response} response - The response received from the server.
+	* @param {ClientContext} context - The context of the client making the request.
+	* @param {MethodType} methodType - The type of method being called.
+	* @throws {TempoError} Throws an error if any validation checks fail or if there's a problem parsing or storing credentials.
+	*/
+	processResponseHeaders(response, _context, _methodType) {
+		const statusCode = response.status;
+		if (statusCode === void 0) throw new TempoError(TempoStatusCode.UNKNOWN, "tempo-status missing from response.");
+		if (statusCode !== TempoStatusCode.OK && statusCode !== TempoStatusCode.CANCELLED) {
+			let tempoMessage = response.msg;
+			if (!tempoMessage) tempoMessage = "unknown error";
+			throw new TempoError(statusCode, tempoMessage);
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startUnary}
+	*/
+	async startUnary(request, context, method, options) {
+		try {
+			const requestData = request.encode();
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = this.createRequest(requestData, context, method, options);
+			let response;
+			if (options?.retryPolicy) response = await this.executeWithRetry(async (retryAttempt) => {
+				if (retryAttempt > 0) requestInit.previousAttempts = retryAttempt;
+				return await this.fetchUnary(requestInit);
+			}, options.retryPolicy, options.deadline, options.controller);
+			else if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
+				return await this.fetchUnary(requestInit, options);
+			}, options.controller);
+			else response = await this.fetchUnary(requestInit, options);
+			this.processResponseHeaders(response, context, method.type);
+			if (this.hooks !== void 0) await this.hooks.executeResponseHooks(context);
+			const responseData = response.data;
+			const record = method.deserialize(responseData);
+			if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+			return record;
+		} catch (e) {
+			if (this.hooks !== void 0 && e instanceof Error) await this.hooks.executeErrorHooks(context, e);
+			if (e instanceof TempoError) throw e;
+			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
+			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startClientStream}
+	*/
+	async startClientStream(generator, context, method, options) {
+		try {
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = this.createRequest(new Uint8Array(), context, method, options);
+			let response;
+			if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
+				return await this.fetchClientStream(requestInit, method, generator, options);
+			}, options.controller);
+			else response = await this.fetchClientStream(requestInit, method, generator, options);
+			this.processResponseHeaders(response, context, method.type);
+			const responseData = response.data;
+			const record = this.deserializeResponse(responseData, method);
+			if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+			return record;
+		} catch (e) {
+			if (this.hooks !== void 0 && e instanceof Error) await this.hooks.executeErrorHooks(context, e);
+			if (e instanceof TempoError) throw e;
+			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
+			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startServerStream}
+	*/
+	async startServerStream(request, context, method, options) {
+		try {
+			const requestData = request.encode();
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = this.createRequest(requestData, context, method, options);
+			let response;
+			if (options?.retryPolicy) response = await this.executeWithRetry(async (retryAttempt) => {
+				if (retryAttempt > 0) requestInit.previousAttempts = retryAttempt;
+				return this.fetchServerStream(requestInit, context, method, options);
+			}, options.retryPolicy, options.deadline, options.controller);
+			else if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
+				return this.fetchServerStream(requestInit, context, method, options);
+			}, options.controller);
+			else response = this.fetchServerStream(requestInit, context, method, options);
+			return response;
+		} catch (e) {
+			if (this.hooks !== void 0 && e instanceof Error) await this.hooks.executeErrorHooks(context, e);
+			if (e instanceof TempoError) throw e;
+			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
+			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startDuplexStream}
+	*/
+	async startDuplexStream(generator, context, method, options) {
+		try {
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = this.createRequest(new Uint8Array(), context, method, options);
+			let response;
+			if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
+				return this.fetchDuplexStream(requestInit, context, method, generator, options);
+			}, options.controller);
+			else response = this.fetchDuplexStream(requestInit, context, method, generator, options);
+			return response;
+		} catch (e) {
+			if (this.hooks !== void 0 && e instanceof Error) await this.hooks.executeErrorHooks(context, e);
+			if (e instanceof TempoError) throw e;
+			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
+			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+		}
+	}
+};
+//#endregion
+export { TempoWorkerChannel };

package/dist/worker-router.d.mts

@@ -0,0 +1,26 @@
+import { Message } from "./bebop.mjs";
+import { TempoLogger } from "@tempojs/common";
+import { AuthInterceptor, BaseRouter, ServiceRegistry, TempoRouterConfiguration } from "@tempojs/server";
+
+//#region src/worker-router.d.ts
+declare class TempoWorkerRouter<TEnv> extends BaseRouter<Buffer, TEnv, Message> {
+  private readonly events;
+  private readonly clientStreams;
+  private readonly serverStreams;
+  constructor(logger: TempoLogger, registry: ServiceRegistry, configuration?: TempoRouterConfiguration, authInterceptor?: AuthInterceptor);
+  private setAuthContext;
+  private invokeUnaryMethod;
+  private invokeClientStreamMethod;
+  private invokeServerStreamMethod;
+  private invokeDuplexStreamMethod;
+  /**
+   * Tear down all open streams for this connection (driven by the host
+   * close/error lifecycle). Returns each server-stream generator and emits a
+   * synthetic CANCELLED to each client/duplex stream, then clears listeners.
+   */
+  closeConnection(): Promise<void>;
+  process(req: Uint8Array, response: Message, env: TEnv): Promise<void>;
+  handle(_request: string | Buffer, _env: TEnv): Promise<Message>;
+}
+//#endregion
+export { TempoWorkerRouter };