@rebasepro/client 0.7.0 → 0.9.0

package/dist/index.umd.js

@@ -36,94 +36,27 @@
 	}
 	//#endregion
 	//#region src/transport.ts
-	var RebaseApiError = class extends Error {
-		status;
-		code;
-		details;
-		constructor(status, message, code, details) {
-			super(message);
-			this.name = "RebaseApiError";
-			this.status = status;
-			this.code = code;
-			this.details = details;
-		}
-	};
-	/**
-	* Maps a short operator alias to the PostgREST-style short code.
-	*/
-	var OP_MAP = {
-		"==": "eq",
-		"!=": "neq",
-		">": "gt",
-		">=": "gte",
-		"<": "lt",
-		"<=": "lte",
-		"not-in": "nin",
-		"array-contains": "cs",
-		"array-contains-any": "csa"
-	};
-	/**
-	* Normalise a single `WhereFieldValue` into the PostgREST query-string
-	* representation the backend expects.
-	*
-	* Supports:
-	*  - `null`          → `"eq.null"`
-	*  - `true`/`false`  → `"eq.true"` / `"eq.false"`
-	*  - `42`            → `"42"` (plain equality)
-	*  - `"active"`      → `"active"` (plain equality, backward-compat)
-	*  - `"gte.18"`      → `"gte.18"` (pass-through PostgREST string)
-	*  - `[">=", 18]`    → `"gte.18"` (tuple syntax)
-	*  - `["in", [1,2]]` → `"in.(1,2)"` (tuple with array value)
-	*  - `["!=", null]`  → `"neq.null"`
-	*/
-	function normalizeWhereValue(value) {
-		if (value === null) return "eq.null";
-		if (typeof value === "boolean") return `eq.${value}`;
-		if (typeof value === "number") return String(value);
-		if (Array.isArray(value)) {
-			const [rawOp, val] = (Array.isArray(value[0]) ? value : [value])[0] || [];
-			if (rawOp) {
-				const op = OP_MAP[rawOp] ?? rawOp;
-				if (val === null) return `${op}.null`;
-				if (Array.isArray(val)) return `${op}.(${val.join(",")})`;
-				return `${op}.${val}`;
-			}
-		}
-		return String(value);
-	}
-	function serializeLogicalCondition(cond) {
-		if ("type" in cond) {
-			const sub = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
-			return `${cond.type}(${sub})`;
-		} else {
-			const op = OP_MAP[cond.operator] ?? cond.operator;
-			let formattedValue = cond.value;
-			if (Array.isArray(cond.value)) formattedValue = `(${cond.value.join(",")})`;
-			else if (cond.value === null) formattedValue = "null";
-			return `${cond.column}.${op}.${formattedValue}`;
-		}
-	}
 	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) parts.push(`orderBy=${encodeURIComponent(params.orderBy)}`);
+		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(serializeLogicalCondition).join(",");
+			const serialized = (root.conditions ?? []).map(_rebasepro_common.serializeLogicalCondition).join(",");
 			parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
 		}
-		if (params.where) for (const [field, value] of Object.entries(params.where)) if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) for (const subVal of value) {
-			const normalized = normalizeWhereValue(subVal);
-			parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
-		}
-		else {
-			const normalized = normalizeWhereValue(value);
-			parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+		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("&") : "";
 	}
@@ -161,8 +94,7 @@
 			} catch (e) {}
 			const getErrorField = (obj, field) => {
 				const err = obj?.error;
-				if (err && typeof err === "object" && err !== null && field in err) return err[field];
-				return obj?.[field];
+				if (err && typeof err === "object" && err !== null) return err[field];
 			};
 			if (res.status === 401 && onUnauthorizedHandler) {
 				if (await onUnauthorizedHandler()) {
@@ -185,7 +117,11 @@
 					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 RebaseApiError(retryRes.status, String(getErrorField(retryBody, "message") || fallbackMessage || `Request failed with status ${retryRes.status}`), getErrorField(retryBody, "code"), getErrorField(retryBody, "details"));
+						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;
 				}
@@ -193,7 +129,11 @@
 			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 RebaseApiError(res.status, String(getErrorField(body, "message") || fallbackMessage || `Request failed with status ${res.status}`), getErrorField(body, "code"), getErrorField(body, "details"));
+				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;
 		}
@@ -229,6 +169,29 @@
 	}
 	//#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 {
@@ -259,11 +222,20 @@
 		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;
 		}
@@ -271,7 +243,11 @@
 			return transport.fetchFn || globalThis.fetch;
 		}
 		function throwApiError(status, body, statusText) {
-			throw new RebaseApiError(status, body?.error?.message || body?.message || statusText, body?.error?.code || body?.code, body?.error?.details || body?.details);
+			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 {
@@ -279,7 +255,7 @@
 			} catch (e) {}
 		}
 		function saveSession(session) {
-			if (!persistSession) return;
+			if (!persistSession || authFlowMode === "cookie") return;
 			try {
 				storage.setItem(STORAGE_KEY, JSON.stringify(session));
 			} catch (e) {}
@@ -296,28 +272,53 @@
 			} 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) {
-				refreshSession().catch(() => signOut());
+				attemptScheduledRefresh(0);
 				return;
 			}
-			refreshTimeout = setTimeout(async () => {
-				try {
-					await refreshSession();
-				} catch (e) {
-					signOut();
-				}
+			refreshTimeout = setTimeout(() => {
+				attemptScheduledRefresh(0);
 			}, delay);
 		}
 		function handleAuthResponse(data, event) {
+			const user = mapRawUser(data.user);
 			const session = {
 				accessToken: data.tokens.accessToken,
-				refreshToken: data.tokens.refreshToken,
+				refreshToken: data.tokens.refreshToken || currentSession?.refreshToken || "",
 				expiresAt: data.tokens.accessTokenExpiresAt,
-				user: data.user
+				user
 			};
 			currentSession = session;
 			saveSession(session);
@@ -333,7 +334,8 @@
 				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);
@@ -354,7 +356,8 @@
 			const res = await fetchFn(authUrl("/register"), {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(payload)
+				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);
@@ -377,7 +380,8 @@
 			const res = await getFetch()(authUrl("/google"), {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(payload)
+				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);
@@ -395,7 +399,8 @@
 				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);
@@ -414,7 +419,8 @@
 			const res = await getFetch()(authUrl(`/${providerId}`), {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(payload)
+				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);
@@ -490,10 +496,11 @@
 		async function signOut() {
 			const fetchFn = getFetch();
 			try {
-				if (currentSession?.refreshToken) await fetchFn(authUrl("/logout"), {
+				if (authFlowMode === "cookie" || currentSession?.refreshToken) await fetchFn(authUrl("/logout"), {
 					method: "POST",
 					headers: { "Content-Type": "application/json" },
-					body: JSON.stringify({ refreshToken: currentSession.refreshToken })
+					body: JSON.stringify({ refreshToken: currentSession?.refreshToken }),
+					credentials: authFlowMode === "cookie" ? "include" : void 0
 				});
 			} catch (e) {}
 			currentSession = null;
@@ -505,20 +512,35 @@
 			transport.setToken(null);
 			emit("SIGNED_OUT", null);
 		}
-		async function refreshSession() {
-			if (!currentSession?.refreshToken) throw new Error("No active session to refresh");
+		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 })
+				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: body.tokens.accessToken,
-				refreshToken: body.tokens.refreshToken,
+				accessToken,
+				refreshToken: body.tokens.refreshToken || currentSession?.refreshToken || "",
 				expiresAt: body.tokens.accessTokenExpiresAt,
-				user: currentSession.user
+				user: user ?? EMPTY_USER
 			};
 			currentSession = session;
 			saveSession(session);
@@ -530,6 +552,18 @@
 		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",
@@ -603,7 +637,8 @@
 			const res = await getFetch()(authUrl("/magic-link/verify"), {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({ token })
+				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);
@@ -650,21 +685,29 @@
 		}
 		if (persistSession) {
 			const stored = loadStoredSession();
-			if (stored && stored.accessToken && stored.refreshToken) {
-				if (stored.expiresAt > Date.now()) {
-					currentSession = stored;
-					transport.setToken(stored.accessToken);
-					scheduleRefresh(stored.expiresAt);
-				} else if (stored.refreshToken) {
-					currentSession = stored;
-					refreshSession().catch(() => {
-						currentSession = null;
-						clearStoredSession();
-						transport.setToken(null);
-					});
-				}
-			}
-		}
+			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,
@@ -684,6 +727,7 @@
 			signOut,
 			refreshSession,
 			getUser,
+			findUserByEmail,
 			updateUser,
 			resetPasswordForEmail,
 			resetPassword,
@@ -697,7 +741,8 @@
 			revokeAllSessions,
 			getAuthConfig,
 			getSession,
-			onAuthStateChange
+			onAuthStateChange,
+			isInitialized: () => isInitialized
 		};
 	}
 	function createCookieStorage(options = {}) {
@@ -874,108 +919,108 @@
 		};
 	}
 	//#endregion
-	//#region src/collection.ts
-	function parseWhereFilter(where) {
-		if (!where) return void 0;
-		const filters = {};
-		const OP_TO_FILTER = {
-			"eq": "==",
-			"neq": "!=",
-			"gt": ">",
-			"gte": ">=",
-			"lt": "<",
-			"lte": "<=",
-			"==": "==",
-			"!=": "!=",
-			">": ">",
-			">=": ">=",
-			"<": "<",
-			"<=": "<=",
-			"in": "in",
-			"nin": "not-in",
-			"not-in": "not-in",
-			"cs": "array-contains",
-			"csa": "array-contains-any",
-			"array-contains": "array-contains",
-			"array-contains-any": "array-contains-any"
-		};
-		const parseSingle = (rawValue, fieldKey) => {
-			if (rawValue === null) return ["==", null];
-			if (typeof rawValue === "boolean") return ["==", rawValue];
-			if (typeof rawValue === "number") return ["==", rawValue];
-			if (Array.isArray(rawValue) && rawValue.length === 2 && typeof rawValue[0] === "string") {
-				const [rawOp, val] = rawValue;
-				return [OP_TO_FILTER[rawOp] ?? "==", val];
-			}
-			const value = String(rawValue);
-			const dotIndex = value.indexOf(".");
-			if (dotIndex > 0) {
-				const opStr = value.substring(0, dotIndex);
-				const valStr = value.substring(dotIndex + 1);
-				let op = "==";
-				let val = valStr;
-				switch (opStr) {
-					case "eq":
-						op = "==";
-						break;
-					case "neq":
-						op = "!=";
-						break;
-					case "gt":
-						op = ">";
-						break;
-					case "gte":
-						op = ">=";
-						break;
-					case "lt":
-						op = "<";
-						break;
-					case "lte":
-						op = "<=";
-						break;
-					case "in":
-						op = "in";
-						val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
-						break;
-					case "nin":
-						op = "not-in";
-						val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
-						break;
-					case "cs":
-						op = "array-contains";
-						break;
-					case "csa":
-						op = "array-contains-any";
-						val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
-						break;
-					default:
-						op = "==";
-						val = value;
-				}
-				if (val === "true") val = true;
-				else if (val === "false") val = false;
-				else if (val === "null") val = null;
-				else if (typeof val === "string" && /^[0-9]+(\.[0-9]+)?$/.test(val) && fieldKey !== "id" && !fieldKey.endsWith("_id")) val = Number(val);
-				return [op, val];
-			} else return ["==", value];
-		};
-		for (const [key, rawValue] of Object.entries(where)) if (Array.isArray(rawValue) && rawValue.length > 0 && Array.isArray(rawValue[0])) filters[key] = rawValue.map((r) => parseSingle(r, key));
-		else filters[key] = parseSingle(rawValue, key);
-		return filters;
-	}
+	//#region src/sdk_query_builder.ts
 	/**
-	* Wrap a flat row (returned by the REST API as `{ id, ...fields }`) into
-	* a proper `Entity<M>` structure expected by the core framework.
-	* The `id` is kept inside `values` as well, since collection properties
-	* may define an `isId` field that the form binds to `formex.values`.
+	* 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
 	*/
-	function rowToEntity(row, slug) {
-		return {
-			id: row.id,
-			path: slug,
-			values: row
-		};
-	}
+	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 = {
@@ -983,7 +1028,7 @@
 				const qs = buildQueryString(params);
 				const raw = await transport.request(basePath + qs, { method: "GET" });
 				return {
-					data: (raw.data || []).map((row) => rowToEntity(row, slug)),
+					data: raw.data || [],
 					meta: raw.meta
 				};
 			},
@@ -991,28 +1036,28 @@
 				try {
 					const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
 					if (!raw) return void 0;
-					return rowToEntity(raw, slug);
+					return raw;
 				} catch (err) {
-					if (err instanceof RebaseApiError && err.status === 404) return;
+					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 rowToEntity(await transport.request(basePath, {
+				return await transport.request(basePath, {
 					method: "POST",
 					body: JSON.stringify(body)
-				}), slug);
+				});
 			},
 			async update(id, data) {
-				return rowToEntity(await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
+				return await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
 					method: "PUT",
 					body: JSON.stringify(data)
-				}), slug);
+				});
 			},
 			async delete(id) {
-				return transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "DELETE" });
+				await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "DELETE" });
 			},
 			async count(params) {
 				const qs = buildQueryString({
@@ -1023,55 +1068,87 @@
 				return (await transport.request(basePath + "/count" + qs, { method: "GET" })).count ?? 0;
 			},
 			where(columnOrCondition, operator, value) {
-				const builder = new _rebasepro_common.QueryBuilder(client);
+				const builder = new SDKQueryBuilder(client);
 				if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
 				return builder.where(columnOrCondition, operator, value);
 			},
-			orderBy(column, ascending) {
-				return new _rebasepro_common.QueryBuilder(client).orderBy(column, ascending);
+			orderBy(column, direction) {
+				return new SDKQueryBuilder(client).orderBy(column, direction);
 			},
 			limit(count) {
-				return new _rebasepro_common.QueryBuilder(client).limit(count);
+				return new SDKQueryBuilder(client).limit(count);
 			},
 			offset(count) {
-				return new _rebasepro_common.QueryBuilder(client).offset(count);
+				return new SDKQueryBuilder(client).offset(count);
 			},
 			search(searchString) {
-				return new _rebasepro_common.QueryBuilder(client).search(searchString);
+				return new SDKQueryBuilder(client).search(searchString);
 			},
 			include(...relations) {
-				return new _rebasepro_common.QueryBuilder(client).include(...relations);
+				return new SDKQueryBuilder(client).include(...relations);
 			}
 		};
 		if (ws) {
 			client.listen = (params, onUpdate, onError) => {
-				return ws.listenCollection({
+				let active = true;
+				let lastUpdateId = 0;
+				const unsub = ws.listenCollection({
 					path: slug,
-					filter: parseWhereFilter(params?.where),
+					filter: params?.where,
 					limit: params?.limit,
 					startAfter: params?.offset ? String(params.offset) : void 0,
-					orderBy: params?.orderBy?.split(":")[0],
-					order: params?.orderBy?.split(":")[1],
+					orderBy: params?.orderBy?.[0],
+					order: params?.orderBy?.[1],
 					searchString: params?.searchString
-				}, (entities) => {
+				}, (incomingRows) => {
+					const currentUpdateId = ++lastUpdateId;
 					const requestedLimit = params?.limit || 20;
-					onUpdate({
-						data: entities,
+					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: entities.length,
+							total: heuristicTotal,
 							limit: requestedLimit,
-							offset: params?.offset || 0,
-							hasMore: entities.length >= requestedLimit
+							offset,
+							hasMore: heuristicHasMore
 						}
 					});
 				}, onError);
+				return () => {
+					active = false;
+					unsub();
+				};
 			};
 			client.listenById = (id, onUpdate, onError) => {
-				return ws.listenEntity({
+				return ws.listenOne({
 					path: slug,
-					entityId: String(id)
-				}, (entity) => {
-					if (entity) onUpdate(entity);
+					id: String(id)
+				}, (row) => {
+					if (row) onUpdate(row);
 					else onUpdate(void 0);
 				}, onError);
 			};
@@ -1104,17 +1181,33 @@
 	}
 	//#endregion
 	//#region src/storage.ts
-	function createStorage(transport) {
+	/**
+	* 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();
-		async function putObject({ file, key, metadata, bucket }) {
+		/** 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);
-			if (key) formData.append("key", key);
+			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("/storage/upload", {
+			return (await transport.request(withStorageId("/storage/upload"), {
 				method: "POST",
 				body: formData,
 				headers: {}
@@ -1122,24 +1215,44 @@
 		}
 		async function getSignedUrl(keyOrUrl, bucket) {
 			const cacheKey = bucket ? `${bucket}/${keyOrUrl}` : keyOrUrl;
-			const cached = urlsCache.get(cacheKey);
-			if (cached) return cached;
+			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 = filePath.substring(filePath.indexOf("://") + 3);
+			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(`/storage/metadata/${filePath}`);
-				const activeToken = await transport.resolveToken();
-				const tokenQuery = activeToken ? `?token=${activeToken}` : "";
+				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: `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`,
+					url: withStorageId(`${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`),
 					metadata: result.data
 				};
-				urlsCache.set(cacheKey, downloadConfig);
+				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 {
@@ -1150,25 +1263,22 @@
 			}
 		}
 		async function getObject(key, bucket) {
-			let filePath = key;
-			if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
-			if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
-			if (!filePath || filePath.trim() === "" || filePath === "/") return null;
-			const url = `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`;
-			const response = await transport.fetchFn(url, { headers: transport.getHeaders ? transport.getHeaders() : {} });
+			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 = filePath.split("/").pop() || "file";
+			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 = filePath.substring(filePath.indexOf("://") + 3);
+			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(`/storage/file/${filePath}`, { method: "DELETE" });
+				await transport.request(withStorageId(`/storage/file/${filePath}`), { method: "DELETE" });
 			} catch (e) {
 				if (!(e instanceof Error && "status" in e && e.status === 404)) throw e;
 			}
@@ -1180,6 +1290,7 @@
 			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 {
@@ -1191,6 +1302,62 @@
 		};
 	}
 	//#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.
@@ -1204,16 +1371,15 @@
 			errorCode: typeof errPayload === "object" ? errPayload.code : payload?.code
 		};
 	}
-	var ApiError = class extends Error {
-		code;
-		error;
-		constructor(message, error, code) {
-			super(message);
-			this.name = "ApiError";
-			this.code = code;
-			this.error = error;
-		}
-	};
+	/**
+	* 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;
@@ -1229,7 +1395,7 @@
 			if (this.listeners.has(event)) this.listeners.get(event).forEach((cb) => cb(...args));
 		}
 		collectionSubscriptions = /* @__PURE__ */ new Map();
-		entitySubscriptions = /* @__PURE__ */ new Map();
+		singleSubscriptions = /* @__PURE__ */ new Map();
 		backendToCollectionKey = /* @__PURE__ */ new Map();
 		backendToEntityKey = /* @__PURE__ */ new Map();
 		pendingRequests = /* @__PURE__ */ new Map();
@@ -1364,7 +1530,7 @@
 							request.message._queuedResolve = request.resolve;
 							request.message._queuedReject = request.reject;
 							this.messageQueue.push(request.message);
-						} else request.reject(new ApiError("Connection closed", "Connection closed"));
+						} else request.reject(new _rebasepro_types.RebaseApiError("Connection closed"));
 						this.pendingRequests.delete(reqId);
 					}
 					this.attemptReconnect();
@@ -1431,7 +1597,7 @@
 			}
 		}
 		/**
-		* Shared logic for re-subscribing a collection or entity subscription
+		* 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) {
@@ -1456,7 +1622,7 @@
 					});
 				} else {
 					const { errorMessage, errorCode } = extractMessageError(message);
-					const error = new ApiError(errorMessage, errorMessage, errorCode);
+					const error = new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode });
 					subscription.callbacks.forEach((callback) => {
 						if (callback.onError) callback.onError(error);
 					});
@@ -1477,7 +1643,7 @@
 						if (refreshed && pendingReq.message) this.doSendMessage(pendingReq.message, pendingReq.resolve, pendingReq.reject).catch(pendingReq.reject);
 						else {
 							const { errorMessage, errorCode } = extractMessageError(message);
-							pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+							pendingReq.reject(new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode }));
 						}
 					}).catch((err) => {
 						pendingReq.reject(err);
@@ -1485,7 +1651,7 @@
 				} else {
 					this.pendingRequests.delete(requestId);
 					const { errorMessage, errorCode } = extractMessageError(message);
-					pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+					pendingReq.reject(new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode }));
 				}
 				else {
 					this.pendingRequests.delete(requestId);
@@ -1498,14 +1664,14 @@
 				if (subscriptionKey) {
 					const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
 					if (collectionSub) {
-						const incomingEntities = message.entities || [];
-						const entities = this.mergeEntities(collectionSub.latestData, incomingEntities);
-						collectionSub.latestData = entities;
+						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(entities);
+								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)));
@@ -1515,21 +1681,22 @@
 					}
 				}
 			}
-			if (subscriptionId && type === "collection_entity_patch") {
+			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 patchEntity = message.entity ?? null;
-						const patchEntityId = message.entityId;
+						const patchWireEntity = message.row ?? null;
+						const patchEntityId = message.id;
+						const patchRow = patchWireEntity ? patchWireEntity : null;
 						let updated;
-						if (patchEntity === null || patchEntity === void 0) updated = collectionSub.latestData.filter((e) => String(e.id) !== String(patchEntityId));
+						if (patchRow === null) updated = collectionSub.latestData.filter((e) => String(e.id) !== String(patchEntityId));
 						else {
-							const idx = collectionSub.latestData.findIndex((e) => String(e.id) === String(patchEntity.id));
+							const idx = collectionSub.latestData.findIndex((e) => String(e.id) === String(patchRow.id));
 							if (idx >= 0) {
 								updated = [...collectionSub.latestData];
-								updated[idx] = patchEntity;
-							} else updated = [patchEntity, ...collectionSub.latestData];
+								updated[idx] = patchRow;
+							} else updated = [patchRow, ...collectionSub.latestData];
 						}
 						collectionSub.latestData = updated;
 						collectionSub.lastUpdated = Date.now();
@@ -1545,20 +1712,21 @@
 					}
 				}
 			}
-			if (subscriptionId && type === "entity_update") {
+			if (subscriptionId && type === "single_update") {
 				const subscriptionKey = this.backendToEntityKey.get(subscriptionId);
 				if (subscriptionKey) {
-					const entitySub = this.entitySubscriptions.get(subscriptionKey);
+					const entitySub = this.singleSubscriptions.get(subscriptionKey);
 					if (entitySub) {
-						const entity = message.entity ?? null;
-						entitySub.latestData = entity;
+						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(entity);
+								callback.onUpdate(row);
 							} catch (error) {
-								console.error("Error in entity subscription callback:", error);
+								console.error("Error in row subscription callback:", error);
 								if (callback.onError) callback.onError(error instanceof Error ? error : new Error(String(error)));
 							}
 						});
@@ -1576,7 +1744,7 @@
 							return;
 						}
 						const { errorMessage, errorCode } = extractMessageError(message);
-						const error = new ApiError(errorMessage, errorMessage, errorCode);
+						const error = new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode });
 						collectionSub.callbacks.forEach((callback) => {
 							if (callback.onError) callback.onError(error);
 						});
@@ -1585,14 +1753,14 @@
 				}
 				const entityKey = this.backendToEntityKey.get(subscriptionId);
 				if (entityKey) {
-					const entitySub = this.entitySubscriptions.get(entityKey);
+					const entitySub = this.singleSubscriptions.get(entityKey);
 					if (entitySub) {
 						if (this.isAuthError(message)) {
-							this.resubscribeAfterAuthRefresh(message, entitySub, entityKey, "entity", this.backendToEntityKey, "subscribe_entity");
+							this.resubscribeAfterAuthRefresh(message, entitySub, entityKey, "row", this.backendToEntityKey, "subscribe_one");
 							return;
 						}
 						const { errorMessage, errorCode } = extractMessageError(message);
-						const error = new ApiError(errorMessage, errorMessage, errorCode);
+						const error = new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode });
 						entitySub.callbacks.forEach((callback) => {
 							if (callback.onError) callback.onError(error);
 						});
@@ -1606,7 +1774,7 @@
 				if (message.type === "ERROR" || message.error) {
 					if (callback.onError) {
 						const { errorMessage, errorCode } = extractMessageError(message);
-						callback.onError(new ApiError(errorMessage, errorMessage, errorCode));
+						callback.onError(new _rebasepro_types.RebaseApiError(errorMessage, { code: errorCode }));
 					}
 				} else callback.onUpdate(message);
 			}
@@ -1680,15 +1848,14 @@
 			if (message.type !== "AUTHENTICATE" && this.getAuthToken && !this.isAuthenticated) try {
 				await this.ensureAuthenticated();
 			} catch (error) {
-				const errorMessage = error instanceof Error ? error.message : "Authentication required";
-				reject(new ApiError(errorMessage, errorMessage));
+				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_entity",
+				"subscribe_one",
 				"unsubscribe",
 				"join_channel",
 				"leave_channel",
@@ -1701,7 +1868,7 @@
 				const timeoutHandle = setTimeout(() => {
 					if (this.pendingRequests.has(requestId)) {
 						this.pendingRequests.delete(requestId);
-						reject(new ApiError("Request timed out", "Request timed out"));
+						reject(new _rebasepro_types.RebaseApiError("Request timed out"));
 					}
 				}, this.requestTimeoutMs);
 				this.pendingRequests.set(requestId, {
@@ -1721,30 +1888,30 @@
 				if (!expectsResponse) resolve(void 0);
 			} catch (error) {
 				if (expectsResponse) this.pendingRequests.delete(requestId);
-				reject(new ApiError("Failed to send message", error instanceof Error ? error.message : "Unknown error"));
+				reject(new _rebasepro_types.RebaseApiError("Failed to send message", { cause: error }));
 			}
 		}
 		async fetchCollection(props) {
 			return (await this.sendMessage({
 				type: "FETCH_COLLECTION",
 				payload: props
-			})).entities || [];
+			})).rows || [];
 		}
-		async fetchEntity(props) {
+		async fetchOne(props) {
 			return (await this.sendMessage({
-				type: "FETCH_ENTITY",
+				type: "FETCH_ONE",
 				payload: props
-			})).entity ?? void 0;
+			})).row ?? void 0;
 		}
-		async saveEntity(props) {
+		async save(props) {
 			return (await this.sendMessage({
-				type: "SAVE_ENTITY",
+				type: "SAVE",
 				payload: props
-			})).entity;
+			})).row;
 		}
-		async deleteEntity(props) {
+		async delete(props) {
 			await this.sendMessage({
-				type: "DELETE_ENTITY",
+				type: "DELETE",
 				payload: props
 			});
 		}
@@ -1769,21 +1936,21 @@
 		async fetchCurrentDatabase() {
 			return (await this.sendMessage({ type: "FETCH_CURRENT_DATABASE" })).database;
 		}
-		async checkUniqueField(path, name, value, entityId, collection) {
+		async checkUniqueField(path, name, value, id, collection) {
 			return (await this.sendMessage({
 				type: "CHECK_UNIQUE_FIELD",
 				payload: {
 					path,
 					name,
 					value,
-					entityId,
+					id,
 					collection
 				}
 			})).isUnique;
 		}
-		async countEntities(props) {
+		async count(props) {
 			return (await this.sendMessage({
-				type: "COUNT_ENTITIES",
+				type: "COUNT",
 				payload: props
 			})).count;
 		}
@@ -1875,33 +2042,31 @@
 			return val;
 		}
 		/**
-		* Merge incoming entities with cached data, preserving cached references
-		* for entities whose values haven't changed. This avoids unnecessary
-		* React re-renders when the server refetches all entities but most
+		* 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.
 		*/
-		mergeEntities(cached, incoming) {
+		mergeRows(cached, incoming) {
 			if (!cached || cached.length === 0) return incoming;
 			const cachedById = /* @__PURE__ */ new Map();
-			for (const entity of cached) cachedById.set(entity.id, entity);
-			return incoming.map((incomingEntity) => {
-				const cachedEntity = cachedById.get(incomingEntity.id);
-				if (!cachedEntity) return incomingEntity;
-				if (cachedEntity.path === incomingEntity.path) {
-					const normCached = this.normalizeForComparison(cachedEntity.values);
-					const normIncoming = this.normalizeForComparison(incomingEntity.values);
-					if (this.deepEqual(normCached, normIncoming)) return cachedEntity;
-					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 ${incomingEntity.id} refetch mismatch:\n`, JSON.stringify(mismatches, null, 2));
-					}
+			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 incomingEntity;
+				return incomingRow;
 			});
 		}
 		listenCollection(props, onUpdate, onError) {
@@ -1969,10 +2134,10 @@
 				}
 			};
 		}
-		listenEntity(props, onUpdate, onError) {
-			const subscriptionKey = this.createEntitySubscriptionKey(props);
+		listenOne(props, onUpdate, onError) {
+			const subscriptionKey = this.createSingleSubscriptionKey(props);
 			const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-			const existingSubscription = this.entitySubscriptions.get(subscriptionKey);
+			const existingSubscription = this.singleSubscriptions.get(subscriptionKey);
 			if (existingSubscription) {
 				const callbackMap = existingSubscription.callbacks;
 				callbackMap.set(callbackId, {
@@ -1982,13 +2147,13 @@
 				if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) try {
 					onUpdate(existingSubscription.latestData);
 				} catch (error) {
-					console.error("Error in entity subscription callback:", 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.entitySubscriptions.delete(subscriptionKey);
+						this.singleSubscriptions.delete(subscriptionKey);
 						this.backendToEntityKey.delete(existingSubscription.backendSubscriptionId);
 						if (this.isConnected && this.ws) this.sendMessage({
 							type: "unsubscribe",
@@ -2003,14 +2168,14 @@
 				onUpdate,
 				onError
 			});
-			this.entitySubscriptions.set(subscriptionKey, {
+			this.singleSubscriptions.set(subscriptionKey, {
 				backendSubscriptionId,
 				callbacks: callbackMap,
 				props
 			});
 			this.backendToEntityKey.set(backendSubscriptionId, subscriptionKey);
 			this.sendMessage({
-				type: "subscribe_entity",
+				type: "subscribe_one",
 				payload: {
 					...props,
 					subscriptionId: backendSubscriptionId
@@ -2019,12 +2184,12 @@
 				if (onError) onError(error);
 			});
 			return () => {
-				const subscription = this.entitySubscriptions.get(subscriptionKey);
+				const subscription = this.singleSubscriptions.get(subscriptionKey);
 				if (subscription) {
 					const callbacks = subscription.callbacks;
 					callbacks.delete(callbackId);
 					if (callbacks.size === 0) {
-						this.entitySubscriptions.delete(subscriptionKey);
+						this.singleSubscriptions.delete(subscriptionKey);
 						this.backendToEntityKey.delete(subscription.backendSubscriptionId);
 						if (this.isConnected && this.ws) this.sendMessage({
 							type: "unsubscribe",
@@ -2040,7 +2205,7 @@
 		* we need to re-register everything to resume receiving updates.
 		*/
 		resubscribeAll() {
-			console.debug(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.entitySubscriptions.size} entity(ies)`);
+			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)}`;
@@ -2057,20 +2222,20 @@
 					console.error("[WS] Failed to re-subscribe collection:", key, error);
 				});
 			}
-			for (const [key, sub] of this.entitySubscriptions.entries()) {
+			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_entity",
+					type: "subscribe_one",
 					payload: {
 						...sub.props,
 						subscriptionId: newBackendId
 					}
 				}).catch((error) => {
-					console.error("[WS] Failed to re-subscribe entity:", key, error);
+					console.error("[WS] Failed to re-subscribe row:", key, error);
 				});
 			}
 		}
@@ -2093,8 +2258,8 @@
 				return value;
 			});
 		}
-		createEntitySubscriptionKey(props) {
-			return `${props.path}|${props.entityId}`;
+		createSingleSubscriptionKey(props) {
+			return `${props.path}|${props.id}`;
 		}
 	};
 	//#endregion
@@ -2128,6 +2293,23 @@
 		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) {
@@ -2165,7 +2347,45 @@
 				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);
@@ -2173,7 +2393,22 @@
 		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") return collection((0, _rebasepro_utils.toSnakeCase)(prop));
+			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,
@@ -2182,6 +2417,9 @@
 			apiKeys,
 			functions,
 			storage,
+			storageRegistry,
+			createStorageSource,
+			fetchStorageSources,
 			ws,
 			setToken: transport.setToken,
 			setAuthTokenGetter: transport.setAuthTokenGetter,
@@ -2197,19 +2435,28 @@
 				});
 				return res.data ?? res;
 			},
-			data: dataProxy,
-			email: void 0
+			data: dataProxy
 		};
 	}
 	//#endregion
-	exports.ApiError = ApiError;
 	Object.defineProperty(exports, "QueryBuilder", {
 		enumerable: true,
 		get: function() {
 			return _rebasepro_common.QueryBuilder;
 		}
 	});
-	exports.RebaseApiError = RebaseApiError;
+	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,
@@ -2217,31 +2464,21 @@
 			return _rebasepro_common.and;
 		}
 	});
-	exports.buildQueryString = buildQueryString;
 	Object.defineProperty(exports, "cond", {
 		enumerable: true,
 		get: function() {
 			return _rebasepro_common.cond;
 		}
 	});
-	exports.createAdmin = createAdmin;
-	exports.createApiKeys = createApiKeys;
-	exports.createAuth = createAuth;
-	exports.createCollectionClient = createCollectionClient;
 	exports.createCookieStorage = createCookieStorage;
-	exports.createCron = createCron;
-	exports.createFunctionsClient = createFunctionsClient;
 	exports.createMemoryStorage = createMemoryStorage;
 	exports.createRebaseClient = createRebaseClient;
-	exports.createStorage = createStorage;
-	exports.createTransport = createTransport;
 	Object.defineProperty(exports, "or", {
 		enumerable: true,
 		get: function() {
 			return _rebasepro_common.or;
 		}
 	});
-	exports.rebaseReviver = rebaseReviver;
 });
 
 //# sourceMappingURL=index.umd.js.map