@vampgg/utils 1.0.0-beta.1

package/dist/ws-channel.mjs

@@ -0,0 +1,520 @@
+import { Message } from "./bebop.mjs";
+import { createEventIterator } from "./create-event-iterator.mjs";
+import { createDuplexIterator } from "./create-duplex-iterator.mjs";
+import { ConsoleLogger, Deadline, TempoError, TempoStatusCode, TempoUtil, TempoVersion, parseCredential } from "@tempojs/common";
+import { BaseChannel, InsecureChannelCredential } from "@tempojs/client";
+import { EventEmitter } from "tseep";
+import { Websocket, WebsocketEvent } from "websocket-ts";
+//#region src/ws-channel.ts
+var ExistingWebSocket = class extends Websocket {
+	constructor(ws, protocols, options) {
+		super(ws.url, protocols, options);
+		this._underlyingWebsocket = ws;
+	}
+	tryConnect() {
+		this._underlyingWebsocket.addEventListener(WebsocketEvent.open, this.handleOpenEvent);
+		this._underlyingWebsocket.addEventListener(WebsocketEvent.close, this.handleCloseEvent);
+		this._underlyingWebsocket.addEventListener(WebsocketEvent.error, this.handleErrorEvent);
+		this._underlyingWebsocket.addEventListener(WebsocketEvent.message, this.handleMessageEvent);
+		return this._underlyingWebsocket;
+	}
+};
+/**
+* Represents a Tempo channel for communication with a remote server.
+*/
+var TempoWSChannel = class TempoWSChannel extends BaseChannel {
+	static defaultMaxRetryAttempts = 5;
+	static defaultMaxReceiveMessageSize = 1024 * 1024 * 4;
+	static defaultMaxSendMessageSize = 1024 * 1024 * 4;
+	static defaultCredential = InsecureChannelCredential.create();
+	static defaultContentType = "bebop";
+	ws;
+	events = new EventEmitter();
+	pending = /* @__PURE__ */ new Map();
+	closed = false;
+	isSecure;
+	credential;
+	userAgent;
+	maxReceiveMessageSize;
+	maxSendMessageSize;
+	_url;
+	_wsOptions;
+	get log() {
+		return this.logger;
+	}
+	/**
+	* Constructs a new TempoChannel instance.
+	*
+	* @param {URL} target - The target URL for the channel.
+	* @param {TempoWSChannelOptions} options - The configuration options for the channel.
+	* @protected
+	*/
+	constructor(target, options) {
+		const url = target instanceof URL ? target : new URL(target.url);
+		super(url, options.logger ?? new ConsoleLogger("TempoWSChannel"), options.contentType ?? TempoWSChannel.defaultContentType);
+		this.logger.trace("creating new TempoWSChannel");
+		this._url = url;
+		this._wsOptions = options;
+		this.isSecure = target.protocol === "https:" || target.protocol === "wss:";
+		this.credential = options.credential ?? TempoWSChannel.defaultCredential;
+		if (!this.isSecure && !(this.credential instanceof InsecureChannelCredential) && options.unsafeUseInsecureChannelCallCredential !== true) throw new Error("Cannot use secure credential with insecure channel");
+		this.maxReceiveMessageSize = options.maxReceiveMessageSize ?? TempoWSChannel.defaultMaxReceiveMessageSize;
+		this.maxSendMessageSize = options.maxSendMessageSize ?? TempoWSChannel.defaultMaxSendMessageSize;
+		this.userAgent = TempoUtil.buildUserAgent("javascript", TempoVersion, void 0, { runtime: TempoUtil.getEnvironmentName() });
+		this._setupWebSocket(target);
+		this.logger.trace(`created new TempoWSChannel for ${url.href} / ${this.userAgent}`);
+	}
+	/**
+	* Creates a new TempoChannel instance for the specified address.
+	*
+	* @param {string | URL} address - The target address as a string or URL object.
+	* @param {TempoChannelOptions} [options] - Optional configuration options for the channel.
+	* @returns {TempoChannel} - A new TempoChannel instance.
+	*/
+	static forWebSocket(target, options) {
+		options ??= {};
+		return new TempoWSChannel(target, options);
+	}
+	/**
+	* Creates a new TempoChannel instance for the specified address.
+	*
+	* @param {string | URL} address - The target address as a string or URL object.
+	* @param {TempoChannelOptions} [options] - Optional configuration options for the channel.
+	* @returns {TempoChannel} - A new TempoChannel instance.
+	*/
+	static forAddress(address, options) {
+		if (!address) throw new Error("no address");
+		if (typeof address === "string") address = new URL(address);
+		options ??= {};
+		return new TempoWSChannel(address, options);
+	}
+	_setupWebSocket(target) {
+		if (target instanceof URL) this.ws = new Websocket(target.toString(), [], this._wsOptions);
+		else this.ws = new ExistingWebSocket(target, [], this._wsOptions);
+		this.ws.binaryType = this._wsOptions.binaryType || "arraybuffer";
+		this.ws.addEventListener(WebsocketEvent.open, () => {
+			this.logger.trace(`opened TempoWSChannel for ${this._url.href} / ${this.userAgent}`);
+		});
+		this.ws.addEventListener(WebsocketEvent.close, (ws) => {
+			if (this.closed) return;
+			if (ws.lastConnection === void 0) return;
+			this.logger.trace(`closed TempoWSChannel for ${this._url.href} / ${this.userAgent}`);
+			this.close(new TempoError(TempoStatusCode.UNAVAILABLE, "channel closed"));
+		});
+		this.ws.addEventListener(WebsocketEvent.error, (ws) => {
+			if (this.closed) return;
+			if (ws.lastConnection === void 0) return;
+			this.close(new TempoError(TempoStatusCode.UNAVAILABLE, "channel transport error"));
+		});
+		this.ws.addEventListener(WebsocketEvent.message, (_ws, ev) => {
+			const byteLength = typeof ev.data === "string" ? ev.data.length : ev.data.byteLength;
+			if (byteLength > this.maxReceiveMessageSize) {
+				this.logger.error(`inbound frame ${byteLength}B exceeds maxReceiveMessageSize ${this.maxReceiveMessageSize}B; dropping`);
+				return;
+			}
+			let message;
+			if (typeof ev.data === "string") message = Message(JSON.parse(ev.data));
+			else message = Message(Message.decode(new Uint8Array(ev.data)));
+			const messageId = message.messageId;
+			this.events.emit(messageId, message);
+			this.logger.trace(`received new message ${messageId}`);
+		});
+	}
+	_reconnect() {
+		this.ws.close();
+		this._setupWebSocket(new URL(this._url.href));
+	}
+	async removeCredential() {
+		await this.credential.removeCredential();
+	}
+	async getCredential() {
+		return await this.credential.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);
+			this.send(init);
+		}).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()) this.send(Message({
+					...init,
+					data: new Uint8Array(method.serialize(value))
+				}));
+				this.send(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 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);
+			this.send(init);
+			return () => {
+				this.events.off(messageId, eventHandler);
+				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+				if (!terminated && !this.closed) this.send(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.send(Message({
+				...init,
+				data: new Uint8Array(method.serialize(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 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);
+				if (!terminated && !this.closed) this.send(Message({
+					messageId,
+					methodId: init.methodId,
+					status: TempoStatusCode.CANCELLED,
+					data: new Uint8Array(),
+					timestamp: /* @__PURE__ */ new Date()
+				}));
+			};
+		});
+	}
+	/**
+	* 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.
+	*/
+	async createRequest(payload, _context, method, options) {
+		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());
+		const credentialHeader = await this.credential.getHeader();
+		if (credentialHeader) requestInit.authorization = credentialHeader.value;
+		return Message(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.
+	*/
+	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) {
+			const credential = parseCredential(responseCredential);
+			if (!credential) throw new TempoError(TempoStatusCode.INVALID_ARGUMENT, "unable to parse credentials received on 'tempo-credential' header");
+			await this.credential.storeCredential(credential);
+		}
+	}
+	async waitForOpen() {
+		const maxAttempts = 2;
+		let lastError;
+		for (let attempt = 0; attempt < maxAttempts; attempt++) {
+			if (attempt > 0) {
+				await new Promise((r) => setTimeout(r, 100));
+				this._reconnect();
+			}
+			const state = this.ws.readyState;
+			if (state === 1) return;
+			if (state === 2 || state === 3) throw new TempoError(TempoStatusCode.UNAVAILABLE, "socket is closing or closed");
+			try {
+				await Deadline.after(5, "seconds").executeWithinDeadline(() => new Promise((resolve, reject) => {
+					const teardown = () => {
+						this.ws.removeEventListener(WebsocketEvent.open, onOpen);
+						this.ws.removeEventListener(WebsocketEvent.error, onError);
+						this.ws.removeEventListener(WebsocketEvent.close, onClose);
+					};
+					const onOpen = () => {
+						teardown();
+						resolve();
+					};
+					const onError = (ws, event) => {
+						teardown();
+						const message = event.message;
+						const detail = typeof message === "string" ? message : event.type;
+						reject(new TempoError(TempoStatusCode.UNAVAILABLE, `socket error before open: ${detail}`));
+					};
+					const onClose = () => {
+						teardown();
+						reject(new TempoError(TempoStatusCode.UNAVAILABLE, "socket closed before open"));
+					};
+					this.ws.addEventListener(WebsocketEvent.open, onOpen);
+					this.ws.addEventListener(WebsocketEvent.error, onError);
+					this.ws.addEventListener(WebsocketEvent.close, onClose);
+				}));
+				return;
+			} catch (err) {
+				lastError = err;
+				if (attempt < maxAttempts - 1 && err instanceof TempoError && err.message.startsWith("socket error before open")) continue;
+				throw err;
+			}
+		}
+		throw lastError ?? new TempoError(TempoStatusCode.UNAVAILABLE, "socket error before open");
+	}
+	send(message) {
+		const frame = Message.encode(message);
+		if (frame.length > this.maxSendMessageSize) throw new TempoError(TempoStatusCode.INVALID_ARGUMENT, `outbound frame ${frame.length}B exceeds maxSendMessageSize ${this.maxSendMessageSize}B`);
+		this.ws.send(frame);
+	}
+	/**
+	* Tear down the channel: reject every in-flight unary/client-stream call,
+	* remove all event listeners, and close the socket. Idempotent and safe to
+	* invoke from the socket `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");
+		for (const reject of this.pending.values()) reject(err);
+		this.pending.clear();
+		this.events.removeAllListeners();
+		try {
+			this.ws.close();
+		} catch {}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startUnary}
+	*/
+	async startUnary(request, context, method, options) {
+		try {
+			await this.waitForOpen();
+			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) {
+			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 {
+			await this.waitForOpen();
+			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) {
+			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 {
+			await this.waitForOpen();
+			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) {
+			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 {
+			await this.waitForOpen();
+			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) {
+			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 { TempoWSChannel };

package/dist/ws-router.d.mts

@@ -0,0 +1,52 @@
+import { Message } from "./bebop.mjs";
+import { TempoLogger } from "@tempojs/common";
+import { AuthInterceptor, BaseRouter, ServiceRegistry, TempoRouterConfiguration } from "@tempojs/server";
+
+//#region src/ws-router.d.ts
+interface GenericWs {
+  send(message: string | Blob | BufferSource): void;
+}
+/**
+ * Client-metadata keys under which {@link TempoWsRouter.process} exposes the
+ * current call's message/method ids to a service handler (read via
+ * `context.clientMetadata`). A streaming handler persists these so the
+ * hibernation-safe broadcast path can re-frame server->client pushes.
+ */
+declare const STREAM_MESSAGE_ID_KEY = "tempo-message-id";
+declare const STREAM_METHOD_ID_KEY = "tempo-method-id";
+/**
+ * Build an encoded server-stream frame identical to the one {@link TempoWsRouter}
+ * emits from a streaming handler: status OK, the given `methodId`/`messageId`, and
+ * the already-serialized record bytes `data`. Used by the hibernation-safe
+ * broadcast path to push frames over a live socket WITHOUT a live generator — the
+ * client's server-stream iterator matches them by `messageId` exactly like
+ * generator-emitted frames. `messageId` MUST be the original observe call's id
+ * (a GUID); `methodId` its method id.
+ */
+declare function encodeServerStreamFrame(opts: {
+  methodId: number;
+  messageId: string;
+  data: Uint8Array;
+}): Uint8Array;
+declare class TempoWsRouter<Context, Ws extends GenericWs = WebSocket, Env extends [Context, Ws] = [Context, Ws]> extends BaseRouter<ArrayBuffer, Env, Message> {
+  private readonly events;
+  private readonly clientStreams;
+  private readonly serverStreams;
+  private readonly _streamEncodeCache;
+  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 DO socket
+   * close/error lifecycle). Emits a synthetic CANCELLED to each in-flight
+   * client/duplex stream so its generator ends, then clears all listeners.
+   */
+  closeConnection(): Promise<void>;
+  process(req: ArrayBuffer, response: Message, env: Env): Promise<void>;
+  handle(_request: ArrayBuffer, _env: Env): Promise<Message>;
+}
+//#endregion
+export { STREAM_MESSAGE_ID_KEY, STREAM_METHOD_ID_KEY, TempoWsRouter, encodeServerStreamFrame };