@vampgg/utils 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/worker-channel.d.mts

@@ -1,24 +1,21 @@
-import { BebopRecord } from "bebop";
-import { BebopContentType, Credential, Deadline, TempoError } from "@tempojs/common";
-import { BaseChannel, CallCredential, CallOptions, ClientContext, MethodInfo, RetryPolicy, TempoChannelOptions } from "@tempojs/client";
+import { Message } from "./bebop.mjs";
+import { CoreChannel } from "./channel-core.mjs";
+import { CallCredential, TempoChannelOptions } from "@tempojs/client";
+import { BebopContentType, TempoError } from "@tempojs/common";
 
 //#region src/worker-channel.d.ts
 /**
  * Represents a Tempo channel for communication with a worker thread.
  */
-declare class TempoWorkerChannel extends BaseChannel {
+declare class TempoWorkerChannel extends CoreChannel {
   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>;
   /**
@@ -29,71 +26,18 @@ declare class TempoWorkerChannel extends BaseChannel {
    * @protected
    */
   constructor(url: string, options?: TempoChannelOptions);
+  /** Reject a pending `ready` before in-flight calls are settled. */
+  protected onClosing(reason: TempoError): void;
+  /** Terminate the owned worker on {@link CoreChannel.close}. */
+  protected closeTransport(): void;
+  protected generateMessageId(): string;
   /**
-   * 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.
+   * {@inheritDoc CoreChannel.sendFrame}
    *
-   * @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}
+   * `.slice()` owns a fresh ArrayBuffer; transferring it cannot detach bebop's
+   * process-wide singleton write buffer.
    */
-  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>>;
+  protected sendFrame(message: Message): void;
 }
 //#endregion
 export { TempoWorkerChannel };

package/dist/worker-channel.mjs

@@ -1,26 +1,20 @@
 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";
+import { CoreChannel } from "./channel-core.mjs";
+import { InsecureChannelCredential } from "@tempojs/client";
+import { ConsoleLogger, TempoError, TempoStatusCode } from "@tempojs/common";
 //#region src/worker-channel.ts
 /**
 * Represents a Tempo channel for communication with a worker thread.
 */
-var TempoWorkerChannel = class TempoWorkerChannel extends BaseChannel {
+var TempoWorkerChannel = class TempoWorkerChannel extends CoreChannel {
 	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;
 	}
@@ -37,7 +31,6 @@ var TempoWorkerChannel = class TempoWorkerChannel extends BaseChannel {
 	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;
@@ -81,338 +74,28 @@ var TempoWorkerChannel = class TempoWorkerChannel extends BaseChannel {
 		});
 		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();
+	/** Reject a pending `ready` before in-flight calls are settled. */
+	onClosing(reason) {
+		this._rejectReady?.(reason);
+	}
+	/** Terminate the owned worker on {@link CoreChannel.close}. */
+	closeTransport() {
 		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;
+	generateMessageId() {
+		return Bun.randomUUIDv7();
 	}
 	/**
-	* 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.
+	* {@inheritDoc CoreChannel.sendFrame}
 	*
-	* @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}
+	* `.slice()` owns a fresh ArrayBuffer; transferring it cannot detach bebop's
+	* process-wide singleton write buffer.
 	*/
-	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 });
-		}
+	sendFrame(message) {
+		const frame = Message.encode(message).slice();
+		this._worker.postMessage(frame, [frame.buffer]);
 	}
 };
 //#endregion

package/dist/worker-router.d.mts

@@ -4,15 +4,9 @@ import { AuthInterceptor, BaseRouter, ServiceRegistry, TempoRouterConfiguration
 
 //#region src/worker-router.d.ts
 declare class TempoWorkerRouter<TEnv> extends BaseRouter<Buffer, TEnv, Message> {
-  private readonly events;
-  private readonly clientStreams;
+  private readonly core;
   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