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

package/README.md

@@ -213,7 +213,7 @@ import { createEventIterator } from "@vampgg/utils/create-event-iterator";
 import type { Subscriber, Context, CleanupFn } from "@vampgg/utils/create-event-iterator";
 ```
 
-Converts any push-based event source (EventEmitter, WebSocket messages, browser events) into an `AsyncGenerator`. The subscriber receives `{ emit, cancel }` and returns an optional cleanup function.
+Converts any push-based event source (EventEmitter, WebSocket messages, browser events) into an `AsyncGenerator`. The subscriber receives `{ emit, cancel, error }` (`error(e)` surfaces a failure at the consumer instead of a clean end) and returns an optional cleanup function.
 
 ```ts
 const stream = createEventIterator<MyEvent>(({ emit, cancel }) => {
@@ -292,6 +292,25 @@ await channel.waitForOpen();
 
 All four tempo method types (unary, server-stream, client-stream, duplex) are supported with deadline and retry policy propagation.
 
+**Full client round-trip.** In practice you connect, obtain a tempo-generated client stub from the channel, and call RPC methods directly — the channel handles encoding, correlation, and streaming:
+
+```ts
+import { TempoWSChannel } from "@vampgg/utils/ws-channel";
+import { RpcClient, MutationScope } from "./bebop"; // your tempo-generated client + types
+
+const channel = TempoWSChannel.forAddress("wss://host/v1/game?ns=room1", { maxRetries: 3 });
+await channel.waitForOpen();
+
+const client = channel.getClient(RpcClient);
+
+const spawned = await client.spawn(entity); // unary
+for await (const scope of await client.observe(MutationScope({}))) {
+  // server-stream: each frame is a decoded record
+}
+
+channel.close();
+```
+
 ---
 
 ### `@vampgg/utils/ws-router` — WebSocket Tempo Server Router

package/dist/channel-core.d.mts

@@ -0,0 +1,139 @@
+import { Message } from "./bebop.mjs";
+import { BebopRecord } from "bebop";
+import { BaseChannel, CallOptions, ClientContext, MethodInfo, RetryPolicy } from "@tempojs/client";
+import { BebopContentType, Credential, Deadline, MethodType, TempoError, TempoLogger } from "@tempojs/common";
+import { EventEmitter } from "tseep";
+
+//#region src/channel-core.d.ts
+/**
+ * Shared client-channel core for the worker, WebSocket, and browser-extension
+ * transports.
+ *
+ * All three transports speak the same framed protocol: each request is a
+ * {@link Message} envelope matched to its response(s) by `messageId`, streamed
+ * frames reuse the envelope with fresh `data`, and a `CANCELLED` status frame
+ * terminates a stream. This class owns the protocol machinery — request
+ * construction, retry/deadline handling, response validation, the four RPC
+ * shapes (unary / client-stream / server-stream / duplex) and teardown —
+ * while subclasses supply only the genuinely transport-specific pieces via the
+ * small protected surface ({@link sendFrame} et al).
+ *
+ * Internal to `@vampgg/utils`; the public transports are the concrete
+ * subclasses (`TempoWorkerChannel`, `TempoWSChannel`, `TempoExtensionChannel`).
+ */
+declare abstract class CoreChannel extends BaseChannel {
+  /** Per-call response listeners keyed by messageId (response demultiplexing). */
+  readonly events: EventEmitter<Record<string, (message: Message) => void>>;
+  /**
+   * Reject callbacks for in-flight unary / client-stream calls, keyed by
+   * messageId. Lets close()/error() settle parked requests instead of hanging.
+   */
+  readonly pending: Map<string, (e: unknown) => void>;
+  protected closed: boolean;
+  /** The reason a closed channel settles calls that arrive after teardown. */
+  protected closeReason?: TempoError;
+  protected readonly userAgent: string;
+  protected constructor(target: URL, logger: TempoLogger, contentType: BebopContentType);
+  /**
+   * Encodes and delivers one {@link Message} frame over the transport. May be
+   * synchronous (worker / WebSocket) or asynchronous (extension runtime); the
+   * call sites await or attach rejection handlers as each RPC shape requires.
+   */
+  protected abstract sendFrame(message: Message): void | Promise<unknown>;
+  /** Generates the unique id for an outgoing request envelope. */
+  protected generateMessageId(): string;
+  /**
+   * Serializes one streamed record into the bytes placed on `Message.data`.
+   * The default copies out of bebop's shared static write buffer so a later
+   * encode cannot clobber the payload; a transport whose {@link sendFrame}
+   * consumes the bytes synchronously may override to skip the copy.
+   */
+  protected serializeStreamItem(method: MethodInfo<BebopRecord, BebopRecord>, value: BebopRecord): Uint8Array;
+  /** Awaited before every RPC (e.g. the WebSocket transport's open gate). */
+  protected beforeCall(): Promise<void>;
+  /** Value for the request `authorization` field, if the transport has one. */
+  protected getAuthorizationValue(): Promise<string | undefined>;
+  /**
+   * Persists a `credential` value received on a response envelope. The default
+   * ignores it (the worker/extension transports carry no credentials).
+   */
+  protected storeResponseCredential(_credential: string): Promise<void>;
+  /**
+   * Whether tearing down a duplex-stream consumer sends a terminal CANCELLED
+   * frame to the server (the WebSocket transport does; the others do not).
+   */
+  protected readonly cancelDuplexOnCleanup: boolean;
+  /** Runs inside {@link close} before in-flight calls are rejected. */
+  protected onClosing(_reason: TempoError): void;
+  /** Runs at the end of {@link close} to tear down the underlying transport. */
+  protected closeTransport(): void;
+  /**
+   * Tear down the channel: reject every in-flight unary/client-stream call,
+   * remove all event listeners, and dispose the underlying transport.
+   * Idempotent and safe to invoke from transport close/error events or by an
+   * explicit caller.
+   */
+  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>;
+  protected fetchUnary(init: Message, options?: CallOptions): Promise<Message>;
+  protected fetchClientStream(init: Message, method: MethodInfo<BebopRecord, BebopRecord>, generator: () => AsyncGenerator<BebopRecord, void, undefined>, options?: CallOptions): Promise<Message>;
+  protected fetchServerStream(init: Message, context: ClientContext, method: MethodInfo<BebopRecord, BebopRecord>, options?: CallOptions): AsyncGenerator<BebopRecord, void, undefined>;
+  protected fetchDuplexStream(init: Message, context: ClientContext, method: MethodInfo<BebopRecord, BebopRecord>, generator: () => AsyncGenerator<BebopRecord, void, undefined>, options?: CallOptions): AsyncGenerator<BebopRecord, void, undefined>;
+  /**
+   * Creates the request {@link Message} envelope for a given payload, context,
+   * method and optional call options.
+   *
+   * @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<Message>} A Promise resolving to the created request envelope.
+   * @throws {TempoError} Throws an error if there's a problem while getting the credential header.
+   */
+  protected createRequest(payload: Uint8Array, _context: ClientContext, method: MethodInfo<BebopRecord, BebopRecord>, options?: CallOptions): Promise<Message>;
+  /**
+   * Processes the headers of the response from the server, validating their
+   * integrity and correctness, and hands any received credential to the
+   * transport via {@link storeResponseCredential}.
+   *
+   * @param {Message} 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.
+   */
+  protected processResponseHeaders(response: Message, _context: ClientContext, _methodType: MethodType): Promise<void>;
+  private raiseCallError;
+  /**
+   * {@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 { CoreChannel };

package/dist/channel-core.mjs

@@ -0,0 +1,411 @@
+import { Message } from "./bebop.mjs";
+import { createEventIterator } from "./create-event-iterator.mjs";
+import { createDuplexIterator } from "./create-duplex-iterator.mjs";
+import { BaseChannel } from "@tempojs/client";
+import { TempoError, TempoStatusCode, TempoUtil, TempoVersion } from "@tempojs/common";
+import { EventEmitter } from "tseep";
+//#region src/channel-core.ts
+/**
+* Shared client-channel core for the worker, WebSocket, and browser-extension
+* transports.
+*
+* All three transports speak the same framed protocol: each request is a
+* {@link Message} envelope matched to its response(s) by `messageId`, streamed
+* frames reuse the envelope with fresh `data`, and a `CANCELLED` status frame
+* terminates a stream. This class owns the protocol machinery — request
+* construction, retry/deadline handling, response validation, the four RPC
+* shapes (unary / client-stream / server-stream / duplex) and teardown —
+* while subclasses supply only the genuinely transport-specific pieces via the
+* small protected surface ({@link sendFrame} et al).
+*
+* Internal to `@vampgg/utils`; the public transports are the concrete
+* subclasses (`TempoWorkerChannel`, `TempoWSChannel`, `TempoExtensionChannel`).
+*/
+var CoreChannel = class extends BaseChannel {
+	/** Per-call response listeners keyed by messageId (response demultiplexing). */
+	events = new EventEmitter();
+	/**
+	* Reject callbacks for in-flight unary / client-stream calls, keyed by
+	* messageId. Lets close()/error() settle parked requests instead of hanging.
+	*/
+	pending = /* @__PURE__ */ new Map();
+	closed = false;
+	/** The reason a closed channel settles calls that arrive after teardown. */
+	closeReason;
+	userAgent;
+	constructor(target, logger, contentType) {
+		super(target, logger, contentType);
+		this.userAgent = TempoUtil.buildUserAgent("javascript", TempoVersion, void 0, { runtime: TempoUtil.getEnvironmentName() });
+	}
+	/** Generates the unique id for an outgoing request envelope. */
+	generateMessageId() {
+		return crypto.randomUUID();
+	}
+	/**
+	* Serializes one streamed record into the bytes placed on `Message.data`.
+	* The default copies out of bebop's shared static write buffer so a later
+	* encode cannot clobber the payload; a transport whose {@link sendFrame}
+	* consumes the bytes synchronously may override to skip the copy.
+	*/
+	serializeStreamItem(method, value) {
+		return new Uint8Array(method.serialize(value));
+	}
+	/** Awaited before every RPC (e.g. the WebSocket transport's open gate). */
+	async beforeCall() {}
+	/** Value for the request `authorization` field, if the transport has one. */
+	async getAuthorizationValue() {}
+	/**
+	* Persists a `credential` value received on a response envelope. The default
+	* ignores it (the worker/extension transports carry no credentials).
+	*/
+	async storeResponseCredential(_credential) {}
+	/**
+	* Whether tearing down a duplex-stream consumer sends a terminal CANCELLED
+	* frame to the server (the WebSocket transport does; the others do not).
+	*/
+	cancelDuplexOnCleanup = false;
+	/** Runs inside {@link close} before in-flight calls are rejected. */
+	onClosing(_reason) {}
+	/** Runs at the end of {@link close} to tear down the underlying transport. */
+	closeTransport() {}
+	/**
+	* Tear down the channel: reject every in-flight unary/client-stream call,
+	* remove all event listeners, and dispose the underlying transport.
+	* Idempotent and safe to invoke from transport close/error events or by an
+	* explicit caller.
+	*/
+	close(reason) {
+		if (this.closed) return;
+		this.closed = true;
+		const err = reason ?? new TempoError(TempoStatusCode.CANCELLED, "channel disposed");
+		this.closeReason = err;
+		this.onClosing(err);
+		for (const reject of this.pending.values()) reject(err);
+		this.pending.clear();
+		this.events.removeAllListeners();
+		this.closeTransport();
+	}
+	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) => {
+			if (this.closed) {
+				reject(this.closeReason ?? new TempoError(TempoStatusCode.CANCELLED, "channel disposed"));
+				return;
+			}
+			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 sent = this.sendFrame(init);
+			if (sent instanceof Promise) sent.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) => {
+			if (this.closed) {
+				reject(this.closeReason ?? new TempoError(TempoStatusCode.CANCELLED, "channel disposed"));
+				return;
+			}
+			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.sendFrame(Message({
+					...init,
+					data: this.serializeStreamItem(method, value)
+				}));
+				await this.sendFrame(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;
+					}
+					await this.processResponseHeaders(message, context, method.type);
+					const record = method.deserialize(message.data);
+					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.sendFrame(init);
+			return () => {
+				this.events.off(messageId, eventHandler);
+				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+				if (terminated || this.closed) return;
+				this.sendFrame(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.sendFrame(Message({
+				...init,
+				data: this.serializeStreamItem(method, value)
+			}));
+		}, ({ emit, cancel, error }) => {
+			let terminated = false;
+			let onAbort;
+			const eventHandler = async (message) => {
+				try {
+					if (message.status === TempoStatusCode.CANCELLED) {
+						terminated = true;
+						cancel();
+						return;
+					}
+					await this.processResponseHeaders(message, context, method.type);
+					const record = method.deserialize(message.data);
+					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);
+				if (this.cancelDuplexOnCleanup && !terminated && !this.closed) this.sendFrame(Message({
+					messageId,
+					methodId: init.methodId,
+					status: TempoStatusCode.CANCELLED,
+					data: new Uint8Array(),
+					timestamp: /* @__PURE__ */ new Date()
+				}));
+			};
+		});
+	}
+	/**
+	* Creates the request {@link Message} envelope for a given payload, context,
+	* method and optional call options.
+	*
+	* @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<Message>} A Promise resolving to the created request envelope.
+	* @throws {TempoError} Throws an error if there's a problem while getting the credential header.
+	*/
+	async createRequest(payload, _context, method, options) {
+		const requestInit = {
+			messageId: this.generateMessageId(),
+			methodId: method.id,
+			data: new Uint8Array(payload),
+			timestamp: /* @__PURE__ */ new Date()
+		};
+		if (options?.deadline) requestInit.deadline = new Date(options.deadline.toUnixTimestamp());
+		const authorization = await this.getAuthorizationValue();
+		if (authorization !== void 0) requestInit.authorization = authorization;
+		return Message(requestInit);
+	}
+	/**
+	* Processes the headers of the response from the server, validating their
+	* integrity and correctness, and hands any received credential to the
+	* transport via {@link storeResponseCredential}.
+	*
+	* @param {Message} 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.
+	*/
+	async 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);
+		}
+		const responseCredential = response.credential;
+		if (responseCredential) await this.storeResponseCredential(responseCredential);
+	}
+	/**
+	* Runs the shared error-hook + error-mapping tail of every `start*` method.
+	* Always throws.
+	*/
+	async raiseCallError(context, 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);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+		}
+		throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+	}
+	/**
+	* {@inheritDoc BaseChannel.startUnary}
+	*/
+	async startUnary(request, context, method, options) {
+		try {
+			await this.beforeCall();
+			const requestData = method.serialize(request);
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = await 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);
+			await this.processResponseHeaders(response, context, method.type);
+			if (this.hooks !== void 0) await this.hooks.executeResponseHooks(context);
+			const record = method.deserialize(response.data);
+			if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+			return record;
+		} catch (e) {
+			return await this.raiseCallError(context, e);
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startClientStream}
+	*/
+	async startClientStream(generator, context, method, options) {
+		try {
+			await this.beforeCall();
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = await 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);
+			await this.processResponseHeaders(response, context, method.type);
+			const record = this.deserializeResponse(response.data, method);
+			if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+			return record;
+		} catch (e) {
+			return await this.raiseCallError(context, e);
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startServerStream}
+	*/
+	async startServerStream(request, context, method, options) {
+		try {
+			await this.beforeCall();
+			const requestData = method.serialize(request);
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = await 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) {
+			return await this.raiseCallError(context, e);
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startDuplexStream}
+	*/
+	async startDuplexStream(generator, context, method, options) {
+		try {
+			await this.beforeCall();
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = await 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) {
+			return await this.raiseCallError(context, e);
+		}
+	}
+};
+//#endregion
+export { CoreChannel };