@rebasepro/client 0.9.1-canary.ed943fa → 0.9.1-canary.f2f61da

package/dist/index.d.ts

@@ -27,8 +27,6 @@ export type { CreateBackupsOptions } from "./backups";
 export type { ApiKeyMasked, ApiKeyPermission, ApiKeyWithSecret, CreateApiKeyRequest, CreateApiKeysOptions, UpdateApiKeyRequest } from "./api-keys";
 export type { FunctionInvokeOptions, FunctionsClient } from "./functions";
 export { RebaseWebSocketClient } from "./websocket";
-export { RebaseRealtimeChannel } from "./realtime-channel";
-export type { PresenceState, PresenceDiff, BroadcastEvent, ChannelTransport } from "./realtime-channel";
 export interface CreateRebaseClientOptions extends RebaseClientConfig {
     auth?: CreateAuthOptions;
     admin?: CreateAdminOptions;

package/dist/index.es.js

@@ -1397,11 +1397,9 @@ var ClientStorageSourceRegistry = class ClientStorageSourceRegistry {
 function extractMessageError(message) {
 	const payload = message.payload;
 	const errPayload = payload?.error;
-	const errorMessage = typeof errPayload === "object" ? errPayload.message : payload?.message || (typeof errPayload === "string" ? errPayload : void 0) || message.error || "Unknown error";
-	const errorCode = typeof errPayload === "object" ? errPayload.code : payload?.code;
 	return {
-		errorMessage: typeof errorMessage === "string" ? errorMessage : errorMessage == null ? "Unknown error" : JSON.stringify(errorMessage),
-		errorCode
+		errorMessage: typeof errPayload === "object" ? errPayload.message : payload?.message || (typeof errPayload === "string" ? errPayload : void 0) || message.error || "Unknown error",
+		errorCode: typeof errPayload === "object" ? errPayload.code : payload?.code
 	};
 }
 /**
@@ -1419,23 +1417,6 @@ var RebaseWebSocketClient = class {
 	getAuthToken;
 	subscriptions = /* @__PURE__ */ new Map();
 	listeners = /* @__PURE__ */ new Map();
-	/** Channel-name → handlers, for broadcast and presence frames. */
-	channelHandlers = /* @__PURE__ */ new Map();
-	/** Subscribe to broadcast/presence frames for one channel. */
-	onChannelMessage(channel, handler) {
-		if (!this.channelHandlers.has(channel)) this.channelHandlers.set(channel, /* @__PURE__ */ new Set());
-		this.channelHandlers.get(channel).add(handler);
-		return () => {
-			const handlers = this.channelHandlers.get(channel);
-			if (!handlers) return;
-			handlers.delete(handler);
-			if (handlers.size === 0) this.channelHandlers.delete(channel);
-		};
-	}
-	/** Notified after the socket comes back, so channels can re-join. */
-	onReconnect(handler) {
-		return this.on("reconnect", handler);
-	}
 	on(event, cb) {
 		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
 		this.listeners.get(event).add(cb);
@@ -1454,7 +1435,6 @@ var RebaseWebSocketClient = class {
 	isConnected = false;
 	messageQueue = [];
 	requestTimeoutMs = 3e4;
-	subscriptionTimeoutMs = 3e4;
 	reconnectTimeout = null;
 	isAuthenticated = false;
 	authPromise = null;
@@ -1560,7 +1540,6 @@ var RebaseWebSocketClient = class {
 				this.emit(wasReconnect ? "reconnect" : "connect");
 				this.processMessageQueue();
 				if (wasReconnect) this.resubscribeAll();
-				this.armPendingSubscribeWatchdogs();
 			};
 			this.ws.onmessage = (event) => {
 				try {
@@ -1575,7 +1554,6 @@ var RebaseWebSocketClient = class {
 				this.isConnected = false;
 				this.isAuthenticated = false;
 				this.authPromise = null;
-				this.suspendSubscribeWatchdogs();
 				this.emit("disconnect");
 				for (const [reqId, request] of this.pendingRequests.entries()) {
 					if (reqId.startsWith("auth_")) request.reject(/* @__PURE__ */ new Error("Connection closed during authentication"));
@@ -1607,7 +1585,6 @@ var RebaseWebSocketClient = class {
 	attemptReconnect() {
 		if (this.reconnectAttempts >= this.maxReconnectAttempts) {
 			console.error("Max reconnection attempts reached");
-			this.failAllPendingSubscriptions(new RebaseApiError$1("Connection lost", { code: "CONNECTION_LOST" }));
 			return;
 		}
 		this.reconnectAttempts++;
@@ -1662,18 +1639,29 @@ var RebaseWebSocketClient = class {
 				subscription.backendSubscriptionId = newBackendId;
 				backendKeyMap.delete(oldBackendId);
 				backendKeyMap.set(newBackendId, subscriptionKey);
-				if (messageType === "subscribe_collection") this.sendCollectionSubscribe(subscriptionKey);
-				else this.sendEntitySubscribe(subscriptionKey);
-				return;
+				this.sendMessage({
+					type: messageType,
+					payload: {
+						...subscription.props,
+						subscriptionId: newBackendId
+					}
+				}).catch((error) => {
+					console.error(`[WS] Failed to re-subscribe ${idPrefix} after auth refresh:`, subscriptionKey, error);
+					subscription.callbacks.forEach((callback) => {
+						if (callback.onError) callback.onError(error);
+					});
+				});
+			} else {
+				const { errorMessage, errorCode } = extractMessageError(message);
+				const error = new RebaseApiError$1(errorMessage, { code: errorCode });
+				subscription.callbacks.forEach((callback) => {
+					if (callback.onError) callback.onError(error);
+				});
 			}
-			const { errorMessage, errorCode } = extractMessageError(message);
-			const error = new RebaseApiError$1(errorMessage, { code: errorCode });
-			if (messageType === "subscribe_collection") this.failCollectionSubscription(subscriptionKey, error);
-			else this.failEntitySubscription(subscriptionKey, error);
 		}).catch((err) => {
-			const error = err instanceof Error ? err : new Error(String(err));
-			if (messageType === "subscribe_collection") this.failCollectionSubscription(subscriptionKey, error);
-			else this.failEntitySubscription(subscriptionKey, error);
+			subscription.callbacks.forEach((callback) => {
+				if (callback.onError) callback.onError(err);
+			});
 		});
 	}
 	handleWebSocketMessage(message) {
@@ -1702,15 +1690,6 @@ var RebaseWebSocketClient = class {
 			}
 			return;
 		}
-		if (typeof message.channel === "string" && (type === "broadcast" || type === "presence_state" || type === "presence_diff")) {
-			const handlers = this.channelHandlers.get(message.channel);
-			if (handlers) for (const handler of [...handlers]) try {
-				handler(message);
-			} catch (error) {
-				console.error("Error in channel handler:", error);
-			}
-			return;
-		}
 		if (subscriptionId && type === "collection_update") {
 			const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
 			if (subscriptionKey) {
@@ -1723,9 +1702,6 @@ var RebaseWebSocketClient = class {
 					collectionSub.latestData = rows;
 					collectionSub.lastUpdated = Date.now();
 					collectionSub.isInitialDataReceived = true;
-					if (collectionSub.subscribeTimeout) clearTimeout(collectionSub.subscribeTimeout);
-					collectionSub.subscribeTimeout = void 0;
-					collectionSub.subscribeInFlight = false;
 					collectionSub.callbacks.forEach((callback) => {
 						try {
 							callback.onUpdate(rows);
@@ -1781,9 +1757,6 @@ var RebaseWebSocketClient = class {
 					entitySub.latestData = row;
 					entitySub.lastUpdated = Date.now();
 					entitySub.isInitialDataReceived = true;
-					if (entitySub.subscribeTimeout) clearTimeout(entitySub.subscribeTimeout);
-					entitySub.subscribeTimeout = void 0;
-					entitySub.subscribeInFlight = false;
 					entitySub.callbacks.forEach((callback) => {
 						try {
 							callback.onUpdate(row);
@@ -1805,9 +1778,6 @@ var RebaseWebSocketClient = class {
 						this.resubscribeAfterAuthRefresh(message, collectionSub, collectionKey, "collection", this.backendToCollectionKey, "subscribe_collection");
 						return;
 					}
-					if (collectionSub.subscribeTimeout) clearTimeout(collectionSub.subscribeTimeout);
-					collectionSub.subscribeTimeout = void 0;
-					collectionSub.subscribeInFlight = false;
 					const { errorMessage, errorCode } = extractMessageError(message);
 					const error = new RebaseApiError$1(errorMessage, { code: errorCode });
 					collectionSub.callbacks.forEach((callback) => {
@@ -1824,9 +1794,6 @@ var RebaseWebSocketClient = class {
 						this.resubscribeAfterAuthRefresh(message, entitySub, entityKey, "row", this.backendToEntityKey, "subscribe_one");
 						return;
 					}
-					if (entitySub.subscribeTimeout) clearTimeout(entitySub.subscribeTimeout);
-					entitySub.subscribeTimeout = void 0;
-					entitySub.subscribeInFlight = false;
 					const { errorMessage, errorCode } = extractMessageError(message);
 					const error = new RebaseApiError$1(errorMessage, { code: errorCode });
 					entitySub.callbacks.forEach((callback) => {
@@ -1899,10 +1866,6 @@ var RebaseWebSocketClient = class {
 			throw error;
 		}
 	}
-	/**
-	* Public because `RebaseRealtimeChannel` sends channel frames through it.
-	* Not part of the stable surface — prefer `client.realtime.channel(name)`.
-	*/
 	sendMessage(message) {
 		const queuedMsg = message;
 		if (queuedMsg._queuedResolve && queuedMsg._queuedReject) return this.doSendMessage(message, queuedMsg._queuedResolve, queuedMsg._queuedReject);
@@ -2179,12 +2142,9 @@ var RebaseWebSocketClient = class {
 				console.error("Error in collection subscription callback:", error);
 				if (onError) onError(error instanceof Error ? error : new Error(String(error)));
 			}
-			else if (!existingSubscription.subscribeInFlight) this.sendCollectionSubscribe(subscriptionKey);
 			return () => {
 				callbackMap.delete(callbackId);
 				if (callbackMap.size === 0) {
-					if (this.collectionSubscriptions.get(subscriptionKey) !== existingSubscription) return;
-					if (existingSubscription.subscribeTimeout) clearTimeout(existingSubscription.subscribeTimeout);
 					this.collectionSubscriptions.delete(subscriptionKey);
 					this.backendToCollectionKey.delete(existingSubscription.backendSubscriptionId);
 					if (this.isConnected && this.ws) this.sendMessage({
@@ -2206,14 +2166,21 @@ var RebaseWebSocketClient = class {
 			props
 		});
 		this.backendToCollectionKey.set(backendSubscriptionId, subscriptionKey);
-		this.sendCollectionSubscribe(subscriptionKey);
+		this.sendMessage({
+			type: "subscribe_collection",
+			payload: {
+				...props,
+				subscriptionId: backendSubscriptionId
+			}
+		}).catch((error) => {
+			if (onError) onError(error);
+		});
 		return () => {
 			const subscription = this.collectionSubscriptions.get(subscriptionKey);
 			if (subscription) {
 				const callbacks = subscription.callbacks;
 				callbacks.delete(callbackId);
 				if (callbacks.size === 0) {
-					if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
 					this.collectionSubscriptions.delete(subscriptionKey);
 					this.backendToCollectionKey.delete(subscription.backendSubscriptionId);
 					if (this.isConnected && this.ws) this.sendMessage({
@@ -2240,12 +2207,9 @@ var RebaseWebSocketClient = class {
 				console.error("Error in row subscription callback:", error);
 				if (onError) onError(error instanceof Error ? error : new Error(String(error)));
 			}
-			else if (!existingSubscription.subscribeInFlight) this.sendEntitySubscribe(subscriptionKey);
 			return () => {
 				callbackMap.delete(callbackId);
 				if (callbackMap.size === 0) {
-					if (this.singleSubscriptions.get(subscriptionKey) !== existingSubscription) return;
-					if (existingSubscription.subscribeTimeout) clearTimeout(existingSubscription.subscribeTimeout);
 					this.singleSubscriptions.delete(subscriptionKey);
 					this.backendToEntityKey.delete(existingSubscription.backendSubscriptionId);
 					if (this.isConnected && this.ws) this.sendMessage({
@@ -2267,7 +2231,15 @@ var RebaseWebSocketClient = class {
 			props
 		});
 		this.backendToEntityKey.set(backendSubscriptionId, subscriptionKey);
-		this.sendEntitySubscribe(subscriptionKey);
+		this.sendMessage({
+			type: "subscribe_one",
+			payload: {
+				...props,
+				subscriptionId: backendSubscriptionId
+			}
+		}).catch((error) => {
+			if (onError) onError(error);
+		});
 		return () => {
 			const subscription = this.singleSubscriptions.get(subscriptionKey);
 			if (subscription) {
@@ -2285,157 +2257,6 @@ var RebaseWebSocketClient = class {
 		};
 	}
 	/**
-	* Send a `subscribe_collection` for an already-registered subscription and
-	* arm its watchdog.
-	*
-	* Every path that registers a collection subscription goes through here, so
-	* that a subscribe which never lands — a rejected send, or a server that
-	* never answers — always ends up in `failCollectionSubscription` rather than
-	* leaving the entry parked with `isInitialDataReceived === false` forever.
-	*/
-	sendCollectionSubscribe(subscriptionKey) {
-		const subscription = this.collectionSubscriptions.get(subscriptionKey);
-		if (!subscription) return;
-		const backendSubscriptionId = subscription.backendSubscriptionId;
-		subscription.subscribeInFlight = true;
-		if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
-		subscription.subscribeTimeout = void 0;
-		if (this.isConnected) this.sendCollectionSubscribeWatchdog(subscriptionKey);
-		this.sendMessage({
-			type: "subscribe_collection",
-			payload: {
-				...subscription.props,
-				subscriptionId: backendSubscriptionId
-			}
-		}).catch((error) => {
-			const current = this.collectionSubscriptions.get(subscriptionKey);
-			if (!current || current.backendSubscriptionId !== backendSubscriptionId) return;
-			this.failCollectionSubscription(subscriptionKey, error instanceof Error ? error : new Error(String(error)));
-		});
-	}
-	/** The `listenOne` counterpart of {@link sendCollectionSubscribe}. */
-	sendEntitySubscribe(subscriptionKey) {
-		const subscription = this.singleSubscriptions.get(subscriptionKey);
-		if (!subscription) return;
-		const backendSubscriptionId = subscription.backendSubscriptionId;
-		subscription.subscribeInFlight = true;
-		if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
-		subscription.subscribeTimeout = void 0;
-		if (this.isConnected) this.sendEntitySubscribeWatchdog(subscriptionKey);
-		this.sendMessage({
-			type: "subscribe_one",
-			payload: {
-				...subscription.props,
-				subscriptionId: backendSubscriptionId
-			}
-		}).catch((error) => {
-			const current = this.singleSubscriptions.get(subscriptionKey);
-			if (!current || current.backendSubscriptionId !== backendSubscriptionId) return;
-			this.failEntitySubscription(subscriptionKey, error instanceof Error ? error : new Error(String(error)));
-		});
-	}
-	/**
-	* Report a subscribe failure to every listener and drop the registration.
-	*
-	* Dropping it is the point: the callbacks stay live (their components are
-	* still mounted and have been told), but the next `listenCollection` for
-	* these params finds no entry and issues a fresh subscribe instead of
-	* silently attaching to a dead one.
-	*/
-	failCollectionSubscription(subscriptionKey, error) {
-		const subscription = this.collectionSubscriptions.get(subscriptionKey);
-		if (!subscription) return;
-		if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
-		subscription.subscribeInFlight = false;
-		this.collectionSubscriptions.delete(subscriptionKey);
-		this.backendToCollectionKey.delete(subscription.backendSubscriptionId);
-		subscription.callbacks.forEach((callback) => {
-			if (callback.onError) try {
-				callback.onError(error);
-			} catch (callbackError) {
-				console.error("Error in collection subscription error callback:", callbackError);
-			}
-		});
-	}
-	/** The `listenOne` counterpart of {@link failCollectionSubscription}. */
-	failEntitySubscription(subscriptionKey, error) {
-		const subscription = this.singleSubscriptions.get(subscriptionKey);
-		if (!subscription) return;
-		if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
-		subscription.subscribeInFlight = false;
-		this.singleSubscriptions.delete(subscriptionKey);
-		this.backendToEntityKey.delete(subscription.backendSubscriptionId);
-		subscription.callbacks.forEach((callback) => {
-			if (callback.onError) try {
-				callback.onError(error);
-			} catch (callbackError) {
-				console.error("Error in row subscription error callback:", callbackError);
-			}
-		});
-	}
-	/**
-	* Stop the watchdogs without failing anything — used when the socket drops,
-	* since the reconnect path re-subscribes everything anyway and a watchdog
-	* firing mid-reconnect would tear down healthy subscriptions.
-	*/
-	suspendSubscribeWatchdogs() {
-		for (const sub of this.collectionSubscriptions.values()) {
-			if (sub.subscribeTimeout) clearTimeout(sub.subscribeTimeout);
-			sub.subscribeTimeout = void 0;
-			sub.subscribeInFlight = false;
-		}
-		for (const sub of this.singleSubscriptions.values()) {
-			if (sub.subscribeTimeout) clearTimeout(sub.subscribeTimeout);
-			sub.subscribeTimeout = void 0;
-			sub.subscribeInFlight = false;
-		}
-	}
-	/**
-	* Arm watchdogs for subscribes that were requested while offline and have
-	* just been flushed to the socket. Their timers were deliberately not set at
-	* request time, so without this they would have no timeout at all.
-	*/
-	armPendingSubscribeWatchdogs() {
-		for (const [key, sub] of this.collectionSubscriptions.entries()) if (sub.subscribeInFlight && !sub.subscribeTimeout) this.sendCollectionSubscribeWatchdog(key);
-		for (const [key, sub] of this.singleSubscriptions.entries()) if (sub.subscribeInFlight && !sub.subscribeTimeout) this.sendEntitySubscribeWatchdog(key);
-	}
-	sendCollectionSubscribeWatchdog(subscriptionKey) {
-		const subscription = this.collectionSubscriptions.get(subscriptionKey);
-		if (!subscription) return;
-		const backendSubscriptionId = subscription.backendSubscriptionId;
-		subscription.subscribeTimeout = setTimeout(() => {
-			const current = this.collectionSubscriptions.get(subscriptionKey);
-			if (!current || current.backendSubscriptionId !== backendSubscriptionId) return;
-			if (!current.subscribeInFlight) return;
-			this.failCollectionSubscription(subscriptionKey, new RebaseApiError$1("Subscription timed out", { code: "SUBSCRIPTION_TIMEOUT" }));
-		}, this.subscriptionTimeoutMs);
-	}
-	sendEntitySubscribeWatchdog(subscriptionKey) {
-		const subscription = this.singleSubscriptions.get(subscriptionKey);
-		if (!subscription) return;
-		const backendSubscriptionId = subscription.backendSubscriptionId;
-		subscription.subscribeTimeout = setTimeout(() => {
-			const current = this.singleSubscriptions.get(subscriptionKey);
-			if (!current || current.backendSubscriptionId !== backendSubscriptionId) return;
-			if (!current.subscribeInFlight) return;
-			this.failEntitySubscription(subscriptionKey, new RebaseApiError$1("Subscription timed out", { code: "SUBSCRIPTION_TIMEOUT" }));
-		}, this.subscriptionTimeoutMs);
-	}
-	/**
-	* Fail every subscription that never received data. Called when reconnection
-	* is given up on, so views surface an error instead of spinning forever.
-	*/
-	failAllPendingSubscriptions(error) {
-		for (const key of [...this.collectionSubscriptions.keys()]) {
-			const sub = this.collectionSubscriptions.get(key);
-			if (sub && !sub.isInitialDataReceived) this.failCollectionSubscription(key, error);
-		}
-		for (const key of [...this.singleSubscriptions.keys()]) {
-			const sub = this.singleSubscriptions.get(key);
-			if (sub && !sub.isInitialDataReceived) this.failEntitySubscription(key, error);
-		}
-	}
-	/**
 	* Re-send all active subscriptions to the backend after a reconnect.
 	* The server wipes subscription state when a client disconnects, so
 	* we need to re-register everything to resume receiving updates.
@@ -2448,7 +2269,15 @@ var RebaseWebSocketClient = class {
 			sub.backendSubscriptionId = newBackendId;
 			this.backendToCollectionKey.delete(oldBackendId);
 			this.backendToCollectionKey.set(newBackendId, key);
-			this.sendCollectionSubscribe(key);
+			this.sendMessage({
+				type: "subscribe_collection",
+				payload: {
+					...sub.props,
+					subscriptionId: newBackendId
+				}
+			}).catch((error) => {
+				console.error("[WS] Failed to re-subscribe collection:", key, error);
+			});
 		}
 		for (const [key, sub] of this.singleSubscriptions.entries()) {
 			const oldBackendId = sub.backendSubscriptionId;
@@ -2456,7 +2285,15 @@ var RebaseWebSocketClient = class {
 			sub.backendSubscriptionId = newBackendId;
 			this.backendToEntityKey.delete(oldBackendId);
 			this.backendToEntityKey.set(newBackendId, key);
-			this.sendEntitySubscribe(key);
+			this.sendMessage({
+				type: "subscribe_one",
+				payload: {
+					...sub.props,
+					subscriptionId: newBackendId
+				}
+			}).catch((error) => {
+				console.error("[WS] Failed to re-subscribe row:", key, error);
+			});
 		}
 	}
 	createCollectionSubscriptionKey(props) {
@@ -2483,190 +2320,6 @@ var RebaseWebSocketClient = class {
 	}
 };
 //#endregion
-//#region src/realtime-channel.ts
-/**
-* Re-send presence comfortably inside the server's 30s expiry.
-*
-* Two-thirds of the window: one lost heartbeat still leaves time for the next
-* before the entry is reaped, so a single dropped frame is not a disappearance.
-*/
-var PRESENCE_HEARTBEAT_MS = 2e4;
-var RebaseRealtimeChannel = class {
-	name;
-	transport;
-	presenceHandlers = /* @__PURE__ */ new Set();
-	broadcastHandlers = /* @__PURE__ */ new Set();
-	unsubscribers = [];
-	/** Last known roster, kept so handlers always get a full picture. */
-	presences = {};
-	/** What this client last tracked, replayed on reconnect and heartbeat. */
-	trackedState = null;
-	heartbeat = null;
-	joined = false;
-	constructor(name, transport) {
-		this.name = name;
-		this.transport = transport;
-	}
-	/**
-	* Join the channel and ask for the current roster.
-	*
-	* Called automatically by `track`, `broadcast`, `onPresence` and
-	* `onBroadcast`; calling it directly is only needed to start receiving
-	* before there is anything to send.
-	*/
-	async join() {
-		if (this.joined) return;
-		this.joined = true;
-		this.unsubscribers.push(this.transport.onChannelMessage(this.name, (message) => this.handle(message)));
-		this.unsubscribers.push(this.transport.onReconnect(() => {
-			this.rejoin();
-		}));
-		await this.transport.sendMessage({
-			type: "join_channel",
-			channel: this.name
-		});
-		await this.transport.sendMessage({
-			type: "presence_state",
-			channel: this.name
-		});
-	}
-	async rejoin() {
-		try {
-			await this.transport.sendMessage({
-				type: "join_channel",
-				channel: this.name
-			});
-			await this.transport.sendMessage({
-				type: "presence_state",
-				channel: this.name
-			});
-			if (this.trackedState) await this.transport.sendMessage({
-				type: "presence_track",
-				channel: this.name,
-				state: this.trackedState
-			});
-		} catch {}
-	}
-	/**
-	* Publish this client's presence state, and keep publishing it.
-	*
-	* Calling `track` again replaces the state (and restarts the heartbeat),
-	* which is how you update e.g. a cursor position.
-	*/
-	async track(state) {
-		await this.join();
-		this.trackedState = state;
-		await this.transport.sendMessage({
-			type: "presence_track",
-			channel: this.name,
-			state
-		});
-		if (!this.heartbeat) {
-			this.heartbeat = setInterval(() => {
-				if (!this.trackedState) return;
-				this.transport.sendMessage({
-					type: "presence_track",
-					channel: this.name,
-					state: this.trackedState
-				}).catch(() => {});
-			}, PRESENCE_HEARTBEAT_MS);
-			this.heartbeat.unref?.();
-		}
-	}
-	/** Stop publishing presence, without leaving the channel. */
-	async untrack() {
-		this.stopHeartbeat();
-		this.trackedState = null;
-		if (this.joined) await this.transport.sendMessage({
-			type: "presence_untrack",
-			channel: this.name
-		});
-	}
-	/**
-	* Observe the roster. The handler fires immediately with what is already
-	* known, then on every change.
-	*/
-	onPresence(handler) {
-		this.presenceHandlers.add(handler);
-		this.join();
-		if (Object.keys(this.presences).length > 0) handler({ ...this.presences });
-		return () => this.presenceHandlers.delete(handler);
-	}
-	/** Send a broadcast. The sender does not receive its own message. */
-	async broadcast(event, payload) {
-		await this.join();
-		await this.transport.sendMessage({
-			type: "broadcast",
-			channel: this.name,
-			event,
-			payload
-		});
-	}
-	onBroadcast(eventOrHandler, maybeHandler) {
-		const wrapped = typeof eventOrHandler === "string" ? (e) => {
-			if (e.event === eventOrHandler) maybeHandler(e.payload);
-		} : eventOrHandler;
-		this.broadcastHandlers.add(wrapped);
-		this.join();
-		return () => this.broadcastHandlers.delete(wrapped);
-	}
-	/** Leave the channel and release every listener and timer. */
-	async leave() {
-		this.stopHeartbeat();
-		this.trackedState = null;
-		this.presences = {};
-		this.presenceHandlers.clear();
-		this.broadcastHandlers.clear();
-		for (const off of this.unsubscribers) off();
-		this.unsubscribers = [];
-		if (this.joined) {
-			this.joined = false;
-			await this.transport.sendMessage({
-				type: "leave_channel",
-				channel: this.name
-			});
-		}
-	}
-	stopHeartbeat() {
-		if (this.heartbeat) {
-			clearInterval(this.heartbeat);
-			this.heartbeat = null;
-		}
-	}
-	/** Fold an incoming frame into the roster and fan it out. */
-	handle(message) {
-		switch (message.type) {
-			case "presence_state":
-				this.presences = message.presences ?? {};
-				this.emitPresence();
-				break;
-			case "presence_diff": {
-				const joins = message.joins ?? {};
-				const leaves = message.leaves ?? {};
-				for (const [id, state] of Object.entries(joins)) this.presences[id] = state;
-				for (const id of Object.keys(leaves)) delete this.presences[id];
-				this.emitPresence({
-					joins,
-					leaves
-				});
-				break;
-			}
-			case "broadcast": {
-				const event = {
-					event: message.event,
-					payload: message.payload
-				};
-				for (const handler of this.broadcastHandlers) handler(event);
-				break;
-			}
-		}
-	}
-	emitPresence(diff) {
-		const snapshot = { ...this.presences };
-		for (const handler of this.presenceHandlers) handler(snapshot, diff);
-	}
-};
-//#endregion
 //#region src/index.ts
 /**
 * Derive a WebSocket URL from an HTTP base URL.
@@ -2717,8 +2370,6 @@ function createRebaseClient(options) {
 	};
 	const resolvedWsUrl = options.realtime !== false ? options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl) : void 0;
 	let ws;
-	/** One channel object per name — see `realtime.channel`. */
-	const realtimeChannels = /* @__PURE__ */ new Map();
 	if (resolvedWsUrl) {
 		ws = new RebaseWebSocketClient({
 			websocketUrl: resolvedWsUrl,
@@ -2829,24 +2480,6 @@ function createRebaseClient(options) {
 		createStorageSource,
 		fetchStorageSources,
 		ws,
-		realtime: { 
-		/**
-		* Join a broadcast/presence channel.
-		*
-		* Repeated calls with the same name return the same channel, so
-		* separate components can attach handlers without each opening its
-		* own membership — and `leave()` from one would otherwise silently
-		* cut off the others.
-		*/
-channel: (name) => {
-			if (!ws) throw new RebaseClientError("Realtime is disabled on this client (realtime: false), so channels are unavailable.");
-			let existing = realtimeChannels.get(name);
-			if (!existing) {
-				existing = new RebaseRealtimeChannel(name, ws);
-				realtimeChannels.set(name, existing);
-			}
-			return existing;
-		} },
 		/**
 		* Release the realtime socket and its reconnect timer.
 		*
@@ -2855,8 +2488,6 @@ channel: (name) => {
 		* was never started, and safe to call twice.
 		*/
 		close: () => {
-			for (const channel of realtimeChannels.values()) channel.leave();
-			realtimeChannels.clear();
 			ws?.disconnect();
 		},
 		setToken: transport.setToken,
@@ -2877,6 +2508,6 @@ channel: (name) => {
 	};
 }
 //#endregion
-export { QueryBuilder, RebaseApiError, RebaseClientError, RebaseRealtimeChannel, RebaseWebSocketClient, and, cond, createBackups, createCookieStorage, createMemoryStorage, createRebaseClient, or };
+export { QueryBuilder, RebaseApiError, RebaseClientError, RebaseWebSocketClient, and, cond, createBackups, createCookieStorage, createMemoryStorage, createRebaseClient, or };
 
 //# sourceMappingURL=index.es.js.map