capnweb-auto-reconnect 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VastBlast
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# capnweb-auto-reconnect
+
+Small reconnecting WebSocket RPC session support for [`capnweb`](https://github.com/cloudflare/capnweb).
+
+I built this for my personal projects and decided to publish it in case anyone else needs it.
+
+- npm: https://www.npmjs.com/package/capnweb-auto-reconnect
+- capnweb: https://github.com/cloudflare/capnweb
+
+## Install
+
+```bash
+npm i capnweb-auto-reconnect
+```
+
+## Quick start
+
+```ts
+import { ReconnectingWebSocketRpcSession } from "capnweb-auto-reconnect";
+
+type MyApi = {
+  square(i: number): Promise<number>;
+};
+
+const session = new ReconnectingWebSocketRpcSession<MyApi>({
+    // `createWebSocket` must return a new socket each attempt.
+    createWebSocket: () => new WebSocket("wss://example.com/rpc"),
+});
+
+const rpc = await session.getRPC();
+console.log(await rpc.square(12)); // 144
+```
+
+## What it does
+
+- Keeps a capnweb RPC session connected over WebSocket.
+- Automatically reconnects after disconnects (configurable delay, max delay, and backoff factor).
+- Emits connection lifecycle hooks with connection IDs (`onOpen`/`onClose`).
+- Runs optional one-time startup logic with `onFirstInit` before the first open event.
+- Deduplicates concurrent `start()`/`getRPC()` calls while connecting.
+- Lets you pause/resume reconnecting with `stop()` and `start()`.
+
+## Example: lifecycle hooks
+
+```ts
+const session = new ReconnectingWebSocketRpcSession({
+    createWebSocket: () => new WebSocket("wss://example.com/rpc"),
+    reconnectOptions: { delayMs: 250, maxDelayMs: 5000, backoffFactor: 2 },
+    onFirstInit: async rpc => {
+        // Runs once after first successful open.
+        await rpc.warmup?.();
+    },
+});
+
+const offOpen = session.onOpen(({ connectionId, firstConnection }) => {
+    console.log("open", connectionId, { firstConnection });
+});
+
+const offClose = session.onClose(({ connectionId, intentional, error }) => {
+    console.log("close", connectionId, { intentional, error });
+});
+
+// Later, when done:
+offOpen();
+offClose();
+session.stop("app shutdown");
+```
+
+## Example: Node + `ws`
+
+```ts
+import { WebSocket } from "ws";
+import { ReconnectingWebSocketRpcSession } from "capnweb-auto-reconnect";
+
+const session = new ReconnectingWebSocketRpcSession({
+    createWebSocket: () => new WebSocket("ws://127.0.0.1:8787"),
+});
+
+const rpc = await session.start();
+await rpc.ping?.();
+```
+
+## API notes
+
+- `getRPC()` returns a live stub, connecting/reconnecting as needed.
+- `start()` resumes connection attempts if you previously called `stop()`.
+- `stop(reason?)` closes the current connection and pauses reconnecting.

package/dist/index.cjs

@@ -0,0 +1,313 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let capnweb = require("capnweb");
+
+//#region src/helpers.ts
+function closeEventToError(event) {
+	if (event.reason) return /* @__PURE__ */ new Error(`WebSocket closed: ${event.code} ${event.reason}`);
+	return /* @__PURE__ */ new Error(`WebSocket closed: ${event.code}`);
+}
+function toError(reason, fallbackMessage) {
+	if (reason instanceof Error) return reason;
+	if (typeof reason === "string" && reason.length > 0) return new Error(reason);
+	return new Error(fallbackMessage);
+}
+
+//#endregion
+//#region src/reconnectingWebsocket.ts
+const READY_STATE_OPEN = 1;
+const READY_STATE_CLOSING = 2;
+const READY_STATE_CLOSED = 3;
+var ConnectionAttemptCancelledError = class extends Error {
+	constructor() {
+		super("Connection attempt was cancelled by stop or replacement.");
+	}
+};
+/** Reconnecting wrapper around capnweb WebSocket RPC sessions. */
+var ReconnectingWebSocketRpcSession = class {
+	#connectPromise;
+	#activeConnection;
+	#connectionId = 0;
+	#lifecycleToken = 0;
+	#started = false;
+	#stopReason = /* @__PURE__ */ new Error("RPC session stopped.");
+	#firstInitDone = false;
+	#openedConnectionCount = 0;
+	#retryDelayWait;
+	#openListeners = /* @__PURE__ */ new Set();
+	#closeListeners = /* @__PURE__ */ new Set();
+	#reconnect;
+	#reconnectDelayMs;
+	#reconnectDelayMaxMs;
+	#reconnectBackoffFactor;
+	#nextReconnectDelayMs;
+	constructor(options) {
+		this.options = options;
+		const reconnectOptions = options.reconnectOptions;
+		this.#reconnect = reconnectOptions?.enabled ?? true;
+		this.#reconnectDelayMs = reconnectOptions?.delayMs ?? 250;
+		this.#reconnectDelayMaxMs = reconnectOptions?.maxDelayMs ?? 5e3;
+		this.#reconnectBackoffFactor = reconnectOptions?.backoffFactor ?? 2;
+		this.#nextReconnectDelayMs = this.#reconnectDelayMs;
+		if (!Number.isFinite(this.#reconnectDelayMs) || this.#reconnectDelayMs < 0) throw new RangeError("reconnectOptions.delayMs must be a finite number >= 0.");
+		if (!Number.isFinite(this.#reconnectDelayMaxMs) || this.#reconnectDelayMaxMs < this.#reconnectDelayMs) throw new RangeError("reconnectOptions.maxDelayMs must be >= reconnectOptions.delayMs.");
+		if (!Number.isFinite(this.#reconnectBackoffFactor) || this.#reconnectBackoffFactor < 1) throw new RangeError("reconnectOptions.backoffFactor must be a finite number >= 1.");
+		this.#started = true;
+		queueMicrotask(() => {
+			if (!this.#started) return;
+			this.#ensureConnected().catch(() => {});
+		});
+	}
+	/** True when `stop()` has been called and reconnecting is disabled. */
+	get isStopped() {
+		return !this.#started;
+	}
+	/** True when a fully-open RPC connection is currently available. */
+	get isConnected() {
+		const connection = this.#activeConnection;
+		return connection !== void 0 && connection.opened && !connection.closed;
+	}
+	/** Listen for each successful connection open. Returns an unsubscribe function. */
+	onOpen(listener) {
+		this.#openListeners.add(listener);
+		const connection = this.#activeConnection;
+		if (connection && connection.opened && !connection.closed) {
+			const event = {
+				connectionId: connection.id,
+				firstConnection: connection.firstConnection,
+				rpc: connection.rpc
+			};
+			try {
+				Promise.resolve(listener(event)).catch(() => {});
+			} catch {}
+		}
+		return () => this.#openListeners.delete(listener);
+	}
+	/** Listen for each opened connection close. Returns an unsubscribe function. */
+	onClose(listener) {
+		this.#closeListeners.add(listener);
+		return () => this.#closeListeners.delete(listener);
+	}
+	/** Returns a live RPC stub, starting or reconnecting if needed. */
+	async getRPC() {
+		const connection = this.#activeConnection;
+		if (connection && connection.opened && !connection.closed) return connection.rpc;
+		return this.start();
+	}
+	/** Starts (or resumes) connection attempts and resolves when ready. */
+	async start() {
+		this.#started = true;
+		return this.#ensureConnected();
+	}
+	/** Stops reconnecting and closes the active connection, if any. */
+	stop(reason = /* @__PURE__ */ new Error("RPC session was stopped by the application.")) {
+		this.#stopReason = reason;
+		this.#started = false;
+		this.#lifecycleToken++;
+		this.#interruptRetryDelay();
+		this.#nextReconnectDelayMs = this.#reconnectDelayMs;
+		const connection = this.#activeConnection;
+		if (connection) this.#disconnectConnection(connection, reason, true);
+		this.#connectPromise = void 0;
+	}
+	#ensureConnected() {
+		const connection = this.#activeConnection;
+		if (connection && connection.opened && !connection.closed) return Promise.resolve(connection.rpc);
+		if (this.#connectPromise) return this.#connectPromise;
+		const token = this.#lifecycleToken;
+		const promise = this.#connectUntilReady(token);
+		this.#connectPromise = promise;
+		const clearConnectPromise = () => {
+			if (this.#connectPromise === promise) this.#connectPromise = void 0;
+		};
+		promise.then(clearConnectPromise, clearConnectPromise);
+		return promise;
+	}
+	async #connectUntilReady(token) {
+		while (true) {
+			if (!this.#started) throw toError(this.#stopReason, "RPC session is stopped.");
+			if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();
+			try {
+				const rpc = await this.#connectOnce(token);
+				if (!this.#started) throw toError(this.#stopReason, "RPC session is stopped.");
+				if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();
+				const activeConnection = this.#activeConnection;
+				if (!activeConnection || activeConnection.closed || activeConnection.rpc !== rpc) throw new Error("Connection became unavailable before it was returned.");
+				this.#nextReconnectDelayMs = this.#reconnectDelayMs;
+				return rpc;
+			} catch (err) {
+				if (!this.#started) throw toError(this.#stopReason, "RPC session is stopped.");
+				if (err instanceof ConnectionAttemptCancelledError) throw err;
+				if (!this.#reconnect) throw err;
+				const delay = this.#nextReconnectDelayMs;
+				this.#nextReconnectDelayMs = Math.min(this.#reconnectDelayMaxMs, Math.ceil(this.#nextReconnectDelayMs * this.#reconnectBackoffFactor));
+				try {
+					await this.#waitForRetryDelay(delay, token);
+				} catch (waitError) {
+					if (!this.#started) throw toError(this.#stopReason, "RPC session is stopped.");
+					throw waitError;
+				}
+			}
+		}
+	}
+	async #connectOnce(token) {
+		const webSocket = await this.#createWebSocket();
+		if (!this.#started || token !== this.#lifecycleToken) {
+			this.#closeWebSocket(webSocket, "Connection attempt was replaced.");
+			throw new ConnectionAttemptCancelledError();
+		}
+		const rpc = (0, capnweb.newWebSocketRpcSession)(webSocket, this.options.localMain, this.options.rpcSessionOptions);
+		const connection = this.#installConnection(webSocket, rpc);
+		this.#activeConnection = connection;
+		const throwIfCancelled = () => {
+			if (this.#started && token === this.#lifecycleToken) return;
+			const error = new ConnectionAttemptCancelledError();
+			this.#disconnectConnection(connection, error, true);
+			throw error;
+		};
+		try {
+			await this.#waitUntilSocketOpen(webSocket);
+			if (connection.closed) throw new Error("WebSocket connection closed while opening.");
+			throwIfCancelled();
+			if (!this.#firstInitDone && this.options.onFirstInit) {
+				await this.options.onFirstInit(connection.rpc);
+				this.#firstInitDone = true;
+			}
+			if (connection.closed) throw new Error("WebSocket connection closed during initialization.");
+			throwIfCancelled();
+			connection.opened = true;
+			connection.firstConnection = this.#openedConnectionCount === 0;
+			this.#openedConnectionCount++;
+			this.#emitOpen({
+				connectionId: connection.id,
+				firstConnection: connection.firstConnection,
+				rpc: connection.rpc
+			});
+			if (connection.closed) throw new Error("WebSocket connection closed during open listeners.");
+			throwIfCancelled();
+			return connection.rpc;
+		} catch (err) {
+			this.#disconnectConnection(connection, err, false);
+			throw err;
+		}
+	}
+	#installConnection(webSocket, rpc) {
+		const connection = {
+			id: ++this.#connectionId,
+			webSocket,
+			rpc,
+			firstConnection: false,
+			opened: false,
+			closed: false,
+			removeTransportListeners: () => {}
+		};
+		const closeListener = (event) => this.#disconnectConnection(connection, closeEventToError(event), false);
+		const errorListener = () => this.#disconnectConnection(connection, /* @__PURE__ */ new Error("WebSocket connection failed."), false);
+		webSocket.addEventListener("close", closeListener);
+		webSocket.addEventListener("error", errorListener);
+		connection.removeTransportListeners = () => {
+			webSocket.removeEventListener("close", closeListener);
+			webSocket.removeEventListener("error", errorListener);
+		};
+		rpc.onRpcBroken((error) => this.#disconnectConnection(connection, error, false));
+		return connection;
+	}
+	#disconnectConnection(connection, error, intentional) {
+		if (connection.closed) return;
+		connection.closed = true;
+		connection.removeTransportListeners();
+		if (this.#activeConnection?.id === connection.id) this.#activeConnection = void 0;
+		const wasConnected = connection.opened;
+		this.#closeWebSocket(connection.webSocket, "RPC session reconnecting.");
+		try {
+			connection.rpc[Symbol.dispose]();
+		} catch {}
+		if (wasConnected) this.#emitClose({
+			connectionId: connection.id,
+			error,
+			intentional,
+			wasConnected
+		});
+		if (wasConnected && !intentional && this.#started && this.#reconnect) this.#ensureConnected().catch(() => {});
+	}
+	#emitOpen(event) {
+		for (const listener of this.#openListeners) try {
+			Promise.resolve(listener(event)).catch(() => {});
+		} catch {}
+	}
+	#emitClose(event) {
+		for (const listener of this.#closeListeners) try {
+			Promise.resolve(listener(event)).catch(() => {});
+		} catch {}
+	}
+	async #createWebSocket() {
+		return this.options.createWebSocket();
+	}
+	async #waitUntilSocketOpen(webSocket) {
+		if (webSocket.readyState === READY_STATE_OPEN) return;
+		if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) throw new Error("WebSocket is already closed.");
+		await new Promise((resolve, reject) => {
+			const openListener = () => {
+				cleanup();
+				resolve();
+			};
+			const closeListener = (event) => {
+				cleanup();
+				reject(closeEventToError(event));
+			};
+			const errorListener = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("WebSocket connection failed."));
+			};
+			const cleanup = () => {
+				webSocket.removeEventListener("open", openListener);
+				webSocket.removeEventListener("close", closeListener);
+				webSocket.removeEventListener("error", errorListener);
+			};
+			webSocket.addEventListener("open", openListener);
+			webSocket.addEventListener("close", closeListener);
+			webSocket.addEventListener("error", errorListener);
+			if (webSocket.readyState === READY_STATE_OPEN) {
+				cleanup();
+				resolve();
+			} else if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("WebSocket is already closed."));
+			}
+		});
+	}
+	async #waitForRetryDelay(delayMs, token) {
+		if (delayMs <= 0) {
+			if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();
+			return;
+		}
+		await new Promise((resolve) => {
+			const wait = {
+				timer: setTimeout(() => {
+					if (this.#retryDelayWait !== wait) return;
+					this.#retryDelayWait = void 0;
+					wait.resolve();
+				}, delayMs),
+				resolve
+			};
+			this.#retryDelayWait = wait;
+		});
+		if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();
+	}
+	#interruptRetryDelay() {
+		const wait = this.#retryDelayWait;
+		if (!wait) return;
+		this.#retryDelayWait = void 0;
+		clearTimeout(wait.timer);
+		wait.resolve();
+	}
+	#closeWebSocket(webSocket, reason) {
+		if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) return;
+		try {
+			webSocket.close(3e3, reason.slice(0, 120));
+		} catch {}
+	}
+};
+
+//#endregion
+exports.ReconnectingWebSocketRpcSession = ReconnectingWebSocketRpcSession;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["#openListeners","#closeListeners","#reconnect","#reconnectDelayMs","#reconnectDelayMaxMs","#reconnectBackoffFactor","#nextReconnectDelayMs","#started","#ensureConnected","#activeConnection","#stopReason","#lifecycleToken","#interruptRetryDelay","#disconnectConnection","#connectPromise","#connectUntilReady","#connectOnce","#waitForRetryDelay","#createWebSocket","#closeWebSocket","#installConnection","#waitUntilSocketOpen","#firstInitDone","#openedConnectionCount","#emitOpen","#connectionId","#emitClose","#retryDelayWait"],"sources":["../src/helpers.ts","../src/reconnectingWebsocket.ts"],"sourcesContent":["export function closeEventToError(event: CloseEvent): Error {\n    if (event.reason) return new Error(`WebSocket closed: ${event.code} ${event.reason}`);\n    return new Error(`WebSocket closed: ${event.code}`);\n}\n\nexport function toError(reason: unknown, fallbackMessage: string): Error {\n    if (reason instanceof Error) return reason;\n    if (typeof reason === \"string\" && reason.length > 0) return new Error(reason);\n    return new Error(fallbackMessage);\n}\n\nexport type MaybePromise<T> = T | Promise<T>;\n","import { newWebSocketRpcSession, type RpcSessionOptions } from \"capnweb\";\r\nimport { closeEventToError, MaybePromise, toError } from \"./helpers.js\";\r\n\r\ntype DisposableRpcStub = { [Symbol.dispose](): void, onRpcBroken(callback: (error: unknown) => void): void };\ntype RpcShape<T> = T extends object ? { [K in keyof T]: any } : Record<string, any>;\nexport type DynamicRpcStub = DisposableRpcStub & Record<string, any>;\nexport type ReconnectingWebSocketRpc<T = Record<string, never>> = RpcShape<T> & DisposableRpcStub;\ntype WebSocketSource = {\n    /**\n     * Return a brand-new socket for each connection attempt.\n     *\n     * @example\n     * createWebSocket: () => new WebSocket(\"wss://api.example.com/rpc\")\n     */\n    createWebSocket: () => WebSocket | Promise<WebSocket>,\n};\n\nexport type ReconnectingWebSocketRpcOpenEvent<T = Record<string, never>> = {\n    /** Monotonic connection id for this session instance. */\n    connectionId: number,\n    /** True only for the first successful connection open. */\n    firstConnection: boolean,\n    /** Ready RPC stub bound to this opened connection. */\n    rpc: ReconnectingWebSocketRpc<T>,\n};\n\nexport type ReconnectingWebSocketRpcCloseEvent = {\n    /** Connection id from the matching open event. */\n    connectionId: number,\n    /** Original disconnect error/cause. */\n    error: unknown,\n    /** True when closed by `stop()`. */\n    intentional: boolean,\n    /** True only if this connection reached fully-open state. */\n    wasConnected: boolean,\n};\n\nexport type ReconnectingWebSocketRpcReconnectOptions = {\n    /** Enable or disable automatic reconnect (default: true). */\n    enabled?: boolean,\n    /** First retry delay in ms (default: 250). */\n    delayMs?: number,\n    /** Maximum retry delay in ms (default: 5000). */\n    maxDelayMs?: number,\n    /** Multiplier applied after each failed attempt (default: 2). */\n    backoffFactor?: number,\n};\n\nexport type ReconnectingWebSocketRpcSessionOptions<T = Record<string, never>> = WebSocketSource & {\n    /** Local capnweb RPC target exposed to the remote peer. */\n    localMain?: any,\n    /** Options forwarded to `newWebSocketRpcSession`. */\n    rpcSessionOptions?: RpcSessionOptions,\n    /** Reconnect/backoff configuration. */\n    reconnectOptions?: ReconnectingWebSocketRpcReconnectOptions,\n    /** Runs once after the first successful socket open, before onOpen is emitted. */\n    onFirstInit?: (rpc: ReconnectingWebSocketRpc<T>) => MaybePromise<void>,\n};\n\r\ntype OpenListener<T> = (event: ReconnectingWebSocketRpcOpenEvent<T>) => MaybePromise<void>;\r\ntype CloseListener = (event: ReconnectingWebSocketRpcCloseEvent) => MaybePromise<void>;\r\n\r\ntype ActiveConnection<T> = {\r\n    id: number,\r\n    webSocket: WebSocket,\r\n    rpc: ReconnectingWebSocketRpc<T>,\r\n    firstConnection: boolean,\r\n    opened: boolean,\r\n    closed: boolean,\r\n    removeTransportListeners: () => void,\r\n};\r\n\r\nconst READY_STATE_OPEN = 1;\r\nconst READY_STATE_CLOSING = 2;\r\nconst READY_STATE_CLOSED = 3;\r\n\r\nclass ConnectionAttemptCancelledError extends Error {\n    constructor() {\n        super(\"Connection attempt was cancelled by stop or replacement.\");\n    }\n}\n\n/** Reconnecting wrapper around capnweb WebSocket RPC sessions. */\nexport class ReconnectingWebSocketRpcSession<T = Record<string, never>> {\n    #connectPromise?: Promise<ReconnectingWebSocketRpc<T>>;\r\n    #activeConnection?: ActiveConnection<T>;\r\n    #connectionId = 0;\r\n    #lifecycleToken = 0;\r\n    #started = false;\r\n    #stopReason: unknown = new Error(\"RPC session stopped.\");\r\n    #firstInitDone = false;\r\n    #openedConnectionCount = 0;\r\n    #retryDelayWait?: { timer: ReturnType<typeof setTimeout>, resolve: () => void };\r\n    readonly #openListeners = new Set<OpenListener<T>>();\r\n    readonly #closeListeners = new Set<CloseListener>();\r\n    readonly #reconnect: boolean;\r\n    readonly #reconnectDelayMs: number;\r\n    readonly #reconnectDelayMaxMs: number;\r\n    readonly #reconnectBackoffFactor: number;\r\n    #nextReconnectDelayMs: number;\r\n\r\n    constructor(readonly options: ReconnectingWebSocketRpcSessionOptions<T>) {\n        const reconnectOptions = options.reconnectOptions;\r\n        this.#reconnect = reconnectOptions?.enabled ?? true;\r\n        this.#reconnectDelayMs = reconnectOptions?.delayMs ?? 250;\r\n        this.#reconnectDelayMaxMs = reconnectOptions?.maxDelayMs ?? 5000;\r\n        this.#reconnectBackoffFactor = reconnectOptions?.backoffFactor ?? 2;\r\n        this.#nextReconnectDelayMs = this.#reconnectDelayMs;\r\n\r\n        if (!Number.isFinite(this.#reconnectDelayMs) || this.#reconnectDelayMs < 0) throw new RangeError(\"reconnectOptions.delayMs must be a finite number >= 0.\");\r\n        if (!Number.isFinite(this.#reconnectDelayMaxMs) || this.#reconnectDelayMaxMs < this.#reconnectDelayMs) throw new RangeError(\"reconnectOptions.maxDelayMs must be >= reconnectOptions.delayMs.\");\r\n        if (!Number.isFinite(this.#reconnectBackoffFactor) || this.#reconnectBackoffFactor < 1) throw new RangeError(\"reconnectOptions.backoffFactor must be a finite number >= 1.\");\r\n\r\n        // Start immediately after construction so onOpen/onClose hooks can drive app behavior\r\n        // without requiring an initial getRPC() call.\r\n        this.#started = true;\r\n        queueMicrotask(() => {\r\n            if (!this.#started) return;\r\n            void this.#ensureConnected().catch(() => { });\r\n        });\r\n    }\n\n    /** True when `stop()` has been called and reconnecting is disabled. */\n    get isStopped(): boolean {\n        return !this.#started;\n    }\n\n    /** True when a fully-open RPC connection is currently available. */\n    get isConnected(): boolean {\n        const connection = this.#activeConnection;\n        return connection !== undefined && connection.opened && !connection.closed;\n    }\n\n    /** Listen for each successful connection open. Returns an unsubscribe function. */\n    onOpen(listener: OpenListener<T>): () => void {\n        this.#openListeners.add(listener);\n\r\n        const connection = this.#activeConnection;\r\n        if (connection && connection.opened && !connection.closed) {\r\n            const event = { connectionId: connection.id, firstConnection: connection.firstConnection, rpc: connection.rpc };\r\n            try {\r\n                Promise.resolve(listener(event)).catch(() => { });\r\n            } catch { }\r\n        }\r\n\r\n        return () => this.#openListeners.delete(listener);\n    }\n\n    /** Listen for each opened connection close. Returns an unsubscribe function. */\n    onClose(listener: CloseListener): () => void {\n        this.#closeListeners.add(listener);\n        return () => this.#closeListeners.delete(listener);\n    }\n\n    /** Returns a live RPC stub, starting or reconnecting if needed. */\n    async getRPC(): Promise<ReconnectingWebSocketRpc<T>> {\n        const connection = this.#activeConnection;\n        if (connection && connection.opened && !connection.closed) return connection.rpc;\n        return this.start();\n    }\n\n    /** Starts (or resumes) connection attempts and resolves when ready. */\n    async start(): Promise<ReconnectingWebSocketRpc<T>> {\n        this.#started = true;\n        return this.#ensureConnected();\n    }\n\n    /** Stops reconnecting and closes the active connection, if any. */\n    stop(reason: unknown = new Error(\"RPC session was stopped by the application.\")): void {\n        this.#stopReason = reason;\n        this.#started = false;\n        this.#lifecycleToken++;\n        this.#interruptRetryDelay();\n        this.#nextReconnectDelayMs = this.#reconnectDelayMs;\n        const connection = this.#activeConnection;\n        if (connection) this.#disconnectConnection(connection, reason, true);\n        this.#connectPromise = undefined;\n    }\n\r\n    #ensureConnected(): Promise<ReconnectingWebSocketRpc<T>> {\r\n        const connection = this.#activeConnection;\r\n        if (connection && connection.opened && !connection.closed) return Promise.resolve(connection.rpc);\r\n        if (this.#connectPromise) return this.#connectPromise;\r\n\r\n        const token = this.#lifecycleToken;\r\n        const promise = this.#connectUntilReady(token);\r\n        this.#connectPromise = promise;\r\n        // This promise is shared by concurrent getRPC() calls.\r\n        // Clear it on both resolve and reject so future calls can start a fresh attempt.\r\n        // The identity check avoids clearing a newer attempt from an older settled promise.\r\n        const clearConnectPromise = () => { if (this.#connectPromise === promise) this.#connectPromise = undefined; };\r\n        promise.then(clearConnectPromise, clearConnectPromise);\r\n        return promise;\r\n    }\r\n\r\n    async #connectUntilReady(token: number): Promise<ReconnectingWebSocketRpc<T>> {\r\n        while (true) {\r\n            if (!this.#started) throw toError(this.#stopReason, \"RPC session is stopped.\");\r\n            // Any stop() bumps this token and cancels prior in-flight attempts.\r\n            if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();\r\n\r\n            try {\r\n                const rpc = await this.#connectOnce(token);\r\n                if (!this.#started) throw toError(this.#stopReason, \"RPC session is stopped.\");\r\n                if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();\r\n\r\n                const activeConnection = this.#activeConnection;\r\n                // Guard against races where a connection dies between setup completion and return.\r\n                if (!activeConnection || activeConnection.closed || activeConnection.rpc !== rpc) throw new Error(\"Connection became unavailable before it was returned.\");\r\n\r\n                this.#nextReconnectDelayMs = this.#reconnectDelayMs;\r\n                return rpc;\r\n            } catch (err) {\r\n                if (!this.#started) throw toError(this.#stopReason, \"RPC session is stopped.\");\r\n                if (err instanceof ConnectionAttemptCancelledError) throw err;\r\n                if (!this.#reconnect) throw err;\r\n\r\n                const delay = this.#nextReconnectDelayMs;\r\n                this.#nextReconnectDelayMs = Math.min(this.#reconnectDelayMaxMs, Math.ceil(this.#nextReconnectDelayMs * this.#reconnectBackoffFactor));\r\n\r\n                try {\r\n                    await this.#waitForRetryDelay(delay, token);\r\n                } catch (waitError) {\r\n                    if (!this.#started) throw toError(this.#stopReason, \"RPC session is stopped.\");\r\n                    throw waitError;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    async #connectOnce(token: number): Promise<ReconnectingWebSocketRpc<T>> {\r\n        const webSocket = await this.#createWebSocket();\r\n        if (!this.#started || token !== this.#lifecycleToken) {\r\n            this.#closeWebSocket(webSocket, \"Connection attempt was replaced.\");\r\n            throw new ConnectionAttemptCancelledError();\r\n        }\r\n\r\n        const rpc = newWebSocketRpcSession(webSocket, this.options.localMain, this.options.rpcSessionOptions) as unknown as ReconnectingWebSocketRpc<T>;\r\n        const connection = this.#installConnection(webSocket, rpc);\r\n        this.#activeConnection = connection;\r\n        const throwIfCancelled = () => {\r\n            if (this.#started && token === this.#lifecycleToken) return;\r\n            const error = new ConnectionAttemptCancelledError();\r\n            this.#disconnectConnection(connection, error, true);\r\n            throw error;\r\n        };\r\n\r\n        try {\r\n            await this.#waitUntilSocketOpen(webSocket);\r\n            if (connection.closed) throw new Error(\"WebSocket connection closed while opening.\");\r\n            throwIfCancelled();\r\n\r\n            if (!this.#firstInitDone && this.options.onFirstInit) {\r\n                await this.options.onFirstInit(connection.rpc);\r\n                this.#firstInitDone = true;\r\n            }\r\n\r\n            if (connection.closed) throw new Error(\"WebSocket connection closed during initialization.\");\r\n            throwIfCancelled();\r\n\r\n            // Mark as opened only when this connection is fully ready and about to emit onOpen.\r\n            connection.opened = true;\r\n            connection.firstConnection = this.#openedConnectionCount === 0;\r\n            this.#openedConnectionCount++;\r\n            // Open listeners are non-blocking; they can kick off background subscription setup.\r\n            this.#emitOpen({ connectionId: connection.id, firstConnection: connection.firstConnection, rpc: connection.rpc });\r\n\r\n            if (connection.closed) throw new Error(\"WebSocket connection closed during open listeners.\");\r\n            throwIfCancelled();\r\n            return connection.rpc;\r\n        } catch (err) {\r\n            this.#disconnectConnection(connection, err, false);\r\n            throw err;\r\n        }\r\n    }\r\n\r\n    #installConnection(webSocket: WebSocket, rpc: ReconnectingWebSocketRpc<T>): ActiveConnection<T> {\r\n        const connection: ActiveConnection<T> = { id: ++this.#connectionId, webSocket, rpc, firstConnection: false, opened: false, closed: false, removeTransportListeners: () => { } };\r\n        const closeListener = (event: CloseEvent) => this.#disconnectConnection(connection, closeEventToError(event), false);\r\n        const errorListener = () => this.#disconnectConnection(connection, new Error(\"WebSocket connection failed.\"), false);\r\n\r\n        webSocket.addEventListener(\"close\", closeListener);\r\n        webSocket.addEventListener(\"error\", errorListener);\r\n        connection.removeTransportListeners = () => {\r\n            webSocket.removeEventListener(\"close\", closeListener);\r\n            webSocket.removeEventListener(\"error\", errorListener);\r\n        };\r\n        rpc.onRpcBroken(error => this.#disconnectConnection(connection, error, false));\r\n        return connection;\r\n    }\r\n\r\n    #disconnectConnection(connection: ActiveConnection<T>, error: unknown, intentional: boolean) {\r\n        if (connection.closed) return;\r\n        connection.closed = true;\r\n        connection.removeTransportListeners();\r\n        if (this.#activeConnection?.id === connection.id) this.#activeConnection = undefined;\r\n        const wasConnected = connection.opened;\r\n\r\n        this.#closeWebSocket(connection.webSocket, \"RPC session reconnecting.\");\r\n        try {\r\n            connection.rpc[Symbol.dispose]();\r\n        } catch { }\r\n\r\n        // onClose is a lifecycle signal (one close per opened connection), not a per-attempt failure signal.\r\n        if (wasConnected) this.#emitClose({ connectionId: connection.id, error, intentional, wasConnected });\r\n        // Unexpected disconnects trigger reconnect in the background if enabled.\r\n        if (wasConnected && !intentional && this.#started && this.#reconnect) void this.#ensureConnected().catch(() => { });\r\n    }\r\n\r\n    #emitOpen(event: ReconnectingWebSocketRpcOpenEvent<T>): void {\r\n        for (const listener of this.#openListeners) {\r\n            try {\r\n                // Listener failures should not bring down a healthy connection.\r\n                Promise.resolve(listener(event)).catch(() => { });\r\n            } catch { }\r\n        }\r\n    }\r\n\r\n    #emitClose(event: ReconnectingWebSocketRpcCloseEvent): void {\r\n        for (const listener of this.#closeListeners) {\r\n            try {\r\n                Promise.resolve(listener(event)).catch(() => { });\r\n            } catch { }\r\n        }\r\n    }\r\n\r\n    async #createWebSocket(): Promise<WebSocket> {\r\n        return this.options.createWebSocket();\r\n    }\r\n\r\n    async #waitUntilSocketOpen(webSocket: WebSocket): Promise<void> {\r\n        if (webSocket.readyState === READY_STATE_OPEN) return;\r\n        if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) throw new Error(\"WebSocket is already closed.\");\r\n\r\n        await new Promise<void>((resolve, reject) => {\r\n            const openListener = () => {\r\n                cleanup();\r\n                resolve();\r\n            };\r\n            const closeListener = (event: CloseEvent) => {\r\n                cleanup();\r\n                reject(closeEventToError(event));\r\n            };\r\n            const errorListener = () => {\r\n                cleanup();\r\n                reject(new Error(\"WebSocket connection failed.\"));\r\n            };\r\n            const cleanup = () => {\r\n                webSocket.removeEventListener(\"open\", openListener);\r\n                webSocket.removeEventListener(\"close\", closeListener);\r\n                webSocket.removeEventListener(\"error\", errorListener);\r\n            };\r\n\r\n            webSocket.addEventListener(\"open\", openListener);\r\n            webSocket.addEventListener(\"close\", closeListener);\r\n            webSocket.addEventListener(\"error\", errorListener);\r\n\r\n            // Re-check after listener registration to avoid missing a fast state transition.\r\n            if (webSocket.readyState === READY_STATE_OPEN) {\r\n                cleanup();\r\n                resolve();\r\n            } else if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) {\r\n                cleanup();\r\n                reject(new Error(\"WebSocket is already closed.\"));\r\n            }\r\n        });\r\n    }\r\n\r\n    async #waitForRetryDelay(delayMs: number, token: number): Promise<void> {\r\n        if (delayMs <= 0) {\r\n            if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();\r\n            return;\r\n        }\r\n\r\n        await new Promise<void>((resolve) => {\r\n            // Keep a single in-flight backoff wait and guard with identity checks so an old timer\r\n            // can never clear or resolve a newer wait after stop/start churn.\r\n            const wait = {\r\n                timer: setTimeout(() => {\r\n                    if (this.#retryDelayWait !== wait) return;\r\n                    this.#retryDelayWait = undefined;\r\n                    wait.resolve();\r\n                }, delayMs), resolve\r\n            };\r\n            this.#retryDelayWait = wait;\r\n        });\r\n\r\n        // Token might have changed while waiting (stop during backoff).\r\n        if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();\r\n    }\r\n\r\n    #interruptRetryDelay(): void {\r\n        const wait = this.#retryDelayWait;\r\n        if (!wait) return;\r\n        this.#retryDelayWait = undefined;\r\n        clearTimeout(wait.timer);\r\n        wait.resolve();\r\n    }\r\n\r\n    #closeWebSocket(webSocket: WebSocket, reason: string): void {\r\n        if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) return;\r\n        try {\r\n            webSocket.close(3000, reason.slice(0, 120));\r\n        } catch { }\r\n    }\r\n}\r\n\r\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,70 @@
+import { RpcSessionOptions } from "capnweb";
+
+//#region src/helpers.d.ts
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+//#region src/reconnectingWebsocket.d.ts
+type DisposableRpcStub = {
+  [Symbol.dispose](): void;
+  onRpcBroken(callback: (error: unknown) => void): void;
+};
+type RpcShape<T> = T extends object ? { [K in keyof T]: any } : Record<string, any>;
+type DynamicRpcStub = DisposableRpcStub & Record<string, any>;
+type ReconnectingWebSocketRpc<T = Record<string, never>> = RpcShape<T> & DisposableRpcStub;
+type WebSocketSource = {
+  /**
+   * Return a brand-new socket for each connection attempt.
+   *
+   * @example
+   * createWebSocket: () => new WebSocket("wss://api.example.com/rpc")
+   */
+  createWebSocket: () => WebSocket | Promise<WebSocket>;
+};
+type ReconnectingWebSocketRpcOpenEvent<T = Record<string, never>> = {
+  /** Monotonic connection id for this session instance. */connectionId: number; /** True only for the first successful connection open. */
+  firstConnection: boolean; /** Ready RPC stub bound to this opened connection. */
+  rpc: ReconnectingWebSocketRpc<T>;
+};
+type ReconnectingWebSocketRpcCloseEvent = {
+  /** Connection id from the matching open event. */connectionId: number; /** Original disconnect error/cause. */
+  error: unknown; /** True when closed by `stop()`. */
+  intentional: boolean; /** True only if this connection reached fully-open state. */
+  wasConnected: boolean;
+};
+type ReconnectingWebSocketRpcReconnectOptions = {
+  /** Enable or disable automatic reconnect (default: true). */enabled?: boolean; /** First retry delay in ms (default: 250). */
+  delayMs?: number; /** Maximum retry delay in ms (default: 5000). */
+  maxDelayMs?: number; /** Multiplier applied after each failed attempt (default: 2). */
+  backoffFactor?: number;
+};
+type ReconnectingWebSocketRpcSessionOptions<T = Record<string, never>> = WebSocketSource & {
+  /** Local capnweb RPC target exposed to the remote peer. */localMain?: any; /** Options forwarded to `newWebSocketRpcSession`. */
+  rpcSessionOptions?: RpcSessionOptions; /** Reconnect/backoff configuration. */
+  reconnectOptions?: ReconnectingWebSocketRpcReconnectOptions; /** Runs once after the first successful socket open, before onOpen is emitted. */
+  onFirstInit?: (rpc: ReconnectingWebSocketRpc<T>) => MaybePromise<void>;
+};
+type OpenListener<T> = (event: ReconnectingWebSocketRpcOpenEvent<T>) => MaybePromise<void>;
+type CloseListener = (event: ReconnectingWebSocketRpcCloseEvent) => MaybePromise<void>;
+/** Reconnecting wrapper around capnweb WebSocket RPC sessions. */
+declare class ReconnectingWebSocketRpcSession<T = Record<string, never>> {
+  #private;
+  readonly options: ReconnectingWebSocketRpcSessionOptions<T>;
+  constructor(options: ReconnectingWebSocketRpcSessionOptions<T>);
+  /** True when `stop()` has been called and reconnecting is disabled. */
+  get isStopped(): boolean;
+  /** True when a fully-open RPC connection is currently available. */
+  get isConnected(): boolean;
+  /** Listen for each successful connection open. Returns an unsubscribe function. */
+  onOpen(listener: OpenListener<T>): () => void;
+  /** Listen for each opened connection close. Returns an unsubscribe function. */
+  onClose(listener: CloseListener): () => void;
+  /** Returns a live RPC stub, starting or reconnecting if needed. */
+  getRPC(): Promise<ReconnectingWebSocketRpc<T>>;
+  /** Starts (or resumes) connection attempts and resolves when ready. */
+  start(): Promise<ReconnectingWebSocketRpc<T>>;
+  /** Stops reconnecting and closes the active connection, if any. */
+  stop(reason?: unknown): void;
+}
+//#endregion
+export { DynamicRpcStub, ReconnectingWebSocketRpc, ReconnectingWebSocketRpcCloseEvent, ReconnectingWebSocketRpcOpenEvent, ReconnectingWebSocketRpcReconnectOptions, ReconnectingWebSocketRpcSession, ReconnectingWebSocketRpcSessionOptions };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+import { RpcSessionOptions } from "capnweb";
+
+//#region src/helpers.d.ts
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+//#region src/reconnectingWebsocket.d.ts
+type DisposableRpcStub = {
+  [Symbol.dispose](): void;
+  onRpcBroken(callback: (error: unknown) => void): void;
+};
+type RpcShape<T> = T extends object ? { [K in keyof T]: any } : Record<string, any>;
+type DynamicRpcStub = DisposableRpcStub & Record<string, any>;
+type ReconnectingWebSocketRpc<T = Record<string, never>> = RpcShape<T> & DisposableRpcStub;
+type WebSocketSource = {
+  /**
+   * Return a brand-new socket for each connection attempt.
+   *
+   * @example
+   * createWebSocket: () => new WebSocket("wss://api.example.com/rpc")
+   */
+  createWebSocket: () => WebSocket | Promise<WebSocket>;
+};
+type ReconnectingWebSocketRpcOpenEvent<T = Record<string, never>> = {
+  /** Monotonic connection id for this session instance. */connectionId: number; /** True only for the first successful connection open. */
+  firstConnection: boolean; /** Ready RPC stub bound to this opened connection. */
+  rpc: ReconnectingWebSocketRpc<T>;
+};
+type ReconnectingWebSocketRpcCloseEvent = {
+  /** Connection id from the matching open event. */connectionId: number; /** Original disconnect error/cause. */
+  error: unknown; /** True when closed by `stop()`. */
+  intentional: boolean; /** True only if this connection reached fully-open state. */
+  wasConnected: boolean;
+};
+type ReconnectingWebSocketRpcReconnectOptions = {
+  /** Enable or disable automatic reconnect (default: true). */enabled?: boolean; /** First retry delay in ms (default: 250). */
+  delayMs?: number; /** Maximum retry delay in ms (default: 5000). */
+  maxDelayMs?: number; /** Multiplier applied after each failed attempt (default: 2). */
+  backoffFactor?: number;
+};
+type ReconnectingWebSocketRpcSessionOptions<T = Record<string, never>> = WebSocketSource & {
+  /** Local capnweb RPC target exposed to the remote peer. */localMain?: any; /** Options forwarded to `newWebSocketRpcSession`. */
+  rpcSessionOptions?: RpcSessionOptions; /** Reconnect/backoff configuration. */
+  reconnectOptions?: ReconnectingWebSocketRpcReconnectOptions; /** Runs once after the first successful socket open, before onOpen is emitted. */
+  onFirstInit?: (rpc: ReconnectingWebSocketRpc<T>) => MaybePromise<void>;
+};
+type OpenListener<T> = (event: ReconnectingWebSocketRpcOpenEvent<T>) => MaybePromise<void>;
+type CloseListener = (event: ReconnectingWebSocketRpcCloseEvent) => MaybePromise<void>;
+/** Reconnecting wrapper around capnweb WebSocket RPC sessions. */
+declare class ReconnectingWebSocketRpcSession<T = Record<string, never>> {
+  #private;
+  readonly options: ReconnectingWebSocketRpcSessionOptions<T>;
+  constructor(options: ReconnectingWebSocketRpcSessionOptions<T>);
+  /** True when `stop()` has been called and reconnecting is disabled. */
+  get isStopped(): boolean;
+  /** True when a fully-open RPC connection is currently available. */
+  get isConnected(): boolean;
+  /** Listen for each successful connection open. Returns an unsubscribe function. */
+  onOpen(listener: OpenListener<T>): () => void;
+  /** Listen for each opened connection close. Returns an unsubscribe function. */
+  onClose(listener: CloseListener): () => void;
+  /** Returns a live RPC stub, starting or reconnecting if needed. */
+  getRPC(): Promise<ReconnectingWebSocketRpc<T>>;
+  /** Starts (or resumes) connection attempts and resolves when ready. */
+  start(): Promise<ReconnectingWebSocketRpc<T>>;
+  /** Stops reconnecting and closes the active connection, if any. */
+  stop(reason?: unknown): void;
+}
+//#endregion
+export { DynamicRpcStub, ReconnectingWebSocketRpc, ReconnectingWebSocketRpcCloseEvent, ReconnectingWebSocketRpcOpenEvent, ReconnectingWebSocketRpcReconnectOptions, ReconnectingWebSocketRpcSession, ReconnectingWebSocketRpcSessionOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,312 @@
+import { newWebSocketRpcSession } from "capnweb";
+
+//#region src/helpers.ts
+function closeEventToError(event) {
+	if (event.reason) return /* @__PURE__ */ new Error(`WebSocket closed: ${event.code} ${event.reason}`);
+	return /* @__PURE__ */ new Error(`WebSocket closed: ${event.code}`);
+}
+function toError(reason, fallbackMessage) {
+	if (reason instanceof Error) return reason;
+	if (typeof reason === "string" && reason.length > 0) return new Error(reason);
+	return new Error(fallbackMessage);
+}
+
+//#endregion
+//#region src/reconnectingWebsocket.ts
+const READY_STATE_OPEN = 1;
+const READY_STATE_CLOSING = 2;
+const READY_STATE_CLOSED = 3;
+var ConnectionAttemptCancelledError = class extends Error {
+	constructor() {
+		super("Connection attempt was cancelled by stop or replacement.");
+	}
+};
+/** Reconnecting wrapper around capnweb WebSocket RPC sessions. */
+var ReconnectingWebSocketRpcSession = class {
+	#connectPromise;
+	#activeConnection;
+	#connectionId = 0;
+	#lifecycleToken = 0;
+	#started = false;
+	#stopReason = /* @__PURE__ */ new Error("RPC session stopped.");
+	#firstInitDone = false;
+	#openedConnectionCount = 0;
+	#retryDelayWait;
+	#openListeners = /* @__PURE__ */ new Set();
+	#closeListeners = /* @__PURE__ */ new Set();
+	#reconnect;
+	#reconnectDelayMs;
+	#reconnectDelayMaxMs;
+	#reconnectBackoffFactor;
+	#nextReconnectDelayMs;
+	constructor(options) {
+		this.options = options;
+		const reconnectOptions = options.reconnectOptions;
+		this.#reconnect = reconnectOptions?.enabled ?? true;
+		this.#reconnectDelayMs = reconnectOptions?.delayMs ?? 250;
+		this.#reconnectDelayMaxMs = reconnectOptions?.maxDelayMs ?? 5e3;
+		this.#reconnectBackoffFactor = reconnectOptions?.backoffFactor ?? 2;
+		this.#nextReconnectDelayMs = this.#reconnectDelayMs;
+		if (!Number.isFinite(this.#reconnectDelayMs) || this.#reconnectDelayMs < 0) throw new RangeError("reconnectOptions.delayMs must be a finite number >= 0.");
+		if (!Number.isFinite(this.#reconnectDelayMaxMs) || this.#reconnectDelayMaxMs < this.#reconnectDelayMs) throw new RangeError("reconnectOptions.maxDelayMs must be >= reconnectOptions.delayMs.");
+		if (!Number.isFinite(this.#reconnectBackoffFactor) || this.#reconnectBackoffFactor < 1) throw new RangeError("reconnectOptions.backoffFactor must be a finite number >= 1.");
+		this.#started = true;
+		queueMicrotask(() => {
+			if (!this.#started) return;
+			this.#ensureConnected().catch(() => {});
+		});
+	}
+	/** True when `stop()` has been called and reconnecting is disabled. */
+	get isStopped() {
+		return !this.#started;
+	}
+	/** True when a fully-open RPC connection is currently available. */
+	get isConnected() {
+		const connection = this.#activeConnection;
+		return connection !== void 0 && connection.opened && !connection.closed;
+	}
+	/** Listen for each successful connection open. Returns an unsubscribe function. */
+	onOpen(listener) {
+		this.#openListeners.add(listener);
+		const connection = this.#activeConnection;
+		if (connection && connection.opened && !connection.closed) {
+			const event = {
+				connectionId: connection.id,
+				firstConnection: connection.firstConnection,
+				rpc: connection.rpc
+			};
+			try {
+				Promise.resolve(listener(event)).catch(() => {});
+			} catch {}
+		}
+		return () => this.#openListeners.delete(listener);
+	}
+	/** Listen for each opened connection close. Returns an unsubscribe function. */
+	onClose(listener) {
+		this.#closeListeners.add(listener);
+		return () => this.#closeListeners.delete(listener);
+	}
+	/** Returns a live RPC stub, starting or reconnecting if needed. */
+	async getRPC() {
+		const connection = this.#activeConnection;
+		if (connection && connection.opened && !connection.closed) return connection.rpc;
+		return this.start();
+	}
+	/** Starts (or resumes) connection attempts and resolves when ready. */
+	async start() {
+		this.#started = true;
+		return this.#ensureConnected();
+	}
+	/** Stops reconnecting and closes the active connection, if any. */
+	stop(reason = /* @__PURE__ */ new Error("RPC session was stopped by the application.")) {
+		this.#stopReason = reason;
+		this.#started = false;
+		this.#lifecycleToken++;
+		this.#interruptRetryDelay();
+		this.#nextReconnectDelayMs = this.#reconnectDelayMs;
+		const connection = this.#activeConnection;
+		if (connection) this.#disconnectConnection(connection, reason, true);
+		this.#connectPromise = void 0;
+	}
+	#ensureConnected() {
+		const connection = this.#activeConnection;
+		if (connection && connection.opened && !connection.closed) return Promise.resolve(connection.rpc);
+		if (this.#connectPromise) return this.#connectPromise;
+		const token = this.#lifecycleToken;
+		const promise = this.#connectUntilReady(token);
+		this.#connectPromise = promise;
+		const clearConnectPromise = () => {
+			if (this.#connectPromise === promise) this.#connectPromise = void 0;
+		};
+		promise.then(clearConnectPromise, clearConnectPromise);
+		return promise;
+	}
+	async #connectUntilReady(token) {
+		while (true) {
+			if (!this.#started) throw toError(this.#stopReason, "RPC session is stopped.");
+			if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();
+			try {
+				const rpc = await this.#connectOnce(token);
+				if (!this.#started) throw toError(this.#stopReason, "RPC session is stopped.");
+				if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();
+				const activeConnection = this.#activeConnection;
+				if (!activeConnection || activeConnection.closed || activeConnection.rpc !== rpc) throw new Error("Connection became unavailable before it was returned.");
+				this.#nextReconnectDelayMs = this.#reconnectDelayMs;
+				return rpc;
+			} catch (err) {
+				if (!this.#started) throw toError(this.#stopReason, "RPC session is stopped.");
+				if (err instanceof ConnectionAttemptCancelledError) throw err;
+				if (!this.#reconnect) throw err;
+				const delay = this.#nextReconnectDelayMs;
+				this.#nextReconnectDelayMs = Math.min(this.#reconnectDelayMaxMs, Math.ceil(this.#nextReconnectDelayMs * this.#reconnectBackoffFactor));
+				try {
+					await this.#waitForRetryDelay(delay, token);
+				} catch (waitError) {
+					if (!this.#started) throw toError(this.#stopReason, "RPC session is stopped.");
+					throw waitError;
+				}
+			}
+		}
+	}
+	async #connectOnce(token) {
+		const webSocket = await this.#createWebSocket();
+		if (!this.#started || token !== this.#lifecycleToken) {
+			this.#closeWebSocket(webSocket, "Connection attempt was replaced.");
+			throw new ConnectionAttemptCancelledError();
+		}
+		const rpc = newWebSocketRpcSession(webSocket, this.options.localMain, this.options.rpcSessionOptions);
+		const connection = this.#installConnection(webSocket, rpc);
+		this.#activeConnection = connection;
+		const throwIfCancelled = () => {
+			if (this.#started && token === this.#lifecycleToken) return;
+			const error = new ConnectionAttemptCancelledError();
+			this.#disconnectConnection(connection, error, true);
+			throw error;
+		};
+		try {
+			await this.#waitUntilSocketOpen(webSocket);
+			if (connection.closed) throw new Error("WebSocket connection closed while opening.");
+			throwIfCancelled();
+			if (!this.#firstInitDone && this.options.onFirstInit) {
+				await this.options.onFirstInit(connection.rpc);
+				this.#firstInitDone = true;
+			}
+			if (connection.closed) throw new Error("WebSocket connection closed during initialization.");
+			throwIfCancelled();
+			connection.opened = true;
+			connection.firstConnection = this.#openedConnectionCount === 0;
+			this.#openedConnectionCount++;
+			this.#emitOpen({
+				connectionId: connection.id,
+				firstConnection: connection.firstConnection,
+				rpc: connection.rpc
+			});
+			if (connection.closed) throw new Error("WebSocket connection closed during open listeners.");
+			throwIfCancelled();
+			return connection.rpc;
+		} catch (err) {
+			this.#disconnectConnection(connection, err, false);
+			throw err;
+		}
+	}
+	#installConnection(webSocket, rpc) {
+		const connection = {
+			id: ++this.#connectionId,
+			webSocket,
+			rpc,
+			firstConnection: false,
+			opened: false,
+			closed: false,
+			removeTransportListeners: () => {}
+		};
+		const closeListener = (event) => this.#disconnectConnection(connection, closeEventToError(event), false);
+		const errorListener = () => this.#disconnectConnection(connection, /* @__PURE__ */ new Error("WebSocket connection failed."), false);
+		webSocket.addEventListener("close", closeListener);
+		webSocket.addEventListener("error", errorListener);
+		connection.removeTransportListeners = () => {
+			webSocket.removeEventListener("close", closeListener);
+			webSocket.removeEventListener("error", errorListener);
+		};
+		rpc.onRpcBroken((error) => this.#disconnectConnection(connection, error, false));
+		return connection;
+	}
+	#disconnectConnection(connection, error, intentional) {
+		if (connection.closed) return;
+		connection.closed = true;
+		connection.removeTransportListeners();
+		if (this.#activeConnection?.id === connection.id) this.#activeConnection = void 0;
+		const wasConnected = connection.opened;
+		this.#closeWebSocket(connection.webSocket, "RPC session reconnecting.");
+		try {
+			connection.rpc[Symbol.dispose]();
+		} catch {}
+		if (wasConnected) this.#emitClose({
+			connectionId: connection.id,
+			error,
+			intentional,
+			wasConnected
+		});
+		if (wasConnected && !intentional && this.#started && this.#reconnect) this.#ensureConnected().catch(() => {});
+	}
+	#emitOpen(event) {
+		for (const listener of this.#openListeners) try {
+			Promise.resolve(listener(event)).catch(() => {});
+		} catch {}
+	}
+	#emitClose(event) {
+		for (const listener of this.#closeListeners) try {
+			Promise.resolve(listener(event)).catch(() => {});
+		} catch {}
+	}
+	async #createWebSocket() {
+		return this.options.createWebSocket();
+	}
+	async #waitUntilSocketOpen(webSocket) {
+		if (webSocket.readyState === READY_STATE_OPEN) return;
+		if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) throw new Error("WebSocket is already closed.");
+		await new Promise((resolve, reject) => {
+			const openListener = () => {
+				cleanup();
+				resolve();
+			};
+			const closeListener = (event) => {
+				cleanup();
+				reject(closeEventToError(event));
+			};
+			const errorListener = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("WebSocket connection failed."));
+			};
+			const cleanup = () => {
+				webSocket.removeEventListener("open", openListener);
+				webSocket.removeEventListener("close", closeListener);
+				webSocket.removeEventListener("error", errorListener);
+			};
+			webSocket.addEventListener("open", openListener);
+			webSocket.addEventListener("close", closeListener);
+			webSocket.addEventListener("error", errorListener);
+			if (webSocket.readyState === READY_STATE_OPEN) {
+				cleanup();
+				resolve();
+			} else if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("WebSocket is already closed."));
+			}
+		});
+	}
+	async #waitForRetryDelay(delayMs, token) {
+		if (delayMs <= 0) {
+			if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();
+			return;
+		}
+		await new Promise((resolve) => {
+			const wait = {
+				timer: setTimeout(() => {
+					if (this.#retryDelayWait !== wait) return;
+					this.#retryDelayWait = void 0;
+					wait.resolve();
+				}, delayMs),
+				resolve
+			};
+			this.#retryDelayWait = wait;
+		});
+		if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();
+	}
+	#interruptRetryDelay() {
+		const wait = this.#retryDelayWait;
+		if (!wait) return;
+		this.#retryDelayWait = void 0;
+		clearTimeout(wait.timer);
+		wait.resolve();
+	}
+	#closeWebSocket(webSocket, reason) {
+		if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) return;
+		try {
+			webSocket.close(3e3, reason.slice(0, 120));
+		} catch {}
+	}
+};
+
+//#endregion
+export { ReconnectingWebSocketRpcSession };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["#openListeners","#closeListeners","#reconnect","#reconnectDelayMs","#reconnectDelayMaxMs","#reconnectBackoffFactor","#nextReconnectDelayMs","#started","#ensureConnected","#activeConnection","#stopReason","#lifecycleToken","#interruptRetryDelay","#disconnectConnection","#connectPromise","#connectUntilReady","#connectOnce","#waitForRetryDelay","#createWebSocket","#closeWebSocket","#installConnection","#waitUntilSocketOpen","#firstInitDone","#openedConnectionCount","#emitOpen","#connectionId","#emitClose","#retryDelayWait"],"sources":["../src/helpers.ts","../src/reconnectingWebsocket.ts"],"sourcesContent":["export function closeEventToError(event: CloseEvent): Error {\n    if (event.reason) return new Error(`WebSocket closed: ${event.code} ${event.reason}`);\n    return new Error(`WebSocket closed: ${event.code}`);\n}\n\nexport function toError(reason: unknown, fallbackMessage: string): Error {\n    if (reason instanceof Error) return reason;\n    if (typeof reason === \"string\" && reason.length > 0) return new Error(reason);\n    return new Error(fallbackMessage);\n}\n\nexport type MaybePromise<T> = T | Promise<T>;\n","import { newWebSocketRpcSession, type RpcSessionOptions } from \"capnweb\";\r\nimport { closeEventToError, MaybePromise, toError } from \"./helpers.js\";\r\n\r\ntype DisposableRpcStub = { [Symbol.dispose](): void, onRpcBroken(callback: (error: unknown) => void): void };\ntype RpcShape<T> = T extends object ? { [K in keyof T]: any } : Record<string, any>;\nexport type DynamicRpcStub = DisposableRpcStub & Record<string, any>;\nexport type ReconnectingWebSocketRpc<T = Record<string, never>> = RpcShape<T> & DisposableRpcStub;\ntype WebSocketSource = {\n    /**\n     * Return a brand-new socket for each connection attempt.\n     *\n     * @example\n     * createWebSocket: () => new WebSocket(\"wss://api.example.com/rpc\")\n     */\n    createWebSocket: () => WebSocket | Promise<WebSocket>,\n};\n\nexport type ReconnectingWebSocketRpcOpenEvent<T = Record<string, never>> = {\n    /** Monotonic connection id for this session instance. */\n    connectionId: number,\n    /** True only for the first successful connection open. */\n    firstConnection: boolean,\n    /** Ready RPC stub bound to this opened connection. */\n    rpc: ReconnectingWebSocketRpc<T>,\n};\n\nexport type ReconnectingWebSocketRpcCloseEvent = {\n    /** Connection id from the matching open event. */\n    connectionId: number,\n    /** Original disconnect error/cause. */\n    error: unknown,\n    /** True when closed by `stop()`. */\n    intentional: boolean,\n    /** True only if this connection reached fully-open state. */\n    wasConnected: boolean,\n};\n\nexport type ReconnectingWebSocketRpcReconnectOptions = {\n    /** Enable or disable automatic reconnect (default: true). */\n    enabled?: boolean,\n    /** First retry delay in ms (default: 250). */\n    delayMs?: number,\n    /** Maximum retry delay in ms (default: 5000). */\n    maxDelayMs?: number,\n    /** Multiplier applied after each failed attempt (default: 2). */\n    backoffFactor?: number,\n};\n\nexport type ReconnectingWebSocketRpcSessionOptions<T = Record<string, never>> = WebSocketSource & {\n    /** Local capnweb RPC target exposed to the remote peer. */\n    localMain?: any,\n    /** Options forwarded to `newWebSocketRpcSession`. */\n    rpcSessionOptions?: RpcSessionOptions,\n    /** Reconnect/backoff configuration. */\n    reconnectOptions?: ReconnectingWebSocketRpcReconnectOptions,\n    /** Runs once after the first successful socket open, before onOpen is emitted. */\n    onFirstInit?: (rpc: ReconnectingWebSocketRpc<T>) => MaybePromise<void>,\n};\n\r\ntype OpenListener<T> = (event: ReconnectingWebSocketRpcOpenEvent<T>) => MaybePromise<void>;\r\ntype CloseListener = (event: ReconnectingWebSocketRpcCloseEvent) => MaybePromise<void>;\r\n\r\ntype ActiveConnection<T> = {\r\n    id: number,\r\n    webSocket: WebSocket,\r\n    rpc: ReconnectingWebSocketRpc<T>,\r\n    firstConnection: boolean,\r\n    opened: boolean,\r\n    closed: boolean,\r\n    removeTransportListeners: () => void,\r\n};\r\n\r\nconst READY_STATE_OPEN = 1;\r\nconst READY_STATE_CLOSING = 2;\r\nconst READY_STATE_CLOSED = 3;\r\n\r\nclass ConnectionAttemptCancelledError extends Error {\n    constructor() {\n        super(\"Connection attempt was cancelled by stop or replacement.\");\n    }\n}\n\n/** Reconnecting wrapper around capnweb WebSocket RPC sessions. */\nexport class ReconnectingWebSocketRpcSession<T = Record<string, never>> {\n    #connectPromise?: Promise<ReconnectingWebSocketRpc<T>>;\r\n    #activeConnection?: ActiveConnection<T>;\r\n    #connectionId = 0;\r\n    #lifecycleToken = 0;\r\n    #started = false;\r\n    #stopReason: unknown = new Error(\"RPC session stopped.\");\r\n    #firstInitDone = false;\r\n    #openedConnectionCount = 0;\r\n    #retryDelayWait?: { timer: ReturnType<typeof setTimeout>, resolve: () => void };\r\n    readonly #openListeners = new Set<OpenListener<T>>();\r\n    readonly #closeListeners = new Set<CloseListener>();\r\n    readonly #reconnect: boolean;\r\n    readonly #reconnectDelayMs: number;\r\n    readonly #reconnectDelayMaxMs: number;\r\n    readonly #reconnectBackoffFactor: number;\r\n    #nextReconnectDelayMs: number;\r\n\r\n    constructor(readonly options: ReconnectingWebSocketRpcSessionOptions<T>) {\n        const reconnectOptions = options.reconnectOptions;\r\n        this.#reconnect = reconnectOptions?.enabled ?? true;\r\n        this.#reconnectDelayMs = reconnectOptions?.delayMs ?? 250;\r\n        this.#reconnectDelayMaxMs = reconnectOptions?.maxDelayMs ?? 5000;\r\n        this.#reconnectBackoffFactor = reconnectOptions?.backoffFactor ?? 2;\r\n        this.#nextReconnectDelayMs = this.#reconnectDelayMs;\r\n\r\n        if (!Number.isFinite(this.#reconnectDelayMs) || this.#reconnectDelayMs < 0) throw new RangeError(\"reconnectOptions.delayMs must be a finite number >= 0.\");\r\n        if (!Number.isFinite(this.#reconnectDelayMaxMs) || this.#reconnectDelayMaxMs < this.#reconnectDelayMs) throw new RangeError(\"reconnectOptions.maxDelayMs must be >= reconnectOptions.delayMs.\");\r\n        if (!Number.isFinite(this.#reconnectBackoffFactor) || this.#reconnectBackoffFactor < 1) throw new RangeError(\"reconnectOptions.backoffFactor must be a finite number >= 1.\");\r\n\r\n        // Start immediately after construction so onOpen/onClose hooks can drive app behavior\r\n        // without requiring an initial getRPC() call.\r\n        this.#started = true;\r\n        queueMicrotask(() => {\r\n            if (!this.#started) return;\r\n            void this.#ensureConnected().catch(() => { });\r\n        });\r\n    }\n\n    /** True when `stop()` has been called and reconnecting is disabled. */\n    get isStopped(): boolean {\n        return !this.#started;\n    }\n\n    /** True when a fully-open RPC connection is currently available. */\n    get isConnected(): boolean {\n        const connection = this.#activeConnection;\n        return connection !== undefined && connection.opened && !connection.closed;\n    }\n\n    /** Listen for each successful connection open. Returns an unsubscribe function. */\n    onOpen(listener: OpenListener<T>): () => void {\n        this.#openListeners.add(listener);\n\r\n        const connection = this.#activeConnection;\r\n        if (connection && connection.opened && !connection.closed) {\r\n            const event = { connectionId: connection.id, firstConnection: connection.firstConnection, rpc: connection.rpc };\r\n            try {\r\n                Promise.resolve(listener(event)).catch(() => { });\r\n            } catch { }\r\n        }\r\n\r\n        return () => this.#openListeners.delete(listener);\n    }\n\n    /** Listen for each opened connection close. Returns an unsubscribe function. */\n    onClose(listener: CloseListener): () => void {\n        this.#closeListeners.add(listener);\n        return () => this.#closeListeners.delete(listener);\n    }\n\n    /** Returns a live RPC stub, starting or reconnecting if needed. */\n    async getRPC(): Promise<ReconnectingWebSocketRpc<T>> {\n        const connection = this.#activeConnection;\n        if (connection && connection.opened && !connection.closed) return connection.rpc;\n        return this.start();\n    }\n\n    /** Starts (or resumes) connection attempts and resolves when ready. */\n    async start(): Promise<ReconnectingWebSocketRpc<T>> {\n        this.#started = true;\n        return this.#ensureConnected();\n    }\n\n    /** Stops reconnecting and closes the active connection, if any. */\n    stop(reason: unknown = new Error(\"RPC session was stopped by the application.\")): void {\n        this.#stopReason = reason;\n        this.#started = false;\n        this.#lifecycleToken++;\n        this.#interruptRetryDelay();\n        this.#nextReconnectDelayMs = this.#reconnectDelayMs;\n        const connection = this.#activeConnection;\n        if (connection) this.#disconnectConnection(connection, reason, true);\n        this.#connectPromise = undefined;\n    }\n\r\n    #ensureConnected(): Promise<ReconnectingWebSocketRpc<T>> {\r\n        const connection = this.#activeConnection;\r\n        if (connection && connection.opened && !connection.closed) return Promise.resolve(connection.rpc);\r\n        if (this.#connectPromise) return this.#connectPromise;\r\n\r\n        const token = this.#lifecycleToken;\r\n        const promise = this.#connectUntilReady(token);\r\n        this.#connectPromise = promise;\r\n        // This promise is shared by concurrent getRPC() calls.\r\n        // Clear it on both resolve and reject so future calls can start a fresh attempt.\r\n        // The identity check avoids clearing a newer attempt from an older settled promise.\r\n        const clearConnectPromise = () => { if (this.#connectPromise === promise) this.#connectPromise = undefined; };\r\n        promise.then(clearConnectPromise, clearConnectPromise);\r\n        return promise;\r\n    }\r\n\r\n    async #connectUntilReady(token: number): Promise<ReconnectingWebSocketRpc<T>> {\r\n        while (true) {\r\n            if (!this.#started) throw toError(this.#stopReason, \"RPC session is stopped.\");\r\n            // Any stop() bumps this token and cancels prior in-flight attempts.\r\n            if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();\r\n\r\n            try {\r\n                const rpc = await this.#connectOnce(token);\r\n                if (!this.#started) throw toError(this.#stopReason, \"RPC session is stopped.\");\r\n                if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();\r\n\r\n                const activeConnection = this.#activeConnection;\r\n                // Guard against races where a connection dies between setup completion and return.\r\n                if (!activeConnection || activeConnection.closed || activeConnection.rpc !== rpc) throw new Error(\"Connection became unavailable before it was returned.\");\r\n\r\n                this.#nextReconnectDelayMs = this.#reconnectDelayMs;\r\n                return rpc;\r\n            } catch (err) {\r\n                if (!this.#started) throw toError(this.#stopReason, \"RPC session is stopped.\");\r\n                if (err instanceof ConnectionAttemptCancelledError) throw err;\r\n                if (!this.#reconnect) throw err;\r\n\r\n                const delay = this.#nextReconnectDelayMs;\r\n                this.#nextReconnectDelayMs = Math.min(this.#reconnectDelayMaxMs, Math.ceil(this.#nextReconnectDelayMs * this.#reconnectBackoffFactor));\r\n\r\n                try {\r\n                    await this.#waitForRetryDelay(delay, token);\r\n                } catch (waitError) {\r\n                    if (!this.#started) throw toError(this.#stopReason, \"RPC session is stopped.\");\r\n                    throw waitError;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    async #connectOnce(token: number): Promise<ReconnectingWebSocketRpc<T>> {\r\n        const webSocket = await this.#createWebSocket();\r\n        if (!this.#started || token !== this.#lifecycleToken) {\r\n            this.#closeWebSocket(webSocket, \"Connection attempt was replaced.\");\r\n            throw new ConnectionAttemptCancelledError();\r\n        }\r\n\r\n        const rpc = newWebSocketRpcSession(webSocket, this.options.localMain, this.options.rpcSessionOptions) as unknown as ReconnectingWebSocketRpc<T>;\r\n        const connection = this.#installConnection(webSocket, rpc);\r\n        this.#activeConnection = connection;\r\n        const throwIfCancelled = () => {\r\n            if (this.#started && token === this.#lifecycleToken) return;\r\n            const error = new ConnectionAttemptCancelledError();\r\n            this.#disconnectConnection(connection, error, true);\r\n            throw error;\r\n        };\r\n\r\n        try {\r\n            await this.#waitUntilSocketOpen(webSocket);\r\n            if (connection.closed) throw new Error(\"WebSocket connection closed while opening.\");\r\n            throwIfCancelled();\r\n\r\n            if (!this.#firstInitDone && this.options.onFirstInit) {\r\n                await this.options.onFirstInit(connection.rpc);\r\n                this.#firstInitDone = true;\r\n            }\r\n\r\n            if (connection.closed) throw new Error(\"WebSocket connection closed during initialization.\");\r\n            throwIfCancelled();\r\n\r\n            // Mark as opened only when this connection is fully ready and about to emit onOpen.\r\n            connection.opened = true;\r\n            connection.firstConnection = this.#openedConnectionCount === 0;\r\n            this.#openedConnectionCount++;\r\n            // Open listeners are non-blocking; they can kick off background subscription setup.\r\n            this.#emitOpen({ connectionId: connection.id, firstConnection: connection.firstConnection, rpc: connection.rpc });\r\n\r\n            if (connection.closed) throw new Error(\"WebSocket connection closed during open listeners.\");\r\n            throwIfCancelled();\r\n            return connection.rpc;\r\n        } catch (err) {\r\n            this.#disconnectConnection(connection, err, false);\r\n            throw err;\r\n        }\r\n    }\r\n\r\n    #installConnection(webSocket: WebSocket, rpc: ReconnectingWebSocketRpc<T>): ActiveConnection<T> {\r\n        const connection: ActiveConnection<T> = { id: ++this.#connectionId, webSocket, rpc, firstConnection: false, opened: false, closed: false, removeTransportListeners: () => { } };\r\n        const closeListener = (event: CloseEvent) => this.#disconnectConnection(connection, closeEventToError(event), false);\r\n        const errorListener = () => this.#disconnectConnection(connection, new Error(\"WebSocket connection failed.\"), false);\r\n\r\n        webSocket.addEventListener(\"close\", closeListener);\r\n        webSocket.addEventListener(\"error\", errorListener);\r\n        connection.removeTransportListeners = () => {\r\n            webSocket.removeEventListener(\"close\", closeListener);\r\n            webSocket.removeEventListener(\"error\", errorListener);\r\n        };\r\n        rpc.onRpcBroken(error => this.#disconnectConnection(connection, error, false));\r\n        return connection;\r\n    }\r\n\r\n    #disconnectConnection(connection: ActiveConnection<T>, error: unknown, intentional: boolean) {\r\n        if (connection.closed) return;\r\n        connection.closed = true;\r\n        connection.removeTransportListeners();\r\n        if (this.#activeConnection?.id === connection.id) this.#activeConnection = undefined;\r\n        const wasConnected = connection.opened;\r\n\r\n        this.#closeWebSocket(connection.webSocket, \"RPC session reconnecting.\");\r\n        try {\r\n            connection.rpc[Symbol.dispose]();\r\n        } catch { }\r\n\r\n        // onClose is a lifecycle signal (one close per opened connection), not a per-attempt failure signal.\r\n        if (wasConnected) this.#emitClose({ connectionId: connection.id, error, intentional, wasConnected });\r\n        // Unexpected disconnects trigger reconnect in the background if enabled.\r\n        if (wasConnected && !intentional && this.#started && this.#reconnect) void this.#ensureConnected().catch(() => { });\r\n    }\r\n\r\n    #emitOpen(event: ReconnectingWebSocketRpcOpenEvent<T>): void {\r\n        for (const listener of this.#openListeners) {\r\n            try {\r\n                // Listener failures should not bring down a healthy connection.\r\n                Promise.resolve(listener(event)).catch(() => { });\r\n            } catch { }\r\n        }\r\n    }\r\n\r\n    #emitClose(event: ReconnectingWebSocketRpcCloseEvent): void {\r\n        for (const listener of this.#closeListeners) {\r\n            try {\r\n                Promise.resolve(listener(event)).catch(() => { });\r\n            } catch { }\r\n        }\r\n    }\r\n\r\n    async #createWebSocket(): Promise<WebSocket> {\r\n        return this.options.createWebSocket();\r\n    }\r\n\r\n    async #waitUntilSocketOpen(webSocket: WebSocket): Promise<void> {\r\n        if (webSocket.readyState === READY_STATE_OPEN) return;\r\n        if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) throw new Error(\"WebSocket is already closed.\");\r\n\r\n        await new Promise<void>((resolve, reject) => {\r\n            const openListener = () => {\r\n                cleanup();\r\n                resolve();\r\n            };\r\n            const closeListener = (event: CloseEvent) => {\r\n                cleanup();\r\n                reject(closeEventToError(event));\r\n            };\r\n            const errorListener = () => {\r\n                cleanup();\r\n                reject(new Error(\"WebSocket connection failed.\"));\r\n            };\r\n            const cleanup = () => {\r\n                webSocket.removeEventListener(\"open\", openListener);\r\n                webSocket.removeEventListener(\"close\", closeListener);\r\n                webSocket.removeEventListener(\"error\", errorListener);\r\n            };\r\n\r\n            webSocket.addEventListener(\"open\", openListener);\r\n            webSocket.addEventListener(\"close\", closeListener);\r\n            webSocket.addEventListener(\"error\", errorListener);\r\n\r\n            // Re-check after listener registration to avoid missing a fast state transition.\r\n            if (webSocket.readyState === READY_STATE_OPEN) {\r\n                cleanup();\r\n                resolve();\r\n            } else if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) {\r\n                cleanup();\r\n                reject(new Error(\"WebSocket is already closed.\"));\r\n            }\r\n        });\r\n    }\r\n\r\n    async #waitForRetryDelay(delayMs: number, token: number): Promise<void> {\r\n        if (delayMs <= 0) {\r\n            if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();\r\n            return;\r\n        }\r\n\r\n        await new Promise<void>((resolve) => {\r\n            // Keep a single in-flight backoff wait and guard with identity checks so an old timer\r\n            // can never clear or resolve a newer wait after stop/start churn.\r\n            const wait = {\r\n                timer: setTimeout(() => {\r\n                    if (this.#retryDelayWait !== wait) return;\r\n                    this.#retryDelayWait = undefined;\r\n                    wait.resolve();\r\n                }, delayMs), resolve\r\n            };\r\n            this.#retryDelayWait = wait;\r\n        });\r\n\r\n        // Token might have changed while waiting (stop during backoff).\r\n        if (token !== this.#lifecycleToken) throw new ConnectionAttemptCancelledError();\r\n    }\r\n\r\n    #interruptRetryDelay(): void {\r\n        const wait = this.#retryDelayWait;\r\n        if (!wait) return;\r\n        this.#retryDelayWait = undefined;\r\n        clearTimeout(wait.timer);\r\n        wait.resolve();\r\n    }\r\n\r\n    #closeWebSocket(webSocket: WebSocket, reason: string): void {\r\n        if (webSocket.readyState === READY_STATE_CLOSING || webSocket.readyState === READY_STATE_CLOSED) return;\r\n        try {\r\n            webSocket.close(3000, reason.slice(0, 120));\r\n        } catch { }\r\n    }\r\n}\r\n\r\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "capnweb-auto-reconnect",
+  "version": "0.0.1",
+  "description": "Reconnecting WebSocket RPC session support for capnweb.",
+  "scripts": {
+    "build": "tsdown",
+    "check:types": "tsgo --noEmit",
+    "lint": "oxlint --type-aware",
+    "check": "npm run lint && npm run check:types",
+    "test": "vitest run",
+    "prepublishOnly": "npm run check && npm run test && npm run build"
+  },
+  "keywords": [
+    "capnweb",
+    "rpc",
+    "websocket",
+    "reconnect"
+  ],
+  "author": "VastBlast",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "devDependencies": {
+    "@types/ws": "^8.18.1",
+    "@typescript/native-preview": "^7.0.0-dev.20260216.1",
+    "oxlint": "^1.48.0",
+    "oxlint-tsgolint": "^0.14.0",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "ws": "^8.19.0"
+  },
+  "dependencies": {
+    "capnweb": "^0.4.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  }
+}