@rebasepro/client 0.7.0 → 0.9.0

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import { EntityReference, EntityRelation, GeoPoint, Vector } from "@rebasepro/types";
-import { QueryBuilder, and, cond, or } from "@rebasepro/common";
+import { DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, GeoPoint, PUBLIC_STORAGE_PREFIX, RebaseApiError, RebaseApiError as RebaseApiError$1, RebaseClientError, Vector, isPublicStoragePath } from "@rebasepro/types";
+import { QueryBuilder, and, cond, or, serializeFilter, serializeLogicalCondition, serializeOrderBy } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 //#region src/reviver.ts
 function rebaseReviver(_key, value) {
@@ -30,80 +30,16 @@ function rebaseReviver(_key, value) {
 }
 //#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 = 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) {
@@ -111,13 +47,10 @@ function buildQueryString(params) {
 		const serialized = (root.conditions ?? []).map(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 = 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("&") : "";
 }
@@ -155,8 +88,7 @@ function createTransport(config) {
 		} 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()) {
@@ -179,7 +111,11 @@ function createTransport(config) {
 				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 RebaseApiError$1(String(getErrorField(retryBody, "message") || fallbackMessage || `Request failed with status ${retryRes.status}`), {
+						status: retryRes.status,
+						code: getErrorField(retryBody, "code"),
+						details: getErrorField(retryBody, "details")
+					});
 				}
 				return retryBody;
 			}
@@ -187,7 +123,11 @@ function createTransport(config) {
 		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 RebaseApiError$1(String(getErrorField(body, "message") || fallbackMessage || `Request failed with status ${res.status}`), {
+				status: res.status,
+				code: getErrorField(body, "code"),
+				details: getErrorField(body, "details")
+			});
 		}
 		return body;
 	}
@@ -223,6 +163,29 @@ function createTransport(config) {
 }
 //#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 {
@@ -253,11 +216,20 @@ function createAuth(transport, options) {
 	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;
 	}
@@ -265,7 +237,11 @@ function createAuth(transport, options) {
 		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 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 {
@@ -273,7 +249,7 @@ function createAuth(transport, options) {
 		} catch (e) {}
 	}
 	function saveSession(session) {
-		if (!persistSession) return;
+		if (!persistSession || authFlowMode === "cookie") return;
 		try {
 			storage.setItem(STORAGE_KEY, JSON.stringify(session));
 		} catch (e) {}
@@ -290,28 +266,53 @@ function createAuth(transport, options) {
 		} 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 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);
@@ -327,7 +328,8 @@ function createAuth(transport, options) {
 			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);
@@ -348,7 +350,8 @@ function createAuth(transport, options) {
 		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);
@@ -371,7 +374,8 @@ function createAuth(transport, options) {
 		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);
@@ -389,7 +393,8 @@ function createAuth(transport, options) {
 			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);
@@ -408,7 +413,8 @@ function createAuth(transport, options) {
 		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);
@@ -484,10 +490,11 @@ function createAuth(transport, options) {
 	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;
@@ -499,20 +506,35 @@ function createAuth(transport, options) {
 		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);
@@ -524,6 +546,18 @@ function createAuth(transport, options) {
 	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",
@@ -597,7 +631,8 @@ function createAuth(transport, options) {
 		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);
@@ -644,21 +679,29 @@ function createAuth(transport, options) {
 	}
 	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,
@@ -678,6 +721,7 @@ function createAuth(transport, options) {
 		signOut,
 		refreshSession,
 		getUser,
+		findUserByEmail,
 		updateUser,
 		resetPasswordForEmail,
 		resetPassword,
@@ -691,7 +735,8 @@ function createAuth(transport, options) {
 		revokeAllSessions,
 		getAuthConfig,
 		getSession,
-		onAuthStateChange
+		onAuthStateChange,
+		isInitialized: () => isInitialized
 	};
 }
 function createCookieStorage(options = {}) {
@@ -868,108 +913,108 @@ function createApiKeys(transport, options) {
 	};
 }
 //#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 = {
@@ -977,7 +1022,7 @@ function createCollectionClient(transport, slug, ws) {
 			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
 			};
 		},
@@ -985,7 +1030,7 @@ function createCollectionClient(transport, slug, ws) {
 			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;
 				throw err;
@@ -994,19 +1039,19 @@ function createCollectionClient(transport, slug, ws) {
 		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({
@@ -1017,55 +1062,87 @@ function createCollectionClient(transport, slug, ws) {
 			return (await transport.request(basePath + "/count" + qs, { method: "GET" })).count ?? 0;
 		},
 		where(columnOrCondition, operator, value) {
-			const builder = new 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 QueryBuilder(client).orderBy(column, ascending);
+		orderBy(column, direction) {
+			return new SDKQueryBuilder(client).orderBy(column, direction);
 		},
 		limit(count) {
-			return new QueryBuilder(client).limit(count);
+			return new SDKQueryBuilder(client).limit(count);
 		},
 		offset(count) {
-			return new QueryBuilder(client).offset(count);
+			return new SDKQueryBuilder(client).offset(count);
 		},
 		search(searchString) {
-			return new QueryBuilder(client).search(searchString);
+			return new SDKQueryBuilder(client).search(searchString);
 		},
 		include(...relations) {
-			return new 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);
 		};
@@ -1098,17 +1175,33 @@ function createFunctionsClient(transport) {
 }
 //#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 && !isPublicStoragePath(effectiveKey)) effectiveKey = `${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: {}
@@ -1116,24 +1209,44 @@ function createStorage(transport) {
 	}
 	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 (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 {
@@ -1144,25 +1257,22 @@ function createStorage(transport) {
 		}
 	}
 	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;
 		}
@@ -1174,6 +1284,7 @@ function createStorage(transport) {
 		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 {
@@ -1185,6 +1296,62 @@ function createStorage(transport) {
 	};
 }
 //#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(DEFAULT_STORAGE_SOURCE_KEY);
+		if (!source) throw new Error(`[StorageSourceRegistry] No default storage source registered. Register one with key "${DEFAULT_STORAGE_SOURCE_KEY}".`);
+		return source;
+	}
+	get(key) {
+		if (key === void 0 || key === null) return this.sources.get(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 "${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 === 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.
@@ -1198,16 +1365,15 @@ function extractMessageError(message) {
 		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;
@@ -1223,7 +1389,7 @@ var RebaseWebSocketClient = class {
 		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();
@@ -1358,7 +1524,7 @@ var RebaseWebSocketClient = class {
 						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 RebaseApiError$1("Connection closed"));
 					this.pendingRequests.delete(reqId);
 				}
 				this.attemptReconnect();
@@ -1425,7 +1591,7 @@ var RebaseWebSocketClient = class {
 		}
 	}
 	/**
-	* 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) {
@@ -1450,7 +1616,7 @@ var RebaseWebSocketClient = class {
 				});
 			} else {
 				const { errorMessage, errorCode } = extractMessageError(message);
-				const error = new ApiError(errorMessage, errorMessage, errorCode);
+				const error = new RebaseApiError$1(errorMessage, { code: errorCode });
 				subscription.callbacks.forEach((callback) => {
 					if (callback.onError) callback.onError(error);
 				});
@@ -1471,7 +1637,7 @@ var RebaseWebSocketClient = class {
 					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 RebaseApiError$1(errorMessage, { code: errorCode }));
 					}
 				}).catch((err) => {
 					pendingReq.reject(err);
@@ -1479,7 +1645,7 @@ var RebaseWebSocketClient = class {
 			} else {
 				this.pendingRequests.delete(requestId);
 				const { errorMessage, errorCode } = extractMessageError(message);
-				pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+				pendingReq.reject(new RebaseApiError$1(errorMessage, { code: errorCode }));
 			}
 			else {
 				this.pendingRequests.delete(requestId);
@@ -1492,14 +1658,14 @@ var RebaseWebSocketClient = class {
 			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)));
@@ -1509,21 +1675,22 @@ var RebaseWebSocketClient = class {
 				}
 			}
 		}
-		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();
@@ -1539,20 +1706,21 @@ var RebaseWebSocketClient = class {
 				}
 			}
 		}
-		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)));
 						}
 					});
@@ -1570,7 +1738,7 @@ var RebaseWebSocketClient = class {
 						return;
 					}
 					const { errorMessage, errorCode } = extractMessageError(message);
-					const error = new ApiError(errorMessage, errorMessage, errorCode);
+					const error = new RebaseApiError$1(errorMessage, { code: errorCode });
 					collectionSub.callbacks.forEach((callback) => {
 						if (callback.onError) callback.onError(error);
 					});
@@ -1579,14 +1747,14 @@ var RebaseWebSocketClient = class {
 			}
 			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 RebaseApiError$1(errorMessage, { code: errorCode });
 					entitySub.callbacks.forEach((callback) => {
 						if (callback.onError) callback.onError(error);
 					});
@@ -1600,7 +1768,7 @@ var RebaseWebSocketClient = class {
 			if (message.type === "ERROR" || message.error) {
 				if (callback.onError) {
 					const { errorMessage, errorCode } = extractMessageError(message);
-					callback.onError(new ApiError(errorMessage, errorMessage, errorCode));
+					callback.onError(new RebaseApiError$1(errorMessage, { code: errorCode }));
 				}
 			} else callback.onUpdate(message);
 		}
@@ -1674,15 +1842,14 @@ var RebaseWebSocketClient = class {
 		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 RebaseApiError$1(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",
@@ -1695,7 +1862,7 @@ var RebaseWebSocketClient = class {
 			const timeoutHandle = setTimeout(() => {
 				if (this.pendingRequests.has(requestId)) {
 					this.pendingRequests.delete(requestId);
-					reject(new ApiError("Request timed out", "Request timed out"));
+					reject(new RebaseApiError$1("Request timed out"));
 				}
 			}, this.requestTimeoutMs);
 			this.pendingRequests.set(requestId, {
@@ -1715,30 +1882,30 @@ var RebaseWebSocketClient = class {
 			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 RebaseApiError$1("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
 		});
 	}
@@ -1763,21 +1930,21 @@ var RebaseWebSocketClient = class {
 	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;
 	}
@@ -1869,33 +2036,31 @@ var RebaseWebSocketClient = class {
 		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) {
@@ -1963,10 +2128,10 @@ var RebaseWebSocketClient = class {
 			}
 		};
 	}
-	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, {
@@ -1976,13 +2141,13 @@ var RebaseWebSocketClient = class {
 			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",
@@ -1997,14 +2162,14 @@ var RebaseWebSocketClient = class {
 			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
@@ -2013,12 +2178,12 @@ var RebaseWebSocketClient = class {
 			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",
@@ -2034,7 +2199,7 @@ var RebaseWebSocketClient = class {
 	* 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)}`;
@@ -2051,20 +2216,20 @@ var RebaseWebSocketClient = class {
 				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);
 			});
 		}
 	}
@@ -2087,8 +2252,8 @@ var RebaseWebSocketClient = class {
 			return value;
 		});
 	}
-	createEntitySubscriptionKey(props) {
-		return `${props.path}|${props.entityId}`;
+	createSingleSubscriptionKey(props) {
+		return `${props.path}|${props.id}`;
 	}
 };
 //#endregion
@@ -2122,6 +2287,23 @@ function createRebaseClient(options) {
 	const apiKeys = createApiKeys(transport, options.apiKeys);
 	const storage = createStorage(transport);
 	const functions = createFunctionsClient(transport);
+	const createStorageSource = (storageId) => storageId === DEFAULT_STORAGE_SOURCE_KEY ? storage : createStorage(transport, storageId);
+	const storageRegistry = new ClientStorageSourceRegistry();
+	storageRegistry.register(DEFAULT_STORAGE_SOURCE_KEY, storage);
+	for (const def of options.storageSources ?? []) if (def.transport === "server" && def.key !== 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 !== 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) {
@@ -2159,7 +2341,45 @@ function createRebaseClient(options) {
 			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);
@@ -2167,7 +2387,22 @@ function createRebaseClient(options) {
 	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(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 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(toSnakeCase(prop));
+		}
 	} });
 	return {
 		auth,
@@ -2176,6 +2411,9 @@ function createRebaseClient(options) {
 		apiKeys,
 		functions,
 		storage,
+		storageRegistry,
+		createStorageSource,
+		fetchStorageSources,
 		ws,
 		setToken: transport.setToken,
 		setAuthTokenGetter: transport.setAuthTokenGetter,
@@ -2191,11 +2429,10 @@ function createRebaseClient(options) {
 			});
 			return res.data ?? res;
 		},
-		data: dataProxy,
-		email: void 0
+		data: dataProxy
 	};
 }
 //#endregion
-export { ApiError, QueryBuilder, RebaseApiError, RebaseWebSocketClient, and, buildQueryString, cond, createAdmin, createApiKeys, createAuth, createCollectionClient, createCookieStorage, createCron, createFunctionsClient, createMemoryStorage, createRebaseClient, createStorage, createTransport, or, rebaseReviver };
+export { QueryBuilder, RebaseApiError, RebaseClientError, RebaseWebSocketClient, and, cond, createCookieStorage, createMemoryStorage, createRebaseClient, or };
 
 //# sourceMappingURL=index.es.js.map