@kyneta/websocket-transport 1.3.1 → 1.5.0

package/dist/client-transport-B2V7s2VP.js

@@ -0,0 +1,525 @@
+import { DEFAULT_RECONNECT, Transport, computeBackoffDelay } from "@kyneta/transport";
+import { createObservableProgram } from "@kyneta/machine";
+import { FragmentReassembler, applyInboundAliasing, applyOutboundAliasing, createFrameIdCounter, decodeBinaryWires, emptyAliasState, encodeWireFrameAndSend } from "@kyneta/wire";
+//#region src/client-program.ts
+/**
+* Create the websocket client connection lifecycle program — a pure Mealy machine.
+*
+* The returned `Program<WsClientMsg, WebsocketClientState, WsClientEffect>`
+* encodes every state transition and effect as inspectable data. The imperative
+* shell interprets `WsClientEffect` as actual I/O.
+*/
+function createWsClientProgram(options = {}) {
+	const { jitterFn = () => Math.random() * 1e3 } = options;
+	const reconnect = {
+		...DEFAULT_RECONNECT,
+		...options.reconnect
+	};
+	/**
+	* Attempt to transition into reconnecting, or give up and disconnect.
+	*
+	* Pure — computes the next state and effects from the current attempt
+	* count and reconnect configuration. Returns a tuple suitable for
+	* spreading into an `update` return.
+	*/
+	function tryReconnect(currentAttempt, reason, ...extraEffects) {
+		if (!reconnect.enabled) return [{
+			status: "disconnected",
+			reason
+		}, ...extraEffects];
+		if (currentAttempt >= reconnect.maxAttempts) return [{
+			status: "disconnected",
+			reason: {
+				type: "max-retries-exceeded",
+				attempts: currentAttempt
+			}
+		}, ...extraEffects];
+		const delay = computeBackoffDelay(currentAttempt + 1, reconnect.baseDelay, reconnect.maxDelay, jitterFn());
+		return [
+			{
+				status: "reconnecting",
+				attempt: currentAttempt + 1,
+				nextAttemptMs: delay
+			},
+			...extraEffects,
+			{
+				type: "start-reconnect-timer",
+				delayMs: delay
+			}
+		];
+	}
+	return {
+		init: [{ status: "disconnected" }],
+		update(msg, model) {
+			switch (msg.type) {
+				case "start":
+					if (model.status !== "disconnected") return [model];
+					return [{
+						status: "connecting",
+						attempt: 1
+					}, {
+						type: "create-websocket",
+						attempt: 1
+					}];
+				case "socket-opened":
+					if (model.status !== "connecting") return [model];
+					return [{ status: "connected" }, { type: "start-keepalive" }];
+				case "server-ready":
+					if (model.status === "ready") return [model];
+					if (model.status === "connected") return [{ status: "ready" }, { type: "add-channel-and-establish" }];
+					if (model.status === "connecting") return [
+						{ status: "ready" },
+						{ type: "start-keepalive" },
+						{ type: "add-channel-and-establish" }
+					];
+					return [model];
+				case "socket-closed": {
+					const reason = {
+						type: "closed",
+						code: msg.code,
+						reason: msg.reason
+					};
+					if (model.status === "connected") return tryReconnect(0, reason, { type: "stop-keepalive" });
+					if (model.status === "ready") return tryReconnect(0, reason, { type: "stop-keepalive" }, { type: "remove-channel" });
+					return [model];
+				}
+				case "socket-error": {
+					const reason = {
+						type: "error",
+						error: msg.error
+					};
+					if (model.status === "connecting") return tryReconnect(model.attempt, reason);
+					if (model.status === "connected") return tryReconnect(0, reason, { type: "stop-keepalive" });
+					if (model.status === "ready") return tryReconnect(0, reason, { type: "stop-keepalive" }, { type: "remove-channel" });
+					return [model];
+				}
+				case "reconnect-timer-fired":
+					if (model.status !== "reconnecting") return [model];
+					return [{
+						status: "connecting",
+						attempt: model.attempt
+					}, {
+						type: "create-websocket",
+						attempt: model.attempt
+					}];
+				case "stop": {
+					if (model.status === "disconnected") return [model];
+					const effects = [{ type: "cancel-reconnect-timer" }];
+					if (model.status === "connecting") effects.push({ type: "close-websocket" });
+					if (model.status === "connected") effects.push({ type: "close-websocket" }, { type: "stop-keepalive" });
+					if (model.status === "ready") effects.push({ type: "close-websocket" }, { type: "stop-keepalive" }, { type: "remove-channel" });
+					return [{
+						status: "disconnected",
+						reason: { type: "intentional" }
+					}, ...effects];
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/types.ts
+/**
+* WebSocket readyState constants per the WHATWG WebSocket spec.
+* Replaces references to `WebSocket.CONNECTING`, `WebSocket.OPEN`, etc.
+* so that shared code never depends on the browser global.
+*/
+const READY_STATE = {
+	CONNECTING: 0,
+	OPEN: 1,
+	CLOSING: 2,
+	CLOSED: 3
+};
+/**
+* Wrap a standard `WebSocket` (browser or Node.js `ws` via `ws` package
+* in `WebSocket`-compatible mode) into the `Socket` interface.
+*
+* Handles `ArrayBuffer`, `Blob`, and string messages.
+*/
+function wrapStandardWebsocket(ws) {
+	return {
+		send(data) {
+			ws.send(data);
+		},
+		close(code, reason) {
+			ws.close(code, reason);
+		},
+		onMessage(handler) {
+			ws.addEventListener("message", (event) => {
+				if (event.data instanceof ArrayBuffer) handler(new Uint8Array(event.data));
+				else if (typeof Blob !== "undefined" && event.data instanceof Blob) event.data.arrayBuffer().then((buffer) => {
+					handler(new Uint8Array(buffer));
+				});
+				else handler(event.data);
+			});
+		},
+		onClose(handler) {
+			ws.addEventListener("close", (event) => {
+				handler(event.code, event.reason);
+			});
+		},
+		onError(handler) {
+			ws.addEventListener("error", (_event) => {
+				handler(/* @__PURE__ */ new Error("WebSocket error"));
+			});
+		},
+		get readyState() {
+			switch (ws.readyState) {
+				case READY_STATE.CONNECTING: return "connecting";
+				case READY_STATE.OPEN: return "open";
+				case READY_STATE.CLOSING: return "closing";
+				case READY_STATE.CLOSED: return "closed";
+				default: return "closed";
+			}
+		}
+	};
+}
+/**
+* Wrap a Node.js `ws` library WebSocket into the `Socket` interface.
+*
+* Handles `Buffer` → `Uint8Array` conversion for binary messages.
+*/
+function wrapNodeWebsocket(ws) {
+	const CONNECTING = 0;
+	const OPEN = 1;
+	const CLOSING = 2;
+	return {
+		send(data) {
+			ws.send(data);
+		},
+		close(code, reason) {
+			ws.close(code, reason);
+		},
+		onMessage(handler) {
+			ws.on("message", (data, isBinary) => {
+				if (isBinary) if (data instanceof ArrayBuffer) handler(new Uint8Array(data));
+				else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) handler(new Uint8Array(data));
+				else handler(new Uint8Array(data));
+				else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) handler(data.toString("utf-8"));
+				else handler(data);
+			});
+		},
+		onClose(handler) {
+			ws.on("close", (code, reason) => {
+				handler(code, reason.toString());
+			});
+		},
+		onError(handler) {
+			ws.on("error", handler);
+		},
+		get readyState() {
+			switch (ws.readyState) {
+				case CONNECTING: return "connecting";
+				case OPEN: return "open";
+				case CLOSING: return "closing";
+				default: return "closed";
+			}
+		}
+	};
+}
+//#endregion
+//#region src/client-transport.ts
+/**
+* Default fragment threshold in bytes.
+* AWS API Gateway has a 128KB limit, so 100KB provides a safe margin.
+*/
+const DEFAULT_FRAGMENT_THRESHOLD = 100 * 1024;
+/**
+* Websocket client network transport for @kyneta/exchange.
+*
+* Connects to a Websocket server, sends and receives ChannelMsg via
+* the kyneta wire format (CBOR codec + framing + fragmentation).
+*
+* Internally, the connection lifecycle is a `Program<Msg, Model, Fx>` —
+* a pure Mealy machine whose transitions are deterministically testable.
+* This class is the imperative shell that interprets data effects as I/O.
+*
+* Prefer the factory functions for construction:
+* - `createWebsocketClient()` — browser-to-server (from `./browser`)
+* - `createServiceWebsocketClient()` — service-to-service with headers (from `./server`)
+*/
+var WebsocketClientTransport = class extends Transport {
+	#peerId;
+	#options;
+	#WebSocketImpl;
+	#handle;
+	#socket;
+	#serverChannel;
+	#keepaliveTimer;
+	#reconnectTimer;
+	#fragmentThreshold;
+	#reassembler;
+	#aliasState = emptyAliasState();
+	constructor(options) {
+		super({ transportType: "websocket-client" });
+		this.#options = options;
+		this.#WebSocketImpl = options.WebSocket;
+		this.#fragmentThreshold = options.fragmentThreshold ?? 102400;
+		this.#reassembler = new FragmentReassembler({ timeoutMs: 1e4 });
+		const program = createWsClientProgram({ reconnect: options.reconnect });
+		this.#handle = createObservableProgram(program, (effect, dispatch) => {
+			this.#executeEffect(effect, dispatch);
+		});
+		this.#setupLifecycleEvents();
+	}
+	#executeEffect(effect, dispatch) {
+		switch (effect.type) {
+			case "create-websocket":
+				this.#doCreateWebsocket(dispatch);
+				break;
+			case "close-websocket":
+				if (this.#socket) {
+					this.#socket.close(1e3, "Client disconnecting");
+					this.#socket = void 0;
+				}
+				break;
+			case "add-channel-and-establish":
+				if (this.#serverChannel) {
+					this.removeChannel(this.#serverChannel.channelId);
+					this.#serverChannel = void 0;
+				}
+				this.#reassembler.reset();
+				this.#serverChannel = this.addChannel();
+				this.establishChannel(this.#serverChannel.channelId);
+				break;
+			case "remove-channel":
+				if (this.#serverChannel) {
+					this.removeChannel(this.#serverChannel.channelId);
+					this.#serverChannel = void 0;
+				}
+				break;
+			case "start-reconnect-timer":
+				this.#reconnectTimer = setTimeout(() => {
+					this.#reconnectTimer = void 0;
+					dispatch({ type: "reconnect-timer-fired" });
+				}, effect.delayMs);
+				break;
+			case "cancel-reconnect-timer":
+				if (this.#reconnectTimer !== void 0) {
+					clearTimeout(this.#reconnectTimer);
+					this.#reconnectTimer = void 0;
+				}
+				break;
+			case "start-keepalive":
+				this.#startKeepalive();
+				break;
+			case "stop-keepalive":
+				this.#stopKeepalive();
+				break;
+		}
+	}
+	/**
+	* Create a WebSocket and wire up event handlers to dispatch messages.
+	*
+	* The message handler is set up IMMEDIATELY after creation (before
+	* the open event) to handle the race condition where the server sends
+	* "ready" before the client's open promise resolves.
+	*/
+	#doCreateWebsocket(dispatch) {
+		const peerId = this.#peerId;
+		if (!peerId) {
+			dispatch({
+				type: "socket-error",
+				error: /* @__PURE__ */ new Error("Cannot connect: peerId not set")
+			});
+			return;
+		}
+		const url = typeof this.#options.url === "function" ? this.#options.url(peerId) : this.#options.url;
+		try {
+			if (this.#options.headers && Object.keys(this.#options.headers).length > 0) this.#socket = new this.#WebSocketImpl(url, { headers: this.#options.headers });
+			else this.#socket = new this.#WebSocketImpl(url);
+			this.#socket.binaryType = "arraybuffer";
+			const socket = this.#socket;
+			socket.addEventListener("message", (event) => {
+				this.#handleMessage(event, dispatch);
+			});
+			let settled = false;
+			const onOpen = () => {
+				cleanup();
+				settled = true;
+				dispatch({ type: "socket-opened" });
+				socket.addEventListener("close", (event) => {
+					dispatch({
+						type: "socket-closed",
+						code: event.code,
+						reason: event.reason
+					});
+				});
+			};
+			const onError = () => {
+				if (settled) return;
+				cleanup();
+				settled = true;
+				dispatch({
+					type: "socket-error",
+					error: /* @__PURE__ */ new Error("WebSocket connection failed")
+				});
+			};
+			const onClose = () => {
+				if (settled) return;
+				cleanup();
+				settled = true;
+				dispatch({
+					type: "socket-error",
+					error: /* @__PURE__ */ new Error("WebSocket closed during connection")
+				});
+			};
+			const cleanup = () => {
+				socket.removeEventListener("open", onOpen);
+				socket.removeEventListener("error", onError);
+				socket.removeEventListener("close", onClose);
+			};
+			socket.addEventListener("open", onOpen);
+			socket.addEventListener("error", onError);
+			socket.addEventListener("close", onClose);
+		} catch (error) {
+			dispatch({
+				type: "socket-error",
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+		}
+	}
+	/**
+	* Handle incoming Websocket messages.
+	*
+	* Text frames carry the "ready" handshake and keepalive pong.
+	* Binary frames carry CBOR-encoded ChannelMsg.
+	*/
+	#handleMessage(event, dispatch) {
+		const data = event.data;
+		if (typeof data === "string") {
+			if (data === "ready") dispatch({ type: "server-ready" });
+			return;
+		}
+		if (data instanceof ArrayBuffer) try {
+			const wires = decodeBinaryWires(new Uint8Array(data), this.#reassembler);
+			if (!wires) return;
+			for (const wire of wires) {
+				const result = applyInboundAliasing(this.#aliasState, wire);
+				this.#aliasState = result.state;
+				if (result.error || !result.msg) {
+					console.warn("[WebsocketClient] alias resolution failed:", result.error);
+					continue;
+				}
+				this.#handleChannelMessage(result.msg);
+			}
+		} catch (error) {
+			console.error("Failed to decode message:", error);
+		}
+	}
+	/**
+	* Handle a decoded channel message.
+	*/
+	#handleChannelMessage(msg) {
+		if (!this.#serverChannel) return;
+		this.#serverChannel.onReceive(msg);
+	}
+	#startKeepalive() {
+		this.#stopKeepalive();
+		const interval = this.#options.keepaliveInterval ?? 3e4;
+		this.#keepaliveTimer = setInterval(() => {
+			if (this.#socket?.readyState === READY_STATE.OPEN) this.#socket.send("ping");
+		}, interval);
+	}
+	#stopKeepalive() {
+		if (this.#keepaliveTimer) {
+			clearInterval(this.#keepaliveTimer);
+			this.#keepaliveTimer = void 0;
+		}
+	}
+	#setupLifecycleEvents() {
+		let wasConnectedBefore = false;
+		this.#handle.subscribeToTransitions((transition) => {
+			this.#options.lifecycle?.onStateChange?.(transition);
+			const { from, to } = transition;
+			if (to.status === "disconnected" && to.reason) this.#options.lifecycle?.onDisconnect?.(to.reason);
+			if (to.status === "reconnecting") this.#options.lifecycle?.onReconnecting?.(to.attempt, to.nextAttemptMs);
+			if (wasConnectedBefore && (from.status === "reconnecting" || from.status === "connecting") && (to.status === "connected" || to.status === "ready")) this.#options.lifecycle?.onReconnected?.();
+			if (to.status === "ready") {
+				this.#options.lifecycle?.onReady?.();
+				wasConnectedBefore = true;
+			}
+		});
+	}
+	/**
+	* Get the current connection state.
+	*/
+	getState() {
+		return this.#handle.getState();
+	}
+	/**
+	* Subscribe to state transitions.
+	*/
+	subscribeToTransitions(listener) {
+		return this.#handle.subscribeToTransitions(listener);
+	}
+	/**
+	* Wait for a specific state.
+	*/
+	waitForState(predicate, options) {
+		return this.#handle.waitForState(predicate, options);
+	}
+	/**
+	* Wait for a specific status.
+	*/
+	waitForStatus(status, options) {
+		return this.#handle.waitForStatus(status, options);
+	}
+	/**
+	* Whether the client is ready (server ready signal received).
+	*/
+	get isReady() {
+		return this.#handle.getState().status === "ready";
+	}
+	generate() {
+		const nextFrameId = createFrameIdCounter();
+		this.#aliasState = emptyAliasState();
+		return {
+			transportType: this.transportType,
+			send: (msg) => {
+				const socket = this.#socket;
+				if (!socket || socket.readyState !== READY_STATE.OPEN) return;
+				const { state, wire } = applyOutboundAliasing(this.#aliasState, msg);
+				this.#aliasState = state;
+				encodeWireFrameAndSend(wire, (data) => socket.send(new Uint8Array(data).buffer), this.#fragmentThreshold, nextFrameId);
+			},
+			stop: () => {}
+		};
+	}
+	async onStart() {
+		if (!this.identity) throw new Error("Transport not properly initialized — identity not available");
+		this.#peerId = this.identity.peerId;
+		this.#handle.dispatch({ type: "start" });
+	}
+	async onStop() {
+		this.#reassembler.dispose();
+		this.#handle.dispatch({ type: "stop" });
+	}
+};
+/**
+* Create a Websocket client transport factory for browser-to-server
+* connections.
+*
+* Returns an `TransportFactory` — a closure that creates a fresh transport
+* instance when called. Pass directly to `Exchange({ transports: [...] })`.
+*
+* @example
+* ```typescript
+* import { createWebsocketClient } from "@kyneta/websocket-transport/browser"
+*
+* const exchange = new Exchange({
+*   transports: [createWebsocketClient({
+*     url: "ws://localhost:3000/ws",
+*     WebSocket,
+*     reconnect: { enabled: true },
+*   })],
+* })
+* ```
+*/
+function createWebsocketClient(options) {
+	return () => new WebsocketClientTransport(options);
+}
+//#endregion
+export { wrapNodeWebsocket as a, READY_STATE as i, WebsocketClientTransport as n, wrapStandardWebsocket as o, createWebsocketClient as r, createWsClientProgram as s, DEFAULT_FRAGMENT_THRESHOLD as t };
+
+//# sourceMappingURL=client-transport-B2V7s2VP.js.map

package/dist/client-transport-B2V7s2VP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-transport-B2V7s2VP.js","names":["#fragmentThreshold","#reassembler","#options","#WebSocketImpl","#handle","#executeEffect","#setupLifecycleEvents","#doCreateWebsocket","#socket","#serverChannel","#reconnectTimer","#startKeepalive","#stopKeepalive","#peerId","#handleMessage","#aliasState","#handleChannelMessage","#keepaliveTimer"],"sources":["../src/client-program.ts","../src/types.ts","../src/client-transport.ts"],"sourcesContent":["// client-program — pure Mealy machine for websocket client connection lifecycle.\n//\n// The client program encodes every state transition and effect as data.\n// The imperative shell (client-transport.ts) interprets effects as I/O.\n// Tests assert on data — no sockets, no timing, never flaky.\n//\n// Algebra: Program<WsClientMsg, WebsocketClientState, WsClientEffect>\n// Interpreter: client-transport.ts executeClientEffect()\n//\n// The websocket client has a 5-state lifecycle with an extra \"ready\" state\n// compared to the unix socket client. The server sends a text \"ready\" signal\n// after the connection opens, and only then does the client create a channel\n// and start the establishment handshake.\n//\n// Race condition: the server may send \"ready\" before the client's open event\n// fires (server-ready while connecting). The program handles this by\n// transitioning directly to ready, skipping the connected state.\n\nimport type { Program } from \"@kyneta/machine\"\nimport type { ReconnectOptions } from \"@kyneta/transport\"\nimport { computeBackoffDelay, DEFAULT_RECONNECT } from \"@kyneta/transport\"\n\nimport type { DisconnectReason, WebsocketClientState } from \"./types.js\"\n\n// ---------------------------------------------------------------------------\n// Messages\n// ---------------------------------------------------------------------------\n\nexport type WsClientMsg =\n  | { type: \"start\" }\n  | { type: \"socket-opened\" }\n  | { type: \"server-ready\" }\n  | { type: \"socket-closed\"; code: number; reason: string }\n  | { type: \"socket-error\"; error: Error }\n  | { type: \"reconnect-timer-fired\" }\n  | { type: \"stop\" }\n\n// ---------------------------------------------------------------------------\n// Effects (data — interpreted by the imperative shell)\n// ---------------------------------------------------------------------------\n\nexport type WsClientEffect =\n  | { type: \"create-websocket\"; attempt: number }\n  | { type: \"close-websocket\" }\n  | { type: \"add-channel-and-establish\" }\n  | { type: \"remove-channel\" }\n  | { type: \"start-reconnect-timer\"; delayMs: number }\n  | { type: \"cancel-reconnect-timer\" }\n  | { type: \"start-keepalive\" }\n  | { type: \"stop-keepalive\" }\n\n// ---------------------------------------------------------------------------\n// Program factory\n// ---------------------------------------------------------------------------\n\nexport interface WsClientProgramOptions {\n  reconnect?: Partial<ReconnectOptions>\n  /** Inject jitter source for deterministic testing. Default: () => Math.random() * 1000 */\n  jitterFn?: () => number\n}\n\n/**\n * Create the websocket client connection lifecycle program — a pure Mealy machine.\n *\n * The returned `Program<WsClientMsg, WebsocketClientState, WsClientEffect>`\n * encodes every state transition and effect as inspectable data. The imperative\n * shell interprets `WsClientEffect` as actual I/O.\n */\nexport function createWsClientProgram(\n  options: WsClientProgramOptions = {},\n): Program<WsClientMsg, WebsocketClientState, WsClientEffect> {\n  const { jitterFn = () => Math.random() * 1000 } = options\n  const reconnect: ReconnectOptions = {\n    ...DEFAULT_RECONNECT,\n    ...options.reconnect,\n  }\n\n  /**\n   * Attempt to transition into reconnecting, or give up and disconnect.\n   *\n   * Pure — computes the next state and effects from the current attempt\n   * count and reconnect configuration. Returns a tuple suitable for\n   * spreading into an `update` return.\n   */\n  function tryReconnect(\n    currentAttempt: number,\n    reason: DisconnectReason,\n    ...extraEffects: WsClientEffect[]\n  ): [WebsocketClientState, ...WsClientEffect[]] {\n    if (!reconnect.enabled) {\n      return [{ status: \"disconnected\", reason }, ...extraEffects]\n    }\n\n    if (currentAttempt >= reconnect.maxAttempts) {\n      return [\n        {\n          status: \"disconnected\",\n          reason: { type: \"max-retries-exceeded\", attempts: currentAttempt },\n        },\n        ...extraEffects,\n      ]\n    }\n\n    const delay = computeBackoffDelay(\n      currentAttempt + 1,\n      reconnect.baseDelay,\n      reconnect.maxDelay,\n      jitterFn(),\n    )\n\n    return [\n      {\n        status: \"reconnecting\",\n        attempt: currentAttempt + 1,\n        nextAttemptMs: delay,\n      },\n      ...extraEffects,\n      { type: \"start-reconnect-timer\", delayMs: delay },\n    ]\n  }\n\n  return {\n    init: [{ status: \"disconnected\" }],\n\n    update(msg, model): [WebsocketClientState, ...WsClientEffect[]] {\n      switch (msg.type) {\n        // -----------------------------------------------------------------\n        // start\n        // -----------------------------------------------------------------\n        case \"start\": {\n          if (model.status !== \"disconnected\") return [model]\n          return [\n            { status: \"connecting\", attempt: 1 },\n            { type: \"create-websocket\", attempt: 1 },\n          ]\n        }\n\n        // -----------------------------------------------------------------\n        // socket-opened\n        // -----------------------------------------------------------------\n        case \"socket-opened\": {\n          if (model.status !== \"connecting\") return [model]\n          return [{ status: \"connected\" }, { type: \"start-keepalive\" }]\n        }\n\n        // -----------------------------------------------------------------\n        // server-ready\n        // -----------------------------------------------------------------\n        case \"server-ready\": {\n          // Already ready — ignore duplicate\n          if (model.status === \"ready\") return [model]\n\n          // Normal path: connected → ready\n          if (model.status === \"connected\") {\n            return [{ status: \"ready\" }, { type: \"add-channel-and-establish\" }]\n          }\n\n          // Race condition: server sent \"ready\" before client's open event fired.\n          // Skip connected, go directly to ready with both keepalive and channel effects.\n          if (model.status === \"connecting\") {\n            return [\n              { status: \"ready\" },\n              { type: \"start-keepalive\" },\n              { type: \"add-channel-and-establish\" },\n            ]\n          }\n\n          return [model]\n        }\n\n        // -----------------------------------------------------------------\n        // socket-closed\n        // -----------------------------------------------------------------\n        case \"socket-closed\": {\n          const reason: DisconnectReason = {\n            type: \"closed\",\n            code: msg.code,\n            reason: msg.reason,\n          }\n\n          if (model.status === \"connected\") {\n            return tryReconnect(0, reason, { type: \"stop-keepalive\" })\n          }\n\n          if (model.status === \"ready\") {\n            return tryReconnect(\n              0,\n              reason,\n              { type: \"stop-keepalive\" },\n              { type: \"remove-channel\" },\n            )\n          }\n\n          return [model]\n        }\n\n        // -----------------------------------------------------------------\n        // socket-error\n        // -----------------------------------------------------------------\n        case \"socket-error\": {\n          const reason: DisconnectReason = {\n            type: \"error\",\n            error: msg.error,\n          }\n\n          if (model.status === \"connecting\") {\n            return tryReconnect(model.attempt, reason)\n          }\n\n          if (model.status === \"connected\") {\n            return tryReconnect(0, reason, { type: \"stop-keepalive\" })\n          }\n\n          if (model.status === \"ready\") {\n            return tryReconnect(\n              0,\n              reason,\n              { type: \"stop-keepalive\" },\n              { type: \"remove-channel\" },\n            )\n          }\n\n          return [model]\n        }\n\n        // -----------------------------------------------------------------\n        // reconnect-timer-fired\n        // -----------------------------------------------------------------\n        case \"reconnect-timer-fired\": {\n          if (model.status !== \"reconnecting\") return [model]\n          return [\n            { status: \"connecting\", attempt: model.attempt },\n            { type: \"create-websocket\", attempt: model.attempt },\n          ]\n        }\n\n        // -----------------------------------------------------------------\n        // stop\n        // -----------------------------------------------------------------\n        case \"stop\": {\n          if (model.status === \"disconnected\") return [model]\n\n          const effects: WsClientEffect[] = [{ type: \"cancel-reconnect-timer\" }]\n\n          if (model.status === \"connecting\") {\n            effects.push({ type: \"close-websocket\" })\n          }\n\n          if (model.status === \"connected\") {\n            effects.push(\n              { type: \"close-websocket\" },\n              { type: \"stop-keepalive\" },\n            )\n          }\n\n          if (model.status === \"ready\") {\n            effects.push(\n              { type: \"close-websocket\" },\n              { type: \"stop-keepalive\" },\n              { type: \"remove-channel\" },\n            )\n          }\n\n          return [\n            { status: \"disconnected\", reason: { type: \"intentional\" } },\n            ...effects,\n          ]\n        }\n      }\n    },\n  }\n}\n","// types — framework-agnostic Websocket abstractions for @kyneta/websocket-transport.\n//\n// The `Socket` interface decouples the adapter from any specific Websocket\n// library (browser WebSocket, Node `ws`, Bun ServerWebSocket). Platform-\n// specific wrappers (`wrapStandardWebsocket`, `wrapNodeWebsocket`,\n// `wrapBunWebsocket`) adapt concrete implementations to this interface.\n//\n// Ported from @loro-extended/adapter-websocket's WsSocket with kyneta\n// naming conventions applied.\n\nimport type {\n  TransitionListener as GenericTransitionListener,\n  PeerId,\n  StateTransition,\n} from \"@kyneta/transport\"\n\n// ---------------------------------------------------------------------------\n// WebSocket readyState constants (spec values, no global dependency)\n// ---------------------------------------------------------------------------\n\n/**\n * WebSocket readyState constants per the WHATWG WebSocket spec.\n * Replaces references to `WebSocket.CONNECTING`, `WebSocket.OPEN`, etc.\n * so that shared code never depends on the browser global.\n */\nexport const READY_STATE = {\n  CONNECTING: 0,\n  OPEN: 1,\n  CLOSING: 2,\n  CLOSED: 3,\n} as const\n\n// ---------------------------------------------------------------------------\n// Structural event types (replace DOM MessageEvent / CloseEvent)\n// ---------------------------------------------------------------------------\n\n/** Minimal message event — only the fields the transport accesses. */\nexport interface WebSocketMessageEvent {\n  readonly data: string | ArrayBuffer\n}\n\n/** Minimal close event — only the fields the transport accesses. */\nexport interface WebSocketCloseEvent {\n  readonly code: number\n  readonly reason: string\n}\n\n// ---------------------------------------------------------------------------\n// WebSocket instance and constructor structural types\n// ---------------------------------------------------------------------------\n\n/**\n * Structural type for a constructed WebSocket instance.\n *\n * Covers the browser's `WebSocket`, the `ws` library's `WebSocket`,\n * and Bun's client `WebSocket` — all satisfy this interface without casting.\n *\n * The client transport uses `addEventListener`/`removeEventListener` for\n * one-shot connection handlers with explicit cleanup during the connect\n * phase. This is why `WebSocketLike` exists alongside the server-side\n * `Socket` interface (which uses single-callback registration).\n */\nexport interface WebSocketLike {\n  readonly readyState: number\n  binaryType: string\n  send(data: string | ArrayBuffer): void\n  close(code?: number, reason?: string): void\n  addEventListener(type: string, listener: (event: any) => void): void\n  removeEventListener(type: string, listener: (event: any) => void): void\n}\n\n/**\n * Structural type for a WebSocket constructor.\n *\n * Type safety for constructor arguments is intentionally at the options\n * layer (`WebsocketClientOptions.headers`), not here. The `...rest: any[]`\n * absorbs both the browser's `protocols` arg and backend's `{ headers }`\n * arg without requiring the transport to know which runtime it's in.\n */\nexport type WebSocketConstructor = new (\n  url: string,\n  ...rest: any[]\n) => WebSocketLike\n\n// ---------------------------------------------------------------------------\n// Socket ready states (string enum for server-side Socket interface)\n// ---------------------------------------------------------------------------\n\n/**\n * Websocket ready states — mirrors the standard WebSocket readyState\n * values as human-readable strings.\n */\nexport type SocketReadyState = \"connecting\" | \"open\" | \"closing\" | \"closed\"\n\n// ---------------------------------------------------------------------------\n// Socket interface\n// ---------------------------------------------------------------------------\n\n/**\n * Framework-agnostic Websocket interface.\n *\n * This allows the adapter to work with any Websocket library:\n * - Browser `WebSocket` via `wrapStandardWebsocket()`\n * - Node.js `ws` library via `wrapNodeWebsocket()`\n * - Bun `ServerWebSocket` via `wrapBunWebsocket()`\n *\n * The interface is intentionally minimal — only the operations the\n * adapter needs are exposed.\n */\nexport interface Socket {\n  /**\n   * Narrowed to `Uint8Array<ArrayBuffer>` because the strictest downstream\n   * runtimes reject `SharedArrayBuffer`-backed views: Bun's `BufferSource`\n   * resolves to `ArrayBufferView<ArrayBuffer> | ArrayBuffer`, and Hono's\n   * `WSContext.send` takes `Uint8Array<ArrayBuffer>` directly. The wire\n   * pipeline allocates with `new Uint8Array(n)`, so producers satisfy this\n   * without changes.\n   */\n  send(data: Uint8Array<ArrayBuffer> | string): void\n\n  /** Close the Websocket connection. */\n  close(code?: number, reason?: string): void\n\n  /** Register a handler for incoming messages (binary or text). */\n  onMessage(handler: (data: Uint8Array<ArrayBuffer> | string) => void): void\n\n  /** Register a handler for connection close. */\n  onClose(handler: (code: number, reason: string) => void): void\n\n  /** Register a handler for errors. */\n  onError(handler: (error: Error) => void): void\n\n  /** The current ready state of the Websocket. */\n  readonly readyState: SocketReadyState\n}\n\n// ---------------------------------------------------------------------------\n// Connection types — used by server adapter\n// ---------------------------------------------------------------------------\n\n/**\n * Options for handling a new Websocket connection on the server.\n */\nexport interface WebsocketConnectionOptions {\n  /** The Websocket instance, wrapped in the Socket interface. */\n  socket: Socket\n\n  /** Optional peer ID extracted from the upgrade request. */\n  peerId?: PeerId\n\n  /** Optional authentication token from the upgrade request. */\n  authToken?: string\n}\n\n/**\n * Handle for an active Websocket connection.\n */\nexport interface WebsocketConnectionHandle {\n  /** The peer ID for this connection. */\n  readonly peerId: PeerId\n\n  /** The channel ID for this connection. */\n  readonly channelId: number\n\n  /** Close the connection. */\n  close(code?: number, reason?: string): void\n}\n\n/**\n * Result of handling a Websocket connection on the server.\n */\nexport interface WebsocketConnectionResult {\n  /** The connection handle for managing this peer. */\n  connection: WebsocketConnectionHandle\n\n  /** Call this to start processing messages. */\n  start(): void\n}\n\n// ---------------------------------------------------------------------------\n// Disconnect reason\n// ---------------------------------------------------------------------------\n\n/**\n * Discriminated union describing why a Websocket connection was lost.\n */\nexport type DisconnectReason =\n  | { type: \"intentional\" }\n  | { type: \"error\"; error: Error }\n  | { type: \"closed\"; code: number; reason: string }\n  | { type: \"max-retries-exceeded\"; attempts: number }\n  | { type: \"not-started\" }\n\n// ---------------------------------------------------------------------------\n// Connection state (for client adapter observability)\n// ---------------------------------------------------------------------------\n\n/**\n * All possible states of the Websocket client.\n *\n * State machine transitions:\n * ```\n * disconnected → connecting → connected → ready\n *                    ↓            ↓         ↓\n *               reconnecting ← ─ ┴ ─ ─ ─ ─ ┘\n *                    ↓\n *               connecting (retry)\n *                    ↓\n *               disconnected (max retries)\n * ```\n */\nexport type WebsocketClientState =\n  | { status: \"disconnected\"; reason?: DisconnectReason }\n  | { status: \"connecting\"; attempt: number }\n  | { status: \"connected\" }\n  | { status: \"ready\" }\n  | { status: \"reconnecting\"; attempt: number; nextAttemptMs: number }\n\n/**\n * A state transition event for websocket client states.\n * Specialized from the generic `StateTransition<S>`.\n */\nexport type WebsocketClientStateTransition =\n  StateTransition<WebsocketClientState>\n\n/**\n * Listener for websocket client state transitions.\n * Specialized from the generic `TransitionListener<S>`.\n */\nexport type TransitionListener = GenericTransitionListener<WebsocketClientState>\n\n// ---------------------------------------------------------------------------\n// Socket wrapper — standard WebSocket API (browser + Node ws)\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap a standard `WebSocket` (browser or Node.js `ws` via `ws` package\n * in `WebSocket`-compatible mode) into the `Socket` interface.\n *\n * Handles `ArrayBuffer`, `Blob`, and string messages.\n */\nexport function wrapStandardWebsocket(ws: WebSocket): Socket {\n  return {\n    send(data: Uint8Array<ArrayBuffer> | string): void {\n      ws.send(data)\n    },\n\n    close(code?: number, reason?: string): void {\n      ws.close(code, reason)\n    },\n\n    onMessage(handler: (data: Uint8Array<ArrayBuffer> | string) => void): void {\n      ws.addEventListener(\"message\", event => {\n        if (event.data instanceof ArrayBuffer) {\n          handler(new Uint8Array(event.data))\n        } else if (typeof Blob !== \"undefined\" && event.data instanceof Blob) {\n          // Handle Blob data (browser)\n          event.data.arrayBuffer().then(buffer => {\n            handler(new Uint8Array(buffer))\n          })\n        } else {\n          handler(event.data as string)\n        }\n      })\n    },\n\n    onClose(handler: (code: number, reason: string) => void): void {\n      ws.addEventListener(\"close\", event => {\n        handler(event.code, event.reason)\n      })\n    },\n\n    onError(handler: (error: Error) => void): void {\n      ws.addEventListener(\"error\", _event => {\n        handler(new Error(\"WebSocket error\"))\n      })\n    },\n\n    get readyState(): SocketReadyState {\n      switch (ws.readyState) {\n        case READY_STATE.CONNECTING:\n          return \"connecting\"\n        case READY_STATE.OPEN:\n          return \"open\"\n        case READY_STATE.CLOSING:\n          return \"closing\"\n        case READY_STATE.CLOSED:\n          return \"closed\"\n        default:\n          return \"closed\"\n      }\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Socket wrapper — Node.js `ws` library (raw API, not WebSocket-compat)\n// ---------------------------------------------------------------------------\n\n/**\n * The minimal interface we need from the Node.js `ws` library's `WebSocket`.\n *\n * Using a structural type rather than importing `ws` — consumers provide\n * the actual `ws` instance, we just need these methods.\n */\nexport interface NodeWebsocketLike {\n  send(data: Uint8Array<ArrayBuffer> | string): void\n  close(code?: number, reason?: string): void\n  on(\n    event: \"message\",\n    handler: (data: Buffer | ArrayBuffer | string, isBinary: boolean) => void,\n  ): void\n  on(event: \"close\", handler: (code: number, reason: Buffer) => void): void\n  on(event: \"error\", handler: (error: Error) => void): void\n  readyState: number\n}\n\n/**\n * Wrap a Node.js `ws` library WebSocket into the `Socket` interface.\n *\n * Handles `Buffer` → `Uint8Array` conversion for binary messages.\n */\nexport function wrapNodeWebsocket(ws: NodeWebsocketLike): Socket {\n  const CONNECTING = 0\n  const OPEN = 1\n  const CLOSING = 2\n\n  return {\n    send(data: Uint8Array<ArrayBuffer> | string): void {\n      ws.send(data)\n    },\n\n    close(code?: number, reason?: string): void {\n      ws.close(code, reason)\n    },\n\n    onMessage(handler: (data: Uint8Array<ArrayBuffer> | string) => void): void {\n      ws.on(\n        \"message\",\n        (data: Buffer | ArrayBuffer | string, isBinary: boolean) => {\n          if (isBinary) {\n            if (data instanceof ArrayBuffer) {\n              handler(new Uint8Array(data))\n            } else if (typeof Buffer !== \"undefined\" && Buffer.isBuffer(data)) {\n              handler(new Uint8Array(data))\n            } else {\n              handler(new Uint8Array(data as unknown as ArrayBuffer))\n            }\n          } else {\n            if (typeof Buffer !== \"undefined\" && Buffer.isBuffer(data)) {\n              handler(data.toString(\"utf-8\"))\n            } else {\n              handler(data as string)\n            }\n          }\n        },\n      )\n    },\n\n    onClose(handler: (code: number, reason: string) => void): void {\n      ws.on(\"close\", (code: number, reason: Buffer) => {\n        handler(code, reason.toString())\n      })\n    },\n\n    onError(handler: (error: Error) => void): void {\n      ws.on(\"error\", handler)\n    },\n\n    get readyState(): SocketReadyState {\n      switch (ws.readyState) {\n        case CONNECTING:\n          return \"connecting\"\n        case OPEN:\n          return \"open\"\n        case CLOSING:\n          return \"closing\"\n        default:\n          return \"closed\"\n      }\n    },\n  }\n}\n","// client-transport — Websocket client transport for @kyneta/exchange.\n//\n// Thin imperative shell around the pure client program (client-program.ts).\n// The program produces data effects; this module interprets them as I/O.\n//\n// FC/IS design:\n// - client-program.ts: pure Mealy machine (functional core)\n// - client-transport.ts: effect executor (imperative shell)\n//\n// Uses the kyneta wire format (CBOR codec + framing + fragmentation)\n// for binary messages. Text frames carry the \"ready\" handshake and\n// keepalive ping/pong.\n\nimport type { ObservableHandle, TransitionListener } from \"@kyneta/machine\"\nimport { createObservableProgram } from \"@kyneta/machine\"\nimport type {\n  Channel,\n  ChannelMsg,\n  GeneratedChannel,\n  PeerId,\n  TransportFactory,\n} from \"@kyneta/transport\"\nimport { Transport } from \"@kyneta/transport\"\nimport {\n  type AliasState,\n  applyInboundAliasing,\n  applyOutboundAliasing,\n  createFrameIdCounter,\n  decodeBinaryWires,\n  emptyAliasState,\n  encodeWireFrameAndSend,\n  FragmentReassembler,\n} from \"@kyneta/wire\"\nimport {\n  createWsClientProgram,\n  type WsClientEffect,\n  type WsClientMsg,\n} from \"./client-program.js\"\nimport type {\n  DisconnectReason,\n  WebsocketClientState,\n  WebsocketClientStateTransition,\n} from \"./types.js\"\nimport {\n  READY_STATE,\n  type WebSocketCloseEvent,\n  type WebSocketConstructor,\n  type WebSocketLike,\n  type WebSocketMessageEvent,\n} from \"./types.js\"\n\n// Re-export state types for convenience\nexport type {\n  DisconnectReason,\n  WebsocketClientState,\n  WebsocketClientStateTransition,\n}\n\n// ---------------------------------------------------------------------------\n// Options\n// ---------------------------------------------------------------------------\n\n/**\n * Default fragment threshold in bytes.\n * AWS API Gateway has a 128KB limit, so 100KB provides a safe margin.\n */\nexport const DEFAULT_FRAGMENT_THRESHOLD = 100 * 1024\n\n/**\n * Options for the Websocket client transport (browser connections).\n */\nexport interface WebsocketClientOptions {\n  /** Websocket URL to connect to. Can be a string or a function of peerId. */\n  url: string | ((peerId: PeerId) => string)\n\n  /**\n   * WebSocket constructor — caller must provide explicitly.\n   *\n   * In browsers, pass the global `WebSocket`. In Node.js, pass `ws`'s\n   * `WebSocket`. In Bun, pass `globalThis.WebSocket`. The transport\n   * never probes `globalThis` on its own.\n   */\n  WebSocket: WebSocketConstructor\n\n  /**\n   * Headers to send during Websocket upgrade.\n   * Used for authentication in service-to-service communication.\n   *\n   * Note: Headers are a Bun/Node-specific extension. The browser WebSocket\n   * API does not support custom headers per the WHATWG spec.\n   */\n  headers?: Record<string, string>\n\n  /** Reconnection options. */\n  reconnect?: {\n    enabled?: boolean\n    maxAttempts?: number\n    baseDelay?: number\n    maxDelay?: number\n  }\n\n  /** Keepalive interval in ms (default: 30000). */\n  keepaliveInterval?: number\n\n  /**\n   * Fragment threshold in bytes. Messages larger than this are fragmented.\n   * Set to 0 to disable fragmentation (not recommended for cloud deployments).\n   * Default: 100KB\n   */\n  fragmentThreshold?: number\n\n  /** Lifecycle event callbacks. */\n  lifecycle?: WebsocketClientLifecycleEvents\n}\n\n/**\n * Lifecycle event callbacks for the Websocket client.\n */\nexport interface WebsocketClientLifecycleEvents {\n  /** Called on every state transition (delivered async via microtask). */\n  onStateChange?: (transition: WebsocketClientStateTransition) => void\n\n  /** Called when the connection is lost. */\n  onDisconnect?: (reason: DisconnectReason) => void\n\n  /** Called when a reconnection attempt is scheduled. */\n  onReconnecting?: (attempt: number, nextAttemptMs: number) => void\n\n  /** Called when reconnection succeeds after a previous connection. */\n  onReconnected?: () => void\n\n  /** Called when the server sends the \"ready\" signal. */\n  onReady?: () => void\n}\n\n// ---------------------------------------------------------------------------\n// WebsocketClientTransport\n// ---------------------------------------------------------------------------\n\n/**\n * Websocket client network transport for @kyneta/exchange.\n *\n * Connects to a Websocket server, sends and receives ChannelMsg via\n * the kyneta wire format (CBOR codec + framing + fragmentation).\n *\n * Internally, the connection lifecycle is a `Program<Msg, Model, Fx>` —\n * a pure Mealy machine whose transitions are deterministically testable.\n * This class is the imperative shell that interprets data effects as I/O.\n *\n * Prefer the factory functions for construction:\n * - `createWebsocketClient()` — browser-to-server (from `./browser`)\n * - `createServiceWebsocketClient()` — service-to-service with headers (from `./server`)\n */\nexport class WebsocketClientTransport extends Transport<void> {\n  #peerId?: PeerId\n  #options: WebsocketClientOptions\n  #WebSocketImpl: WebSocketConstructor\n\n  // Observable program handle — created in constructor, drives all state\n  #handle: ObservableHandle<WsClientMsg, WebsocketClientState>\n\n  // Executor-local I/O state — not in the program model\n  #socket?: WebSocketLike\n  #serverChannel?: Channel\n  #keepaliveTimer?: ReturnType<typeof setInterval>\n  #reconnectTimer?: ReturnType<typeof setTimeout>\n\n  // Fragmentation\n  readonly #fragmentThreshold: number\n  readonly #reassembler: FragmentReassembler\n\n  // Per-channel alias state (Phase 4). Single channel per client.\n  #aliasState: AliasState = emptyAliasState()\n\n  constructor(options: WebsocketClientOptions) {\n    super({ transportType: \"websocket-client\" })\n    this.#options = options\n    this.#WebSocketImpl = options.WebSocket\n    this.#fragmentThreshold =\n      options.fragmentThreshold ?? DEFAULT_FRAGMENT_THRESHOLD\n    this.#reassembler = new FragmentReassembler({\n      timeoutMs: 10_000,\n    })\n\n    const program = createWsClientProgram({\n      reconnect: options.reconnect,\n    })\n\n    this.#handle = createObservableProgram(program, (effect, dispatch) => {\n      this.#executeEffect(effect, dispatch)\n    })\n\n    // Set up lifecycle event forwarding\n    this.#setupLifecycleEvents()\n  }\n\n  // ==========================================================================\n  // Effect executor — interprets data effects as I/O\n  // ==========================================================================\n\n  #executeEffect(\n    effect: WsClientEffect,\n    dispatch: (msg: WsClientMsg) => void,\n  ): void {\n    switch (effect.type) {\n      case \"create-websocket\": {\n        this.#doCreateWebsocket(dispatch)\n        break\n      }\n\n      case \"close-websocket\": {\n        if (this.#socket) {\n          this.#socket.close(1000, \"Client disconnecting\")\n          this.#socket = undefined\n        }\n        break\n      }\n\n      case \"add-channel-and-establish\": {\n        // Clean up previous channel if it exists (e.g. after reconnect)\n        if (this.#serverChannel) {\n          this.removeChannel(this.#serverChannel.channelId)\n          this.#serverChannel = undefined\n        }\n\n        // Fresh reassembler for the new connection — stale fragments from\n        // the old connection must not collide with new fragments.\n        this.#reassembler.reset()\n\n        this.#serverChannel = this.addChannel()\n\n        // Establish immediately — the server already signaled ready\n        this.establishChannel(this.#serverChannel.channelId)\n        break\n      }\n\n      case \"remove-channel\": {\n        if (this.#serverChannel) {\n          this.removeChannel(this.#serverChannel.channelId)\n          this.#serverChannel = undefined\n        }\n        break\n      }\n\n      case \"start-reconnect-timer\": {\n        this.#reconnectTimer = setTimeout(() => {\n          this.#reconnectTimer = undefined\n          dispatch({ type: \"reconnect-timer-fired\" })\n        }, effect.delayMs)\n        break\n      }\n\n      case \"cancel-reconnect-timer\": {\n        if (this.#reconnectTimer !== undefined) {\n          clearTimeout(this.#reconnectTimer)\n          this.#reconnectTimer = undefined\n        }\n        break\n      }\n\n      case \"start-keepalive\": {\n        this.#startKeepalive()\n        break\n      }\n\n      case \"stop-keepalive\": {\n        this.#stopKeepalive()\n        break\n      }\n    }\n  }\n\n  // ==========================================================================\n  // WebSocket creation — the core I/O operation\n  // ==========================================================================\n\n  /**\n   * Create a WebSocket and wire up event handlers to dispatch messages.\n   *\n   * The message handler is set up IMMEDIATELY after creation (before\n   * the open event) to handle the race condition where the server sends\n   * \"ready\" before the client's open promise resolves.\n   */\n  #doCreateWebsocket(dispatch: (msg: WsClientMsg) => void): void {\n    const peerId = this.#peerId\n    if (!peerId) {\n      dispatch({\n        type: \"socket-error\",\n        error: new Error(\"Cannot connect: peerId not set\"),\n      })\n      return\n    }\n\n    // Resolve URL\n    const url =\n      typeof this.#options.url === \"function\"\n        ? this.#options.url(peerId)\n        : this.#options.url\n\n    try {\n      // Create WebSocket — pass headers as second arg when present.\n      // The structural WebSocketConstructor's `...rest: any[]` absorbs\n      // both the browser's protocols arg and backend's { headers } arg.\n      if (\n        this.#options.headers &&\n        Object.keys(this.#options.headers).length > 0\n      ) {\n        this.#socket = new this.#WebSocketImpl(url, {\n          headers: this.#options.headers,\n        })\n      } else {\n        this.#socket = new this.#WebSocketImpl(url)\n      }\n      this.#socket.binaryType = \"arraybuffer\"\n\n      const socket = this.#socket\n\n      // Set up message handler IMMEDIATELY to handle the \"ready\" race condition.\n      // The server may send \"ready\" before the open event fires.\n      socket.addEventListener(\"message\", (event: WebSocketMessageEvent) => {\n        this.#handleMessage(event, dispatch)\n      })\n\n      // Track whether we've dispatched a terminal event for this connection attempt\n      let settled = false\n\n      const onOpen = () => {\n        cleanup()\n        settled = true\n        dispatch({ type: \"socket-opened\" })\n\n        // After open, set up permanent close handler for post-connection closes\n        socket.addEventListener(\"close\", (event: WebSocketCloseEvent) => {\n          dispatch({\n            type: \"socket-closed\",\n            code: event.code,\n            reason: event.reason,\n          })\n        })\n      }\n\n      const onError = () => {\n        if (settled) return\n        cleanup()\n        settled = true\n        dispatch({\n          type: \"socket-error\",\n          error: new Error(\"WebSocket connection failed\"),\n        })\n      }\n\n      const onClose = () => {\n        if (settled) return\n        cleanup()\n        settled = true\n        dispatch({\n          type: \"socket-error\",\n          error: new Error(\"WebSocket closed during connection\"),\n        })\n      }\n\n      const cleanup = () => {\n        socket.removeEventListener(\"open\", onOpen)\n        socket.removeEventListener(\"error\", onError)\n        socket.removeEventListener(\"close\", onClose)\n      }\n\n      socket.addEventListener(\"open\", onOpen)\n      socket.addEventListener(\"error\", onError)\n      socket.addEventListener(\"close\", onClose)\n    } catch (error) {\n      dispatch({\n        type: \"socket-error\",\n        error: error instanceof Error ? error : new Error(String(error)),\n      })\n    }\n  }\n\n  // ==========================================================================\n  // Message handling — I/O parsing logic\n  // ==========================================================================\n\n  /**\n   * Handle incoming Websocket messages.\n   *\n   * Text frames carry the \"ready\" handshake and keepalive pong.\n   * Binary frames carry CBOR-encoded ChannelMsg.\n   */\n  #handleMessage(\n    event: WebSocketMessageEvent,\n    dispatch: (msg: WsClientMsg) => void,\n  ): void {\n    const data = event.data\n\n    // Handle text messages (keepalive and ready signal)\n    if (typeof data === \"string\") {\n      if (data === \"ready\") {\n        dispatch({ type: \"server-ready\" })\n      }\n      // Ignore pong responses and other text\n      return\n    }\n\n    // Handle binary messages through shared decode pipeline\n    if (data instanceof ArrayBuffer) {\n      try {\n        const wires = decodeBinaryWires(new Uint8Array(data), this.#reassembler)\n        if (!wires) return\n        for (const wire of wires) {\n          const result = applyInboundAliasing(this.#aliasState, wire)\n          this.#aliasState = result.state\n          if (result.error || !result.msg) {\n            console.warn(\n              \"[WebsocketClient] alias resolution failed:\",\n              result.error,\n            )\n            continue\n          }\n          this.#handleChannelMessage(result.msg)\n        }\n      } catch (error) {\n        console.error(\"Failed to decode message:\", error)\n      }\n    }\n  }\n\n  /**\n   * Handle a decoded channel message.\n   */\n  #handleChannelMessage(msg: ChannelMsg): void {\n    if (!this.#serverChannel) {\n      return\n    }\n\n    // Deliver synchronously — the Synchronizer's receive queue prevents recursion\n    this.#serverChannel.onReceive(msg)\n  }\n\n  // ==========================================================================\n  // Keepalive\n  // ==========================================================================\n\n  #startKeepalive(): void {\n    this.#stopKeepalive()\n\n    const interval = this.#options.keepaliveInterval ?? 30_000\n\n    this.#keepaliveTimer = setInterval(() => {\n      if (this.#socket?.readyState === READY_STATE.OPEN) {\n        this.#socket.send(\"ping\")\n      }\n    }, interval)\n  }\n\n  #stopKeepalive(): void {\n    if (this.#keepaliveTimer) {\n      clearInterval(this.#keepaliveTimer)\n      this.#keepaliveTimer = undefined\n    }\n  }\n\n  // ==========================================================================\n  // Lifecycle event forwarding\n  // ==========================================================================\n\n  #setupLifecycleEvents(): void {\n    // wasConnectedBefore is observer-local state, not in the program model\n    let wasConnectedBefore = false\n\n    this.#handle.subscribeToTransitions(transition => {\n      // Forward to onStateChange callback\n      this.#options.lifecycle?.onStateChange?.(transition)\n\n      const { from, to } = transition\n\n      // onDisconnect: transitioning TO disconnected\n      if (to.status === \"disconnected\" && to.reason) {\n        this.#options.lifecycle?.onDisconnect?.(to.reason)\n      }\n\n      // onReconnecting: transitioning TO reconnecting\n      if (to.status === \"reconnecting\") {\n        this.#options.lifecycle?.onReconnecting?.(to.attempt, to.nextAttemptMs)\n      }\n\n      // onReconnected: from reconnecting/connecting TO connected/ready (after prior connection)\n      if (\n        wasConnectedBefore &&\n        (from.status === \"reconnecting\" || from.status === \"connecting\") &&\n        (to.status === \"connected\" || to.status === \"ready\")\n      ) {\n        this.#options.lifecycle?.onReconnected?.()\n      }\n\n      // onReady: transitioning TO ready\n      if (to.status === \"ready\") {\n        this.#options.lifecycle?.onReady?.()\n        wasConnectedBefore = true\n      }\n    })\n  }\n\n  // ==========================================================================\n  // State observation — delegated to the observable handle\n  // ==========================================================================\n\n  /**\n   * Get the current connection state.\n   */\n  getState(): WebsocketClientState {\n    return this.#handle.getState()\n  }\n\n  /**\n   * Subscribe to state transitions.\n   */\n  subscribeToTransitions(\n    listener: TransitionListener<WebsocketClientState>,\n  ): () => void {\n    return this.#handle.subscribeToTransitions(listener)\n  }\n\n  /**\n   * Wait for a specific state.\n   */\n  waitForState(\n    predicate: (state: WebsocketClientState) => boolean,\n    options?: { timeoutMs?: number },\n  ): Promise<WebsocketClientState> {\n    return this.#handle.waitForState(predicate, options)\n  }\n\n  /**\n   * Wait for a specific status.\n   */\n  waitForStatus(\n    status: WebsocketClientState[\"status\"],\n    options?: { timeoutMs?: number },\n  ): Promise<WebsocketClientState> {\n    return this.#handle.waitForStatus(status, options)\n  }\n\n  /**\n   * Whether the client is ready (server ready signal received).\n   */\n  get isReady(): boolean {\n    return this.#handle.getState().status === \"ready\"\n  }\n\n  // ==========================================================================\n  // Transport abstract method implementations\n  // ==========================================================================\n\n  protected generate(): GeneratedChannel {\n    const nextFrameId = createFrameIdCounter()\n    // New channel = fresh alias state; reset on (re)connect.\n    this.#aliasState = emptyAliasState()\n    return {\n      transportType: this.transportType,\n      send: (msg: ChannelMsg) => {\n        const socket = this.#socket\n        if (!socket || socket.readyState !== READY_STATE.OPEN) {\n          return\n        }\n\n        const { state, wire } = applyOutboundAliasing(this.#aliasState, msg)\n        this.#aliasState = state\n\n        encodeWireFrameAndSend(\n          wire,\n          data => socket.send(new Uint8Array(data).buffer),\n          this.#fragmentThreshold,\n          nextFrameId,\n        )\n      },\n      stop: () => {\n        // Don't call disconnect here — channel.stop() is called when\n        // the channel is removed, which can happen during effect execution.\n        // The actual disconnect is handled by onStop() or the program.\n      },\n    }\n  }\n\n  async onStart(): Promise<void> {\n    if (!this.identity) {\n      throw new Error(\n        \"Transport not properly initialized — identity not available\",\n      )\n    }\n    this.#peerId = this.identity.peerId\n    this.#handle.dispatch({ type: \"start\" })\n  }\n\n  async onStop(): Promise<void> {\n    this.#reassembler.dispose()\n    this.#handle.dispatch({ type: \"stop\" })\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory functions\n// ---------------------------------------------------------------------------\n\n/**\n * Create a Websocket client transport factory for browser-to-server\n * connections.\n *\n * Returns an `TransportFactory` — a closure that creates a fresh transport\n * instance when called. Pass directly to `Exchange({ transports: [...] })`.\n *\n * @example\n * ```typescript\n * import { createWebsocketClient } from \"@kyneta/websocket-transport/browser\"\n *\n * const exchange = new Exchange({\n *   transports: [createWebsocketClient({\n *     url: \"ws://localhost:3000/ws\",\n *     WebSocket,\n *     reconnect: { enabled: true },\n *   })],\n * })\n * ```\n */\nexport function createWebsocketClient(\n  options: WebsocketClientOptions,\n): TransportFactory {\n  return () => new WebsocketClientTransport(options)\n}\n"],"mappings":"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"}