@neta-art/cohub 12.0.0 → 12.1.1

package/dist/websocket.js

@@ -1,2 +1,952 @@
-import { n as createWebsocketClient, t as WebsocketClient } from "./chunks/websocket.js";
+import { C as getSessionTurnPatchStreamKey, S as getRealtimeSpaceRoom, T as normalizeRealtimeRooms, _ as WS_REALTIME_ROOM_CAPABILITY, b as WS_ROOM_SUBSCRIPTION_CAPABILITY, g as WS_COMPACT_STREAM_CAPABILITY, h as WS_BOARD_AWARENESS_CAPABILITY, r as extractBillingPayload, v as WS_REALTIME_ROOM_HISTORY_CAPABILITY, w as isRealtimeDomain } from "./chunks/http-error.js";
+import { f 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,
+	connectTimeoutMs: normalizeConnectTimeoutMs(options.connectTimeoutMs ?? 15e3),
+	pingIntervalMs: options.pingIntervalMs ?? 2e4,
+	pongTimeoutMs: options.pongTimeoutMs ?? 15e3,
+	debug: options.debug === true
+});
+const formatCloseMessage = (code, reason) => `WebSocket closed: ${code ?? 0} ${reason || ""}`.trim();
+const normalizeConnectTimeoutMs = (value) => {
+	if (!Number.isInteger(value) || value < 1 || value > 2147483647) throw new Error("connectTimeoutMs must be an integer between 1 and 2147483647");
+	return value;
+};
+const AUTH_CLOSE_CODE = 4003;
+const AUTH_CLOSE_REASON = "authentication failed";
+const isRetryableCloseCode = (code) => {
+	if (code === 1e3) return false;
+	if (code === AUTH_CLOSE_CODE) return false;
+	return true;
+};
+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 (!isRealtimeDomain(value.domain)) 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;
+	connectTimeoutMs;
+	pingIntervalMs;
+	pongTimeoutMs;
+	debug;
+	getAccessToken;
+	WebSocketImpl;
+	ws = null;
+	pingTimer = null;
+	reconnectTimer = null;
+	reconnectTimerResolver = null;
+	reconnectAttempt = 0;
+	authReconnectAttempted = false;
+	forceRefreshOnNextAuth = false;
+	retryAuthClose = false;
+	manuallyClosed = false;
+	connectPromise = null;
+	pendingConnectReject = null;
+	authWaiter = null;
+	awaitingPong = false;
+	lastPingRequestId = null;
+	pongDeadlineAt = 0;
+	compactStreamContexts = /* @__PURE__ */ new Map();
+	patchStreamBuffers = /* @__PURE__ */ new Map();
+	roomSubscriptions = /* @__PURE__ */ new Map();
+	serverCapabilities = /* @__PURE__ */ new Set();
+	state = "idle";
+	connectionId = null;
+	supportsCapability(capability) {
+		return this.serverCapabilities.has(capability);
+	}
+	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.connectTimeoutMs = normalized.connectTimeoutMs;
+		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;
+			let closed = false;
+			let connectTimer = null;
+			const clearConnectTimer = () => {
+				if (connectTimer === null) return;
+				clearTimeout(connectTimer);
+				connectTimer = null;
+			};
+			const rejectOnce = (error) => {
+				if (settled) return;
+				clearConnectTimer();
+				settled = true;
+				this.connectPromise = null;
+				if (this.pendingConnectReject === rejectOnce) this.pendingConnectReject = null;
+				reject(error);
+			};
+			const resolveOnce = () => {
+				if (settled) return;
+				clearConnectTimer();
+				settled = true;
+				this.connectPromise = null;
+				if (this.pendingConnectReject === rejectOnce) this.pendingConnectReject = null;
+				resolve();
+			};
+			const isCurrentConnection = () => this.ws === ws && !closed;
+			const cleanupSocket = () => {
+				ws.onopen = null;
+				ws.onmessage = null;
+				ws.onerror = null;
+				ws.onclose = null;
+			};
+			const handleClose = (event) => {
+				if (closed || this.ws !== ws) return;
+				closed = true;
+				clearConnectTimer();
+				this.stopPingLoop();
+				const wasConnecting = this.state === "connecting" || this.state === "reconnecting";
+				this.state = "closed";
+				this.ws = null;
+				this.compactStreamContexts.clear();
+				this.patchStreamBuffers.clear();
+				this.resetRoomSubscriptions();
+				const closeError = new Error(formatCloseMessage(event.code, event.reason));
+				this.rejectAuthWaiter(closeError);
+				const retryAuthClose = event.code === AUTH_CLOSE_CODE && this.retryAuthClose;
+				this.retryAuthClose = false;
+				const willReconnect = !this.manuallyClosed && this.autoReconnect && (retryAuthClose || isRetryableCloseCode(event.code));
+				this.log("closed", {
+					code: event.code,
+					reason: event.reason,
+					willReconnect,
+					wasConnecting
+				});
+				this.emit("close", {
+					code: event.code,
+					reason: event.reason,
+					willReconnect
+				});
+				cleanupSocket();
+				if (wasConnecting) rejectOnce(closeError);
+				if (willReconnect) this.scheduleReconnect(event.code, event.reason);
+			};
+			ws.onopen = async () => {
+				if (!isCurrentConnection()) return;
+				clearConnectTimer();
+				try {
+					this.log("connected", {
+						url: this.url,
+						isReconnect,
+						attempt: this.reconnectAttempt
+					});
+					this.startPingLoop();
+					await this.authenticate();
+					if (!isCurrentConnection()) return;
+					this.state = "open";
+					this.restoreRoomSubscriptions();
+					this.reconnectAttempt = 0;
+					this.emit("open", { connectionId: this.connectionId });
+					resolveOnce();
+				} catch (error) {
+					if (!isCurrentConnection()) return;
+					const authError = error instanceof Error ? error : /* @__PURE__ */ new Error("authentication failed");
+					const recoverable = Boolean(this.getAccessToken && this.autoReconnect && !this.manuallyClosed && !this.authReconnectAttempted);
+					this.retryAuthClose = recoverable;
+					if (recoverable) {
+						this.authReconnectAttempted = true;
+						this.forceRefreshOnNextAuth = true;
+					}
+					this.emit("error", {
+						error: authError,
+						recoverable
+					});
+					rejectOnce(authError);
+					ws.close(AUTH_CLOSE_CODE, AUTH_CLOSE_REASON);
+				}
+			};
+			ws.onmessage = (event) => {
+				if (!isCurrentConnection()) return;
+				this.handleMessage(event.data);
+			};
+			ws.onerror = (error) => {
+				if (!isCurrentConnection()) return;
+				this.emit("error", {
+					error,
+					recoverable: !this.manuallyClosed
+				});
+			};
+			ws.onclose = (event) => {
+				handleClose(event);
+			};
+			this.pendingConnectReject = rejectOnce;
+			connectTimer = setTimeout(() => {
+				if (!isCurrentConnection() || settled) return;
+				const reason = "connect timeout";
+				const error = /* @__PURE__ */ new Error(`WebSocket ${reason} after ${this.connectTimeoutMs}ms`);
+				this.emit("error", {
+					error,
+					recoverable: !this.manuallyClosed && this.autoReconnect
+				});
+				try {
+					ws.close(4002, reason);
+				} finally {
+					handleClose({
+						code: 4002,
+						reason
+					});
+				}
+			}, this.connectTimeoutMs);
+		});
+		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"));
+		const ws = this.ws;
+		this.ws = null;
+		ws?.close(code, reason);
+		this.pendingConnectReject?.(/* @__PURE__ */ new Error(`WebSocket disconnected: ${reason}`));
+		this.pendingConnectReject = null;
+		this.connectPromise = null;
+		if (ws) {
+			ws.onopen = null;
+			ws.onmessage = null;
+			ws.onerror = null;
+			ws.onclose = null;
+			this.emit("close", {
+				code,
+				reason,
+				willReconnect: false
+			});
+		}
+		this.authReconnectAttempted = false;
+		this.forceRefreshOnNextAuth = false;
+		this.retryAuthClose = false;
+		this.compactStreamContexts.clear();
+		this.patchStreamBuffers.clear();
+		this.resetRoomSubscriptions();
+	}
+	async updatePresence(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "presence.update",
+			requestId: input.requestId,
+			payload: {
+				spaceId: input.spaceId,
+				meta: input.meta ?? null
+			}
+		});
+	}
+	async updateBoardAwareness(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "board.awareness.update",
+			requestId: input.requestId,
+			payload: {
+				spaceId: input.spaceId,
+				boardId: input.boardId,
+				seq: input.seq,
+				update: input.update
+			}
+		});
+	}
+	async joinRealtimeRoom(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "realtime.room.join",
+			requestId: input.requestId,
+			payload: {
+				roomId: input.roomId,
+				ticket: input.ticket,
+				...input.instanceId ? { instanceId: input.instanceId } : {},
+				...input.after !== void 0 ? { after: input.after } : {}
+			}
+		});
+	}
+	async readRealtimeRoomHistory(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "realtime.room.history",
+			requestId: input.requestId,
+			payload: {
+				roomId: input.roomId,
+				...input.after !== void 0 ? { after: input.after } : {},
+				...input.limit !== void 0 ? { limit: input.limit } : {}
+			}
+		});
+	}
+	async publishRealtimeRoom(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "realtime.room.publish",
+			requestId: input.requestId,
+			payload: {
+				roomId: input.roomId,
+				event: input.event,
+				data: input.data,
+				clientEventId: input.clientEventId
+			}
+		});
+	}
+	async detachRealtimeRoom(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "realtime.room.detach",
+			requestId: input.requestId,
+			payload: { roomId: input.roomId }
+		});
+	}
+	async leaveRealtimeRoom(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "realtime.room.leave",
+			requestId: input.requestId,
+			payload: { roomId: input.roomId }
+		});
+	}
+	async updateRealtimeRoomPresence(input) {
+		await this.ensureOpen();
+		this.send({
+			type: "realtime.room.presence.update",
+			requestId: input.requestId,
+			payload: {
+				roomId: input.roomId,
+				presence: input.presence
+			}
+		});
+	}
+	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,
+				thinkingLevel: input.thinkingLevel
+			}
+		});
+	}
+	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 forceRefresh = this.forceRefreshOnNextAuth;
+		this.forceRefreshOnNextAuth = false;
+		const token = this.getAccessToken ? await this.getAccessToken(forceRefresh ? { forceRefresh: true } : void 0) : 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,
+					WS_BOARD_AWARENESS_CAPABILITY,
+					WS_REALTIME_ROOM_CAPABILITY,
+					WS_REALTIME_ROOM_HISTORY_CAPABILITY
+				]
+			}
+		});
+		await waiter.promise;
+		this.authReconnectAttempted = false;
+	}
+	flushRoomSubscriptions() {
+		if (this.state !== "open" || 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;
+		}
+	}
+	restoreRoomSubscriptions() {
+		this.resetRoomSubscriptions();
+		this.flushRoomSubscriptions();
+	}
+	resetRoomSubscriptions() {
+		for (const state of this.roomSubscriptions.values()) {
+			state.subscribed = false;
+			state.pending = false;
+		}
+	}
+	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 : {};
+				const capabilities = Array.isArray(envelope.payload.capabilities) ? envelope.payload.capabilities.filter((value) => typeof value === "string") : [];
+				this.serverCapabilities.clear();
+				for (const capability of capabilities) this.serverCapabilities.add(capability);
+				if (connectionId) {
+					this.connectionId = connectionId;
+					this.emit("auth", {
+						connectionId,
+						user,
+						capabilities
+					});
+				}
+				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,
+					billing: extractBillingPayload(payload.billing)
+				});
+				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: /* @__PURE__ */ 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: this.state === "reconnecting"
+			});
+		});
+	}
+};
+const createWebsocketClient = (options) => new WebsocketClient(options);
+//#endregion
 export { WebsocketClient, createWebsocketClient };