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

package/dist/extension-channel.d.mts

@@ -1,95 +1,39 @@
 import { Message } from "./bebop.mjs";
+import { CoreChannel } from "./channel-core.mjs";
 import { BebopRecord } from "bebop";
-import { BebopContentType, Credential, Deadline, TempoError } from "@tempojs/common";
-import { BaseChannel, CallOptions, ClientContext, MethodInfo, RetryPolicy, TempoChannelOptions } from "@tempojs/client";
+import { MethodInfo, TempoChannelOptions } from "@tempojs/client";
+import { BebopContentType, TempoError } from "@tempojs/common";
 
 //#region src/extension-channel.d.ts
 /**
  * Represents a Tempo channel for communication with a remote server.
  */
-declare class TempoExtensionChannel extends BaseChannel {
+declare class TempoExtensionChannel extends CoreChannel {
   static readonly defaultMaxRetryAttempts: number;
   static readonly defaultMaxReceiveMessageSize: number;
   static readonly defaultMaxSendMessageSize: number;
   static readonly defaultContentType: BebopContentType;
-  private readonly events;
-  private readonly userAgent;
-  readonly pending: Map<string, (e: unknown) => void>;
-  private closed;
   private readonly onMessage;
   /**
    * Constructs a new TempoChannel instance.
    *
-   * @param {URL} target - The target URL for the channel.
-   * @param {TempoWSChannelOptions} options - The configuration options for the channel.
-   * @protected
+   * @param {TempoChannelOptions} options - The configuration options for the channel.
    */
   constructor(options?: TempoChannelOptions);
+  /** Remove the runtime message listener before in-flight calls are settled. */
+  protected onClosing(_reason: TempoError): void;
   /**
-   * Tear down the channel: remove the runtime message listener, reject every
-   * in-flight call, and clear all event listeners. 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.serializeStreamItem}
    *
-   * @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}
+   * No copy: {@link sendMessage} encodes the frame synchronously, so the view
+   * into bebop's shared write buffer is consumed before it can be clobbered
+   * (each streamed send is awaited by the core for the same reason).
    */
-  startServerStream<TRequest extends BebopRecord, TResponse extends BebopRecord>(request: TRequest, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<AsyncGenerator<TResponse, void, undefined>>;
+  protected serializeStreamItem(method: MethodInfo<BebopRecord, BebopRecord>, value: BebopRecord): Uint8Array;
   /**
-   * {@inheritDoc BaseChannel.startDuplexStream}
+   * {@inheritDoc CoreChannel.sendFrame}
    */
-  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): Promise<unknown>;
   protected sendMessage(message: Message): Promise<unknown>;
 }
 //#endregion

package/dist/extension-channel.mjs

@@ -1,23 +1,17 @@
 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 } from "@tempojs/client";
-import { EventEmitter } from "tseep";
+import { CoreChannel } from "./channel-core.mjs";
+import "@tempojs/client";
+import { ConsoleLogger } from "@tempojs/common";
 import * as browser from "webextension-polyfill";
 //#region src/extension-channel.ts
 /**
 * Represents a Tempo channel for communication with a remote server.
 */
-var TempoExtensionChannel = class TempoExtensionChannel extends BaseChannel {
+var TempoExtensionChannel = class TempoExtensionChannel extends CoreChannel {
 	static defaultMaxRetryAttempts = 5;
 	static defaultMaxReceiveMessageSize = 1024 * 1024 * 4;
 	static defaultMaxSendMessageSize = 1024 * 1024 * 4;
 	static defaultContentType = "bebop";
-	events = new EventEmitter();
-	userAgent;
-	pending = /* @__PURE__ */ new Map();
-	closed = false;
 	onMessage = (msg) => {
 		let message;
 		try {
@@ -35,342 +29,38 @@ var TempoExtensionChannel = class TempoExtensionChannel extends BaseChannel {
 	/**
 	* Constructs a new TempoChannel instance.
 	*
-	* @param {URL} target - The target URL for the channel.
-	* @param {TempoWSChannelOptions} options - The configuration options for the channel.
-	* @protected
+	* @param {TempoChannelOptions} options - The configuration options for the channel.
 	*/
 	constructor(options = {}) {
 		super(new URL("runtime://"), options.logger ?? new ConsoleLogger("TempoExtensionChannel"), options.contentType ?? TempoExtensionChannel.defaultContentType);
 		this.logger.trace("creating new TempoExtensionChannel");
-		this.userAgent = TempoUtil.buildUserAgent("javascript", TempoVersion, void 0, { runtime: TempoUtil.getEnvironmentName() });
 		browser.runtime.onMessage.addListener(this.onMessage);
 		this.logger.debug(`created new TempoExtensionChannel`);
 	}
-	/**
-	* Tear down the channel: remove the runtime message listener, reject every
-	* in-flight call, and clear all event listeners. Idempotent.
-	*/
-	close(reason) {
-		if (this.closed) return;
-		this.closed = true;
+	/** Remove the runtime message listener before in-flight calls are settled. */
+	onClosing(_reason) {
 		try {
 			browser.runtime.onMessage.removeListener(this.onMessage);
 		} catch {}
-		const err = reason ?? new TempoError(TempoStatusCode.CANCELLED, "channel disposed");
-		for (const reject of this.pending.values()) reject(err);
-		this.pending.clear();
-		this.events.removeAllListeners();
 	}
-	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.
+	* {@inheritDoc CoreChannel.serializeStreamItem}
 	*
-	* @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.
+	* No copy: {@link sendMessage} encodes the frame synchronously, so the view
+	* into bebop's shared write buffer is consumed before it can be clobbered
+	* (each streamed send is awaited by the core for the same reason).
 	*/
-	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);
-			this.sendMessage(init).catch(reject);
-		}).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()) await this.sendMessage(Message({
-					...init,
-					data: method.serialize(value)
-				}));
-				await this.sendMessage(Message({
-					...init,
-					status: TempoStatusCode.CANCELLED,
-					data: new Uint8Array()
-				}));
-			}
-		}).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 responseData = message.data;
-					const record = method.deserialize(responseData);
-					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);
-			this.sendMessage(init);
-			return () => {
-				this.events.off(messageId, eventHandler);
-				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
-				if (terminated || this.closed) return;
-				this.sendMessage(Message({
-					messageId,
-					methodId: init.methodId,
-					status: TempoStatusCode.CANCELLED,
-					data: new Uint8Array(),
-					timestamp: /* @__PURE__ */ new Date()
-				}));
-			};
-		});
-	}
-	fetchDuplexStream(init, context, method, generator, options) {
-		const messageId = init.messageId;
-		return createDuplexIterator(generator(), (value) => {
-			this.sendMessage(Message({
-				...init,
-				data: method.serialize(value)
-			}));
-		}, ({ 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);
-			};
-		});
+	serializeStreamItem(method, value) {
+		return method.serialize(value);
 	}
 	/**
-	* 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.
+	* {@inheritDoc CoreChannel.sendFrame}
 	*/
-	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: crypto.randomUUID(),
-			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 = method.serialize(request);
-			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) 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) this.hooks.executeDecodeHooks(context, record);
-			return record;
-		} catch (e) {
-			if (this.hooks !== void 0 && e instanceof Error) 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 = method.serialize(request);
-			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) 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) 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) {
+		return this.sendMessage(message);
 	}
 	sendMessage(message) {
-		return browser.runtime.sendMessage(Array.apply(null, Message.encode(message)));
+		return browser.runtime.sendMessage(Array.from(Message.encode(message)));
 	}
 };
 //#endregion

package/dist/extension-router.d.mts

@@ -38,6 +38,10 @@ declare class TempoExtensionRouterConfiguration {
    * The maximum number of retry attempts for failed requests. Defaults to the value in `TempoRouterConfiguration.defaultMaxRetryAttempts`.
    */
   maxRetryAttempts?: number;
+  /**
+   * Optional flag to indicate whether the tempo version, runtime, and variant should be exposed in responses via X-Powered-By (and if the GET endpoint should be enabled). Defaults to false.
+   */
+  exposeTempo?: boolean;
   /**
    * Constructs a new instance of TempoRouterConfiguration with default values.
    */
@@ -132,14 +136,8 @@ declare abstract class ExtensionBaseRouter<TRequest, TEnvironment, TResponse> {
 declare class TempoExtensionRouter<Ctx extends {
   sender: Runtime.MessageSender;
 }> extends ExtensionBaseRouter<Message, Ctx, Message> {
-  private readonly events;
-  private readonly clientStreams;
+  private readonly core;
   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. Emits a synthetic CANCELLED
    * to each in-flight client/duplex stream so its generator ends, then clears