@rebasepro/client 0.9.0 → 0.9.1-canary.0fce67c

package/dist/index.umd.js

@@ -1,2484 +0,0 @@
-(function(global, factory) {
-	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@rebasepro/types"), require("@rebasepro/common"), require("@rebasepro/utils")) : typeof define === "function" && define.amd ? define([
-		"exports",
-		"@rebasepro/types",
-		"@rebasepro/common",
-		"@rebasepro/utils"
-	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase Client"] = {}, global._rebasepro_types, global._rebasepro_common, global._rebasepro_utils));
-})(this, function(exports, _rebasepro_types, _rebasepro_common, _rebasepro_utils) {
-	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-	//#region src/reviver.ts
-	function rebaseReviver(_key, value) {
-		if (value && typeof value === "object" && "__type" in value) {
-			const record = value;
-			switch (record.__type) {
-				case "date":
-				case "Date": {
-					if (typeof record.value !== "string") return value;
-					const date = new Date(record.value);
-					return isNaN(date.getTime()) ? null : date;
-				}
-				case "reference":
-				case "EntityReference": return new _rebasepro_types.EntityReference({
-					id: String(record.id),
-					path: record.path,
-					driver: record.driver,
-					databaseId: record.databaseId
-				});
-				case "relation":
-				case "EntityRelation": return new _rebasepro_types.EntityRelation(record.id, record.path, record.data);
-				case "GeoPoint": return new _rebasepro_types.GeoPoint(record.latitude, record.longitude);
-				case "Vector": return new _rebasepro_types.Vector(record.value);
-				default: return value;
-			}
-		}
-		return value;
-	}
-	//#endregion
-	//#region src/transport.ts
-	function buildQueryString(params) {
-		if (!params) return "";
-		const parts = [];
-		if (params.limit != null) parts.push(`limit=${params.limit}`);
-		if (params.offset != null) parts.push(`offset=${params.offset}`);
-		if (params.page != null) parts.push(`page=${params.page}`);
-		if (params.orderBy) {
-			const wire = (0, _rebasepro_common.serializeOrderBy)(params.orderBy);
-			if (wire) parts.push(`orderBy=${encodeURIComponent(wire)}`);
-		}
-		if (params.searchString) parts.push(`searchString=${encodeURIComponent(params.searchString)}`);
-		if (params.include && params.include.length > 0) parts.push(`include=${encodeURIComponent(params.include.join(","))}`);
-		if (params.logical) {
-			const root = params.logical;
-			const serialized = (root.conditions ?? []).map(_rebasepro_common.serializeLogicalCondition).join(",");
-			parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
-		}
-		if (params.where) {
-			const serialized = (0, _rebasepro_common.serializeFilter)(params.where);
-			for (const [field, value] of Object.entries(serialized)) if (Array.isArray(value)) for (const v of value) parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(v)}`);
-			else parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(value)}`);
-		}
-		return parts.length > 0 ? "?" + parts.join("&") : "";
-	}
-	function createTransport(config) {
-		const fetchFn = config.fetch || globalThis.fetch;
-		const apiPath = config.apiPath || "/api";
-		let token = config.token;
-		let tokenGetter;
-		let onUnauthorizedHandler = config.onUnauthorized;
-		function getHeaders(activeToken, init) {
-			return {
-				"Content-Type": "application/json",
-				...activeToken ? { Authorization: `Bearer ${activeToken}` } : {},
-				...init?.headers || {}
-			};
-		}
-		async function request(path, init) {
-			const url = (config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "") + apiPath + path;
-			let activeToken = token;
-			if (tokenGetter) try {
-				const fetched = await tokenGetter();
-				if (fetched !== null && fetched !== void 0) activeToken = fetched;
-			} catch (e) {}
-			const headers = getHeaders(activeToken, init);
-			if (init?.body instanceof FormData) delete headers["Content-Type"];
-			const res = await fetchFn(url, {
-				...init,
-				headers
-			});
-			if (res.status === 204) return void 0;
-			const text = await res.text().catch(() => "");
-			let body = {};
-			if (text) try {
-				body = JSON.parse(text, rebaseReviver);
-			} catch (e) {}
-			const getErrorField = (obj, field) => {
-				const err = obj?.error;
-				if (err && typeof err === "object" && err !== null) return err[field];
-			};
-			if (res.status === 401 && onUnauthorizedHandler) {
-				if (await onUnauthorizedHandler()) {
-					let retryToken = token;
-					if (tokenGetter) try {
-						const fetched = await tokenGetter();
-						if (fetched !== null && fetched !== void 0) retryToken = fetched;
-					} catch (e) {}
-					const retryHeaders = getHeaders(retryToken, init);
-					const retryRes = await fetchFn(url, {
-						...init,
-						headers: retryHeaders
-					});
-					if (retryRes.status === 204) return void 0;
-					const retryText = await retryRes.text().catch(() => "");
-					let retryBody = {};
-					if (retryText) try {
-						retryBody = JSON.parse(retryText, rebaseReviver);
-					} catch (e) {}
-					if (!retryRes.ok) {
-						let fallbackMessage = retryRes.statusText;
-						if (retryRes.status === 404 && !fallbackMessage) fallbackMessage = `Endpoint not found (${init?.method || "GET"} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
-						throw new _rebasepro_types.RebaseApiError(String(getErrorField(retryBody, "message") || fallbackMessage || `Request failed with status ${retryRes.status}`), {
-							status: retryRes.status,
-							code: getErrorField(retryBody, "code"),
-							details: getErrorField(retryBody, "details")
-						});
-					}
-					return retryBody;
-				}
-			}
-			if (!res.ok) {
-				let fallbackMessage = res.statusText;
-				if (res.status === 404 && !fallbackMessage) fallbackMessage = `Endpoint not found (${init?.method || "GET"} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
-				throw new _rebasepro_types.RebaseApiError(String(getErrorField(body, "message") || fallbackMessage || `Request failed with status ${res.status}`), {
-					status: res.status,
-					code: getErrorField(body, "code"),
-					details: getErrorField(body, "details")
-				});
-			}
-			return body;
-		}
-		return {
-			request,
-			setToken(newToken) {
-				token = newToken || void 0;
-			},
-			setAuthTokenGetter(getter) {
-				tokenGetter = getter;
-			},
-			setOnUnauthorized(handler) {
-				onUnauthorizedHandler = handler;
-			},
-			get baseUrl() {
-				return config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "";
-			},
-			get apiPath() {
-				return apiPath;
-			},
-			get fetchFn() {
-				return fetchFn;
-			},
-			getHeaders: (init) => getHeaders(token, init),
-			resolveToken: async () => {
-				if (tokenGetter) try {
-					const fetched = await tokenGetter();
-					if (fetched !== null && fetched !== void 0) return fetched;
-				} catch (e) {}
-				return token || null;
-			}
-		};
-	}
-	//#endregion
-	//#region src/auth.ts
-	/** Map a raw user object from an auth response (`/login`, `/refresh`, `/me`) to a `User`. */
-	function mapRawUser(raw) {
-		return {
-			uid: raw.uid,
-			email: raw.email ?? null,
-			displayName: raw.displayName ?? null,
-			photoURL: raw.photoURL ?? null,
-			providerId: raw.providerId ?? "password",
-			isAnonymous: raw.isAnonymous ?? false,
-			emailVerified: raw.emailVerified,
-			roles: raw.roles,
-			metadata: raw.metadata
-		};
-	}
-	/** Placeholder user, used only as a last resort when none can be resolved. */
-	var EMPTY_USER = {
-		uid: "",
-		email: null,
-		displayName: null,
-		photoURL: null,
-		providerId: "password",
-		isAnonymous: false
-	};
-	function createMemoryStorage() {
-		const store = {};
-		return {
-			getItem(key) {
-				return store[key] ?? null;
-			},
-			setItem(key, value) {
-				store[key] = value;
-			},
-			removeItem(key) {
-				delete store[key];
-			}
-		};
-	}
-	function detectStorage() {
-		try {
-			if (typeof localStorage !== "undefined") {
-				localStorage.setItem("__rebase_test__", "1");
-				localStorage.removeItem("__rebase_test__");
-				return localStorage;
-			}
-		} catch (e) {}
-		return createMemoryStorage();
-	}
-	function createAuth(transport, options) {
-		const opts = options || {};
-		const storage = opts.storage || detectStorage();
-		const authPath = opts.authPath || "/auth";
-		const autoRefresh = opts.autoRefresh !== false;
-		const persistSession = opts.persistSession !== false;
-		const authFlowMode = opts.authFlowMode || "json";
-		const STORAGE_KEY = "rebase_auth";
-		const REFRESH_BUFFER_MS = 12e4;
-		const MAX_REFRESH_RETRIES = 5;
-		const REFRESH_RETRY_BASE_MS = 1e3;
-		const REFRESH_RETRY_MAX_MS = 3e4;
-		let currentSession = null;
-		const listeners = /* @__PURE__ */ new Set();
-		let refreshTimeout = null;
-		let inFlightRefresh = null;
-		let resolveInitialized;
-		const isInitialized = new Promise((resolve) => {
-			resolveInitialized = resolve;
-		});
-		function authUrl(endpoint) {
-			return transport.baseUrl + transport.apiPath + authPath + endpoint;
-		}
-		function getFetch() {
-			return transport.fetchFn || globalThis.fetch;
-		}
-		function throwApiError(status, body, statusText) {
-			throw new _rebasepro_types.RebaseApiError(body?.error?.message || body?.message || statusText, {
-				status,
-				code: body?.error?.code || body?.code,
-				details: body?.error?.details || body?.details
-			});
-		}
-		function emit(event, session) {
-			for (const fn of listeners) try {
-				fn(event, session);
-			} catch (e) {}
-		}
-		function saveSession(session) {
-			if (!persistSession || authFlowMode === "cookie") return;
-			try {
-				storage.setItem(STORAGE_KEY, JSON.stringify(session));
-			} catch (e) {}
-		}
-		function clearStoredSession() {
-			try {
-				storage.removeItem(STORAGE_KEY);
-			} catch (e) {}
-		}
-		function loadStoredSession() {
-			try {
-				const raw = storage.getItem(STORAGE_KEY);
-				if (raw) return JSON.parse(raw);
-			} catch (e) {}
-			return null;
-		}
-		/**
-		* A refresh failure is only fatal if the refresh token itself is rejected
-		* (expired / invalid / forbidden). Network blips, timeouts, and 5xx (e.g. a
-		* backend restart mid-session) are transient and must NOT log the user out.
-		*/
-		function isFatalRefreshError(err) {
-			if (!(err instanceof _rebasepro_types.RebaseApiError)) return false;
-			if (err.code === "INVALID_TOKEN" || err.code === "TOKEN_EXPIRED") return true;
-			return err.status === 401 || err.status === 403;
-		}
-		async function attemptScheduledRefresh(attempt) {
-			try {
-				await refreshSession();
-			} catch (err) {
-				if (isFatalRefreshError(err)) {
-					signOut();
-					return;
-				}
-				if (attempt >= MAX_REFRESH_RETRIES) {
-					signOut();
-					return;
-				}
-				const backoff = Math.min(REFRESH_RETRY_BASE_MS * 2 ** attempt, REFRESH_RETRY_MAX_MS);
-				refreshTimeout = setTimeout(() => {
-					attemptScheduledRefresh(attempt + 1);
-				}, backoff);
-			}
-		}
-		function scheduleRefresh(expiresAt) {
-			if (refreshTimeout) clearTimeout(refreshTimeout);
-			if (!autoRefresh) return;
-			const delay = expiresAt - REFRESH_BUFFER_MS - Date.now();
-			if (delay <= 0) {
-				attemptScheduledRefresh(0);
-				return;
-			}
-			refreshTimeout = setTimeout(() => {
-				attemptScheduledRefresh(0);
-			}, delay);
-		}
-		function handleAuthResponse(data, event) {
-			const user = mapRawUser(data.user);
-			const session = {
-				accessToken: data.tokens.accessToken,
-				refreshToken: data.tokens.refreshToken || currentSession?.refreshToken || "",
-				expiresAt: data.tokens.accessTokenExpiresAt,
-				user
-			};
-			currentSession = session;
-			saveSession(session);
-			transport.setToken(session.accessToken);
-			scheduleRefresh(session.expiresAt);
-			emit(event || "SIGNED_IN", session);
-			return session;
-		}
-		async function signInWithEmail(email, password) {
-			const res = await getFetch()(authUrl("/login"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({
-					email,
-					password
-				}),
-				credentials: authFlowMode === "cookie" ? "include" : void 0
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			const session = handleAuthResponse(body, "SIGNED_IN");
-			return {
-				user: session.user,
-				accessToken: session.accessToken,
-				refreshToken: session.refreshToken
-			};
-		}
-		async function signUp(email, password, displayName) {
-			const fetchFn = getFetch();
-			const payload = {
-				email,
-				password
-			};
-			if (displayName !== void 0) payload.displayName = displayName;
-			const res = await fetchFn(authUrl("/register"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(payload),
-				credentials: authFlowMode === "cookie" ? "include" : void 0
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			const session = handleAuthResponse(body, "SIGNED_IN");
-			return {
-				user: session.user,
-				accessToken: session.accessToken,
-				refreshToken: session.refreshToken
-			};
-		}
-		/**
-		* Sign in with Google.
-		*
-		* Supports three invocation styles:
-		* - `signInWithGoogle({ idToken })` — ID-token flow (One Tap / Sign In button)
-		* - `signInWithGoogle({ accessToken })` — Access-token flow (popup)
-		* - `signInWithGoogle({ code, redirectUri })` — Authorization code flow (most secure)
-		*/
-		async function signInWithGoogle(payload) {
-			const res = await getFetch()(authUrl("/google"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(payload),
-				credentials: authFlowMode === "cookie" ? "include" : void 0
-			});
-			const responseBody = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, responseBody, res.statusText);
-			const session = handleAuthResponse(responseBody, "SIGNED_IN");
-			return {
-				user: session.user,
-				accessToken: session.accessToken,
-				refreshToken: session.refreshToken
-			};
-		}
-		async function signInWithLinkedin(code, redirectUri) {
-			const res = await getFetch()(authUrl("/linkedin"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({
-					code,
-					redirectUri
-				}),
-				credentials: authFlowMode === "cookie" ? "include" : void 0
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			const session = handleAuthResponse(body, "SIGNED_IN");
-			return {
-				user: session.user,
-				accessToken: session.accessToken,
-				refreshToken: session.refreshToken
-			};
-		}
-		/**
-		* Generic OAuth sign-in. Posts the given payload to `/auth/{providerId}`.
-		* Use this for any provider registered on the backend.
-		*/
-		async function signInWithOAuth(providerId, payload) {
-			const res = await getFetch()(authUrl(`/${providerId}`), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(payload),
-				credentials: authFlowMode === "cookie" ? "include" : void 0
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			const session = handleAuthResponse(body, "SIGNED_IN");
-			return {
-				user: session.user,
-				accessToken: session.accessToken,
-				refreshToken: session.refreshToken
-			};
-		}
-		async function signInWithGitHub(code, redirectUri) {
-			return signInWithOAuth("github", {
-				code,
-				redirectUri
-			});
-		}
-		async function signInWithMicrosoft(code, redirectUri) {
-			return signInWithOAuth("microsoft", {
-				code,
-				redirectUri
-			});
-		}
-		async function signInWithApple(code, redirectUri, user) {
-			return signInWithOAuth("apple", {
-				code,
-				redirectUri,
-				user
-			});
-		}
-		async function signInWithFacebook(code, redirectUri) {
-			return signInWithOAuth("facebook", {
-				code,
-				redirectUri
-			});
-		}
-		async function signInWithTwitter(code, redirectUri, codeVerifier) {
-			return signInWithOAuth("twitter", {
-				code,
-				redirectUri,
-				codeVerifier
-			});
-		}
-		async function signInWithDiscord(code, redirectUri) {
-			return signInWithOAuth("discord", {
-				code,
-				redirectUri
-			});
-		}
-		async function signInWithGitLab(code, redirectUri) {
-			return signInWithOAuth("gitlab", {
-				code,
-				redirectUri
-			});
-		}
-		async function signInWithBitbucket(code, redirectUri) {
-			return signInWithOAuth("bitbucket", {
-				code,
-				redirectUri
-			});
-		}
-		async function signInWithSlack(code, redirectUri) {
-			return signInWithOAuth("slack", {
-				code,
-				redirectUri
-			});
-		}
-		async function signInWithSpotify(code, redirectUri) {
-			return signInWithOAuth("spotify", {
-				code,
-				redirectUri
-			});
-		}
-		async function signOut() {
-			const fetchFn = getFetch();
-			try {
-				if (authFlowMode === "cookie" || currentSession?.refreshToken) await fetchFn(authUrl("/logout"), {
-					method: "POST",
-					headers: { "Content-Type": "application/json" },
-					body: JSON.stringify({ refreshToken: currentSession?.refreshToken }),
-					credentials: authFlowMode === "cookie" ? "include" : void 0
-				});
-			} catch (e) {}
-			currentSession = null;
-			clearStoredSession();
-			if (refreshTimeout) {
-				clearTimeout(refreshTimeout);
-				refreshTimeout = null;
-			}
-			transport.setToken(null);
-			emit("SIGNED_OUT", null);
-		}
-		function refreshSession() {
-			if (inFlightRefresh) return inFlightRefresh;
-			inFlightRefresh = doRefreshSession().finally(() => {
-				inFlightRefresh = null;
-			});
-			return inFlightRefresh;
-		}
-		async function doRefreshSession() {
-			if (authFlowMode !== "cookie" && !currentSession?.refreshToken) throw new Error("No active session to refresh");
-			const res = await getFetch()(authUrl("/refresh"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({ refreshToken: currentSession?.refreshToken }),
-				credentials: authFlowMode === "cookie" ? "include" : void 0
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			const accessToken = body.tokens.accessToken;
-			transport.setToken(accessToken);
-			let user = currentSession?.user;
-			if (body.user && typeof body.user.uid === "string") user = mapRawUser(body.user);
-			else if (!user || !user.uid) try {
-				user = await getUser();
-			} catch {}
-			const session = {
-				accessToken,
-				refreshToken: body.tokens.refreshToken || currentSession?.refreshToken || "",
-				expiresAt: body.tokens.accessTokenExpiresAt,
-				user: user ?? EMPTY_USER
-			};
-			currentSession = session;
-			saveSession(session);
-			transport.setToken(session.accessToken);
-			scheduleRefresh(session.expiresAt);
-			emit("TOKEN_REFRESHED", session);
-			return session;
-		}
-		async function getUser() {
-			return (await transport.request(authPath + "/me", { method: "GET" })).user;
-		}
-		/**
-		* Resolve an email to a minimal public profile (`uid`, `displayName`,
-		* `photoURL`) for invite-by-email flows. Returns `null` when no account
-		* matches. Requires the backend to opt in via `auth.allowUserLookup`;
-		* otherwise the endpoint is absent and this rejects.
-		*/
-		async function findUserByEmail(email) {
-			return (await transport.request(authPath + "/find-user", {
-				method: "POST",
-				body: JSON.stringify({ email })
-			})).user;
-		}
-		async function updateUser(updates) {
-			const data = await transport.request(authPath + "/me", {
-				method: "PATCH",
-				body: JSON.stringify(updates)
-			});
-			if (currentSession) {
-				currentSession = {
-					...currentSession,
-					user: data.user
-				};
-				saveSession(currentSession);
-				emit("USER_UPDATED", currentSession);
-			}
-			return data.user;
-		}
-		async function resetPasswordForEmail(email) {
-			const res = await getFetch()(authUrl("/forgot-password"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({ email })
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			return body;
-		}
-		async function resetPassword(token, password) {
-			const res = await getFetch()(authUrl("/reset-password"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({
-					token,
-					password
-				})
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			return body;
-		}
-		async function changePassword(oldPassword, newPassword) {
-			return transport.request(authPath + "/change-password", {
-				method: "POST",
-				body: JSON.stringify({
-					oldPassword,
-					newPassword
-				})
-			});
-		}
-		async function sendVerificationEmail() {
-			return transport.request(authPath + "/send-verification", { method: "POST" });
-		}
-		async function verifyEmail(token) {
-			const res = await getFetch()(authUrl("/verify-email?token=" + encodeURIComponent(token)), {
-				method: "GET",
-				headers: { "Content-Type": "application/json" }
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			return body;
-		}
-		async function sendMagicLink(email) {
-			const res = await getFetch()(authUrl("/magic-link"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({ email })
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			return body;
-		}
-		async function verifyMagicLink(token) {
-			const res = await getFetch()(authUrl("/magic-link/verify"), {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({ token }),
-				credentials: authFlowMode === "cookie" ? "include" : void 0
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			const session = handleAuthResponse(body, "SIGNED_IN");
-			return {
-				user: session.user,
-				accessToken: session.accessToken,
-				refreshToken: session.refreshToken
-			};
-		}
-		async function getSessions() {
-			return (await transport.request(authPath + "/sessions", { method: "GET" })).sessions;
-		}
-		async function revokeSession(sessionId) {
-			return transport.request(authPath + "/sessions/" + encodeURIComponent(sessionId), { method: "DELETE" });
-		}
-		async function revokeAllSessions() {
-			const result = await transport.request(authPath + "/sessions", { method: "DELETE" });
-			currentSession = null;
-			clearStoredSession();
-			if (refreshTimeout) {
-				clearTimeout(refreshTimeout);
-				refreshTimeout = null;
-			}
-			transport.setToken(null);
-			emit("SIGNED_OUT", null);
-			return result;
-		}
-		async function getAuthConfig() {
-			const res = await getFetch()(authUrl("/config"), {
-				method: "GET",
-				headers: { "Content-Type": "application/json" }
-			});
-			const body = await res.json().catch(() => ({}));
-			if (!res.ok) throwApiError(res.status, body, res.statusText);
-			return body;
-		}
-		function getSession() {
-			return currentSession;
-		}
-		function onAuthStateChange(callback) {
-			listeners.add(callback);
-			return () => listeners.delete(callback);
-		}
-		if (persistSession) {
-			const stored = loadStoredSession();
-			if (stored && stored.accessToken) if (stored.expiresAt > Date.now()) {
-				currentSession = stored;
-				transport.setToken(stored.accessToken);
-				scheduleRefresh(stored.expiresAt);
-				resolveInitialized();
-			} else if (authFlowMode === "cookie" || stored.refreshToken) {
-				currentSession = stored;
-				refreshSession().then(() => {
-					resolveInitialized();
-				}).catch(() => {
-					currentSession = null;
-					clearStoredSession();
-					transport.setToken(null);
-					resolveInitialized();
-				});
-			} else resolveInitialized();
-			else if (authFlowMode === "cookie") refreshSession().then(() => {
-				resolveInitialized();
-			}).catch(() => {
-				resolveInitialized();
-			});
-			else resolveInitialized();
-		} else resolveInitialized();
-		return {
-			signInWithEmail,
-			signUp,
-			signInWithGoogle,
-			signInWithLinkedin,
-			signInWithOAuth,
-			signInWithGitHub,
-			signInWithMicrosoft,
-			signInWithApple,
-			signInWithFacebook,
-			signInWithTwitter,
-			signInWithDiscord,
-			signInWithGitLab,
-			signInWithBitbucket,
-			signInWithSlack,
-			signInWithSpotify,
-			signOut,
-			refreshSession,
-			getUser,
-			findUserByEmail,
-			updateUser,
-			resetPasswordForEmail,
-			resetPassword,
-			changePassword,
-			sendVerificationEmail,
-			verifyEmail,
-			sendMagicLink,
-			verifyMagicLink,
-			getSessions,
-			revokeSession,
-			revokeAllSessions,
-			getAuthConfig,
-			getSession,
-			onAuthStateChange,
-			isInitialized: () => isInitialized
-		};
-	}
-	function createCookieStorage(options = {}) {
-		const defaultOptions = {
-			path: "/",
-			sameSite: "Lax",
-			...options
-		};
-		return {
-			getItem(key) {
-				if (typeof document === "undefined") return null;
-				const nameEQ = encodeURIComponent(key) + "=";
-				const ca = document.cookie.split(";");
-				for (let i = 0; i < ca.length; i++) {
-					let c = ca[i];
-					while (c.charAt(0) === " ") c = c.substring(1, c.length);
-					if (c.indexOf(nameEQ) === 0) return decodeURIComponent(c.substring(nameEQ.length, c.length));
-				}
-				return null;
-			},
-			setItem(key, value) {
-				if (typeof document === "undefined") return;
-				let cookieStr = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-				if (defaultOptions.path) cookieStr += `; path=${defaultOptions.path}`;
-				if (defaultOptions.domain) cookieStr += `; domain=${defaultOptions.domain}`;
-				if (defaultOptions.maxAge !== void 0) cookieStr += `; max-age=${defaultOptions.maxAge}`;
-				else cookieStr += `; max-age=${365 * 24 * 60 * 60}`;
-				if (defaultOptions.secure) cookieStr += "; secure";
-				if (defaultOptions.sameSite) cookieStr += `; samesite=${defaultOptions.sameSite}`;
-				document.cookie = cookieStr;
-			},
-			removeItem(key) {
-				if (typeof document === "undefined") return;
-				let cookieStr = `${encodeURIComponent(key)}=; path=${defaultOptions.path || "/"}; max-age=-1`;
-				if (defaultOptions.domain) cookieStr += `; domain=${defaultOptions.domain}`;
-				document.cookie = cookieStr;
-			}
-		};
-	}
-	//#endregion
-	//#region src/admin.ts
-	function createAdmin(transport, options) {
-		const adminPath = (options || {}).adminPath || "/admin";
-		async function listUsers() {
-			return transport.request(adminPath + "/users", { method: "GET" });
-		}
-		async function listUsersPaginated(options) {
-			const params = new URLSearchParams();
-			if (options?.limit !== void 0) params.set("limit", String(options.limit));
-			if (options?.offset !== void 0) params.set("offset", String(options.offset));
-			if (options?.search) params.set("search", options.search);
-			if (options?.orderBy) params.set("orderBy", options.orderBy);
-			if (options?.orderDir) params.set("orderDir", options.orderDir);
-			const qs = params.toString();
-			return transport.request(adminPath + "/users" + (qs ? "?" + qs : ""), { method: "GET" });
-		}
-		async function getUser(userId) {
-			return transport.request(adminPath + "/users/" + encodeURIComponent(userId), { method: "GET" });
-		}
-		async function createUser(data) {
-			return transport.request(adminPath + "/users", {
-				method: "POST",
-				body: JSON.stringify(data)
-			});
-		}
-		async function updateUser(userId, data) {
-			return transport.request(adminPath + "/users/" + encodeURIComponent(userId), {
-				method: "PUT",
-				body: JSON.stringify(data)
-			});
-		}
-		async function deleteUser(userId) {
-			return transport.request(adminPath + "/users/" + encodeURIComponent(userId), { method: "DELETE" });
-		}
-		async function resetPassword(userId, options) {
-			return transport.request(adminPath + "/users/" + encodeURIComponent(userId) + "/reset-password", {
-				method: "POST",
-				...options?.password ? { body: JSON.stringify({ password: options.password }) } : {}
-			});
-		}
-		async function listRoles() {
-			return transport.request(adminPath + "/roles", { method: "GET" });
-		}
-		async function bootstrap() {
-			return transport.request(adminPath + "/bootstrap", { method: "POST" });
-		}
-		return {
-			listUsers,
-			listUsersPaginated,
-			getUser,
-			createUser,
-			updateUser,
-			deleteUser,
-			resetPassword,
-			listRoles,
-			bootstrap
-		};
-	}
-	//#endregion
-	//#region src/cron.ts
-	function createCron(transport, options) {
-		const cronPath = options?.cronPath || "/cron";
-		async function listJobs() {
-			return transport.request(cronPath, { method: "GET" });
-		}
-		async function getJob(jobId) {
-			return transport.request(cronPath + "/" + encodeURIComponent(jobId), { method: "GET" });
-		}
-		async function triggerJob(jobId) {
-			return transport.request(cronPath + "/" + encodeURIComponent(jobId) + "/trigger", { method: "POST" });
-		}
-		async function getJobLogs(jobId, options) {
-			const params = new URLSearchParams();
-			if (options?.limit !== void 0) params.set("limit", String(options.limit));
-			const qs = params.toString();
-			return transport.request(cronPath + "/" + encodeURIComponent(jobId) + "/logs" + (qs ? "?" + qs : ""), { method: "GET" });
-		}
-		async function toggleJob(jobId, enabled) {
-			return transport.request(cronPath + "/" + encodeURIComponent(jobId), {
-				method: "PUT",
-				body: JSON.stringify({ enabled })
-			});
-		}
-		return {
-			listJobs,
-			getJob,
-			triggerJob,
-			getJobLogs,
-			toggleJob
-		};
-	}
-	//#endregion
-	//#region src/api-keys.ts
-	/**
-	* Creates a client for managing API keys via the admin routes.
-	*
-	* @param transport - The shared HTTP transport created by `createTransport`.
-	* @param options   - Optional overrides (e.g. a custom base path).
-	*/
-	function createApiKeys(transport, options) {
-		const apiKeysPath = options?.apiKeysPath || "/admin/api-keys";
-		/** List all API keys (masked). */
-		async function listKeys() {
-			return transport.request(apiKeysPath, { method: "GET" });
-		}
-		/** Get a single API key by ID (masked). */
-		async function getKey(id) {
-			return transport.request(apiKeysPath + "/" + encodeURIComponent(id), { method: "GET" });
-		}
-		/** Create a new API key. The full secret is included in the response. */
-		async function createKey(data) {
-			return transport.request(apiKeysPath, {
-				method: "POST",
-				body: JSON.stringify(data)
-			});
-		}
-		/** Update an existing API key. */
-		async function updateKey(id, data) {
-			return transport.request(apiKeysPath + "/" + encodeURIComponent(id), {
-				method: "PUT",
-				body: JSON.stringify(data)
-			});
-		}
-		/** Revoke (soft-delete) an API key. */
-		async function revokeKey(id) {
-			return transport.request(apiKeysPath + "/" + encodeURIComponent(id), { method: "DELETE" });
-		}
-		return {
-			listKeys,
-			getKey,
-			createKey,
-			updateKey,
-			revokeKey
-		};
-	}
-	//#endregion
-	//#region src/sdk_query_builder.ts
-	/**
-	* SDK Query Builder — returns flat rows (`FindResult<M>`) instead of
-	* Entity-wrapped results (`FindResponse<M>`).
-	*
-	* @example
-	* const { data } = await rebase.data.posts
-	*     .where("status", "==", "published")
-	*     .orderBy("created_at", "desc")
-	*     .limit(10)
-	*     .find();
-	*
-	* console.log(data[0].title); // flat access
-	*/
-	var SDKQueryBuilder = class {
-		collection;
-		params = { where: {} };
-		constructor(collection) {
-			this.collection = collection;
-		}
-		where(columnOrCondition, operator, value) {
-			if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
-				this.params.logical = columnOrCondition;
-				return this;
-			}
-			if (!this.params.where) this.params.where = {};
-			const column = columnOrCondition;
-			const condition = [operator, value];
-			const existing = this.params.where[column];
-			if (existing === void 0) this.params.where[column] = condition;
-			else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) this.params.where[column].push(condition);
-			else {
-				let firstCondition;
-				if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") firstCondition = existing;
-				else firstCondition = ["==", existing];
-				this.params.where[column] = [firstCondition, condition];
-			}
-			return this;
-		}
-		/**
-		* Order the results by a specific column.
-		*/
-		orderBy(column, direction = "asc") {
-			this.params.orderBy = [column, direction];
-			return this;
-		}
-		/**
-		* Limit the number of results returned.
-		*/
-		limit(count) {
-			this.params.limit = count;
-			return this;
-		}
-		/**
-		* Skip the first N results.
-		*/
-		offset(count) {
-			this.params.offset = count;
-			return this;
-		}
-		/**
-		* Set a free-text search string if supported by the backend.
-		*/
-		search(searchString) {
-			this.params.searchString = searchString;
-			return this;
-		}
-		/**
-		* Include related entities in the response.
-		* Relations will be populated with full data instead of just IDs.
-		*
-		* @param relations - Relation names to include, or "*" for all.
-		* @example
-		* client.data.posts.include("tags", "author").find()
-		*/
-		include(...relations) {
-			this.params.include = relations;
-			return this;
-		}
-		/**
-		* Execute the find query and return the results as flat rows.
-		*/
-		async find() {
-			return this.collection.find(this.params);
-		}
-		/**
-		* Count the records matching this query.
-		*/
-		async count() {
-			if (!this.collection.count) throw new Error("count() is not supported by this collection client.");
-			return this.collection.count(this.params);
-		}
-		/**
-		* Listen to realtime updates matching this query.
-		*/
-		listen(onUpdate, onError) {
-			if (!this.collection.listen) throw new Error("Listen is only available when RebaseClient is configured with a websocketUrl.");
-			return this.collection.listen(this.params, onUpdate, onError);
-		}
-	};
-	//#endregion
-	//#region src/collection.ts
-	function createCollectionClient(transport, slug, ws) {
-		const basePath = `/data/${slug}`;
-		const client = {
-			async find(params) {
-				const qs = buildQueryString(params);
-				const raw = await transport.request(basePath + qs, { method: "GET" });
-				return {
-					data: raw.data || [],
-					meta: raw.meta
-				};
-			},
-			async findById(id) {
-				try {
-					const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
-					if (!raw) return void 0;
-					return raw;
-				} catch (err) {
-					if (err instanceof _rebasepro_types.RebaseApiError && err.status === 404) return;
-					throw err;
-				}
-			},
-			async create(data, id) {
-				const body = { ...data };
-				if (id !== void 0) body.id = id;
-				return await transport.request(basePath, {
-					method: "POST",
-					body: JSON.stringify(body)
-				});
-			},
-			async update(id, data) {
-				return await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
-					method: "PUT",
-					body: JSON.stringify(data)
-				});
-			},
-			async delete(id) {
-				await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "DELETE" });
-			},
-			async count(params) {
-				const qs = buildQueryString({
-					...params,
-					limit: void 0,
-					offset: void 0
-				});
-				return (await transport.request(basePath + "/count" + qs, { method: "GET" })).count ?? 0;
-			},
-			where(columnOrCondition, operator, value) {
-				const builder = new SDKQueryBuilder(client);
-				if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
-				return builder.where(columnOrCondition, operator, value);
-			},
-			orderBy(column, direction) {
-				return new SDKQueryBuilder(client).orderBy(column, direction);
-			},
-			limit(count) {
-				return new SDKQueryBuilder(client).limit(count);
-			},
-			offset(count) {
-				return new SDKQueryBuilder(client).offset(count);
-			},
-			search(searchString) {
-				return new SDKQueryBuilder(client).search(searchString);
-			},
-			include(...relations) {
-				return new SDKQueryBuilder(client).include(...relations);
-			}
-		};
-		if (ws) {
-			client.listen = (params, onUpdate, onError) => {
-				let active = true;
-				let lastUpdateId = 0;
-				const unsub = ws.listenCollection({
-					path: slug,
-					filter: params?.where,
-					limit: params?.limit,
-					startAfter: params?.offset ? String(params.offset) : void 0,
-					orderBy: params?.orderBy?.[0],
-					order: params?.orderBy?.[1],
-					searchString: params?.searchString
-				}, (incomingRows) => {
-					const currentUpdateId = ++lastUpdateId;
-					const requestedLimit = params?.limit || 20;
-					const offset = params?.offset || 0;
-					const rows = incomingRows;
-					const heuristicTotal = rows.length;
-					const heuristicHasMore = rows.length >= requestedLimit;
-					if (client.count) client.count(params).then((total) => {
-						if (active && currentUpdateId === lastUpdateId) onUpdate({
-							data: rows,
-							meta: {
-								total,
-								limit: requestedLimit,
-								offset,
-								hasMore: offset + rows.length < total
-							}
-						});
-					}).catch(() => {
-						if (active && currentUpdateId === lastUpdateId) onUpdate({
-							data: rows,
-							meta: {
-								total: heuristicTotal,
-								limit: requestedLimit,
-								offset,
-								hasMore: heuristicHasMore
-							}
-						});
-					});
-					else onUpdate({
-						data: rows,
-						meta: {
-							total: heuristicTotal,
-							limit: requestedLimit,
-							offset,
-							hasMore: heuristicHasMore
-						}
-					});
-				}, onError);
-				return () => {
-					active = false;
-					unsub();
-				};
-			};
-			client.listenById = (id, onUpdate, onError) => {
-				return ws.listenOne({
-					path: slug,
-					id: String(id)
-				}, (row) => {
-					if (row) onUpdate(row);
-					else onUpdate(void 0);
-				}, onError);
-			};
-		}
-		return client;
-	}
-	//#endregion
-	//#region src/functions.ts
-	/**
-	* Create a `FunctionsClient` backed by the given transport.
-	*
-	* The transport already handles:
-	* - Base URL resolution
-	* - JWT injection via `Authorization: Bearer`
-	* - 401 retry / `onUnauthorized` flow
-	* - Consistent error throwing via `RebaseApiError`
-	*
-	* @internal
-	*/
-	function createFunctionsClient(transport) {
-		return { async invoke(name, payload, options) {
-			const method = options?.method ?? "POST";
-			const subPath = options?.path ? `/${options.path.replace(/^\//, "")}` : "";
-			const routePath = `/functions/${encodeURIComponent(name)}${subPath}`;
-			const init = { method };
-			if (payload !== void 0 && method !== "GET") init.body = JSON.stringify(payload);
-			if (options?.headers) init.headers = options.headers;
-			return transport.request(routePath, init);
-		} };
-	}
-	//#endregion
-	//#region src/storage.ts
-	/**
-	* Create a StorageSource that talks to the Rebase backend REST API.
-	*
-	* @param transport - HTTP transport instance
-	* @param storageId - Optional storage-source key for multi-backend routing.
-	*                    When set, it is forwarded to the server so the correct
-	*                    `StorageController` is resolved from the registry.
-	*/
-	function createStorage(transport, storageId) {
-		const urlsCache = /* @__PURE__ */ new Map();
-		/** Append ?storageId=... to a path when multi-backend routing is active. */
-		const withStorageId = (path) => {
-			if (!storageId) return path;
-			return `${path}${path.includes("?") ? "&" : "?"}storageId=${encodeURIComponent(storageId)}`;
-		};
-		async function putObject({ file, key, metadata, bucket, public: isPublic }) {
-			const formData = new FormData();
-			formData.append("file", file);
-			let effectiveKey = key;
-			if (isPublic && effectiveKey && !(0, _rebasepro_types.isPublicStoragePath)(effectiveKey)) effectiveKey = `${_rebasepro_types.PUBLIC_STORAGE_PREFIX}${effectiveKey.replace(/^\/+/, "")}`;
-			if (effectiveKey) formData.append("key", effectiveKey);
-			if (bucket) formData.append("bucket", bucket);
-			if (storageId) formData.append("storageId", storageId);
-			if (metadata) {
-				for (const [key, value] of Object.entries(metadata)) if (value !== void 0 && value !== null) formData.append(`metadata_${key}`, typeof value === "string" ? value : JSON.stringify(value));
-			}
-			return (await transport.request(withStorageId("/storage/upload"), {
-				method: "POST",
-				body: formData,
-				headers: {}
-			})).data;
-		}
-		async function getSignedUrl(keyOrUrl, bucket) {
-			const cacheKey = bucket ? `${bucket}/${keyOrUrl}` : keyOrUrl;
-			const cachedEntry = urlsCache.get(cacheKey);
-			if (cachedEntry) {
-				if (!cachedEntry.expiresAt || cachedEntry.expiresAt > Date.now()) return cachedEntry.config;
-				urlsCache.delete(cacheKey);
-			}
-			let filePath = keyOrUrl;
-			if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
-			if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
-			if (!filePath || filePath.trim() === "" || filePath === "/") return {
-				url: null,
-				fileNotFound: true
-			};
-			if ((0, _rebasepro_types.isPublicStoragePath)(filePath)) {
-				const publicConfig = { url: withStorageId(`${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`) };
-				urlsCache.set(cacheKey, { config: publicConfig });
-				return publicConfig;
-			}
-			try {
-				const result = await transport.request(withStorageId(`/storage/metadata/${filePath}`));
-				if (result.data.public) {
-					const publicConfig = {
-						url: withStorageId(`${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`),
-						metadata: result.data
-					};
-					urlsCache.set(cacheKey, { config: publicConfig });
-					return publicConfig;
-				}
-				const scopedToken = result.data.token;
-				const tokenQuery = scopedToken ? `?token=${scopedToken}` : "";
-				const downloadConfig = {
-					url: withStorageId(`${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`),
-					metadata: result.data
-				};
-				const expiresAt = result.data.tokenExpiresIn ? Date.now() + (result.data.tokenExpiresIn - 10) * 1e3 : void 0;
-				urlsCache.set(cacheKey, {
-					config: downloadConfig,
-					expiresAt
-				});
-				return downloadConfig;
-			} catch (e) {
-				if (e instanceof Error && "status" in e && e.status === 404) return {
-					url: null,
-					fileNotFound: true
-				};
-				throw e;
-			}
-		}
-		async function getObject(key, bucket) {
-			const downloadConfig = await getSignedUrl(key, bucket);
-			if (downloadConfig.fileNotFound || !downloadConfig.url) return null;
-			const response = await transport.fetchFn(downloadConfig.url, { headers: {} });
-			if (response.status === 404) return null;
-			if (!response.ok) throw new Error("Failed to get file");
-			const blob = await response.blob();
-			const fileName = (bucket ? `${bucket}/${key}` : key).split("/").pop() || "file";
-			return new File([blob], fileName, { type: blob.type });
-		}
-		async function deleteObject(key, bucket) {
-			let filePath = key;
-			if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
-			if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
-			if (!filePath || filePath.trim() === "" || filePath === "/") return;
-			try {
-				await transport.request(withStorageId(`/storage/file/${filePath}`), { method: "DELETE" });
-			} catch (e) {
-				if (!(e instanceof Error && "status" in e && e.status === 404)) throw e;
-			}
-			urlsCache.delete(bucket ? `${bucket}/${key}` : key);
-		}
-		async function listObjects(prefix, options) {
-			const params = new URLSearchParams();
-			if (prefix) params.set("prefix", prefix);
-			if (options?.bucket) params.set("bucket", options.bucket);
-			if (options?.maxResults) params.set("maxResults", String(options.maxResults));
-			if (options?.pageToken) params.set("pageToken", options.pageToken);
-			if (storageId) params.set("storageId", storageId);
-			return (await transport.request(`/storage/list?${params.toString()}`)).data;
-		}
-		return {
-			putObject,
-			getSignedUrl,
-			getObject,
-			deleteObject,
-			listObjects
-		};
-	}
-	//#endregion
-	//#region src/storage-registry.ts
-	/**
-	* Default implementation of the client-side `StorageSourceRegistry`.
-	*/
-	var ClientStorageSourceRegistry = class ClientStorageSourceRegistry {
-		sources = /* @__PURE__ */ new Map();
-		/**
-		* Register a storage source.
-		* @param key - Unique key matching a `StorageSourceDefinition.key`
-		* @param source - The `StorageSource` instance
-		*/
-		register(key, source) {
-			this.sources.set(key, source);
-		}
-		getDefault() {
-			const source = this.sources.get(_rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY);
-			if (!source) throw new Error(`[StorageSourceRegistry] No default storage source registered. Register one with key "${_rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY}".`);
-			return source;
-		}
-		get(key) {
-			if (key === void 0 || key === null) return this.sources.get(_rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY);
-			return this.sources.get(key);
-		}
-		getOrDefault(key) {
-			if (key === void 0 || key === null) return this.getDefault();
-			const source = this.sources.get(key);
-			if (source) return source;
-			console.warn(`[StorageSourceRegistry] Storage source "${key}" not found, falling back to "${_rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY}".`);
-			return this.getDefault();
-		}
-		has(key) {
-			return this.sources.has(key);
-		}
-		list() {
-			return Array.from(this.sources.keys());
-		}
-		/**
-		* Build a registry from `StorageSourceDefinition[]` and an HTTP transport.
-		*
-		* - Sources with `transport: "server"` are auto-wired via `createStorage(transport, key)`.
-		* - Sources with `transport: "direct"` are **not** auto-wired — they must
-		*   be registered manually after this call (e.g. via a Firebase hook).
-		*
-		* @param definitions - Array of storage source definitions
-		* @param transport - HTTP transport for server-backed sources
-		*/
-		static fromDefinitions(definitions, transport) {
-			const registry = new ClientStorageSourceRegistry();
-			for (const def of definitions) if (def.transport === "server") {
-				const source = createStorage(transport, def.key === _rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY ? void 0 : def.key);
-				registry.register(def.key, source);
-			}
-			return registry;
-		}
-	};
-	//#endregion
-	//#region src/websocket.ts
-	/**
-	* Extract error message and code from a WebSocket message payload.
-	* Handles both `{ error: string }` and `{ error: { message, code } }` shapes.
-	*/
-	function extractMessageError(message) {
-		const payload = message.payload;
-		const errPayload = payload?.error;
-		return {
-			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
-		};
-	}
-	/**
-	* Low-level realtime WebSocket client.
-	*
-	* @internal Not a stable app-facing API. `createRebaseClient()` constructs and
-	* manages this internally (exposed as `client.ws`, typed by the minimal
-	* `RebaseWebSocket` contract in `@rebasepro/types`). It is re-exported from the
-	* package root only because the `@rebasepro/client-postgresql` driver
-	* instantiates it directly; its surface may change without a major bump.
-	*/
-	var RebaseWebSocketClient = class {
-		websocketUrl;
-		ws = null;
-		getAuthToken;
-		subscriptions = /* @__PURE__ */ new Map();
-		listeners = /* @__PURE__ */ new Map();
-		on(event, cb) {
-			if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
-			this.listeners.get(event).add(cb);
-			return () => this.listeners.get(event).delete(cb);
-		}
-		emit(event, ...args) {
-			if (this.listeners.has(event)) this.listeners.get(event).forEach((cb) => cb(...args));
-		}
-		collectionSubscriptions = /* @__PURE__ */ new Map();
-		singleSubscriptions = /* @__PURE__ */ new Map();
-		backendToCollectionKey = /* @__PURE__ */ new Map();
-		backendToEntityKey = /* @__PURE__ */ new Map();
-		pendingRequests = /* @__PURE__ */ new Map();
-		reconnectAttempts = 0;
-		maxReconnectAttempts = 5;
-		isConnected = false;
-		messageQueue = [];
-		requestTimeoutMs = 3e4;
-		reconnectTimeout = null;
-		isAuthenticated = false;
-		authPromise = null;
-		WebSocketConstructor;
-		onUnauthorized;
-		refreshInProgress = null;
-		constructor(config) {
-			this.websocketUrl = config.websocketUrl;
-			this.getAuthToken = config.getAuthToken;
-			this.onUnauthorized = config.onUnauthorized;
-			this.WebSocketConstructor = config.WebSocket || (typeof WebSocket !== "undefined" ? WebSocket : void 0);
-			if (!this.WebSocketConstructor) console.warn("WebSocket is not defined in this environment. Realtime subscriptions will not work unless you provide a WebSocket implementation in the config.");
-			else this.initWebSocket();
-		}
-		/**
-		* Authenticate the WebSocket connection
-		*/
-		async authenticate(token) {
-			return new Promise((resolve, reject) => {
-				const requestId = `auth_${Date.now()}`;
-				const timeout = setTimeout(() => {
-					this.pendingRequests.delete(requestId);
-					this.authPromise = null;
-					reject(/* @__PURE__ */ new Error("Authentication timeout"));
-				}, 3e4);
-				this.pendingRequests.set(requestId, {
-					resolve: () => {
-						clearTimeout(timeout);
-						this.isAuthenticated = true;
-						resolve();
-					},
-					reject: (error) => {
-						clearTimeout(timeout);
-						reject(error);
-					}
-				});
-				const message = {
-					type: "AUTHENTICATE",
-					requestId,
-					payload: { token }
-				};
-				if (!this.isConnected || !this.ws) this.messageQueue.unshift(message);
-				else this.ws.send(JSON.stringify(message));
-			});
-		}
-		/**
-		* Set the auth token getter function
-		*/
-		setAuthTokenGetter(getAuthToken) {
-			this.getAuthToken = getAuthToken;
-			if (this.isConnected && !this.isAuthenticated && !this.authPromise) {
-				console.debug("WebSocket auto-authenticating after token getter set");
-				this.getAuthToken().then((token) => {
-					if (!this.ws) return;
-					if (token) this.authenticate(token).catch((e) => {
-						if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
-					});
-				}).catch((e) => {
-					if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
-				});
-			}
-		}
-		disconnect() {
-			this.isAuthenticated = false;
-			this.authPromise = null;
-			if (this.reconnectTimeout) {
-				clearTimeout(this.reconnectTimeout);
-				this.reconnectTimeout = null;
-			}
-			if (this.ws) {
-				this.ws.onclose = null;
-				this.ws.onerror = null;
-				this.ws.onopen = null;
-				this.ws.onmessage = null;
-				this.ws.close();
-				this.ws = null;
-			}
-		}
-		initWebSocket() {
-			if (!this.WebSocketConstructor) return;
-			if (this.ws?.readyState === this.WebSocketConstructor.OPEN) return;
-			if (this.ws) {
-				this.ws.onclose = null;
-				this.ws.close();
-				this.ws = null;
-			}
-			try {
-				this.ws = new this.WebSocketConstructor(this.websocketUrl);
-				this.ws.onopen = async () => {
-					console.debug("Connected to PostgreSQL backend");
-					const wasReconnect = this.reconnectAttempts > 0;
-					this.isConnected = true;
-					this.reconnectAttempts = 0;
-					if (this.getAuthToken && !this.isAuthenticated) try {
-						const token = await this.getAuthToken();
-						if (token) {
-							await this.authenticate(token);
-							console.debug("WebSocket auto-authenticated");
-						}
-					} catch (error) {
-						console.debug("WebSocket connected without auth:", error?.message || error);
-					}
-					this.emit(wasReconnect ? "reconnect" : "connect");
-					this.processMessageQueue();
-					if (wasReconnect) this.resubscribeAll();
-				};
-				this.ws.onmessage = (event) => {
-					try {
-						const message = JSON.parse(event.data, rebaseReviver);
-						this.handleWebSocketMessage(message);
-					} catch (error) {
-						console.error("Error parsing WebSocket message:", error);
-					}
-				};
-				this.ws.onclose = () => {
-					console.debug("Disconnected from PostgreSQL backend");
-					this.isConnected = false;
-					this.isAuthenticated = false;
-					this.authPromise = null;
-					this.emit("disconnect");
-					for (const [reqId, request] of this.pendingRequests.entries()) {
-						if (reqId.startsWith("auth_")) request.reject(/* @__PURE__ */ new Error("Connection closed during authentication"));
-						else if (request.message) {
-							request.message._queuedResolve = request.resolve;
-							request.message._queuedReject = request.reject;
-							this.messageQueue.push(request.message);
-						} else request.reject(new _rebasepro_types.RebaseApiError("Connection closed"));
-						this.pendingRequests.delete(reqId);
-					}
-					this.attemptReconnect();
-				};
-				this.ws.onerror = (error) => {
-					console.error("WebSocket error:", error);
-					this.isConnected = false;
-					this.emit("error", error);
-				};
-			} catch (error) {
-				console.error("Failed to initialize WebSocket:", error);
-				this.attemptReconnect();
-			}
-		}
-		processMessageQueue() {
-			while (this.messageQueue.length > 0 && this.isConnected) {
-				const message = this.messageQueue.shift();
-				if (message) this.sendMessage(message);
-			}
-		}
-		attemptReconnect() {
-			if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-				console.error("Max reconnection attempts reached");
-				return;
-			}
-			this.reconnectAttempts++;
-			const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
-			console.debug(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
-			if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
-			this.reconnectTimeout = setTimeout(() => {
-				this.reconnectTimeout = null;
-				this.initWebSocket();
-			}, delay);
-		}
-		isAuthError(message) {
-			if (message.type === "AUTH_ERROR") return true;
-			const { errorMessage, errorCode } = extractMessageError(message);
-			if (errorCode === "UNAUTHORIZED" || errorCode === "JWT_EXPIRED" || errorCode === "AUTH_ERROR") return true;
-			const lowerMessage = errorMessage.toLowerCase();
-			return lowerMessage.includes("unauthorized") || lowerMessage.includes("token expired") || lowerMessage.includes("token is expired") || lowerMessage.includes("invalid token") || lowerMessage.includes("session expired") || lowerMessage.includes("auth error");
-		}
-		async handleAuthFailure() {
-			if (this.refreshInProgress) return this.refreshInProgress;
-			this.refreshInProgress = (async () => {
-				this.isAuthenticated = false;
-				this.authPromise = null;
-				if (this.onUnauthorized) try {
-					if (await this.onUnauthorized() && this.getAuthToken) {
-						const token = await this.getAuthToken();
-						if (token) {
-							await this.authenticate(token);
-							return true;
-						}
-					}
-				} catch (error) {
-					console.error("WebSocket auth refresh failed:", error);
-				}
-				return false;
-			})();
-			try {
-				return await this.refreshInProgress;
-			} finally {
-				this.refreshInProgress = null;
-			}
-		}
-		/**
-		* Shared logic for re-subscribing a collection or row subscription
-		* after an auth error is resolved by refreshing credentials.
-		*/
-		resubscribeAfterAuthRefresh(message, subscription, subscriptionKey, idPrefix, backendKeyMap, messageType) {
-			this.handleAuthFailure().then((refreshed) => {
-				if (refreshed) {
-					const oldBackendId = subscription.backendSubscriptionId;
-					const newBackendId = `${idPrefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-					subscription.backendSubscriptionId = newBackendId;
-					backendKeyMap.delete(oldBackendId);
-					backendKeyMap.set(newBackendId, subscriptionKey);
-					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 _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode });
-					subscription.callbacks.forEach((callback) => {
-						if (callback.onError) callback.onError(error);
-					});
-				}
-			}).catch((err) => {
-				subscription.callbacks.forEach((callback) => {
-					if (callback.onError) callback.onError(err);
-				});
-			});
-		}
-		handleWebSocketMessage(message) {
-			const { type, requestId, subscriptionId } = message;
-			if (requestId && this.pendingRequests.has(requestId)) {
-				const pendingReq = this.pendingRequests.get(requestId);
-				if (type === "ERROR" || type === "AUTH_ERROR" || message.error) if (this.isAuthError(message)) {
-					this.pendingRequests.delete(requestId);
-					this.handleAuthFailure().then((refreshed) => {
-						if (refreshed && pendingReq.message) this.doSendMessage(pendingReq.message, pendingReq.resolve, pendingReq.reject).catch(pendingReq.reject);
-						else {
-							const { errorMessage, errorCode } = extractMessageError(message);
-							pendingReq.reject(new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode }));
-						}
-					}).catch((err) => {
-						pendingReq.reject(err);
-					});
-				} else {
-					this.pendingRequests.delete(requestId);
-					const { errorMessage, errorCode } = extractMessageError(message);
-					pendingReq.reject(new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode }));
-				}
-				else {
-					this.pendingRequests.delete(requestId);
-					pendingReq.resolve(message.payload || message);
-				}
-				return;
-			}
-			if (subscriptionId && type === "collection_update") {
-				const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
-				if (subscriptionKey) {
-					const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
-					if (collectionSub) {
-						const incomingRows = message.rows || [];
-						const rows = this.mergeRows(collectionSub.latestData, incomingRows);
-						collectionSub.latestData = rows;
-						collectionSub.lastUpdated = Date.now();
-						collectionSub.isInitialDataReceived = true;
-						collectionSub.callbacks.forEach((callback) => {
-							try {
-								callback.onUpdate(rows);
-							} catch (error) {
-								console.error("Error in collection subscription callback:", error);
-								if (callback.onError) callback.onError(error instanceof Error ? error : new Error(String(error)));
-							}
-						});
-						return;
-					}
-				}
-			}
-			if (subscriptionId && type === "collection_patch") {
-				const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
-				if (subscriptionKey) {
-					const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
-					if (collectionSub && collectionSub.isInitialDataReceived && collectionSub.latestData) {
-						const patchWireEntity = message.row ?? null;
-						const patchEntityId = message.id;
-						const patchRow = patchWireEntity ? patchWireEntity : null;
-						let updated;
-						if (patchRow === null) updated = collectionSub.latestData.filter((e) => String(e.id) !== String(patchEntityId));
-						else {
-							const idx = collectionSub.latestData.findIndex((e) => String(e.id) === String(patchRow.id));
-							if (idx >= 0) {
-								updated = [...collectionSub.latestData];
-								updated[idx] = patchRow;
-							} else updated = [patchRow, ...collectionSub.latestData];
-						}
-						collectionSub.latestData = updated;
-						collectionSub.lastUpdated = Date.now();
-						collectionSub.callbacks.forEach((callback) => {
-							try {
-								callback.onUpdate(updated);
-							} catch (error) {
-								console.error("Error in collection patch callback:", error);
-								if (callback.onError) callback.onError(error instanceof Error ? error : new Error(String(error)));
-							}
-						});
-						return;
-					}
-				}
-			}
-			if (subscriptionId && type === "single_update") {
-				const subscriptionKey = this.backendToEntityKey.get(subscriptionId);
-				if (subscriptionKey) {
-					const entitySub = this.singleSubscriptions.get(subscriptionKey);
-					if (entitySub) {
-						const wireEntity = message.row ?? null;
-						const row = wireEntity ? wireEntity : null;
-						entitySub.latestData = row;
-						entitySub.lastUpdated = Date.now();
-						entitySub.isInitialDataReceived = true;
-						entitySub.callbacks.forEach((callback) => {
-							try {
-								callback.onUpdate(row);
-							} catch (error) {
-								console.error("Error in row subscription callback:", error);
-								if (callback.onError) callback.onError(error instanceof Error ? error : new Error(String(error)));
-							}
-						});
-						return;
-					}
-				}
-			}
-			if (subscriptionId && (type === "ERROR" || message.error)) {
-				const collectionKey = this.backendToCollectionKey.get(subscriptionId);
-				if (collectionKey) {
-					const collectionSub = this.collectionSubscriptions.get(collectionKey);
-					if (collectionSub) {
-						if (this.isAuthError(message)) {
-							this.resubscribeAfterAuthRefresh(message, collectionSub, collectionKey, "collection", this.backendToCollectionKey, "subscribe_collection");
-							return;
-						}
-						const { errorMessage, errorCode } = extractMessageError(message);
-						const error = new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode });
-						collectionSub.callbacks.forEach((callback) => {
-							if (callback.onError) callback.onError(error);
-						});
-						return;
-					}
-				}
-				const entityKey = this.backendToEntityKey.get(subscriptionId);
-				if (entityKey) {
-					const entitySub = this.singleSubscriptions.get(entityKey);
-					if (entitySub) {
-						if (this.isAuthError(message)) {
-							this.resubscribeAfterAuthRefresh(message, entitySub, entityKey, "row", this.backendToEntityKey, "subscribe_one");
-							return;
-						}
-						const { errorMessage, errorCode } = extractMessageError(message);
-						const error = new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode });
-						entitySub.callbacks.forEach((callback) => {
-							if (callback.onError) callback.onError(error);
-						});
-						return;
-					}
-				}
-			}
-			if (subscriptionId && this.subscriptions.has(subscriptionId)) {
-				const callback = this.subscriptions.get(subscriptionId);
-				if (!callback) throw new Error(`Subscription callback not found for subscriptionId: ${subscriptionId}`);
-				if (message.type === "ERROR" || message.error) {
-					if (callback.onError) {
-						const { errorMessage, errorCode } = extractMessageError(message);
-						callback.onError(new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode }));
-					}
-				} else callback.onUpdate(message);
-			}
-		}
-		async ensureAuthenticated(retryCount = 3) {
-			if (this.isAuthenticated || !this.getAuthToken) return;
-			if (this.authPromise) {
-				await this.authPromise;
-				return;
-			}
-			let lastError = null;
-			for (let attempt = 0; attempt < retryCount; attempt++) try {
-				const token = await this.getAuthToken();
-				if (!token) throw new Error("user not logged in");
-				this.authPromise = this.authenticate(token);
-				await this.authPromise;
-				this.authPromise = null;
-				console.debug("WebSocket authenticated on demand");
-				return;
-			} catch (error) {
-				this.authPromise = null;
-				lastError = error;
-				const errMsg = error instanceof Error ? error.message : String(error);
-				if (errMsg.includes("not logged in") || errMsg.includes("Session expired")) {
-					console.warn("WebSocket auth failed: user not logged in");
-					throw error;
-				}
-				if (errMsg.includes("still loading")) {
-					if (attempt < retryCount - 1) {
-						const delay = Math.min(500 * (attempt + 1), 2e3);
-						await new Promise((resolve) => setTimeout(resolve, delay));
-						continue;
-					}
-				}
-				if (attempt < retryCount - 1) {
-					const delay = Math.min(1e3 * (attempt + 1), 3e3);
-					console.debug(`WebSocket auth attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
-					await new Promise((resolve) => setTimeout(resolve, delay));
-				}
-			}
-			console.warn("WebSocket on-demand auth failed after retries:", lastError);
-			throw lastError;
-		}
-		async reauthenticate() {
-			if (!this.getAuthToken) return;
-			this.isAuthenticated = false;
-			try {
-				const token = await this.getAuthToken();
-				if (!token) throw new Error("user not logged in");
-				await this.authenticate(token);
-				console.debug("WebSocket reauthenticated successfully");
-			} catch (error) {
-				console.error("WebSocket reauthentication failed:", error);
-				throw error;
-			}
-		}
-		sendMessage(message) {
-			const queuedMsg = message;
-			if (queuedMsg._queuedResolve && queuedMsg._queuedReject) return this.doSendMessage(message, queuedMsg._queuedResolve, queuedMsg._queuedReject);
-			if (!this.isConnected || !this.ws) return new Promise((resolve, reject) => {
-				const queueable = message;
-				queueable._queuedResolve = resolve;
-				queueable._queuedReject = reject;
-				this.messageQueue.push(message);
-			});
-			return new Promise((resolve, reject) => {
-				this.doSendMessage(message, resolve, reject);
-			});
-		}
-		async doSendMessage(message, resolve, reject) {
-			if (message.type !== "AUTHENTICATE" && this.getAuthToken && !this.isAuthenticated) try {
-				await this.ensureAuthenticated();
-			} catch (error) {
-				reject(new _rebasepro_types.RebaseApiError(error instanceof Error ? error.message : "Authentication required"));
-				return;
-			}
-			const requestId = message.requestId || `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-			message.requestId = requestId;
-			const expectsResponse = ![
-				"subscribe_collection",
-				"subscribe_one",
-				"unsubscribe",
-				"join_channel",
-				"leave_channel",
-				"broadcast",
-				"presence_track",
-				"presence_untrack",
-				"presence_state"
-			].includes(message.type);
-			if (expectsResponse && !this.pendingRequests.has(requestId)) {
-				const timeoutHandle = setTimeout(() => {
-					if (this.pendingRequests.has(requestId)) {
-						this.pendingRequests.delete(requestId);
-						reject(new _rebasepro_types.RebaseApiError("Request timed out"));
-					}
-				}, this.requestTimeoutMs);
-				this.pendingRequests.set(requestId, {
-					resolve: (value) => {
-						clearTimeout(timeoutHandle);
-						resolve(value);
-					},
-					reject: (error) => {
-						clearTimeout(timeoutHandle);
-						reject(error);
-					},
-					message
-				});
-			}
-			try {
-				this.ws.send(JSON.stringify(message));
-				if (!expectsResponse) resolve(void 0);
-			} catch (error) {
-				if (expectsResponse) this.pendingRequests.delete(requestId);
-				reject(new _rebasepro_types.RebaseApiError("Failed to send message", { cause: error }));
-			}
-		}
-		async fetchCollection(props) {
-			return (await this.sendMessage({
-				type: "FETCH_COLLECTION",
-				payload: props
-			})).rows || [];
-		}
-		async fetchOne(props) {
-			return (await this.sendMessage({
-				type: "FETCH_ONE",
-				payload: props
-			})).row ?? void 0;
-		}
-		async save(props) {
-			return (await this.sendMessage({
-				type: "SAVE",
-				payload: props
-			})).row;
-		}
-		async delete(props) {
-			await this.sendMessage({
-				type: "DELETE",
-				payload: props
-			});
-		}
-		async executeSql(sql, options) {
-			return (await this.sendMessage({
-				type: "EXECUTE_SQL",
-				payload: {
-					sql,
-					options
-				}
-			})).result || [];
-		}
-		async fetchAvailableDatabases() {
-			return (await this.sendMessage({
-				type: "FETCH_DATABASES",
-				payload: {}
-			})).databases || [];
-		}
-		async fetchAvailableRoles() {
-			return (await this.sendMessage({ type: "FETCH_ROLES" })).roles || [];
-		}
-		async fetchCurrentDatabase() {
-			return (await this.sendMessage({ type: "FETCH_CURRENT_DATABASE" })).database;
-		}
-		async checkUniqueField(path, name, value, id, collection) {
-			return (await this.sendMessage({
-				type: "CHECK_UNIQUE_FIELD",
-				payload: {
-					path,
-					name,
-					value,
-					id,
-					collection
-				}
-			})).isUnique;
-		}
-		async count(props) {
-			return (await this.sendMessage({
-				type: "COUNT",
-				payload: props
-			})).count;
-		}
-		async fetchUnmappedTables(mappedPaths) {
-			return (await this.sendMessage({
-				type: "FETCH_UNMAPPED_TABLES",
-				payload: { mappedPaths }
-			})).tables || [];
-		}
-		async fetchTableMetadata(tableName) {
-			return (await this.sendMessage({
-				type: "FETCH_TABLE_METADATA",
-				payload: { tableName }
-			})).metadata || {
-				columns: [],
-				foreignKeys: [],
-				junctions: [],
-				policies: []
-			};
-		}
-		async createBranch(name, options) {
-			return (await this.sendMessage({
-				type: "CREATE_BRANCH",
-				payload: {
-					name,
-					options
-				}
-			})).branch;
-		}
-		async deleteBranch(name) {
-			await this.sendMessage({
-				type: "DELETE_BRANCH",
-				payload: { name }
-			});
-		}
-		async listBranches() {
-			return (await this.sendMessage({
-				type: "LIST_BRANCHES",
-				payload: {}
-			})).branches || [];
-		}
-		/**
-		* Recursively compare two values for structural equality.
-		* Handles primitives, null, undefined, Date, RegExp, arrays, and plain objects.
-		*/
-		deepEqual(a, b) {
-			if (a === b) return true;
-			if (a === null || b === null || a === void 0 || b === void 0) return false;
-			if (typeof a !== typeof b) return false;
-			if (typeof a !== "object") return false;
-			if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
-			if (a instanceof Date || b instanceof Date) return false;
-			if (a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
-			if (a instanceof RegExp || b instanceof RegExp) return false;
-			const aIsArray = Array.isArray(a);
-			const bIsArray = Array.isArray(b);
-			if (aIsArray !== bIsArray) return false;
-			if (aIsArray && bIsArray) {
-				if (a.length !== b.length) return false;
-				for (let i = 0; i < a.length; i++) if (!this.deepEqual(a[i], b[i])) return false;
-				return true;
-			}
-			const aObj = a;
-			const bObj = b;
-			const aKeys = Object.keys(aObj);
-			const bKeys = Object.keys(bObj);
-			if (aKeys.length !== bKeys.length) return false;
-			for (const key of aKeys) {
-				if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
-				if (!this.deepEqual(aObj[key], bObj[key])) return false;
-			}
-			return true;
-		}
-		normalizeForComparison(val) {
-			if (!val) return val;
-			if (Array.isArray(val)) return val.map((item) => this.normalizeForComparison(item));
-			if (typeof val === "object") {
-				if (val instanceof Date) return val;
-				if (val instanceof RegExp) return val;
-				const obj = val;
-				if (obj.__type === "relation") {
-					const { data, ...rest } = obj;
-					return rest;
-				}
-				const result = {};
-				for (const [k, v] of Object.entries(obj)) result[k] = this.normalizeForComparison(v);
-				return result;
-			}
-			return val;
-		}
-		/**
-		* Merge incoming rows with cached data, preserving cached references
-		* for rows whose values haven't changed. This avoids unnecessary
-		* React re-renders when the server refetches all rows but most
-		* haven't actually changed.
-		*/
-		mergeRows(cached, incoming) {
-			if (!cached || cached.length === 0) return incoming;
-			const cachedById = /* @__PURE__ */ new Map();
-			for (const row of cached) cachedById.set(row.id, row);
-			return incoming.map((incomingRow) => {
-				const cachedRow = cachedById.get(incomingRow.id);
-				if (!cachedRow) return incomingRow;
-				const normCached = this.normalizeForComparison(cachedRow);
-				const normIncoming = this.normalizeForComparison(incomingRow);
-				if (this.deepEqual(normCached, normIncoming)) return cachedRow;
-				else {
-					const mismatches = {};
-					const allKeys = new Set([...Object.keys(normCached), ...Object.keys(normIncoming)]);
-					for (const key of allKeys) if (!this.deepEqual(normCached[key], normIncoming[key])) mismatches[key] = {
-						cached: normCached[key],
-						incoming: normIncoming[key]
-					};
-					console.debug(`[RebaseWS] Row ${incomingRow.id} refetch mismatch:\n`, JSON.stringify(mismatches, null, 2));
-				}
-				return incomingRow;
-			});
-		}
-		listenCollection(props, onUpdate, onError) {
-			const subscriptionKey = this.createCollectionSubscriptionKey(props);
-			const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-			const existingSubscription = this.collectionSubscriptions.get(subscriptionKey);
-			if (existingSubscription) {
-				const callbackMap = existingSubscription.callbacks;
-				callbackMap.set(callbackId, {
-					onUpdate,
-					onError
-				});
-				if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) try {
-					onUpdate(existingSubscription.latestData);
-				} catch (error) {
-					console.error("Error in collection subscription callback:", error);
-					if (onError) onError(error instanceof Error ? error : new Error(String(error)));
-				}
-				return () => {
-					callbackMap.delete(callbackId);
-					if (callbackMap.size === 0) {
-						this.collectionSubscriptions.delete(subscriptionKey);
-						this.backendToCollectionKey.delete(existingSubscription.backendSubscriptionId);
-						if (this.isConnected && this.ws) this.sendMessage({
-							type: "unsubscribe",
-							payload: { subscriptionId: existingSubscription.backendSubscriptionId }
-						}).catch(console.error);
-					}
-				};
-			}
-			const backendSubscriptionId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-			const callbackMap = /* @__PURE__ */ new Map();
-			callbackMap.set(callbackId, {
-				onUpdate,
-				onError
-			});
-			this.collectionSubscriptions.set(subscriptionKey, {
-				backendSubscriptionId,
-				callbacks: callbackMap,
-				props
-			});
-			this.backendToCollectionKey.set(backendSubscriptionId, 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) {
-						this.collectionSubscriptions.delete(subscriptionKey);
-						this.backendToCollectionKey.delete(subscription.backendSubscriptionId);
-						if (this.isConnected && this.ws) this.sendMessage({
-							type: "unsubscribe",
-							payload: { subscriptionId: subscription.backendSubscriptionId }
-						}).catch(console.error);
-					}
-				}
-			};
-		}
-		listenOne(props, onUpdate, onError) {
-			const subscriptionKey = this.createSingleSubscriptionKey(props);
-			const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-			const existingSubscription = this.singleSubscriptions.get(subscriptionKey);
-			if (existingSubscription) {
-				const callbackMap = existingSubscription.callbacks;
-				callbackMap.set(callbackId, {
-					onUpdate,
-					onError
-				});
-				if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) try {
-					onUpdate(existingSubscription.latestData);
-				} catch (error) {
-					console.error("Error in row subscription callback:", error);
-					if (onError) onError(error instanceof Error ? error : new Error(String(error)));
-				}
-				return () => {
-					callbackMap.delete(callbackId);
-					if (callbackMap.size === 0) {
-						this.singleSubscriptions.delete(subscriptionKey);
-						this.backendToEntityKey.delete(existingSubscription.backendSubscriptionId);
-						if (this.isConnected && this.ws) this.sendMessage({
-							type: "unsubscribe",
-							payload: { subscriptionId: existingSubscription.backendSubscriptionId }
-						}).catch(console.error);
-					}
-				};
-			}
-			const backendSubscriptionId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-			const callbackMap = /* @__PURE__ */ new Map();
-			callbackMap.set(callbackId, {
-				onUpdate,
-				onError
-			});
-			this.singleSubscriptions.set(subscriptionKey, {
-				backendSubscriptionId,
-				callbacks: callbackMap,
-				props
-			});
-			this.backendToEntityKey.set(backendSubscriptionId, 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) {
-					const callbacks = subscription.callbacks;
-					callbacks.delete(callbackId);
-					if (callbacks.size === 0) {
-						this.singleSubscriptions.delete(subscriptionKey);
-						this.backendToEntityKey.delete(subscription.backendSubscriptionId);
-						if (this.isConnected && this.ws) this.sendMessage({
-							type: "unsubscribe",
-							payload: { subscriptionId: subscription.backendSubscriptionId }
-						}).catch(console.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.
-		*/
-		resubscribeAll() {
-			console.debug(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.singleSubscriptions.size} row(ies)`);
-			for (const [key, sub] of this.collectionSubscriptions.entries()) {
-				const oldBackendId = sub.backendSubscriptionId;
-				const newBackendId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-				sub.backendSubscriptionId = newBackendId;
-				this.backendToCollectionKey.delete(oldBackendId);
-				this.backendToCollectionKey.set(newBackendId, 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;
-				const newBackendId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-				sub.backendSubscriptionId = newBackendId;
-				this.backendToEntityKey.delete(oldBackendId);
-				this.backendToEntityKey.set(newBackendId, 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) {
-			const key = {
-				path: props.path,
-				filter: props.filter,
-				limit: props.limit,
-				startAfter: props.startAfter,
-				orderBy: props.orderBy,
-				order: props.order,
-				searchString: props.searchString,
-				collection: props.collection?.name
-			};
-			return JSON.stringify(key, (_, value) => {
-				if (value && typeof value === "object" && !Array.isArray(value)) return Object.keys(value).sort().reduce((sorted, k) => {
-					sorted[k] = value[k];
-					return sorted;
-				}, {});
-				return value;
-			});
-		}
-		createSingleSubscriptionKey(props) {
-			return `${props.path}|${props.id}`;
-		}
-	};
-	//#endregion
-	//#region src/index.ts
-	/**
-	* Derive a WebSocket URL from an HTTP base URL.
-	* `http://` → `ws://`, `https://` → `wss://`.
-	*/
-	function deriveWebSocketUrl(baseUrl) {
-		if (typeof window !== "undefined") {
-			let absoluteUrl = "";
-			if (!baseUrl) absoluteUrl = window.location.origin;
-			else if (/^https?:\/\//i.test(baseUrl) || /^wss?:\/\//i.test(baseUrl)) absoluteUrl = baseUrl;
-			else try {
-				absoluteUrl = new URL(baseUrl, window.location.href).origin;
-			} catch {
-				absoluteUrl = window.location.origin;
-			}
-			const protocol = absoluteUrl.startsWith("https:") || absoluteUrl.startsWith("wss:") ? "wss:" : "ws:";
-			return absoluteUrl.replace(/^https?:\/\//i, `${protocol}//`).replace(/^wss?:\/\//i, `${protocol}//`).replace(/\/$/, "");
-		}
-		if (!baseUrl) return "";
-		if (!/^https?:\/\//i.test(baseUrl) && !/^wss?:\/\//i.test(baseUrl)) return "";
-		return baseUrl.replace(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://").replace(/\/$/, "");
-	}
-	function createRebaseClient(options) {
-		const transport = createTransport(options);
-		const auth = createAuth(transport, options.auth);
-		const admin = createAdmin(transport, options.admin);
-		const cron = createCron(transport, options.cron);
-		const apiKeys = createApiKeys(transport, options.apiKeys);
-		const storage = createStorage(transport);
-		const functions = createFunctionsClient(transport);
-		const createStorageSource = (storageId) => storageId === _rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY ? storage : createStorage(transport, storageId);
-		const storageRegistry = new ClientStorageSourceRegistry();
-		storageRegistry.register(_rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY, storage);
-		for (const def of options.storageSources ?? []) if (def.transport === "server" && def.key !== _rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY) storageRegistry.register(def.key, createStorageSource(def.key));
-		let storageSourcesPromise;
-		const fetchStorageSources = () => {
-			if (storageSourcesPromise) return storageSourcesPromise;
-			storageSourcesPromise = transport.request("/storage/sources").then((res) => {
-				const defs = res.data ?? [];
-				for (const def of defs) if (def.transport === "server" && def.key !== _rebasepro_types.DEFAULT_STORAGE_SOURCE_KEY && !storageRegistry.has(def.key)) storageRegistry.register(def.key, createStorageSource(def.key));
-				return defs;
-			}).catch((e) => {
-				storageSourcesPromise = void 0;
-				throw e;
-			});
-			return storageSourcesPromise;
-		};
-		const resolvedWsUrl = options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl);
-		let ws;
-		if (resolvedWsUrl) {
-			ws = new RebaseWebSocketClient({
-				websocketUrl: resolvedWsUrl,
-				getAuthToken: async () => {
-					let session = auth.getSession();
-					if (session && session.expiresAt <= Date.now() + 1e4) try {
-						session = await auth.refreshSession();
-					} catch (e) {}
-					return session?.accessToken || options.token || "";
-				},
-				onUnauthorized: options.onUnauthorized || (async () => {
-					try {
-						await auth.refreshSession();
-						return true;
-					} catch (e) {
-						return false;
-					}
-				})
-			});
-			auth.onAuthStateChange((event, session) => {
-				if (!ws) return;
-				if (event === "SIGNED_OUT") ws.disconnect();
-				else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
-					if (session?.accessToken) ws.authenticate(session.accessToken).catch(console.warn);
-				}
-			});
-		}
-		if (!options.onUnauthorized) transport.setOnUnauthorized(async () => {
-			try {
-				await auth.refreshSession();
-				return true;
-			} catch (e) {
-				return false;
-			}
-		});
-		/**
-		* Suggest the closest known collection key for a mistyped accessor.
-		* Uses edit-distance-1 and prefix matching — no external dependency.
-		*/
-		function suggestCollection(prop, knownKeys) {
-			const prefixMatch = knownKeys.find((k) => k.startsWith(prop) || prop.startsWith(k));
-			if (prefixMatch) return prefixMatch;
-			for (const key of knownKeys) {
-				if (Math.abs(key.length - prop.length) > 1) continue;
-				let diffs = 0;
-				const longer = key.length >= prop.length ? key : prop;
-				const shorter = key.length >= prop.length ? prop : key;
-				if (longer.length === shorter.length) for (let i = 0; i < longer.length; i++) {
-					if (longer[i] !== shorter[i]) {
-						if (i + 1 < longer.length && longer[i] === shorter[i + 1] && longer[i + 1] === shorter[i]) {
-							diffs++;
-							i++;
-							if (diffs > 1) break;
-							continue;
-						}
-						diffs++;
-					}
-					if (diffs > 1) break;
-				}
-				else {
-					let li = 0;
-					let si = 0;
-					while (li < longer.length) {
-						if (si < shorter.length && longer[li] === shorter[si]) si++;
-						else diffs++;
-						li++;
-						if (diffs > 1) break;
-					}
-				}
-				if (diffs <= 1) return key;
-			}
-		}
-		const collectionClients = /* @__PURE__ */ new Map();
-		let untypedWarned = false;
-		function collection(slug) {
-			if (!collectionClients.has(slug)) collectionClients.set(slug, createCollectionClient(transport, slug, ws));
-			return collectionClients.get(slug);
-		}
-		const dataProxy = new Proxy({ collection }, { get(_target, prop) {
-			if (prop === "collection") return collection;
-			if (typeof prop === "symbol") return void 0;
-			if (typeof prop === "string" && prop !== "then" && prop !== "toJSON" && prop !== "$$typeof") {
-				if (options.collections) {
-					if (prop in options.collections) return collection(options.collections[prop]);
-					const knownKeys = Object.keys(options.collections);
-					const suggestion = suggestCollection(prop, knownKeys);
-					let msg = `Unknown collection accessor "${prop}". Known collections: ${knownKeys.join(", ")}.`;
-					if (suggestion) msg += ` Did you mean "${suggestion}"?`;
-					msg += ` Use data.collection("<slug>") for dynamic slugs.`;
-					throw new _rebasepro_types.RebaseClientError(msg);
-				}
-				if (!untypedWarned) {
-					untypedWarned = true;
-					console.warn(`[Rebase] Untyped data access detected (client.data.${prop}). Collection names are resolved via snake_case conversion, which may cause silent 404s at request time. Pass a \`collections\` dictionary to createRebaseClient() or use the generated SDK for type-safe access.`);
-				}
-				return collection((0, _rebasepro_utils.toSnakeCase)(prop));
-			}
-		} });
-		return {
-			auth,
-			admin,
-			cron,
-			apiKeys,
-			functions,
-			storage,
-			storageRegistry,
-			createStorageSource,
-			fetchStorageSources,
-			ws,
-			setToken: transport.setToken,
-			setAuthTokenGetter: transport.setAuthTokenGetter,
-			setOnUnauthorized: transport.setOnUnauthorized,
-			resolveToken: transport.resolveToken,
-			baseUrl: transport.baseUrl,
-			collection,
-			call: async (endpoint, payload) => {
-				const prefix = endpoint.startsWith("/") ? "" : "/";
-				const res = await transport.request(`${prefix}${endpoint}`, {
-					method: "POST",
-					body: payload ? JSON.stringify(payload) : void 0
-				});
-				return res.data ?? res;
-			},
-			data: dataProxy
-		};
-	}
-	//#endregion
-	Object.defineProperty(exports, "QueryBuilder", {
-		enumerable: true,
-		get: function() {
-			return _rebasepro_common.QueryBuilder;
-		}
-	});
-	Object.defineProperty(exports, "RebaseApiError", {
-		enumerable: true,
-		get: function() {
-			return _rebasepro_types.RebaseApiError;
-		}
-	});
-	Object.defineProperty(exports, "RebaseClientError", {
-		enumerable: true,
-		get: function() {
-			return _rebasepro_types.RebaseClientError;
-		}
-	});
-	exports.RebaseWebSocketClient = RebaseWebSocketClient;
-	Object.defineProperty(exports, "and", {
-		enumerable: true,
-		get: function() {
-			return _rebasepro_common.and;
-		}
-	});
-	Object.defineProperty(exports, "cond", {
-		enumerable: true,
-		get: function() {
-			return _rebasepro_common.cond;
-		}
-	});
-	exports.createCookieStorage = createCookieStorage;
-	exports.createMemoryStorage = createMemoryStorage;
-	exports.createRebaseClient = createRebaseClient;
-	Object.defineProperty(exports, "or", {
-		enumerable: true,
-		get: function() {
-			return _rebasepro_common.or;
-		}
-	});
-});
-
-//# sourceMappingURL=index.umd.js.map