@xopcai/xopc 0.0.187 → 0.0.189

package/dist/gateway/static/root/index.html

@@ -11,7 +11,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png?v=20260713-1" />
     <link rel="manifest" href="/site.webmanifest?v=20260713-1" />
     <title>XOPC — Turn goals into loops. Keep what matters moving.</title>
-    <script type="module" crossorigin src="/assets/index-vi5KlR5_.js"></script>
+    <script type="module" crossorigin src="/assets/index-BvR-i-m6.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-aKtaBQYM.js">
     <link rel="modulepreload" crossorigin href="/assets/preload-helper-zJ_50EbN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BOUWij0V.js">
@@ -23,17 +23,17 @@
     <link rel="modulepreload" crossorigin href="/assets/createLucideIcon-DPHK1VkS.js">
     <link rel="modulepreload" crossorigin href="/assets/check-DUBLcKHA.js">
     <link rel="modulepreload" crossorigin href="/assets/middleware-Pd0e8Igk.js">
-    <link rel="modulepreload" crossorigin href="/assets/messages-CPxz48hr.js">
-    <link rel="modulepreload" crossorigin href="/assets/locale-store-Bff30u5V.js">
+    <link rel="modulepreload" crossorigin href="/assets/messages-CMjnbdbn.js">
+    <link rel="modulepreload" crossorigin href="/assets/locale-store-DUW5YE3R.js">
     <link rel="modulepreload" crossorigin href="/assets/cn-JdwAhgNB.js">
-    <link rel="modulepreload" crossorigin href="/assets/schemas-C6onAggk.js">
-    <link rel="modulepreload" crossorigin href="/assets/product-delivery-C8JbSj5Y.js">
+    <link rel="modulepreload" crossorigin href="/assets/schemas-zIBW3wiV.js">
+    <link rel="modulepreload" crossorigin href="/assets/product-delivery-tRr-7IxY.js">
     <link rel="modulepreload" crossorigin href="/assets/config-reload-event-Bjh2zoKp.js">
     <link rel="modulepreload" crossorigin href="/assets/copy-to-clipboard-HOJ79TWv.js">
-    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-CntXJF6W.js">
-    <link rel="modulepreload" crossorigin href="/assets/activity-store-WlR2zEvA.js">
-    <link rel="modulepreload" crossorigin href="/assets/theme-store-y7e_tvYi.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-D-YfWVyS.css">
+    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-DxhKNiCF.js">
+    <link rel="modulepreload" crossorigin href="/assets/activity-store-DTFKTPs8.js">
+    <link rel="modulepreload" crossorigin href="/assets/theme-store-BkJe7UDo.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-zybP34zk.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/package.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.0.187";
+var version = "0.0.189";
 //#endregion
 export { version };

package/dist/packages/endpoint-tools-protocol/src/index.js

@@ -0,0 +1,184 @@
+import { z } from "zod";
+const ENDPOINT_MAX_FILE_BYTES = 25 * 1024 * 1024;
+const ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS = 3e3;
+const endpointKindSchema = z.enum([
+	"web",
+	"desktop",
+	"mobile"
+]);
+const endpointAvailabilitySchema = z.enum(["foreground", "background"]);
+const endpointEffectSchema = z.enum([
+	"read",
+	"write",
+	"destructive"
+]);
+const endpointConfirmationSchema = z.enum(["never", "always"]);
+const endpointResultKindSchema = z.enum([
+	"text",
+	"json",
+	"file"
+]);
+const identifierSchema = z.string().min(1).max(160);
+const turnTokenSchema = z.string().min(32).max(160).regex(/^[A-Za-z0-9_-]+$/);
+const turnOriginSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("endpoint"),
+		endpointId: identifierSchema
+	}),
+	z.strictObject({
+		type: z.literal("channel"),
+		channel: z.string().min(1).max(64)
+	}),
+	z.strictObject({
+		type: z.literal("system"),
+		source: z.enum([
+			"cli",
+			"automation",
+			"heartbeat",
+			"workflow",
+			"internal"
+		])
+	})
+]);
+const endpointTurnClaimSchema = turnOriginSchema.options[0].extend({ token: turnTokenSchema });
+const messageIdSchema = z.uuid();
+const timestampSchema = z.number().int().nonnegative();
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const endpointToolDescriptorSchema = z.strictObject({
+	name: z.string().regex(/^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/).max(120),
+	title: z.string().min(1).max(120),
+	description: z.string().min(1).max(2e3),
+	inputSchema: jsonObjectSchema,
+	effect: endpointEffectSchema,
+	confirmation: endpointConfirmationSchema,
+	requiresForeground: z.boolean(),
+	requiredPermissions: z.array(z.string().min(1).max(120)).max(20),
+	timeoutMs: z.number().int().min(1e3).max(3e5),
+	maxConcurrency: z.number().int().min(1).max(4),
+	supportsCancellation: z.boolean(),
+	idempotent: z.boolean(),
+	resultKinds: z.array(endpointResultKindSchema).min(1).max(3)
+});
+const endpointPrincipalRegistrationSchema = z.strictObject({
+	principalId: identifierSchema,
+	displayName: z.string().min(1).max(120),
+	kind: endpointKindSchema,
+	platform: z.string().min(1).max(80),
+	publicKey: z.string().min(32).max(2048)
+});
+const endpointHelloPayloadSchema = z.strictObject({
+	principalId: identifierSchema,
+	endpointId: identifierSchema,
+	connectionInstanceId: z.uuid(),
+	displayName: z.string().min(1).max(120),
+	kind: endpointKindSchema,
+	platform: z.string().min(1).max(80),
+	appVersion: z.string().min(1).max(80),
+	availability: endpointAvailabilitySchema,
+	nonce: identifierSchema,
+	signedAt: timestampSchema,
+	signature: z.string().min(16).max(1024),
+	tools: z.array(endpointToolDescriptorSchema).max(100)
+});
+const toolInvokePayloadSchema = z.strictObject({
+	invocationId: z.uuid(),
+	toolCallId: identifierSchema,
+	toolName: endpointToolDescriptorSchema.shape.name,
+	arguments: jsonObjectSchema,
+	descriptorRevision: z.string().min(1).max(128),
+	confirmationRequired: z.boolean(),
+	deadlineAt: timestampSchema,
+	uploadGrant: z.strictObject({
+		path: z.string().startsWith("/").max(500),
+		token: identifierSchema,
+		maxBytes: z.number().int().positive(),
+		maxFiles: z.number().int().min(1).max(20),
+		expiresAt: timestampSchema
+	}).optional()
+});
+const toolCancelPayloadSchema = z.strictObject({
+	invocationId: z.uuid(),
+	reason: z.string().min(1).max(500)
+});
+const invocationPayloadSchema = z.strictObject({ invocationId: z.uuid() });
+const endpointToolContentSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("text"),
+		text: z.string().max(256 * 1024)
+	}),
+	z.strictObject({
+		type: z.literal("json"),
+		value: z.unknown()
+	}),
+	z.strictObject({
+		type: z.literal("file"),
+		fileId: identifierSchema,
+		name: z.string().min(1).max(255),
+		mimeType: z.string().min(1).max(255),
+		size: z.number().int().nonnegative(),
+		sha256: z.string().regex(/^[a-f0-9]{64}$/)
+	})
+]);
+const endpointToolErrorCodeSchema = z.enum([
+	"ENDPOINT_OFFLINE",
+	"ENDPOINT_NOT_FOREGROUND",
+	"ENDPOINT_DISCONNECTED",
+	"TOOL_NOT_FOUND",
+	"TOOL_REVISION_MISMATCH",
+	"INVALID_ARGUMENTS",
+	"PERMISSION_DENIED",
+	"USER_DENIED",
+	"TOOL_BUSY",
+	"TOOL_TIMEOUT",
+	"TOOL_CANCELLED",
+	"RESULT_TOO_LARGE",
+	"PROTOCOL_ERROR"
+]);
+const envelope = (type, payload) => z.strictObject({
+	protocolVersion: z.literal(1),
+	messageId: messageIdSchema,
+	type: z.literal(type),
+	sentAt: timestampSchema,
+	payload
+});
+const clientEndpointMessageSchema = z.discriminatedUnion("type", [
+	envelope("endpoint.availability_changed", z.strictObject({ availability: endpointAvailabilitySchema })),
+	envelope("tool.received", invocationPayloadSchema),
+	envelope("tool.progress", z.strictObject({
+		invocationId: z.uuid(),
+		message: z.string().max(500).optional(),
+		percent: z.number().min(0).max(100).optional()
+	})),
+	envelope("tool.result", z.strictObject({
+		invocationId: z.uuid(),
+		content: z.array(endpointToolContentSchema).min(1).max(20),
+		details: jsonObjectSchema.optional()
+	})),
+	envelope("tool.error", z.strictObject({
+		invocationId: z.uuid(),
+		code: endpointToolErrorCodeSchema,
+		message: z.string().min(1).max(2e3)
+	})),
+	envelope("tool.cancelled", invocationPayloadSchema)
+]);
+const serverEndpointMessageSchema = z.discriminatedUnion("type", [envelope("tool.invoke", toolInvokePayloadSchema), envelope("tool.cancel", toolCancelPayloadSchema)]);
+function canonicalJson(value) {
+	if (value === null) return "null";
+	if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("Canonical JSON only supports finite numbers");
+		return JSON.stringify(value);
+	}
+	if (typeof value !== "object") throw new Error(`Canonical JSON does not support ${typeof value}`);
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new Error("Canonical JSON only supports plain objects");
+	const record = value;
+	return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+function endpointHelloSigningPayload(payload) {
+	const { signature: _signature, ...unsigned } = payload;
+	return canonicalJson(unsigned);
+}
+//#endregion
+export { ENDPOINT_INVOCATION_RECEIPT_TIMEOUT_MS, ENDPOINT_MAX_FILE_BYTES, canonicalJson, clientEndpointMessageSchema, endpointHelloPayloadSchema, endpointHelloSigningPayload, endpointPrincipalRegistrationSchema, endpointTurnClaimSchema, serverEndpointMessageSchema, turnOriginSchema };

package/dist/packages/gateway-contract/src/tool-activity.js

@@ -0,0 +1,223 @@
+//#region packages/gateway-contract/src/tool-activity.ts
+const OTHER_ACTIVITY = {
+	category: "other",
+	action: "use",
+	source: "unknown",
+	sensitivity: "normal"
+};
+const TOOL_ACTIVITY_CATALOG = {
+	memory_search: {
+		category: "memory",
+		action: "search",
+		source: "memory",
+		sensitivity: "personal",
+		purpose: "personal_context"
+	},
+	memory_get: {
+		category: "memory",
+		action: "read",
+		source: "memory",
+		sensitivity: "personal",
+		purpose: "personal_context"
+	},
+	web_search: {
+		category: "web",
+		action: "search",
+		source: "internet",
+		sensitivity: "normal"
+	},
+	brave_search: {
+		category: "web",
+		action: "search",
+		source: "internet",
+		sensitivity: "normal"
+	},
+	image_query: {
+		category: "web",
+		action: "search",
+		source: "internet",
+		sensitivity: "normal"
+	},
+	web_fetch: {
+		category: "web",
+		action: "read",
+		source: "internet",
+		sensitivity: "normal"
+	},
+	fetch_url: {
+		category: "web",
+		action: "read",
+		source: "internet",
+		sensitivity: "normal"
+	},
+	open_url: {
+		category: "navigation",
+		action: "open",
+		source: "internet",
+		sensitivity: "normal"
+	},
+	browser_use: {
+		category: "navigation",
+		action: "open",
+		source: "internet",
+		sensitivity: "normal"
+	},
+	search_graph: {
+		category: "code",
+		action: "search",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	search_code: {
+		category: "code",
+		action: "search",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	query_graph: {
+		category: "code",
+		action: "search",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	trace_path: {
+		category: "code",
+		action: "search",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	get_architecture: {
+		category: "code",
+		action: "search",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	get_code_snippet: {
+		category: "file",
+		action: "read",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	grep: {
+		category: "code",
+		action: "search",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	glob: {
+		category: "code",
+		action: "search",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	find_files: {
+		category: "code",
+		action: "search",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	session_search: {
+		category: "other",
+		action: "search",
+		source: "runtime",
+		sensitivity: "normal"
+	},
+	search: {
+		category: "other",
+		action: "search",
+		source: "unknown",
+		sensitivity: "normal"
+	},
+	read_file: {
+		category: "file",
+		action: "read",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	"review.prepare_diff": {
+		category: "file",
+		action: "read",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	list_dir: {
+		category: "file",
+		action: "list",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	ls: {
+		category: "file",
+		action: "list",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	write_file: {
+		category: "file",
+		action: "write",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	apply_patch: {
+		category: "file",
+		action: "edit",
+		source: "workspace",
+		sensitivity: "normal"
+	},
+	exec_command: {
+		category: "command",
+		action: "execute",
+		source: "runtime",
+		sensitivity: "normal"
+	},
+	run_command: {
+		category: "command",
+		action: "execute",
+		source: "runtime",
+		sensitivity: "normal"
+	},
+	update_plan: {
+		category: "planning",
+		action: "plan",
+		source: "runtime",
+		sensitivity: "normal"
+	}
+};
+function toolActivityId(name) {
+	const normalized = name.trim().toLowerCase().replace(/-/g, "_");
+	const namespaced = normalized.split("__").at(-1) ?? normalized;
+	return namespaced.split(".").at(-1) ?? namespaced;
+}
+function resolveToolActivityDefinition(name) {
+	const normalized = name.trim().toLowerCase().replace(/-/g, "_");
+	return TOOL_ACTIVITY_CATALOG[normalized] ?? TOOL_ACTIVITY_CATALOG[toolActivityId(normalized)] ?? OTHER_ACTIVITY;
+}
+function asRecord(value) {
+	if (typeof value === "string") try {
+		return asRecord(JSON.parse(value));
+	} catch {
+		return null;
+	}
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function resultCount(result) {
+	const record = asRecord(result);
+	const results = asRecord(record?.details)?.results ?? record?.results;
+	return Array.isArray(results) ? results.length : void 0;
+}
+function resultHasError(result) {
+	const record = asRecord(result);
+	return typeof (asRecord(record?.details)?.error ?? record?.error) === "string";
+}
+function resolveToolActivity(name, status, result) {
+	const definition = resolveToolActivityDefinition(name);
+	const count = resultCount(result);
+	const resolvedStatus = status === "completed" && resultHasError(result) ? "failed" : status === "completed" && count === 0 ? "empty" : status;
+	return {
+		...definition,
+		status: resolvedStatus,
+		...count === void 0 ? {} : { count }
+	};
+}
+//#endregion
+export { resolveToolActivity };

package/dist/packages/realtime-client/src/index.js

@@ -0,0 +1,199 @@
+import { parseServerRealtimeMessage } from "../../realtime-protocol/src/index.js";
+//#region packages/realtime-client/src/index.ts
+function clientMessage(kind, payload) {
+	return {
+		protocolVersion: 1,
+		messageId: crypto.randomUUID(),
+		kind,
+		sentAt: Date.now(),
+		payload
+	};
+}
+function frameText(data) {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) {
+		const bytes = Uint8Array.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+		return new TextDecoder().decode(bytes);
+	}
+	throw new Error("Realtime server sent a non-text frame");
+}
+var RealtimeClient = class {
+	desiredSubscriptions = /* @__PURE__ */ new Map();
+	cursors = /* @__PURE__ */ new Map();
+	socket;
+	reconnectTimer;
+	heartbeatTimer;
+	generation = 0;
+	reconnectAttempts = 0;
+	shouldReconnect = false;
+	ready = false;
+	endpointBinding;
+	constructor(options) {
+		this.options = options;
+	}
+	connect() {
+		if (this.shouldReconnect) return;
+		this.shouldReconnect = true;
+		this.open(false);
+	}
+	disconnect() {
+		this.shouldReconnect = false;
+		this.generation += 1;
+		this.clearTimers();
+		this.ready = false;
+		this.endpointBinding?.onDisconnected?.();
+		this.socket?.close(1e3, "Client disconnected");
+		this.socket = void 0;
+		this.options.onStateChange?.("disconnected");
+	}
+	reconnect() {
+		this.generation += 1;
+		this.clearTimers();
+		this.ready = false;
+		this.endpointBinding?.onDisconnected?.();
+		this.socket?.close(1e3, "Client reconnecting");
+		this.socket = void 0;
+		this.reconnectAttempts = 0;
+		this.shouldReconnect = true;
+		this.open(true);
+	}
+	subscribe(topic, afterSeq) {
+		this.desiredSubscriptions.set(topic, afterSeq);
+		if (this.ready) {
+			this.sendSubscriptions([{
+				topic,
+				afterSeq: afterSeq ?? this.cursors.get(topic)
+			}]);
+			this.desiredSubscriptions.set(topic, void 0);
+		}
+	}
+	unsubscribe(topic) {
+		this.desiredSubscriptions.delete(topic);
+		if (this.ready) this.send(clientMessage("realtime.unsubscribe", { topics: [topic] }));
+	}
+	sendEndpointMessage(message) {
+		if (!this.ready) throw new Error("Realtime connection is not ready");
+		this.send(clientMessage("endpoint.message", message));
+	}
+	setEndpoint(binding) {
+		this.endpointBinding = binding;
+		if (this.shouldReconnect) this.reconnect();
+	}
+	clearEndpoint(binding) {
+		if (binding && this.endpointBinding !== binding) return;
+		const previous = this.endpointBinding;
+		this.endpointBinding = void 0;
+		previous?.onDisconnected?.();
+		if (this.shouldReconnect) this.reconnect();
+	}
+	async open(reconnecting) {
+		const generation = ++this.generation;
+		this.options.onStateChange?.(reconnecting ? "reconnecting" : "connecting");
+		try {
+			const [ticket, endpoint] = await Promise.all([this.options.issueTicket(), this.endpointBinding?.createHello()]);
+			if (!this.shouldReconnect || generation !== this.generation) return;
+			const socket = this.options.createWebSocket(this.options.getWebSocketUrl());
+			this.socket = socket;
+			socket.onopen = () => {
+				if (generation !== this.generation) return;
+				const subscriptions = [...this.desiredSubscriptions].map(([topic, afterSeq]) => ({
+					topic,
+					afterSeq: afterSeq ?? this.cursors.get(topic)
+				}));
+				for (const topic of this.desiredSubscriptions.keys()) this.desiredSubscriptions.set(topic, void 0);
+				this.send(clientMessage("realtime.hello", {
+					ticket,
+					clientId: this.options.clientId,
+					clientKind: this.options.clientKind,
+					subscriptions,
+					...endpoint ? { endpoint } : {}
+				}));
+			};
+			socket.onmessage = (event) => {
+				if (generation !== this.generation) return;
+				try {
+					this.handleServerMessage(frameText(event.data));
+				} catch (error) {
+					this.fail(error instanceof Error ? error.message : "Invalid realtime server message");
+				}
+			};
+			socket.onerror = () => {
+				if (generation === this.generation) this.options.onStateChange?.("reconnecting");
+			};
+			socket.onclose = (event) => {
+				if (generation !== this.generation) return;
+				this.ready = false;
+				this.endpointBinding?.onDisconnected?.();
+				this.socket = void 0;
+				this.clearHeartbeat();
+				if (this.shouldReconnect) this.scheduleReconnect(event.reason || `WebSocket closed (${event.code ?? 0})`);
+				else this.options.onStateChange?.("disconnected");
+			};
+		} catch (error) {
+			if (generation !== this.generation) return;
+			this.scheduleReconnect(error instanceof Error ? error.message : "Realtime connection failed");
+		}
+	}
+	handleServerMessage(text) {
+		const message = parseServerRealtimeMessage(JSON.parse(text));
+		if (message.kind === "realtime.ready") {
+			this.ready = true;
+			this.reconnectAttempts = 0;
+			this.options.onStateChange?.("connected");
+			if (message.payload.endpoint) this.endpointBinding?.onReady(message.payload.endpoint);
+			this.clearHeartbeat();
+			this.heartbeatTimer = setInterval(() => {
+				if (this.ready) this.send(clientMessage("realtime.ping", {}));
+			}, message.payload.heartbeatIntervalMs);
+		} else if (message.kind === "realtime.event") {
+			this.cursors.set(message.payload.topic, message.payload.seq);
+			this.options.onEvent?.(message.payload);
+		} else if (message.kind === "realtime.gap") {
+			this.cursors.set(message.payload.topic, message.payload.earliestSeq - 1);
+			this.options.onGap?.(message.payload);
+		} else if (message.kind === "realtime.error") this.options.onStateChange?.("error", message.payload.message);
+		else if (message.kind === "endpoint.message") {
+			this.endpointBinding?.onMessage(message.payload);
+			this.options.onEndpointMessage?.(message.payload);
+		}
+	}
+	sendSubscriptions(subscriptions) {
+		this.send(clientMessage("realtime.subscribe", { subscriptions }));
+	}
+	send(message) {
+		if (!this.socket || this.socket.readyState !== 1) return;
+		this.socket.send(JSON.stringify(message));
+	}
+	scheduleReconnect(error) {
+		if (!this.shouldReconnect) return;
+		this.reconnectAttempts += 1;
+		const max = this.options.maxReconnectAttempts;
+		if (max !== void 0 && this.reconnectAttempts > max) {
+			this.shouldReconnect = false;
+			this.options.onStateChange?.("error", error);
+			return;
+		}
+		this.options.onStateChange?.("reconnecting", error);
+		const delay = Math.min(3e4, 1e3 * 2 ** Math.min(this.reconnectAttempts - 1, 5));
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = void 0;
+			this.open(true);
+		}, delay);
+	}
+	fail(message) {
+		this.options.onStateChange?.("error", message);
+		this.socket?.close(4400, "Invalid server message");
+	}
+	clearHeartbeat() {
+		if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+		this.heartbeatTimer = void 0;
+	}
+	clearTimers() {
+		if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+		this.reconnectTimer = void 0;
+		this.clearHeartbeat();
+	}
+};
+//#endregion
+export { RealtimeClient };