@neta-art/cohub 1.32.0 → 1.33.1

package/dist/websocket.js

@@ -1,2 +1,770 @@
-import { n as createWebsocketClient, t as WebsocketClient } from "./chunks/websocket.js";
+import { a as normalizeRealtimeRooms, i as getSessionTurnPatchStreamKey, n as WS_ROOM_SUBSCRIPTION_CAPABILITY, r as getRealtimeSpaceRoom, t as WS_COMPACT_STREAM_CAPABILITY } from "./chunks/types.js";
+import { c as resolveWebsocketUrl } from "./chunks/environment.js";
+//#region src/websocket.ts
+const createEventMap = () => ({
+	connecting: /* @__PURE__ */ new Set(),
+	reconnecting: /* @__PURE__ */ new Set(),
+	open: /* @__PURE__ */ new Set(),
+	close: /* @__PURE__ */ new Set(),
+	error: /* @__PURE__ */ new Set(),
+	event: /* @__PURE__ */ new Set(),
+	ready: /* @__PURE__ */ new Set(),
+	auth: /* @__PURE__ */ new Set(),
+	messageAccepted: /* @__PURE__ */ new Set(),
+	serverError: /* @__PURE__ */ new Set(),
+	subscribed: /* @__PURE__ */ new Set(),
+	subscribeError: /* @__PURE__ */ new Set(),
+	pong: /* @__PURE__ */ new Set()
+});
+const toWebSocketUrl = (input, env) => resolveWebsocketUrl({
+	url: input,
+	env
+});
+const normalizeOptions = (options = {}) => ({
+	url: toWebSocketUrl(options.url, options.env),
+	autoReconnect: options.autoReconnect !== false,
+	reconnectBaseDelayMs: options.reconnectBaseDelayMs ?? 1e3,
+	reconnectMaxDelayMs: options.reconnectMaxDelayMs ?? 15e3,
+	pingIntervalMs: options.pingIntervalMs ?? 2e4,
+	pongTimeoutMs: options.pongTimeoutMs ?? 15e3,
+	debug: options.debug === true
+});
+const formatCloseMessage = (code, reason) => `WebSocket closed: ${code ?? 0} ${reason || ""}`.trim();
+const isRetryableCloseCode = (code) => {
+	if (code === 1e3) return false;
+	if (code === 4003) return false;
+	return true;
+};
+const AUTH_CLOSE_REASON = "authentication failed";
+const PATCH_STREAM_BUFFER_MAX_PENDING = 128;
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const isRealtimeCompactFrame = (value) => {
+	if (!isRecord(value)) return false;
+	if (value.t !== "d" && value.t !== "p") return false;
+	if (typeof value.sid !== "string" || !value.sid) return false;
+	if (typeof value.s !== "number" || !Number.isInteger(value.s) || value.s < 0) return false;
+	if (typeof value.b !== "number" || !Number.isInteger(value.b) || value.b < 0) return false;
+	if (value.t === "d") return "v" in value;
+	return (value.o === "append" || value.o === "replace" || value.o === "add" || value.o === "merge" || value.o === "remove") && typeof value.p === "string" && value.p.length > 0;
+};
+const isRealtimeEnvelope = (value) => {
+	if (!isRecord(value)) return false;
+	if (typeof value.id !== "string") return false;
+	if (typeof value.timestamp !== "number") return false;
+	if (value.domain !== "system" && value.domain !== "session" && value.domain !== "space" && value.domain !== "label") return false;
+	if (typeof value.type !== "string") return false;
+	if (!isRecord(value.payload)) return false;
+	return true;
+};
+const compactFrameToPatchOperation = (frame) => {
+	if (frame.t === "d") return { v: frame.v };
+	if (frame.o === "remove") return {
+		o: "remove",
+		p: frame.p
+	};
+	if (frame.o === "merge") return isRecord(frame.v) ? {
+		o: "merge",
+		p: frame.p,
+		v: frame.v
+	} : null;
+	if (!("v" in frame)) return null;
+	switch (frame.o) {
+		case "append": return {
+			o: "append",
+			p: frame.p,
+			v: frame.v
+		};
+		case "replace": return {
+			o: "replace",
+			p: frame.p,
+			v: frame.v
+		};
+		case "add": return {
+			o: "add",
+			p: frame.p,
+			v: frame.v
+		};
+		default: return null;
+	}
+};
+var WebsocketAuthError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WebsocketAuthError";
+	}
+};
+var WebsocketClient = class {
+	url;
+	autoReconnect;
+	reconnectBaseDelayMs;
+	reconnectMaxDelayMs;
+	pingIntervalMs;
+	pongTimeoutMs;
+	debug;
+	getAccessToken;
+	WebSocketImpl;
+	ws = null;
+	pingTimer = null;
+	reconnectTimer = null;
+	reconnectTimerResolver = null;
+	reconnectAttempt = 0;
+	manuallyClosed = false;
+	connectPromise = null;
+	authWaiter = null;
+	awaitingPong = false;
+	lastPingRequestId = null;
+	pongDeadlineAt = 0;
+	compactStreamContexts = /* @__PURE__ */ new Map();
+	patchStreamBuffers = /* @__PURE__ */ new Map();
+	roomSubscriptions = /* @__PURE__ */ new Map();
+	state = "idle";
+	connectionId = null;
+	listeners = createEventMap();
+	constructor(options = {}) {
+		const normalized = normalizeOptions(options);
+		this.url = normalized.url;
+		this.autoReconnect = normalized.autoReconnect;
+		this.reconnectBaseDelayMs = normalized.reconnectBaseDelayMs;
+		this.reconnectMaxDelayMs = normalized.reconnectMaxDelayMs;
+		this.pingIntervalMs = normalized.pingIntervalMs;
+		this.pongTimeoutMs = normalized.pongTimeoutMs;
+		this.debug = normalized.debug;
+		this.getAccessToken = options.getAccessToken;
+		this.WebSocketImpl = options.WebSocketImpl ?? WebSocket;
+	}
+	on(type, handler) {
+		this.listeners[type].add(handler);
+		return () => this.off(type, handler);
+	}
+	off(type, handler) {
+		this.listeners[type].delete(handler);
+	}
+	emit(type, payload) {
+		for (const handler of this.listeners[type]) handler(payload);
+	}
+	log(...args) {
+		if (this.debug) console.log("[WebsocketClient]", ...args);
+	}
+	async connect() {
+		if (this.connectPromise) return this.connectPromise;
+		if (this.state === "open" && this.ws?.readyState === WebSocket.OPEN) return;
+		const isReconnect = this.reconnectAttempt > 0 || this.state === "reconnecting";
+		this.manuallyClosed = false;
+		this.clearReconnectTimer();
+		this.state = isReconnect ? "reconnecting" : "connecting";
+		this.emit("connecting", {
+			isReconnect,
+			attempt: this.reconnectAttempt
+		});
+		this.connectPromise = new Promise((resolve, reject) => {
+			const ws = new this.WebSocketImpl(this.url);
+			this.ws = ws;
+			let settled = false;
+			const rejectOnce = (error) => {
+				if (settled) return;
+				settled = true;
+				this.connectPromise = null;
+				reject(error);
+			};
+			const resolveOnce = () => {
+				if (settled) return;
+				settled = true;
+				this.connectPromise = null;
+				resolve();
+			};
+			ws.onopen = async () => {
+				try {
+					this.log("connected", {
+						url: this.url,
+						isReconnect,
+						attempt: this.reconnectAttempt
+					});
+					this.startPingLoop();
+					await this.authenticate();
+					this.state = "open";
+					this.reconnectAttempt = 0;
+					this.emit("open", { connectionId: this.connectionId });
+					resolveOnce();
+				} catch (error) {
+					const authError = error instanceof Error ? error : /* @__PURE__ */ new Error("authentication failed");
+					this.emit("error", {
+						error: authError,
+						recoverable: false
+					});
+					rejectOnce(authError);
+					ws.close(4003, AUTH_CLOSE_REASON);
+				}
+			};
+			ws.onmessage = (event) => {
+				this.handleMessage(event.data);
+			};
+			ws.onerror = (error) => {
+				this.emit("error", {
+					error,
+					recoverable: !this.manuallyClosed
+				});
+			};
+			ws.onclose = (event) => {
+				this.stopPingLoop();
+				const wasConnecting = this.state === "connecting" || this.state === "reconnecting";
+				this.state = "closed";
+				this.ws = null;
+				this.compactStreamContexts.clear();
+				this.patchStreamBuffers.clear();
+				const closeError = new Error(formatCloseMessage(event.code, event.reason));
+				this.rejectAuthWaiter(closeError);
+				const willReconnect = !this.manuallyClosed && this.autoReconnect && isRetryableCloseCode(event.code);
+				this.log("closed", {
+					code: event.code,
+					reason: event.reason,
+					willReconnect,
+					wasConnecting
+				});
+				this.emit("close", {
+					code: event.code,
+					reason: event.reason,
+					willReconnect
+				});
+				if (wasConnecting) rejectOnce(closeError);
+				if (willReconnect) this.scheduleReconnect(event.code, event.reason);
+			};
+		});
+		return this.connectPromise;
+	}
+	async disconnect(code = 1e3, reason = "manual") {
+		this.manuallyClosed = true;
+		this.clearReconnectTimer();
+		this.stopPingLoop();
+		this.state = "closed";
+		this.rejectAuthWaiter(/* @__PURE__ */ new Error("disconnected"));
+		this.ws?.close(code, reason);
+		this.ws = null;
+		this.connectPromise = null;
+		this.compactStreamContexts.clear();
+		this.patchStreamBuffers.clear();
+		for (const state of this.roomSubscriptions.values()) {
+			state.subscribed = false;
+			state.pending = false;
+		}
+	}
+	async sendCanvasTransaction(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "canvas.tx",
+			requestId: input.requestId,
+			payload: {
+				spaceId: input.spaceId,
+				documentId: input.documentId,
+				txId: input.txId,
+				baseVersion: input.baseVersion ?? null,
+				clientId: input.clientId ?? null,
+				undoGroupId: input.undoGroupId ?? null,
+				ops: input.ops
+			}
+		});
+	}
+	async sendMessage(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "session.message.create",
+			requestId: input.requestId,
+			payload: {
+				spaceId: input.spaceId,
+				sessionId: input.sessionId,
+				content: input.content,
+				clientMessageId: input.clientMessageId,
+				model: input.model,
+				provider: input.provider
+			}
+		});
+	}
+	retainRooms(rooms) {
+		const normalized = normalizeRealtimeRooms(rooms);
+		if (normalized.length === 0) return () => void 0;
+		for (const room of normalized) {
+			const state = this.roomSubscriptions.get(room) ?? {
+				refCount: 0,
+				subscribed: false,
+				pending: false
+			};
+			state.refCount += 1;
+			this.roomSubscriptions.set(room, state);
+		}
+		this.flushRoomSubscriptions();
+		if (this.state !== "open" && this.state !== "connecting" && this.state !== "reconnecting") this.connect().then(() => this.flushRoomSubscriptions()).catch((error) => this.emit("error", {
+			error,
+			recoverable: true
+		}));
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			const roomsToRelease = [];
+			for (const room of normalized) {
+				const state = this.roomSubscriptions.get(room);
+				if (!state) continue;
+				state.refCount -= 1;
+				if (state.refCount > 0) {
+					this.roomSubscriptions.set(room, state);
+					continue;
+				}
+				this.roomSubscriptions.delete(room);
+				if (state.subscribed) roomsToRelease.push(room);
+			}
+			if (roomsToRelease.length === 0) return;
+			if (this.ws?.readyState === WebSocket.OPEN) this.send({
+				type: "unsubscribe",
+				payload: { rooms: roomsToRelease }
+			});
+		};
+	}
+	subscribeRooms(rooms) {
+		return this.retainRooms(rooms);
+	}
+	subscribeSpace(spaceId) {
+		return this.retainRooms([getRealtimeSpaceRoom(spaceId)]);
+	}
+	ack(eventId, requestId) {
+		this.send({
+			type: "ack",
+			requestId,
+			payload: eventId ? { eventId } : void 0
+		});
+	}
+	ping(requestId) {
+		const effectiveRequestId = requestId ?? `ping-${Date.now()}`;
+		this.awaitingPong = true;
+		this.lastPingRequestId = effectiveRequestId;
+		this.pongDeadlineAt = Date.now() + this.pongTimeoutMs;
+		this.send({
+			type: "ping",
+			requestId: effectiveRequestId,
+			payload: {}
+		});
+	}
+	async ensureOpen() {
+		if (this.state === "open" && this.ws?.readyState === WebSocket.OPEN) return;
+		await this.connect();
+	}
+	send(event) {
+		const ws = this.ws;
+		if (!ws || ws.readyState !== WebSocket.OPEN) throw new Error("websocket is not open");
+		ws.send(JSON.stringify(event));
+	}
+	async authenticate() {
+		const token = this.getAccessToken ? await this.getAccessToken() : null;
+		if (!token) throw new WebsocketAuthError("missing access token");
+		const waiter = this.createAuthWaiter();
+		this.send({
+			type: "auth",
+			payload: {
+				token,
+				capabilities: [WS_COMPACT_STREAM_CAPABILITY, WS_ROOM_SUBSCRIPTION_CAPABILITY]
+			}
+		});
+		await waiter.promise;
+		await this.restoreRoomSubscriptions();
+	}
+	flushRoomSubscriptions() {
+		if (this.ws?.readyState !== WebSocket.OPEN) return;
+		const rooms = [...this.roomSubscriptions.entries()].filter(([, state]) => state.refCount > 0 && !state.subscribed && !state.pending).map(([room]) => room);
+		if (rooms.length === 0) return;
+		this.send({
+			type: "subscribe",
+			payload: { rooms }
+		});
+		for (const room of rooms) {
+			const state = this.roomSubscriptions.get(room);
+			if (state) state.pending = true;
+		}
+	}
+	async restoreRoomSubscriptions() {
+		for (const state of this.roomSubscriptions.values()) state.subscribed = false;
+		this.flushRoomSubscriptions();
+	}
+	createAuthWaiter() {
+		this.rejectAuthWaiter(/* @__PURE__ */ new Error("superseded auth waiter"));
+		let resolve;
+		let reject;
+		const promise = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		this.authWaiter = {
+			promise,
+			resolve,
+			reject
+		};
+		return this.authWaiter;
+	}
+	resolveAuthWaiter() {
+		if (!this.authWaiter) return;
+		this.authWaiter.resolve();
+		this.authWaiter = null;
+	}
+	rejectAuthWaiter(error) {
+		if (!this.authWaiter) return;
+		this.authWaiter.reject(error);
+		this.authWaiter = null;
+	}
+	handleMessage(raw) {
+		let parsed;
+		try {
+			parsed = typeof raw === "string" ? JSON.parse(raw) : JSON.parse(String(raw));
+		} catch {
+			this.emit("error", {
+				error: /* @__PURE__ */ new Error("invalid websocket payload"),
+				recoverable: true
+			});
+			return;
+		}
+		if (isRealtimeCompactFrame(parsed)) {
+			this.handleCompactFrame(parsed);
+			return;
+		}
+		if (!isRealtimeEnvelope(parsed)) {
+			this.emit("error", {
+				error: /* @__PURE__ */ new Error("invalid realtime envelope"),
+				recoverable: true
+			});
+			return;
+		}
+		const envelope = parsed;
+		this.rememberCompactStreamContext(envelope);
+		if (envelope.type === "session.turn.patch") {
+			this.handlePatchEnvelope(envelope);
+			return;
+		}
+		switch (envelope.type) {
+			case "system.ready": {
+				const connectionId = typeof envelope.payload.connectionId === "string" ? envelope.payload.connectionId : null;
+				if (connectionId) {
+					this.connectionId = connectionId;
+					this.emit("ready", { connectionId });
+				}
+				this.emit("event", envelope);
+				return;
+			}
+			case "system.auth.ok": {
+				const connectionId = typeof envelope.payload.connectionId === "string" ? envelope.payload.connectionId : this.connectionId;
+				const user = envelope.payload.user && typeof envelope.payload.user === "object" ? envelope.payload.user : {};
+				if (connectionId) {
+					this.connectionId = connectionId;
+					this.emit("auth", {
+						connectionId,
+						user
+					});
+				}
+				this.resolveAuthWaiter();
+				this.emit("event", envelope);
+				return;
+			}
+			case "system.request.error": {
+				const message = typeof envelope.payload.message === "string" ? envelope.payload.message : "request failed";
+				const code = typeof envelope.payload.code === "string" ? envelope.payload.code : void 0;
+				const error = new WebsocketAuthError(message);
+				this.rejectAuthWaiter(error);
+				this.emit("serverError", {
+					code,
+					message,
+					requestId: envelope.requestId ?? null,
+					sessionId: envelope.sessionId ?? null,
+					spaceId: envelope.spaceId ?? null
+				});
+				this.emit("event", envelope);
+				return;
+			}
+			case "session.request.accepted": {
+				const payload = envelope.payload;
+				this.emit("messageAccepted", {
+					requestId: envelope.requestId ?? null,
+					sessionId: envelope.sessionId ?? null,
+					spaceId: envelope.spaceId ?? null,
+					clientMessageId: typeof payload.clientMessageId === "string" ? payload.clientMessageId : null,
+					turnId: typeof payload.turnId === "string" ? payload.turnId : null,
+					userMessageId: typeof payload.userMessageId === "string" ? payload.userMessageId : null,
+					traceId: typeof payload.traceId === "string" ? payload.traceId : null
+				});
+				this.emit("event", envelope);
+				return;
+			}
+			case "session.request.error": {
+				const payload = envelope.payload;
+				this.emit("serverError", {
+					code: typeof payload.code === "string" ? payload.code : void 0,
+					message: typeof payload.message === "string" ? payload.message : void 0,
+					requestId: envelope.requestId ?? null,
+					sessionId: envelope.sessionId ?? null,
+					spaceId: envelope.spaceId ?? null,
+					clientMessageId: typeof payload.clientMessageId === "string" ? payload.clientMessageId : null
+				});
+				this.emit("event", envelope);
+				return;
+			}
+			case "system.pong": {
+				const requestId = envelope.requestId ?? null;
+				if (!requestId || requestId === this.lastPingRequestId) {
+					this.awaitingPong = false;
+					this.lastPingRequestId = null;
+					this.pongDeadlineAt = 0;
+				}
+				this.emit("pong", { requestId });
+				return;
+			}
+			case "system.subscribe.ok": {
+				const payload = envelope.payload;
+				const rooms = normalizeRealtimeRooms(Array.isArray(payload.rooms) ? payload.rooms.filter((room) => typeof room === "string") : []);
+				for (const room of rooms) {
+					const state = this.roomSubscriptions.get(room);
+					if (state) {
+						state.subscribed = true;
+						state.pending = false;
+					}
+				}
+				this.emit("subscribed", {
+					rooms,
+					requestId: envelope.requestId ?? null
+				});
+				this.emit("event", envelope);
+				return;
+			}
+			case "system.subscribe.error": {
+				const payload = envelope.payload;
+				const rejected = Array.isArray(payload.rejected) ? payload.rejected.filter((entry) => Boolean(entry && typeof entry === "object")).map((entry) => ({
+					room: typeof entry.room === "string" ? entry.room : "",
+					code: typeof entry.code === "string" ? entry.code : "UNKNOWN",
+					message: typeof entry.message === "string" ? entry.message : "Subscription failed"
+				})).filter((entry) => entry.room) : [];
+				for (const item of rejected) {
+					const room = normalizeRealtimeRooms([item.room])[0];
+					if (!room) continue;
+					this.roomSubscriptions.delete(room);
+				}
+				this.emit("subscribeError", {
+					rejected,
+					requestId: envelope.requestId ?? null
+				});
+				this.emit("event", envelope);
+				return;
+			}
+			case "system.ack.ok": return;
+			default:
+				this.emit("event", envelope);
+				return;
+		}
+	}
+	rememberCompactStreamContext(envelope) {
+		if (envelope.type === "session.turn.patch") {
+			const payload = envelope.payload;
+			const turnId = typeof payload.turnId === "string" ? payload.turnId : null;
+			const messageId = typeof payload.messageId === "string" ? payload.messageId : null;
+			const realtimeMeta = payload._rt && typeof payload._rt === "object" ? payload._rt : null;
+			const sid = typeof realtimeMeta?.sid === "string" && realtimeMeta.sid.trim() ? realtimeMeta.sid : turnId ?? messageId;
+			if (!sid) return;
+			this.compactStreamContexts.set(sid, {
+				spaceId: envelope.spaceId ?? null,
+				sessionId: envelope.sessionId ?? null,
+				turnId,
+				messageId,
+				messageOrdinal: typeof payload.messageOrdinal === "number" ? payload.messageOrdinal : null,
+				anchorUserMessageId: typeof payload.anchorUserMessageId === "string" ? payload.anchorUserMessageId : null
+			});
+			return;
+		}
+		if (envelope.type !== "session.message.persisted") return;
+		const message = envelope.payload.message;
+		if (!message || typeof message !== "object") return;
+		const meta = message.meta;
+		const turnId = typeof meta?.turnId === "string" ? meta.turnId : null;
+		if (!turnId) return;
+		for (const [sid, context] of this.compactStreamContexts.entries()) if (context.turnId === turnId) {
+			this.compactStreamContexts.delete(sid);
+			this.patchStreamBuffers.delete(sid);
+		}
+	}
+	getPatchStreamBufferKey(envelope) {
+		if (envelope.type !== "session.turn.patch") return null;
+		const payload = envelope.payload;
+		const realtimeMeta = payload._rt && typeof payload._rt === "object" ? payload._rt : null;
+		if (typeof realtimeMeta?.sid === "string" && realtimeMeta.sid.trim()) return realtimeMeta.sid;
+		return getSessionTurnPatchStreamKey(payload, { includeSessionFallback: true });
+	}
+	handlePatchEnvelope(envelope) {
+		const payload = envelope.payload;
+		if (typeof payload.seq !== "number" || typeof payload.baseSeq !== "number" || !Number.isInteger(payload.seq) || !Number.isInteger(payload.baseSeq) || payload.seq < 0 || payload.baseSeq < 0) {
+			this.emit("event", envelope);
+			return;
+		}
+		const key = this.getPatchStreamBufferKey(envelope);
+		if (!key) {
+			this.emit("event", envelope);
+			return;
+		}
+		if (payload.baseSeq === 0) {
+			const buffer = {
+				nextSeq: payload.seq + 1,
+				pending: /* @__PURE__ */ new Map()
+			};
+			this.patchStreamBuffers.set(key, buffer);
+			this.emit("event", envelope);
+			this.flushPatchStreamBuffer(buffer);
+			return;
+		}
+		const buffer = this.patchStreamBuffers.get(key);
+		if (!buffer) {
+			const newBuffer = {
+				nextSeq: payload.baseSeq + 1,
+				pending: new Map([[payload.seq, envelope]])
+			};
+			this.patchStreamBuffers.set(key, newBuffer);
+			this.flushPatchStreamBuffer(newBuffer);
+			return;
+		}
+		if (payload.seq < buffer.nextSeq) return;
+		buffer.pending.set(payload.seq, envelope);
+		if (!this.enforcePatchStreamBufferLimit(key, buffer)) return;
+		this.flushPatchStreamBuffer(buffer);
+	}
+	enforcePatchStreamBufferLimit(key, buffer) {
+		if (buffer.pending.size <= PATCH_STREAM_BUFFER_MAX_PENDING) return true;
+		this.patchStreamBuffers.delete(key);
+		this.emit("error", {
+			error: /* @__PURE__ */ new Error(`patch stream buffer overflow: ${key}`),
+			recoverable: true
+		});
+		return false;
+	}
+	flushPatchStreamBuffer(buffer) {
+		while (true) {
+			const envelope = buffer.pending.get(buffer.nextSeq);
+			if (!envelope) return;
+			const seq = envelope.payload.seq;
+			if (typeof seq !== "number" || !Number.isInteger(seq)) return;
+			buffer.pending.delete(buffer.nextSeq);
+			buffer.nextSeq = seq + 1;
+			this.emit("event", envelope);
+		}
+	}
+	handleCompactFrame(frame) {
+		const context = this.compactStreamContexts.get(frame.sid);
+		if (!context?.sessionId) {
+			this.emit("error", {
+				error: /* @__PURE__ */ new Error(`unknown compact stream: ${frame.sid}`),
+				recoverable: true
+			});
+			return;
+		}
+		const op = compactFrameToPatchOperation(frame);
+		if (!op) {
+			this.emit("error", {
+				error: /* @__PURE__ */ new Error(`invalid compact stream frame: ${frame.sid}`),
+				recoverable: true
+			});
+			return;
+		}
+		const envelope = {
+			id: `compact:${frame.sid}:${frame.s}`,
+			timestamp: Date.now(),
+			domain: "session",
+			type: "session.turn.patch",
+			spaceId: context.spaceId,
+			sessionId: context.sessionId,
+			payload: {
+				turnId: context.turnId,
+				messageId: context.messageId,
+				messageOrdinal: context.messageOrdinal,
+				sourceMessageId: context.messageId,
+				anchorUserMessageId: context.anchorUserMessageId,
+				seq: frame.s,
+				baseSeq: frame.b,
+				ops: [op],
+				_rt: { sid: frame.sid }
+			}
+		};
+		this.handlePatchEnvelope(envelope);
+	}
+	startPingLoop() {
+		this.stopPingLoop();
+		this.pingTimer = setInterval(() => {
+			if (this.ws?.readyState !== WebSocket.OPEN) return;
+			if (this.awaitingPong && this.pongDeadlineAt > 0 && Date.now() > this.pongDeadlineAt) {
+				this.emit("error", {
+					error: /* @__PURE__ */ new Error("websocket pong timeout"),
+					recoverable: true
+				});
+				this.ws.close(4002, "pong timeout");
+				return;
+			}
+			this.ping();
+		}, this.pingIntervalMs);
+	}
+	stopPingLoop() {
+		if (this.pingTimer) {
+			clearInterval(this.pingTimer);
+			this.pingTimer = null;
+		}
+		this.awaitingPong = false;
+		this.lastPingRequestId = null;
+		this.pongDeadlineAt = 0;
+	}
+	clearReconnectTimer() {
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.reconnectTimerResolver) {
+			const resolve = this.reconnectTimerResolver;
+			this.reconnectTimerResolver = null;
+			resolve();
+		}
+	}
+	async scheduleReconnect(code, reason) {
+		this.clearReconnectTimer();
+		const attempt = this.reconnectAttempt + 1;
+		const delay = Math.min(this.reconnectBaseDelayMs * 2 ** this.reconnectAttempt, this.reconnectMaxDelayMs);
+		this.reconnectAttempt = attempt;
+		this.state = "reconnecting";
+		this.log("schedule reconnect", {
+			attempt,
+			delay,
+			code,
+			reason
+		});
+		this.emit("reconnecting", {
+			attempt,
+			delayMs: delay,
+			code,
+			reason
+		});
+		await new Promise((resolve) => {
+			this.reconnectTimerResolver = resolve;
+			this.reconnectTimer = setTimeout(() => {
+				this.reconnectTimer = null;
+				this.reconnectTimerResolver = null;
+				resolve();
+			}, delay);
+		});
+		if (this.manuallyClosed) return;
+		if (typeof navigator !== "undefined" && navigator.onLine === false) {
+			await new Promise((resolve) => {
+				const fallbackTimer = setTimeout(resolve, this.reconnectMaxDelayMs);
+				const handleOnline = () => {
+					clearTimeout(fallbackTimer);
+					globalThis.removeEventListener?.("online", handleOnline);
+					resolve();
+				};
+				globalThis.addEventListener?.("online", handleOnline, { once: true });
+			});
+			if (this.manuallyClosed) return;
+		}
+		await this.connect().catch((error) => {
+			this.emit("error", {
+				error,
+				recoverable: true
+			});
+		});
+	}
+};
+const createWebsocketClient = (options) => new WebsocketClient(options);
+//#endregion
 export { WebsocketClient, createWebsocketClient };